mirror of
https://github.com/fnproject/fn.git
synced 2022-10-28 21:29:17 +03:00
550 lines
12 KiB
Go
550 lines
12 KiB
Go
package govalidator
|
|
|
|
import "testing"
|
|
|
|
func TestAbs(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var tests = []struct {
|
|
param float64
|
|
expected float64
|
|
}{
|
|
{0, 0},
|
|
{-1, 1},
|
|
{10, 10},
|
|
{3.14, 3.14},
|
|
{-96, 96},
|
|
{-10e-12, 10e-12},
|
|
}
|
|
for _, test := range tests {
|
|
actual := Abs(test.param)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected Abs(%v) to be %v, got %v", test.param, test.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSign(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var tests = []struct {
|
|
param float64
|
|
expected float64
|
|
}{
|
|
{0, 0},
|
|
{-1, -1},
|
|
{10, 1},
|
|
{3.14, 1},
|
|
{-96, -1},
|
|
{-10e-12, -1},
|
|
}
|
|
for _, test := range tests {
|
|
actual := Sign(test.param)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected Sign(%v) to be %v, got %v", test.param, test.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestIsNegative(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var tests = []struct {
|
|
param float64
|
|
expected bool
|
|
}{
|
|
{0, false},
|
|
{-1, true},
|
|
{10, false},
|
|
{3.14, false},
|
|
{-96, true},
|
|
{-10e-12, true},
|
|
}
|
|
for _, test := range tests {
|
|
actual := IsNegative(test.param)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected IsNegative(%v) to be %v, got %v", test.param, test.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestIsNonNegative(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var tests = []struct {
|
|
param float64
|
|
expected bool
|
|
}{
|
|
{0, true},
|
|
{-1, false},
|
|
{10, true},
|
|
{3.14, true},
|
|
{-96, false},
|
|
{-10e-12, false},
|
|
}
|
|
for _, test := range tests {
|
|
actual := IsNonNegative(test.param)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected IsNonNegative(%v) to be %v, got %v", test.param, test.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestIsPositive(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var tests = []struct {
|
|
param float64
|
|
expected bool
|
|
}{
|
|
{0, false},
|
|
{-1, false},
|
|
{10, true},
|
|
{3.14, true},
|
|
{-96, false},
|
|
{-10e-12, false},
|
|
}
|
|
for _, test := range tests {
|
|
actual := IsPositive(test.param)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected IsPositive(%v) to be %v, got %v", test.param, test.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestIsNonPositive(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var tests = []struct {
|
|
param float64
|
|
expected bool
|
|
}{
|
|
{0, true},
|
|
{-1, true},
|
|
{10, false},
|
|
{3.14, false},
|
|
{-96, true},
|
|
{-10e-12, true},
|
|
}
|
|
for _, test := range tests {
|
|
actual := IsNonPositive(test.param)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected IsNonPositive(%v) to be %v, got %v", test.param, test.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestIsWhole(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var tests = []struct {
|
|
param float64
|
|
expected bool
|
|
}{
|
|
{0, true},
|
|
{-1, true},
|
|
{10, true},
|
|
{3.14, false},
|
|
{-96, true},
|
|
{-10e-12, false},
|
|
}
|
|
for _, test := range tests {
|
|
actual := IsWhole(test.param)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected IsWhole(%v) to be %v, got %v", test.param, test.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestIsNatural(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var tests = []struct {
|
|
param float64
|
|
expected bool
|
|
}{
|
|
{0, false},
|
|
{-1, false},
|
|
{10, true},
|
|
{3.14, false},
|
|
{96, true},
|
|
{-10e-12, false},
|
|
}
|
|
for _, test := range tests {
|
|
actual := IsNatural(test.param)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected IsNatural(%v) to be %v, got %v", test.param, test.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestInRangeInt(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var testAsInts = []struct {
|
|
param int
|
|
left int
|
|
right int
|
|
expected bool
|
|
}{
|
|
{0, 0, 0, true},
|
|
{1, 0, 0, false},
|
|
{-1, 0, 0, false},
|
|
{0, -1, 1, true},
|
|
{0, 0, 1, true},
|
|
{0, -1, 0, true},
|
|
{0, 0, -1, true},
|
|
{0, 10, 5, false},
|
|
}
|
|
for _, test := range testAsInts {
|
|
actual := InRangeInt(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type int", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
|
|
var testAsInt8s = []struct {
|
|
param int8
|
|
left int8
|
|
right int8
|
|
expected bool
|
|
}{
|
|
{0, 0, 0, true},
|
|
{1, 0, 0, false},
|
|
{-1, 0, 0, false},
|
|
{0, -1, 1, true},
|
|
{0, 0, 1, true},
|
|
{0, -1, 0, true},
|
|
{0, 0, -1, true},
|
|
{0, 10, 5, false},
|
|
}
|
|
for _, test := range testAsInt8s {
|
|
actual := InRangeInt(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type int8", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
|
|
var testAsInt16s = []struct {
|
|
param int16
|
|
left int16
|
|
right int16
|
|
expected bool
|
|
}{
|
|
{0, 0, 0, true},
|
|
{1, 0, 0, false},
|
|
{-1, 0, 0, false},
|
|
{0, -1, 1, true},
|
|
{0, 0, 1, true},
|
|
{0, -1, 0, true},
|
|
{0, 0, -1, true},
|
|
{0, 10, 5, false},
|
|
}
|
|
for _, test := range testAsInt16s {
|
|
actual := InRangeInt(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type int16", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
|
|
var testAsInt32s = []struct {
|
|
param int32
|
|
left int32
|
|
right int32
|
|
expected bool
|
|
}{
|
|
{0, 0, 0, true},
|
|
{1, 0, 0, false},
|
|
{-1, 0, 0, false},
|
|
{0, -1, 1, true},
|
|
{0, 0, 1, true},
|
|
{0, -1, 0, true},
|
|
{0, 0, -1, true},
|
|
{0, 10, 5, false},
|
|
}
|
|
for _, test := range testAsInt32s {
|
|
actual := InRangeInt(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type int32", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
|
|
var testAsInt64s = []struct {
|
|
param int64
|
|
left int64
|
|
right int64
|
|
expected bool
|
|
}{
|
|
{0, 0, 0, true},
|
|
{1, 0, 0, false},
|
|
{-1, 0, 0, false},
|
|
{0, -1, 1, true},
|
|
{0, 0, 1, true},
|
|
{0, -1, 0, true},
|
|
{0, 0, -1, true},
|
|
{0, 10, 5, false},
|
|
}
|
|
for _, test := range testAsInt64s {
|
|
actual := InRangeInt(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type int64", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
|
|
var testAsUInts = []struct {
|
|
param uint
|
|
left uint
|
|
right uint
|
|
expected bool
|
|
}{
|
|
{0, 0, 0, true},
|
|
{1, 0, 0, false},
|
|
{0, 0, 1, true},
|
|
{0, 10, 5, false},
|
|
}
|
|
for _, test := range testAsUInts {
|
|
actual := InRangeInt(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type uint", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
|
|
var testAsUInt8s = []struct {
|
|
param uint8
|
|
left uint8
|
|
right uint8
|
|
expected bool
|
|
}{
|
|
{0, 0, 0, true},
|
|
{1, 0, 0, false},
|
|
{0, 0, 1, true},
|
|
{0, 10, 5, false},
|
|
}
|
|
for _, test := range testAsUInt8s {
|
|
actual := InRangeInt(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type uint", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
|
|
var testAsUInt16s = []struct {
|
|
param uint16
|
|
left uint16
|
|
right uint16
|
|
expected bool
|
|
}{
|
|
{0, 0, 0, true},
|
|
{1, 0, 0, false},
|
|
{0, 0, 1, true},
|
|
{0, 10, 5, false},
|
|
}
|
|
for _, test := range testAsUInt16s {
|
|
actual := InRangeInt(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type uint", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
|
|
var testAsUInt32s = []struct {
|
|
param uint32
|
|
left uint32
|
|
right uint32
|
|
expected bool
|
|
}{
|
|
{0, 0, 0, true},
|
|
{1, 0, 0, false},
|
|
{0, 0, 1, true},
|
|
{0, 10, 5, false},
|
|
}
|
|
for _, test := range testAsUInt32s {
|
|
actual := InRangeInt(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type uint", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
|
|
var testAsUInt64s = []struct {
|
|
param uint64
|
|
left uint64
|
|
right uint64
|
|
expected bool
|
|
}{
|
|
{0, 0, 0, true},
|
|
{1, 0, 0, false},
|
|
{0, 0, 1, true},
|
|
{0, 10, 5, false},
|
|
}
|
|
for _, test := range testAsUInt64s {
|
|
actual := InRangeInt(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type uint", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
|
|
var testAsStrings = []struct {
|
|
param string
|
|
left string
|
|
right string
|
|
expected bool
|
|
}{
|
|
{"0", "0", "0", true},
|
|
{"1", "0", "0", false},
|
|
{"-1", "0", "0", false},
|
|
{"0", "-1", "1", true},
|
|
{"0", "0", "1", true},
|
|
{"0", "-1", "0", true},
|
|
{"0", "0", "-1", true},
|
|
{"0", "10", "5", false},
|
|
}
|
|
for _, test := range testAsStrings {
|
|
actual := InRangeInt(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type string", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestInRangeFloat32(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var tests = []struct {
|
|
param float32
|
|
left float32
|
|
right float32
|
|
expected bool
|
|
}{
|
|
{0, 0, 0, true},
|
|
{1, 0, 0, false},
|
|
{-1, 0, 0, false},
|
|
{0, -1, 1, true},
|
|
{0, 0, 1, true},
|
|
{0, -1, 0, true},
|
|
{0, 0, -1, true},
|
|
{0, 10, 5, false},
|
|
}
|
|
for _, test := range tests {
|
|
actual := InRangeFloat32(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRangeFloat32(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestInRangeFloat64(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var tests = []struct {
|
|
param float64
|
|
left float64
|
|
right float64
|
|
expected bool
|
|
}{
|
|
{0, 0, 0, true},
|
|
{1, 0, 0, false},
|
|
{-1, 0, 0, false},
|
|
{0, -1, 1, true},
|
|
{0, 0, 1, true},
|
|
{0, -1, 0, true},
|
|
{0, 0, -1, true},
|
|
{0, 10, 5, false},
|
|
}
|
|
for _, test := range tests {
|
|
actual := InRangeFloat64(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRangeFloat64(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestInRange(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var testsInt = []struct {
|
|
param int
|
|
left int
|
|
right int
|
|
expected bool
|
|
}{
|
|
{0, 0, 0, true},
|
|
{1, 0, 0, false},
|
|
{-1, 0, 0, false},
|
|
{0, -1, 1, true},
|
|
{0, 0, 1, true},
|
|
{0, -1, 0, true},
|
|
{0, 0, -1, true},
|
|
{0, 10, 5, false},
|
|
}
|
|
for _, test := range testsInt {
|
|
actual := InRange(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
|
|
var testsFloat32 = []struct {
|
|
param float32
|
|
left float32
|
|
right float32
|
|
expected bool
|
|
}{
|
|
{0, 0, 0, true},
|
|
{1, 0, 0, false},
|
|
{-1, 0, 0, false},
|
|
{0, -1, 1, true},
|
|
{0, 0, 1, true},
|
|
{0, -1, 0, true},
|
|
{0, 0, -1, true},
|
|
{0, 10, 5, false},
|
|
}
|
|
for _, test := range testsFloat32 {
|
|
actual := InRange(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
|
|
var testsFloat64 = []struct {
|
|
param float64
|
|
left float64
|
|
right float64
|
|
expected bool
|
|
}{
|
|
{0, 0, 0, true},
|
|
{1, 0, 0, false},
|
|
{-1, 0, 0, false},
|
|
{0, -1, 1, true},
|
|
{0, 0, 1, true},
|
|
{0, -1, 0, true},
|
|
{0, 0, -1, true},
|
|
{0, 10, 5, false},
|
|
}
|
|
for _, test := range testsFloat64 {
|
|
actual := InRange(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
|
|
var testsTypeMix = []struct {
|
|
param int
|
|
left float64
|
|
right float64
|
|
expected bool
|
|
}{
|
|
{0, 0, 0, false},
|
|
{1, 0, 0, false},
|
|
{-1, 0, 0, false},
|
|
{0, -1, 1, false},
|
|
{0, 0, 1, false},
|
|
{0, -1, 0, false},
|
|
{0, 0, -1, false},
|
|
{0, 10, 5, false},
|
|
}
|
|
for _, test := range testsTypeMix {
|
|
actual := InRange(test.param, test.left, test.right)
|
|
if actual != test.expected {
|
|
t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
|
|
}
|
|
}
|
|
}
|