github.com/gnolang/gno@v0.0.0-20240520182011-228e9d0192ce/examples/gno.land/p/demo/int256/arithmetic_test.gno (about)

     1  package int256
     2  
     3  import (
     4  	"testing"
     5  
     6  	"gno.land/p/demo/uint256"
     7  )
     8  
     9  func TestAdd(t *testing.T) {
    10  	tests := []struct {
    11  		x, y, want string
    12  	}{
    13  		{"0", "1", "1"},
    14  		{"1", "0", "1"},
    15  		{"1", "1", "2"},
    16  		{"1", "2", "3"},
    17  		// NEGATIVE
    18  		{"-1", "1", "-0"}, // TODO: remove negative sign for 0 ??
    19  		{"1", "-1", "0"},
    20  		{"-1", "-1", "-2"},
    21  		{"-1", "-2", "-3"},
    22  		{"-1", "3", "2"},
    23  		{"3", "-1", "2"},
    24  		// OVERFLOW
    25  		{"115792089237316195423570985008687907853269984665640564039457584007913129639935", "1", "0"},
    26  	}
    27  
    28  	for _, tc := range tests {
    29  		x, err := FromDecimal(tc.x)
    30  		if err != nil {
    31  			t.Error(err)
    32  			continue
    33  		}
    34  
    35  		y, err := FromDecimal(tc.y)
    36  		if err != nil {
    37  			t.Error(err)
    38  			continue
    39  		}
    40  
    41  		want, err := FromDecimal(tc.want)
    42  		if err != nil {
    43  			t.Error(err)
    44  			continue
    45  		}
    46  
    47  		got := New()
    48  		got.Add(x, y)
    49  
    50  		if got.Neq(want) {
    51  			t.Errorf("Add(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
    52  		}
    53  	}
    54  }
    55  
    56  func TestAddUint256(t *testing.T) {
    57  	tests := []struct {
    58  		x, y, want string
    59  	}{
    60  		{"0", "1", "1"},
    61  		{"1", "0", "1"},
    62  		{"1", "1", "2"},
    63  		{"1", "2", "3"},
    64  		{"-1", "1", "0"},
    65  		{"-1", "3", "2"},
    66  		{"-115792089237316195423570985008687907853269984665640564039457584007913129639934", "115792089237316195423570985008687907853269984665640564039457584007913129639935", "1"},
    67  		{"-115792089237316195423570985008687907853269984665640564039457584007913129639935", "115792089237316195423570985008687907853269984665640564039457584007913129639934", "-1"},
    68  		// OVERFLOW
    69  		{"-115792089237316195423570985008687907853269984665640564039457584007913129639935", "115792089237316195423570985008687907853269984665640564039457584007913129639935", "0"},
    70  	}
    71  
    72  	for _, tc := range tests {
    73  		x, err := FromDecimal(tc.x)
    74  		if err != nil {
    75  			t.Error(err)
    76  			continue
    77  		}
    78  
    79  		y, err := uint256.FromDecimal(tc.y)
    80  		if err != nil {
    81  			t.Error(err)
    82  			continue
    83  		}
    84  
    85  		want, err := FromDecimal(tc.want)
    86  		if err != nil {
    87  			t.Error(err)
    88  			continue
    89  		}
    90  
    91  		got := New()
    92  		got.AddUint256(x, y)
    93  
    94  		if got.Neq(want) {
    95  			t.Errorf("AddUint256(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
    96  		}
    97  	}
    98  }
    99  
   100  func TestAddDelta(t *testing.T) {
   101  	tests := []struct {
   102  		z, x, y, want string
   103  	}{
   104  		{"0", "0", "0", "0"},
   105  		{"0", "0", "1", "1"},
   106  		{"0", "1", "0", "1"},
   107  		{"0", "1", "1", "2"},
   108  		{"1", "2", "3", "5"},
   109  		{"5", "10", "-3", "7"},
   110  		// underflow
   111  		{"1", "2", "-3", "115792089237316195423570985008687907853269984665640564039457584007913129639935"},
   112  	}
   113  
   114  	for _, tc := range tests {
   115  		z, err := uint256.FromDecimal(tc.z)
   116  		if err != nil {
   117  			t.Error(err)
   118  			continue
   119  		}
   120  
   121  		x, err := uint256.FromDecimal(tc.x)
   122  		if err != nil {
   123  			t.Error(err)
   124  			continue
   125  		}
   126  
   127  		y, err := FromDecimal(tc.y)
   128  		if err != nil {
   129  			t.Error(err)
   130  			continue
   131  		}
   132  
   133  		want, err := uint256.FromDecimal(tc.want)
   134  		if err != nil {
   135  			t.Error(err)
   136  			continue
   137  		}
   138  
   139  		AddDelta(z, x, y)
   140  
   141  		if z.Neq(want) {
   142  			t.Errorf("AddDelta(%s, %s, %s) = %v, want %v", tc.z, tc.x, tc.y, z.ToString(), want.ToString())
   143  		}
   144  	}
   145  }
   146  
   147  func TestAddDeltaOverflow(t *testing.T) {
   148  	tests := []struct {
   149  		z, x, y string
   150  		want    bool
   151  	}{
   152  		{"0", "0", "0", false},
   153  		// underflow
   154  		{"1", "2", "-3", true},
   155  	}
   156  
   157  	for _, tc := range tests {
   158  		z, err := uint256.FromDecimal(tc.z)
   159  		if err != nil {
   160  			t.Error(err)
   161  			continue
   162  		}
   163  
   164  		x, err := uint256.FromDecimal(tc.x)
   165  		if err != nil {
   166  			t.Error(err)
   167  			continue
   168  		}
   169  
   170  		y, err := FromDecimal(tc.y)
   171  		if err != nil {
   172  			t.Error(err)
   173  			continue
   174  		}
   175  
   176  		result := AddDeltaOverflow(z, x, y)
   177  		if result != tc.want {
   178  			t.Errorf("AddDeltaOverflow(%s, %s, %s) = %v, want %v", tc.z, tc.x, tc.y, result, tc.want)
   179  		}
   180  	}
   181  }
   182  
   183  func TestSub(t *testing.T) {
   184  	tests := []struct {
   185  		x, y, want string
   186  	}{
   187  		{"1", "0", "1"},
   188  		{"1", "1", "0"},
   189  		{"-1", "1", "-2"},
   190  		{"1", "-1", "2"},
   191  		{"-1", "-1", "-0"},
   192  		{"-115792089237316195423570985008687907853269984665640564039457584007913129639935", "-115792089237316195423570985008687907853269984665640564039457584007913129639935", "-0"},
   193  		{"-115792089237316195423570985008687907853269984665640564039457584007913129639935", "0", "-115792089237316195423570985008687907853269984665640564039457584007913129639935"},
   194  		{x: "-115792089237316195423570985008687907853269984665640564039457584007913129639935", y: "1", want: "-0"},
   195  	}
   196  
   197  	for _, tc := range tests {
   198  		x, err := FromDecimal(tc.x)
   199  		if err != nil {
   200  			t.Error(err)
   201  			continue
   202  		}
   203  
   204  		y, err := FromDecimal(tc.y)
   205  		if err != nil {
   206  			t.Error(err)
   207  			continue
   208  		}
   209  
   210  		want, err := FromDecimal(tc.want)
   211  		if err != nil {
   212  			t.Error(err)
   213  			continue
   214  		}
   215  
   216  		got := New()
   217  		got.Sub(x, y)
   218  
   219  		if got.Neq(want) {
   220  			t.Errorf("Sub(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
   221  		}
   222  	}
   223  }
   224  
   225  func TestSubUint256(t *testing.T) {
   226  	tests := []struct {
   227  		x, y, want string
   228  	}{
   229  		{"0", "1", "-1"},
   230  		{"1", "0", "1"},
   231  		{"1", "1", "0"},
   232  		{"1", "2", "-1"},
   233  		{"-1", "1", "-2"},
   234  		{"-1", "3", "-4"},
   235  		// underflow
   236  		{"-115792089237316195423570985008687907853269984665640564039457584007913129639935", "1", "-0"},
   237  		{"-115792089237316195423570985008687907853269984665640564039457584007913129639935", "2", "-1"},
   238  		{"-115792089237316195423570985008687907853269984665640564039457584007913129639935", "3", "-2"},
   239  	}
   240  
   241  	for _, tc := range tests {
   242  		x, err := FromDecimal(tc.x)
   243  		if err != nil {
   244  			t.Error(err)
   245  			continue
   246  		}
   247  
   248  		y, err := uint256.FromDecimal(tc.y)
   249  		if err != nil {
   250  			t.Error(err)
   251  			continue
   252  		}
   253  
   254  		want, err := FromDecimal(tc.want)
   255  		if err != nil {
   256  			t.Error(err)
   257  			continue
   258  		}
   259  
   260  		got := New()
   261  		got.SubUint256(x, y)
   262  
   263  		if got.Neq(want) {
   264  			t.Errorf("SubUint256(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
   265  		}
   266  	}
   267  }
   268  
   269  func TestMul(t *testing.T) {
   270  	tests := []struct {
   271  		x, y, want string
   272  	}{
   273  		{"5", "3", "15"},
   274  		{"-5", "3", "-15"},
   275  		{"5", "-3", "-15"},
   276  		{"0", "3", "0"},
   277  		{"3", "0", "0"},
   278  	}
   279  
   280  	for _, tc := range tests {
   281  		x, err := FromDecimal(tc.x)
   282  		if err != nil {
   283  			t.Error(err)
   284  			continue
   285  		}
   286  
   287  		y, err := FromDecimal(tc.y)
   288  		if err != nil {
   289  			t.Error(err)
   290  			continue
   291  		}
   292  
   293  		want, err := FromDecimal(tc.want)
   294  		if err != nil {
   295  			t.Error(err)
   296  			continue
   297  		}
   298  
   299  		got := New()
   300  		got.Mul(x, y)
   301  
   302  		if got.Neq(want) {
   303  			t.Errorf("Mul(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
   304  		}
   305  	}
   306  }
   307  
   308  func TestMulUint256(t *testing.T) {
   309  	tests := []struct {
   310  		x, y, want string
   311  	}{
   312  		{"0", "1", "0"},
   313  		{"1", "0", "0"},
   314  		{"1", "1", "1"},
   315  		{"1", "2", "2"},
   316  		{"-1", "1", "-1"},
   317  		{"-1", "3", "-3"},
   318  		{"3", "4", "12"},
   319  		{"-3", "4", "-12"},
   320  		{"-115792089237316195423570985008687907853269984665640564039457584007913129639934", "2", "-115792089237316195423570985008687907853269984665640564039457584007913129639932"},
   321  		{"115792089237316195423570985008687907853269984665640564039457584007913129639934", "2", "115792089237316195423570985008687907853269984665640564039457584007913129639932"},
   322  	}
   323  
   324  	for _, tc := range tests {
   325  		x, err := FromDecimal(tc.x)
   326  		if err != nil {
   327  			t.Error(err)
   328  			continue
   329  		}
   330  
   331  		y, err := uint256.FromDecimal(tc.y)
   332  		if err != nil {
   333  			t.Error(err)
   334  			continue
   335  		}
   336  
   337  		want, err := FromDecimal(tc.want)
   338  		if err != nil {
   339  			t.Error(err)
   340  			continue
   341  		}
   342  
   343  		got := New()
   344  		got.MulUint256(x, y)
   345  
   346  		if got.Neq(want) {
   347  			t.Errorf("MulUint256(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
   348  		}
   349  	}
   350  }
   351  
   352  func TestDiv(t *testing.T) {
   353  	tests := []struct {
   354  		x, y, want string
   355  	}{
   356  		{"0", "1", "0"},
   357  		{"0", "-1", "-0"},
   358  		{"10", "0", "0"},
   359  		{"10", "1", "10"},
   360  		{"10", "-1", "-10"},
   361  		{"-10", "0", "-0"},
   362  		{"-10", "1", "-10"},
   363  		{"-10", "-1", "10"},
   364  		{"10", "-3", "-3"},
   365  		{"10", "3", "3"},
   366  	}
   367  
   368  	for _, tc := range tests {
   369  		x, err := FromDecimal(tc.x)
   370  		if err != nil {
   371  			t.Error(err)
   372  			continue
   373  		}
   374  
   375  		y, err := FromDecimal(tc.y)
   376  		if err != nil {
   377  			t.Error(err)
   378  			continue
   379  		}
   380  
   381  		want, err := FromDecimal(tc.want)
   382  		if err != nil {
   383  			t.Error(err)
   384  			continue
   385  		}
   386  
   387  		got := New()
   388  		got.Div(x, y)
   389  
   390  		if got.Neq(want) {
   391  			t.Errorf("Div(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
   392  		}
   393  	}
   394  }
   395  
   396  func TestDivUint256(t *testing.T) {
   397  	tests := []struct {
   398  		x, y, want string
   399  	}{
   400  		{"0", "1", "0"},
   401  		{"1", "0", "0"},
   402  		{"1", "1", "1"},
   403  		{"1", "2", "0"},
   404  		{"-1", "1", "-1"},
   405  		{"-1", "3", "0"},
   406  		{"4", "3", "1"},
   407  		{"25", "5", "5"},
   408  		{"25", "4", "6"},
   409  		{"-115792089237316195423570985008687907853269984665640564039457584007913129639934", "2", "-57896044618658097711785492504343953926634992332820282019728792003956564819967"},
   410  		{"115792089237316195423570985008687907853269984665640564039457584007913129639934", "2", "57896044618658097711785492504343953926634992332820282019728792003956564819967"},
   411  	}
   412  
   413  	for _, tc := range tests {
   414  		x, err := FromDecimal(tc.x)
   415  		if err != nil {
   416  			t.Error(err)
   417  			continue
   418  		}
   419  
   420  		y, err := uint256.FromDecimal(tc.y)
   421  		if err != nil {
   422  			t.Error(err)
   423  			continue
   424  		}
   425  
   426  		want, err := FromDecimal(tc.want)
   427  		if err != nil {
   428  			t.Error(err)
   429  			continue
   430  		}
   431  
   432  		got := New()
   433  		got.DivUint256(x, y)
   434  
   435  		if got.Neq(want) {
   436  			t.Errorf("DivUint256(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
   437  		}
   438  	}
   439  }
   440  
   441  func TestQuo(t *testing.T) {
   442  	tests := []struct {
   443  		x, y, want string
   444  	}{
   445  		{"0", "1", "0"},
   446  		{"0", "-1", "0"},
   447  		{"10", "1", "10"},
   448  		{"10", "-1", "-10"},
   449  		{"-10", "1", "-10"},
   450  		{"-10", "-1", "10"},
   451  		{"10", "-3", "-3"},
   452  		{"10", "3", "3"},
   453  	}
   454  
   455  	for _, tc := range tests {
   456  		x, err := FromDecimal(tc.x)
   457  		if err != nil {
   458  			t.Error(err)
   459  			continue
   460  		}
   461  
   462  		y, err := FromDecimal(tc.y)
   463  		if err != nil {
   464  			t.Error(err)
   465  			continue
   466  		}
   467  
   468  		want, err := FromDecimal(tc.want)
   469  		if err != nil {
   470  			t.Error(err)
   471  			continue
   472  		}
   473  
   474  		got := New()
   475  		got.Quo(x, y)
   476  
   477  		if got.Neq(want) {
   478  			t.Errorf("Quo(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
   479  		}
   480  	}
   481  }
   482  
   483  func TestRem(t *testing.T) {
   484  	tests := []struct {
   485  		x, y, want string
   486  	}{
   487  		{"0", "1", "0"},
   488  		{"0", "-1", "0"},
   489  		{"10", "1", "0"},
   490  		{"10", "-1", "0"},
   491  		{"-10", "1", "0"},
   492  		{"-10", "-1", "0"},
   493  		{"10", "3", "1"},
   494  		{"10", "-3", "1"},
   495  		{"-10", "3", "-1"},
   496  		{"-10", "-3", "-1"},
   497  	}
   498  
   499  	for _, tc := range tests {
   500  		x, err := FromDecimal(tc.x)
   501  		if err != nil {
   502  			t.Error(err)
   503  			continue
   504  		}
   505  
   506  		y, err := FromDecimal(tc.y)
   507  		if err != nil {
   508  			t.Error(err)
   509  			continue
   510  		}
   511  
   512  		want, err := FromDecimal(tc.want)
   513  		if err != nil {
   514  			t.Error(err)
   515  			continue
   516  		}
   517  
   518  		got := New()
   519  		got.Rem(x, y)
   520  
   521  		if got.Neq(want) {
   522  			t.Errorf("Rem(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
   523  		}
   524  	}
   525  }
   526  
   527  func TestMod(t *testing.T) {
   528  	tests := []struct {
   529  		x, y, want string
   530  	}{
   531  		{"0", "1", "0"},
   532  		{"0", "-1", "0"},
   533  		{"10", "0", "0"},
   534  		{"10", "1", "0"},
   535  		{"10", "-1", "0"},
   536  		{"-10", "0", "0"},
   537  		{"-10", "1", "0"},
   538  		{"-10", "-1", "0"},
   539  		{"10", "3", "1"},
   540  		{"10", "-3", "1"},
   541  		{"-10", "3", "2"},
   542  		{"-10", "-3", "2"},
   543  	}
   544  
   545  	for _, tc := range tests {
   546  		x, err := FromDecimal(tc.x)
   547  		if err != nil {
   548  			t.Error(err)
   549  			continue
   550  		}
   551  
   552  		y, err := FromDecimal(tc.y)
   553  		if err != nil {
   554  			t.Error(err)
   555  			continue
   556  		}
   557  
   558  		want, err := FromDecimal(tc.want)
   559  		if err != nil {
   560  			t.Error(err)
   561  			continue
   562  		}
   563  
   564  		got := New()
   565  		got.Mod(x, y)
   566  
   567  		if got.Neq(want) {
   568  			t.Errorf("Mod(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
   569  		}
   570  	}
   571  }