github.com/tanqiangyes/govalidator@v0.0.5/numerics_test.go (about)

     1  package govalidator
     2  
     3  import "testing"
     4  
     5  func TestAbs(t *testing.T) {
     6  	t.Parallel()
     7  
     8  	var tests = []struct {
     9  		param    float64
    10  		expected float64
    11  	}{
    12  		{0, 0},
    13  		{-1, 1},
    14  		{10, 10},
    15  		{3.14, 3.14},
    16  		{-96, 96},
    17  		{-10e-12, 10e-12},
    18  	}
    19  	for _, test := range tests {
    20  		actual := Abs(test.param)
    21  		if actual != test.expected {
    22  			t.Errorf("Expected Abs(%v) to be %v, got %v", test.param, test.expected, actual)
    23  		}
    24  	}
    25  }
    26  
    27  func TestSign(t *testing.T) {
    28  	t.Parallel()
    29  
    30  	var tests = []struct {
    31  		param    float64
    32  		expected float64
    33  	}{
    34  		{0, 0},
    35  		{-1, -1},
    36  		{10, 1},
    37  		{3.14, 1},
    38  		{-96, -1},
    39  		{-10e-12, -1},
    40  	}
    41  	for _, test := range tests {
    42  		actual := Sign(test.param)
    43  		if actual != test.expected {
    44  			t.Errorf("Expected Sign(%v) to be %v, got %v", test.param, test.expected, actual)
    45  		}
    46  	}
    47  }
    48  
    49  func TestIsNegative(t *testing.T) {
    50  	t.Parallel()
    51  
    52  	var tests = []struct {
    53  		param    float64
    54  		expected bool
    55  	}{
    56  		{0, false},
    57  		{-1, true},
    58  		{10, false},
    59  		{3.14, false},
    60  		{-96, true},
    61  		{-10e-12, true},
    62  	}
    63  	for _, test := range tests {
    64  		actual := IsNegative(test.param)
    65  		if actual != test.expected {
    66  			t.Errorf("Expected IsNegative(%v) to be %v, got %v", test.param, test.expected, actual)
    67  		}
    68  	}
    69  }
    70  
    71  func TestIsNonNegative(t *testing.T) {
    72  	t.Parallel()
    73  
    74  	var tests = []struct {
    75  		param    float64
    76  		expected bool
    77  	}{
    78  		{0, true},
    79  		{-1, false},
    80  		{10, true},
    81  		{3.14, true},
    82  		{-96, false},
    83  		{-10e-12, false},
    84  	}
    85  	for _, test := range tests {
    86  		actual := IsNonNegative(test.param)
    87  		if actual != test.expected {
    88  			t.Errorf("Expected IsNonNegative(%v) to be %v, got %v", test.param, test.expected, actual)
    89  		}
    90  	}
    91  }
    92  
    93  func TestIsPositive(t *testing.T) {
    94  	t.Parallel()
    95  
    96  	var tests = []struct {
    97  		param    float64
    98  		expected bool
    99  	}{
   100  		{0, false},
   101  		{-1, false},
   102  		{10, true},
   103  		{3.14, true},
   104  		{-96, false},
   105  		{-10e-12, false},
   106  	}
   107  	for _, test := range tests {
   108  		actual := IsPositive(test.param)
   109  		if actual != test.expected {
   110  			t.Errorf("Expected IsPositive(%v) to be %v, got %v", test.param, test.expected, actual)
   111  		}
   112  	}
   113  }
   114  
   115  func TestIsNonPositive(t *testing.T) {
   116  	t.Parallel()
   117  
   118  	var tests = []struct {
   119  		param    float64
   120  		expected bool
   121  	}{
   122  		{0, true},
   123  		{-1, true},
   124  		{10, false},
   125  		{3.14, false},
   126  		{-96, true},
   127  		{-10e-12, true},
   128  	}
   129  	for _, test := range tests {
   130  		actual := IsNonPositive(test.param)
   131  		if actual != test.expected {
   132  			t.Errorf("Expected IsNonPositive(%v) to be %v, got %v", test.param, test.expected, actual)
   133  		}
   134  	}
   135  }
   136  
   137  func TestIsWhole(t *testing.T) {
   138  	t.Parallel()
   139  
   140  	var tests = []struct {
   141  		param    float64
   142  		expected bool
   143  	}{
   144  		{0, true},
   145  		{-1, true},
   146  		{10, true},
   147  		{3.14, false},
   148  		{-96, true},
   149  		{-10e-12, false},
   150  	}
   151  	for _, test := range tests {
   152  		actual := IsWhole(test.param)
   153  		if actual != test.expected {
   154  			t.Errorf("Expected IsWhole(%v) to be %v, got %v", test.param, test.expected, actual)
   155  		}
   156  	}
   157  }
   158  
   159  func TestIsNatural(t *testing.T) {
   160  	t.Parallel()
   161  
   162  	var tests = []struct {
   163  		param    float64
   164  		expected bool
   165  	}{
   166  		{0, false},
   167  		{-1, false},
   168  		{10, true},
   169  		{3.14, false},
   170  		{96, true},
   171  		{-10e-12, false},
   172  	}
   173  	for _, test := range tests {
   174  		actual := IsNatural(test.param)
   175  		if actual != test.expected {
   176  			t.Errorf("Expected IsNatural(%v) to be %v, got %v", test.param, test.expected, actual)
   177  		}
   178  	}
   179  }
   180  
   181  func TestInRange(t *testing.T) {
   182  	t.Parallel()
   183  
   184  	var testsInt = []struct {
   185  		param    int
   186  		left     int
   187  		right    int
   188  		expected bool
   189  	}{
   190  		{0, 0, 0, true},
   191  		{1, 0, 0, false},
   192  		{-1, 0, 0, false},
   193  		{0, -1, 1, true},
   194  		{0, 0, 1, true},
   195  		{0, -1, 0, true},
   196  		{0, 0, -1, true},
   197  		{0, 10, 5, false},
   198  	}
   199  	for _, test := range testsInt {
   200  		actual := InRange(test.param, test.left, test.right)
   201  		if actual != test.expected {
   202  			t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
   203  		}
   204  	}
   205  
   206  	var testsFloat32 = []struct {
   207  		param    float32
   208  		left     float32
   209  		right    float32
   210  		expected bool
   211  	}{
   212  		{0, 0, 0, true},
   213  		{1, 0, 0, false},
   214  		{-1, 0, 0, false},
   215  		{0, -1, 1, true},
   216  		{0, 0, 1, true},
   217  		{0, -1, 0, true},
   218  		{0, 0, -1, true},
   219  		{0, 10, 5, false},
   220  	}
   221  	for _, test := range testsFloat32 {
   222  		actual := InRange(test.param, test.left, test.right)
   223  		if actual != test.expected {
   224  			t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
   225  		}
   226  	}
   227  
   228  	var testsFloat64 = []struct {
   229  		param    float64
   230  		left     float64
   231  		right    float64
   232  		expected bool
   233  	}{
   234  		{0, 0, 0, true},
   235  		{1, 0, 0, false},
   236  		{-1, 0, 0, false},
   237  		{0, -1, 1, true},
   238  		{0, 0, 1, true},
   239  		{0, -1, 0, true},
   240  		{0, 0, -1, true},
   241  		{0, 10, 5, false},
   242  	}
   243  	for _, test := range testsFloat64 {
   244  		actual := InRange(test.param, test.left, test.right)
   245  		if actual != test.expected {
   246  			t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
   247  		}
   248  	}
   249  
   250  	var testsTypeMix = []struct {
   251  		param    string
   252  		left     string
   253  		right    string
   254  		expected bool
   255  	}{
   256  		{"0", "0", "0", true},
   257  		{"1", "0", "0", false},
   258  		{"-1", "0", "0", false},
   259  		{"0", "-1", "1", true},
   260  		{"0", "0", "1", true},
   261  		{"0", "-1", "0", true},
   262  		{"0", "0", "-1", true},
   263  		{"0", "10", "5", false},
   264  	}
   265  	for _, test := range testsTypeMix {
   266  		actual := InRange(test.param, test.left, test.right)
   267  		if actual != test.expected {
   268  			t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
   269  		}
   270  	}
   271  }