github.com/angenalZZZ/gofunc@v0.0.0-20210507121333-48ff1be3917b/f/numerics_test.go (about)

     1  package f_test
     2  
     3  import (
     4  	"github.com/angenalZZZ/gofunc/f"
     5  	"testing"
     6  )
     7  
     8  func TestAbs(t *testing.T) {
     9  	t.Parallel()
    10  
    11  	var tests = []struct {
    12  		param    float64
    13  		expected float64
    14  	}{
    15  		{0, 0},
    16  		{-1, 1},
    17  		{10, 10},
    18  		{3.14, 3.14},
    19  		{-96, 96},
    20  		{-10e-12, 10e-12},
    21  	}
    22  	for _, test := range tests {
    23  		actual := f.Abs(test.param)
    24  		if actual != test.expected {
    25  			t.Errorf("Expected Abs(%v) to be %v, got %v", test.param, test.expected, actual)
    26  		}
    27  	}
    28  }
    29  
    30  func TestSign(t *testing.T) {
    31  	t.Parallel()
    32  
    33  	var tests = []struct {
    34  		param    float64
    35  		expected float64
    36  	}{
    37  		{0, 0},
    38  		{-1, -1},
    39  		{10, 1},
    40  		{3.14, 1},
    41  		{-96, -1},
    42  		{-10e-12, -1},
    43  	}
    44  	for _, test := range tests {
    45  		actual := f.Sign(test.param)
    46  		if actual != test.expected {
    47  			t.Errorf("Expected Sign(%v) to be %v, got %v", test.param, test.expected, actual)
    48  		}
    49  	}
    50  }
    51  
    52  func TestIsNegative(t *testing.T) {
    53  	t.Parallel()
    54  
    55  	var tests = []struct {
    56  		param    float64
    57  		expected bool
    58  	}{
    59  		{0, false},
    60  		{-1, true},
    61  		{10, false},
    62  		{3.14, false},
    63  		{-96, true},
    64  		{-10e-12, true},
    65  	}
    66  	for _, test := range tests {
    67  		actual := f.IsNegative(test.param)
    68  		if actual != test.expected {
    69  			t.Errorf("Expected IsNegative(%v) to be %v, got %v", test.param, test.expected, actual)
    70  		}
    71  	}
    72  }
    73  
    74  func TestIsNonNegative(t *testing.T) {
    75  	t.Parallel()
    76  
    77  	var tests = []struct {
    78  		param    float64
    79  		expected bool
    80  	}{
    81  		{0, true},
    82  		{-1, false},
    83  		{10, true},
    84  		{3.14, true},
    85  		{-96, false},
    86  		{-10e-12, false},
    87  	}
    88  	for _, test := range tests {
    89  		actual := f.IsNonNegative(test.param)
    90  		if actual != test.expected {
    91  			t.Errorf("Expected IsNonNegative(%v) to be %v, got %v", test.param, test.expected, actual)
    92  		}
    93  	}
    94  }
    95  
    96  func TestIsPositive(t *testing.T) {
    97  	t.Parallel()
    98  
    99  	var tests = []struct {
   100  		param    float64
   101  		expected bool
   102  	}{
   103  		{0, false},
   104  		{-1, false},
   105  		{10, true},
   106  		{3.14, true},
   107  		{-96, false},
   108  		{-10e-12, false},
   109  	}
   110  	for _, test := range tests {
   111  		actual := f.IsPositive(test.param)
   112  		if actual != test.expected {
   113  			t.Errorf("Expected IsPositive(%v) to be %v, got %v", test.param, test.expected, actual)
   114  		}
   115  	}
   116  }
   117  
   118  func TestIsNonPositive(t *testing.T) {
   119  	t.Parallel()
   120  
   121  	var tests = []struct {
   122  		param    float64
   123  		expected bool
   124  	}{
   125  		{0, true},
   126  		{-1, true},
   127  		{10, false},
   128  		{3.14, false},
   129  		{-96, true},
   130  		{-10e-12, true},
   131  	}
   132  	for _, test := range tests {
   133  		actual := f.IsNonPositive(test.param)
   134  		if actual != test.expected {
   135  			t.Errorf("Expected IsNonPositive(%v) to be %v, got %v", test.param, test.expected, actual)
   136  		}
   137  	}
   138  }
   139  
   140  func TestIsWhole(t *testing.T) {
   141  	t.Parallel()
   142  
   143  	var tests = []struct {
   144  		param    float64
   145  		expected bool
   146  	}{
   147  		{0, true},
   148  		{-1, true},
   149  		{10, true},
   150  		{3.14, false},
   151  		{-96, true},
   152  		{-10e-12, false},
   153  	}
   154  	for _, test := range tests {
   155  		actual := f.IsWhole(test.param)
   156  		if actual != test.expected {
   157  			t.Errorf("Expected IsWhole(%v) to be %v, got %v", test.param, test.expected, actual)
   158  		}
   159  	}
   160  }
   161  
   162  func TestIsNatural(t *testing.T) {
   163  	t.Parallel()
   164  
   165  	var tests = []struct {
   166  		param    float64
   167  		expected bool
   168  	}{
   169  		{0, false},
   170  		{-1, false},
   171  		{10, true},
   172  		{3.14, false},
   173  		{96, true},
   174  		{-10e-12, false},
   175  	}
   176  	for _, test := range tests {
   177  		actual := f.IsNatural(test.param)
   178  		if actual != test.expected {
   179  			t.Errorf("Expected IsNatural(%v) to be %v, got %v", test.param, test.expected, actual)
   180  		}
   181  	}
   182  }
   183  
   184  func TestInRangeInt(t *testing.T) {
   185  	t.Parallel()
   186  
   187  	var testAsInts = []struct {
   188  		param    int
   189  		left     int
   190  		right    int
   191  		expected bool
   192  	}{
   193  		{0, 0, 0, true},
   194  		{1, 0, 0, false},
   195  		{-1, 0, 0, false},
   196  		{0, -1, 1, true},
   197  		{0, 0, 1, true},
   198  		{0, -1, 0, true},
   199  		{0, 0, -1, true},
   200  		{0, 10, 5, false},
   201  	}
   202  	for _, test := range testAsInts {
   203  		actual := f.InRangeInt(test.param, test.left, test.right)
   204  		if actual != test.expected {
   205  			t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type int", test.param, test.left, test.right, test.expected, actual)
   206  		}
   207  	}
   208  
   209  	var testAsInt8s = []struct {
   210  		param    int8
   211  		left     int8
   212  		right    int8
   213  		expected bool
   214  	}{
   215  		{0, 0, 0, true},
   216  		{1, 0, 0, false},
   217  		{-1, 0, 0, false},
   218  		{0, -1, 1, true},
   219  		{0, 0, 1, true},
   220  		{0, -1, 0, true},
   221  		{0, 0, -1, true},
   222  		{0, 10, 5, false},
   223  	}
   224  	for _, test := range testAsInt8s {
   225  		actual := f.InRangeInt(test.param, test.left, test.right)
   226  		if actual != test.expected {
   227  			t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type int8", test.param, test.left, test.right, test.expected, actual)
   228  		}
   229  	}
   230  
   231  	var testAsInt16s = []struct {
   232  		param    int16
   233  		left     int16
   234  		right    int16
   235  		expected bool
   236  	}{
   237  		{0, 0, 0, true},
   238  		{1, 0, 0, false},
   239  		{-1, 0, 0, false},
   240  		{0, -1, 1, true},
   241  		{0, 0, 1, true},
   242  		{0, -1, 0, true},
   243  		{0, 0, -1, true},
   244  		{0, 10, 5, false},
   245  	}
   246  	for _, test := range testAsInt16s {
   247  		actual := f.InRangeInt(test.param, test.left, test.right)
   248  		if actual != test.expected {
   249  			t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type int16", test.param, test.left, test.right, test.expected, actual)
   250  		}
   251  	}
   252  
   253  	var testAsInt32s = []struct {
   254  		param    int32
   255  		left     int32
   256  		right    int32
   257  		expected bool
   258  	}{
   259  		{0, 0, 0, true},
   260  		{1, 0, 0, false},
   261  		{-1, 0, 0, false},
   262  		{0, -1, 1, true},
   263  		{0, 0, 1, true},
   264  		{0, -1, 0, true},
   265  		{0, 0, -1, true},
   266  		{0, 10, 5, false},
   267  	}
   268  	for _, test := range testAsInt32s {
   269  		actual := f.InRangeInt(test.param, test.left, test.right)
   270  		if actual != test.expected {
   271  			t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type int32", test.param, test.left, test.right, test.expected, actual)
   272  		}
   273  	}
   274  
   275  	var testAsInt64s = []struct {
   276  		param    int64
   277  		left     int64
   278  		right    int64
   279  		expected bool
   280  	}{
   281  		{0, 0, 0, true},
   282  		{1, 0, 0, false},
   283  		{-1, 0, 0, false},
   284  		{0, -1, 1, true},
   285  		{0, 0, 1, true},
   286  		{0, -1, 0, true},
   287  		{0, 0, -1, true},
   288  		{0, 10, 5, false},
   289  	}
   290  	for _, test := range testAsInt64s {
   291  		actual := f.InRangeInt(test.param, test.left, test.right)
   292  		if actual != test.expected {
   293  			t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type int64", test.param, test.left, test.right, test.expected, actual)
   294  		}
   295  	}
   296  
   297  	var testAsUInts = []struct {
   298  		param    uint
   299  		left     uint
   300  		right    uint
   301  		expected bool
   302  	}{
   303  		{0, 0, 0, true},
   304  		{1, 0, 0, false},
   305  		{0, 0, 1, true},
   306  		{0, 10, 5, false},
   307  	}
   308  	for _, test := range testAsUInts {
   309  		actual := f.InRangeInt(test.param, test.left, test.right)
   310  		if actual != test.expected {
   311  			t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type uint", test.param, test.left, test.right, test.expected, actual)
   312  		}
   313  	}
   314  
   315  	var testAsUInt8s = []struct {
   316  		param    uint8
   317  		left     uint8
   318  		right    uint8
   319  		expected bool
   320  	}{
   321  		{0, 0, 0, true},
   322  		{1, 0, 0, false},
   323  		{0, 0, 1, true},
   324  		{0, 10, 5, false},
   325  	}
   326  	for _, test := range testAsUInt8s {
   327  		actual := f.InRangeInt(test.param, test.left, test.right)
   328  		if actual != test.expected {
   329  			t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type uint", test.param, test.left, test.right, test.expected, actual)
   330  		}
   331  	}
   332  
   333  	var testAsUInt16s = []struct {
   334  		param    uint16
   335  		left     uint16
   336  		right    uint16
   337  		expected bool
   338  	}{
   339  		{0, 0, 0, true},
   340  		{1, 0, 0, false},
   341  		{0, 0, 1, true},
   342  		{0, 10, 5, false},
   343  	}
   344  	for _, test := range testAsUInt16s {
   345  		actual := f.InRangeInt(test.param, test.left, test.right)
   346  		if actual != test.expected {
   347  			t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type uint", test.param, test.left, test.right, test.expected, actual)
   348  		}
   349  	}
   350  
   351  	var testAsUInt32s = []struct {
   352  		param    uint32
   353  		left     uint32
   354  		right    uint32
   355  		expected bool
   356  	}{
   357  		{0, 0, 0, true},
   358  		{1, 0, 0, false},
   359  		{0, 0, 1, true},
   360  		{0, 10, 5, false},
   361  	}
   362  	for _, test := range testAsUInt32s {
   363  		actual := f.InRangeInt(test.param, test.left, test.right)
   364  		if actual != test.expected {
   365  			t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type uint", test.param, test.left, test.right, test.expected, actual)
   366  		}
   367  	}
   368  
   369  	var testAsUInt64s = []struct {
   370  		param    uint64
   371  		left     uint64
   372  		right    uint64
   373  		expected bool
   374  	}{
   375  		{0, 0, 0, true},
   376  		{1, 0, 0, false},
   377  		{0, 0, 1, true},
   378  		{0, 10, 5, false},
   379  	}
   380  	for _, test := range testAsUInt64s {
   381  		actual := f.InRangeInt(test.param, test.left, test.right)
   382  		if actual != test.expected {
   383  			t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type uint", test.param, test.left, test.right, test.expected, actual)
   384  		}
   385  	}
   386  
   387  	var testAsStrings = []struct {
   388  		param    string
   389  		left     string
   390  		right    string
   391  		expected bool
   392  	}{
   393  		{"0", "0", "0", true},
   394  		{"1", "0", "0", false},
   395  		{"-1", "0", "0", false},
   396  		{"0", "-1", "1", true},
   397  		{"0", "0", "1", true},
   398  		{"0", "-1", "0", true},
   399  		{"0", "0", "-1", true},
   400  		{"0", "10", "5", false},
   401  	}
   402  	for _, test := range testAsStrings {
   403  		actual := f.InRangeInt(test.param, test.left, test.right)
   404  		if actual != test.expected {
   405  			t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v using type string", test.param, test.left, test.right, test.expected, actual)
   406  		}
   407  	}
   408  }
   409  
   410  func TestInRangeFloat32(t *testing.T) {
   411  	t.Parallel()
   412  
   413  	var tests = []struct {
   414  		param    float32
   415  		left     float32
   416  		right    float32
   417  		expected bool
   418  	}{
   419  		{0, 0, 0, true},
   420  		{1, 0, 0, false},
   421  		{-1, 0, 0, false},
   422  		{0, -1, 1, true},
   423  		{0, 0, 1, true},
   424  		{0, -1, 0, true},
   425  		{0, 0, -1, true},
   426  		{0, 10, 5, false},
   427  	}
   428  	for _, test := range tests {
   429  		actual := f.InRangeFloat32(test.param, test.left, test.right)
   430  		if actual != test.expected {
   431  			t.Errorf("Expected InRangeFloat32(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
   432  		}
   433  	}
   434  }
   435  
   436  func TestInRangeFloat64(t *testing.T) {
   437  	t.Parallel()
   438  
   439  	var tests = []struct {
   440  		param    float64
   441  		left     float64
   442  		right    float64
   443  		expected bool
   444  	}{
   445  		{0, 0, 0, true},
   446  		{1, 0, 0, false},
   447  		{-1, 0, 0, false},
   448  		{0, -1, 1, true},
   449  		{0, 0, 1, true},
   450  		{0, -1, 0, true},
   451  		{0, 0, -1, true},
   452  		{0, 10, 5, false},
   453  	}
   454  	for _, test := range tests {
   455  		actual := f.InRangeFloat64(test.param, test.left, test.right)
   456  		if actual != test.expected {
   457  			t.Errorf("Expected InRangeFloat64(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
   458  		}
   459  	}
   460  }
   461  
   462  func TestInRange(t *testing.T) {
   463  	t.Parallel()
   464  
   465  	var testsInt = []struct {
   466  		param    int
   467  		left     int
   468  		right    int
   469  		expected bool
   470  	}{
   471  		{0, 0, 0, true},
   472  		{1, 0, 0, false},
   473  		{-1, 0, 0, false},
   474  		{0, -1, 1, true},
   475  		{0, 0, 1, true},
   476  		{0, -1, 0, true},
   477  		{0, 0, -1, true},
   478  		{0, 10, 5, false},
   479  	}
   480  	for _, test := range testsInt {
   481  		actual := f.InRange(test.param, test.left, test.right)
   482  		if actual != test.expected {
   483  			t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
   484  		}
   485  	}
   486  
   487  	var testsFloat32 = []struct {
   488  		param    float32
   489  		left     float32
   490  		right    float32
   491  		expected bool
   492  	}{
   493  		{0, 0, 0, true},
   494  		{1, 0, 0, false},
   495  		{-1, 0, 0, false},
   496  		{0, -1, 1, true},
   497  		{0, 0, 1, true},
   498  		{0, -1, 0, true},
   499  		{0, 0, -1, true},
   500  		{0, 10, 5, false},
   501  	}
   502  	for _, test := range testsFloat32 {
   503  		actual := f.InRange(test.param, test.left, test.right)
   504  		if actual != test.expected {
   505  			t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
   506  		}
   507  	}
   508  
   509  	var testsFloat64 = []struct {
   510  		param    float64
   511  		left     float64
   512  		right    float64
   513  		expected bool
   514  	}{
   515  		{0, 0, 0, true},
   516  		{1, 0, 0, false},
   517  		{-1, 0, 0, false},
   518  		{0, -1, 1, true},
   519  		{0, 0, 1, true},
   520  		{0, -1, 0, true},
   521  		{0, 0, -1, true},
   522  		{0, 10, 5, false},
   523  	}
   524  	for _, test := range testsFloat64 {
   525  		actual := f.InRange(test.param, test.left, test.right)
   526  		if actual != test.expected {
   527  			t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
   528  		}
   529  	}
   530  
   531  	var testsTypeMix = []struct {
   532  		param    int
   533  		left     float64
   534  		right    float64
   535  		expected bool
   536  	}{
   537  		{0, 0, 0, false},
   538  		{1, 0, 0, false},
   539  		{-1, 0, 0, false},
   540  		{0, -1, 1, false},
   541  		{0, 0, 1, false},
   542  		{0, -1, 0, false},
   543  		{0, 0, -1, false},
   544  		{0, 10, 5, false},
   545  	}
   546  	for _, test := range testsTypeMix {
   547  		actual := f.InRange(test.param, test.left, test.right)
   548  		if actual != test.expected {
   549  			t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
   550  		}
   551  	}
   552  }