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

     1  package uint256
     2  
     3  import "testing"
     4  
     5  type binOp2Test struct {
     6  	x, y, want string
     7  }
     8  
     9  func TestAdd(t *testing.T) {
    10  	tests := []binOp2Test{
    11  		{"0", "1", "1"},
    12  		{"1", "0", "1"},
    13  		{"1", "1", "2"},
    14  		{"1", "3", "4"},
    15  		{"10", "10", "20"},
    16  		{"18446744073709551615", "18446744073709551615", "36893488147419103230"}, // uint64 overflow
    17  	}
    18  
    19  	for _, tc := range tests {
    20  		x, err := FromDecimal(tc.x)
    21  		if err != nil {
    22  			t.Error(err)
    23  			continue
    24  		}
    25  
    26  		y, err := FromDecimal(tc.y)
    27  		if err != nil {
    28  			t.Error(err)
    29  			continue
    30  		}
    31  
    32  		want, err := FromDecimal(tc.want)
    33  		if err != nil {
    34  			t.Error(err)
    35  			continue
    36  		}
    37  
    38  		got := &Uint{}
    39  		got.Add(x, y)
    40  
    41  		if got.Neq(want) {
    42  			t.Errorf("Add(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
    43  		}
    44  	}
    45  }
    46  
    47  func TestSub(t *testing.T) {
    48  	tests := []binOp2Test{
    49  		{"1", "0", "1"},
    50  		{"1", "1", "0"},
    51  		{"10", "10", "0"},
    52  		{"31337", "1337", "30000"},
    53  		{"2", "3", "115792089237316195423570985008687907853269984665640564039457584007913129639935"}, // underflow
    54  	}
    55  
    56  	for _, tc := range tests {
    57  		x, err := FromDecimal(tc.x)
    58  		if err != nil {
    59  			t.Error(err)
    60  			continue
    61  		}
    62  
    63  		y, err := FromDecimal(tc.y)
    64  		if err != nil {
    65  			t.Error(err)
    66  			continue
    67  		}
    68  
    69  		want, err := FromDecimal(tc.want)
    70  		if err != nil {
    71  			t.Error(err)
    72  			continue
    73  		}
    74  
    75  		got := &Uint{}
    76  		got.Sub(x, y)
    77  
    78  		if got.Neq(want) {
    79  			t.Errorf("Sub(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
    80  		}
    81  	}
    82  }
    83  
    84  func TestMul(t *testing.T) {
    85  	tests := []binOp2Test{
    86  		{"1", "0", "0"},
    87  		{"1", "1", "1"},
    88  		{"10", "10", "100"},
    89  		{"18446744073709551615", "2", "36893488147419103230"}, // uint64 overflow
    90  	}
    91  
    92  	for _, tc := range tests {
    93  		x, err := FromDecimal(tc.x)
    94  		if err != nil {
    95  			t.Error(err)
    96  			continue
    97  		}
    98  
    99  		y, err := FromDecimal(tc.y)
   100  		if err != nil {
   101  			t.Error(err)
   102  			continue
   103  		}
   104  
   105  		want, err := FromDecimal(tc.want)
   106  		if err != nil {
   107  			t.Error(err)
   108  			continue
   109  		}
   110  
   111  		got := &Uint{}
   112  		got.Mul(x, y)
   113  
   114  		if got.Neq(want) {
   115  			t.Errorf("Mul(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
   116  		}
   117  	}
   118  }
   119  
   120  func TestDiv(t *testing.T) {
   121  	tests := []binOp2Test{
   122  		{"31337", "3", "10445"},
   123  		{"31337", "0", "0"},
   124  		{"0", "31337", "0"},
   125  		{"1", "1", "1"},
   126  	}
   127  
   128  	for _, tc := range tests {
   129  		x, err := FromDecimal(tc.x)
   130  		if err != nil {
   131  			t.Error(err)
   132  			continue
   133  		}
   134  
   135  		y, err := FromDecimal(tc.y)
   136  		if err != nil {
   137  			t.Error(err)
   138  			continue
   139  		}
   140  
   141  		want, err := FromDecimal(tc.want)
   142  		if err != nil {
   143  			t.Error(err)
   144  			continue
   145  		}
   146  
   147  		got := &Uint{}
   148  		got.Div(x, y)
   149  
   150  		if got.Neq(want) {
   151  			t.Errorf("Div(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
   152  		}
   153  	}
   154  }
   155  
   156  func TestMod(t *testing.T) {
   157  	tests := []binOp2Test{
   158  		{"31337", "3", "2"},
   159  		{"31337", "0", "0"},
   160  		{"0", "31337", "0"},
   161  		{"2", "31337", "2"},
   162  		{"1", "1", "0"},
   163  	}
   164  
   165  	for _, tc := range tests {
   166  		x, err := FromDecimal(tc.x)
   167  		if err != nil {
   168  			t.Error(err)
   169  			continue
   170  		}
   171  
   172  		y, err := FromDecimal(tc.y)
   173  		if err != nil {
   174  			t.Error(err)
   175  			continue
   176  		}
   177  
   178  		want, err := FromDecimal(tc.want)
   179  		if err != nil {
   180  			t.Error(err)
   181  			continue
   182  		}
   183  
   184  		got := &Uint{}
   185  		got.Mod(x, y)
   186  
   187  		if got.Neq(want) {
   188  			t.Errorf("Mod(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
   189  		}
   190  	}
   191  }
   192  
   193  func TestDivMod(t *testing.T) {
   194  	tests := []struct {
   195  		x       string
   196  		y       string
   197  		wantDiv string
   198  		wantMod string
   199  	}{
   200  		{"1", "1", "1", "0"},
   201  		{"10", "10", "1", "0"},
   202  		{"100", "10", "10", "0"},
   203  		{"31337", "3", "10445", "2"},
   204  		{"31337", "0", "0", "0"},
   205  		{"0", "31337", "0", "0"},
   206  		{"2", "31337", "0", "2"},
   207  	}
   208  
   209  	for _, tc := range tests {
   210  		x, err := FromDecimal(tc.x)
   211  		if err != nil {
   212  			t.Error(err)
   213  			continue
   214  		}
   215  
   216  		y, err := FromDecimal(tc.y)
   217  		if err != nil {
   218  			t.Error(err)
   219  			continue
   220  		}
   221  
   222  		wantDiv, err := FromDecimal(tc.wantDiv)
   223  		if err != nil {
   224  			t.Error(err)
   225  			continue
   226  		}
   227  
   228  		wantMod, err := FromDecimal(tc.wantMod)
   229  		if err != nil {
   230  			t.Error(err)
   231  			continue
   232  		}
   233  
   234  		gotDiv := new(Uint)
   235  		gotMod := new(Uint)
   236  		gotDiv.DivMod(x, y, gotMod)
   237  
   238  		for i := range gotDiv.arr {
   239  			if gotDiv.arr[i] != wantDiv.arr[i] {
   240  				t.Errorf("DivMod(%s, %s) got Div %v, want Div %v", tc.x, tc.y, gotDiv, wantDiv)
   241  				break
   242  			}
   243  		}
   244  		for i := range gotMod.arr {
   245  			if gotMod.arr[i] != wantMod.arr[i] {
   246  				t.Errorf("DivMod(%s, %s) got Mod %v, want Mod %v", tc.x, tc.y, gotMod, wantMod)
   247  				break
   248  			}
   249  		}
   250  	}
   251  }
   252  
   253  func TestNeg(t *testing.T) {
   254  	tests := []struct {
   255  		x    string
   256  		want string
   257  	}{
   258  		{"31337", "115792089237316195423570985008687907853269984665640564039457584007913129608599"},
   259  		{"115792089237316195423570985008687907853269984665640564039457584007913129608599", "31337"},
   260  		{"0", "0"},
   261  		{"2", "115792089237316195423570985008687907853269984665640564039457584007913129639934"},
   262  		{"1", "115792089237316195423570985008687907853269984665640564039457584007913129639935"},
   263  	}
   264  
   265  	for _, tc := range tests {
   266  		x, err := FromDecimal(tc.x)
   267  		if err != nil {
   268  			t.Error(err)
   269  			continue
   270  		}
   271  
   272  		want, err := FromDecimal(tc.want)
   273  		if err != nil {
   274  			t.Error(err)
   275  			continue
   276  		}
   277  
   278  		got := &Uint{}
   279  		got.Neg(x)
   280  
   281  		if got.Neq(want) {
   282  			t.Errorf("Neg(%s) = %v, want %v", tc.x, got.ToString(), want.ToString())
   283  		}
   284  	}
   285  }
   286  
   287  func TestExp(t *testing.T) {
   288  	tests := []binOp2Test{
   289  		{"31337", "3", "30773171189753"},
   290  		{"31337", "0", "1"},
   291  		{"0", "31337", "0"},
   292  		{"1", "1", "1"},
   293  		{"2", "3", "8"},
   294  		{"2", "64", "18446744073709551616"},
   295  		{"2", "128", "340282366920938463463374607431768211456"},
   296  		{"2", "255", "57896044618658097711785492504343953926634992332820282019728792003956564819968"},
   297  		{"2", "256", "0"}, // overflow
   298  	}
   299  
   300  	for _, tc := range tests {
   301  		x, err := FromDecimal(tc.x)
   302  		if err != nil {
   303  			t.Error(err)
   304  			continue
   305  		}
   306  
   307  		y, err := FromDecimal(tc.y)
   308  		if err != nil {
   309  			t.Error(err)
   310  			continue
   311  		}
   312  
   313  		want, err := FromDecimal(tc.want)
   314  		if err != nil {
   315  			t.Error(err)
   316  			continue
   317  		}
   318  
   319  		got := &Uint{}
   320  		got.Exp(x, y)
   321  
   322  		if got.Neq(want) {
   323  			t.Errorf("Exp(%s, %s) = %v, want %v", tc.x, tc.y, got.ToString(), want.ToString())
   324  		}
   325  	}
   326  }