bitbucket.org/ai69/amoy@v0.2.3/strconv_test.go (about)

     1  package amoy
     2  
     3  import "testing"
     4  
     5  func TestItoa(t *testing.T) {
     6  	tests := []struct {
     7  		name string
     8  		i    int
     9  		want string
    10  	}{
    11  		{"zero", 0, "0"},
    12  		{"one", 1, "1"},
    13  		{"ten", 10, "10"},
    14  		{"1024", 1024, "1024"},
    15  		{"min int32", -2147483648, "-2147483648"},
    16  		{"min int64", -9223372036854775808, "-9223372036854775808"},
    17  		{"max int32", 2147483647, "2147483647"},
    18  		{"max int64", 9223372036854775807, "9223372036854775807"},
    19  	}
    20  	for _, tt := range tests {
    21  		t.Run(tt.name, func(t *testing.T) {
    22  			if got := Itoa(tt.i); got != tt.want {
    23  				t.Errorf("Itoa() = %v, want %v", got, tt.want)
    24  			}
    25  		})
    26  	}
    27  }
    28  
    29  func TestItoa64(t *testing.T) {
    30  	tests := []struct {
    31  		name string
    32  		i    int64
    33  		want string
    34  	}{
    35  		{"zero", 0, "0"},
    36  		{"one", 1, "1"},
    37  		{"ten", 10, "10"},
    38  		{"1024", 1024, "1024"},
    39  		{"min int32", -2147483648, "-2147483648"},
    40  		{"min int64", -9223372036854775808, "-9223372036854775808"},
    41  		{"max int32", 2147483647, "2147483647"},
    42  		{"max int64", 9223372036854775807, "9223372036854775807"},
    43  	}
    44  	for _, tt := range tests {
    45  		t.Run(tt.name, func(t *testing.T) {
    46  			if got := Itoa64(tt.i); got != tt.want {
    47  				t.Errorf("Itoa64() = %v, want %v", got, tt.want)
    48  			}
    49  		})
    50  	}
    51  }
    52  
    53  func TestItoa32(t *testing.T) {
    54  	tests := []struct {
    55  		name string
    56  		i    int32
    57  		want string
    58  	}{
    59  		{"zero", 0, "0"},
    60  		{"one", 1, "1"},
    61  		{"ten", 10, "10"},
    62  		{"1024", 1024, "1024"},
    63  		{"min int32", -2147483648, "-2147483648"},
    64  		{"max int32", 2147483647, "2147483647"},
    65  	}
    66  	for _, tt := range tests {
    67  		t.Run(tt.name, func(t *testing.T) {
    68  			if got := Itoa32(tt.i); got != tt.want {
    69  				t.Errorf("Itoa32() = %v, want %v", got, tt.want)
    70  			}
    71  		})
    72  	}
    73  }
    74  
    75  func TestItoa16(t *testing.T) {
    76  	tests := []struct {
    77  		name string
    78  		i    int16
    79  		want string
    80  	}{
    81  		{"zero", 0, "0"},
    82  		{"one", 1, "1"},
    83  		{"ten", 10, "10"},
    84  		{"1024", 1024, "1024"},
    85  		{"min int16", -32768, "-32768"},
    86  		{"max int16", 32767, "32767"},
    87  	}
    88  	for _, tt := range tests {
    89  		t.Run(tt.name, func(t *testing.T) {
    90  			if got := Itoa16(tt.i); got != tt.want {
    91  				t.Errorf("Itoa16() = %v, want %v", got, tt.want)
    92  			}
    93  		})
    94  	}
    95  }
    96  
    97  func TestItoa8(t *testing.T) {
    98  	tests := []struct {
    99  		name string
   100  		i    int8
   101  		want string
   102  	}{
   103  		{"zero", 0, "0"},
   104  		{"one", 1, "1"},
   105  		{"ten", 10, "10"},
   106  		{"102", 102, "102"},
   107  		{"min int8", -128, "-128"},
   108  		{"max int8", 127, "127"},
   109  	}
   110  	for _, tt := range tests {
   111  		t.Run(tt.name, func(t *testing.T) {
   112  			if got := Itoa8(tt.i); got != tt.want {
   113  				t.Errorf("Itoa8() = %v, want %v", got, tt.want)
   114  			}
   115  		})
   116  	}
   117  }
   118  
   119  func TestUtoa(t *testing.T) {
   120  	tests := []struct {
   121  		name string
   122  		i    uint
   123  		want string
   124  	}{
   125  		{"zero", 0, "0"},
   126  		{"one", 1, "1"},
   127  		{"ten", 10, "10"},
   128  		{"1024", 1024, "1024"},
   129  		{"max uint32", 4294967295, "4294967295"},
   130  		{"max uint64", 18446744073709551615, "18446744073709551615"},
   131  	}
   132  	for _, tt := range tests {
   133  		t.Run(tt.name, func(t *testing.T) {
   134  			if got := Utoa(tt.i); got != tt.want {
   135  				t.Errorf("Utoa() = %v, want %v", got, tt.want)
   136  			}
   137  		})
   138  	}
   139  }
   140  
   141  func TestUtoa64(t *testing.T) {
   142  	tests := []struct {
   143  		name string
   144  		i    uint64
   145  		want string
   146  	}{
   147  		{"zero", 0, "0"},
   148  		{"one", 1, "1"},
   149  		{"ten", 10, "10"},
   150  		{"1024", 1024, "1024"},
   151  		{"max uint32", 4294967295, "4294967295"},
   152  		{"max uint64", 18446744073709551615, "18446744073709551615"},
   153  	}
   154  	for _, tt := range tests {
   155  		t.Run(tt.name, func(t *testing.T) {
   156  			if got := Utoa64(tt.i); got != tt.want {
   157  				t.Errorf("Utoa64() = %v, want %v", got, tt.want)
   158  			}
   159  		})
   160  	}
   161  }
   162  
   163  func TestUtoa32(t *testing.T) {
   164  	tests := []struct {
   165  		name string
   166  		i    uint32
   167  		want string
   168  	}{
   169  		{"zero", 0, "0"},
   170  		{"one", 1, "1"},
   171  		{"ten", 10, "10"},
   172  		{"1024", 1024, "1024"},
   173  		{"max uint32", 4294967295, "4294967295"},
   174  	}
   175  	for _, tt := range tests {
   176  		t.Run(tt.name, func(t *testing.T) {
   177  			if got := Utoa32(tt.i); got != tt.want {
   178  				t.Errorf("Utoa32() = %v, want %v", got, tt.want)
   179  			}
   180  		})
   181  	}
   182  }
   183  
   184  func TestUtoa16(t *testing.T) {
   185  	tests := []struct {
   186  		name string
   187  		u    uint16
   188  		want string
   189  	}{
   190  		{"zero", 0, "0"},
   191  		{"one", 1, "1"},
   192  		{"max uint16", 65535, "65535"},
   193  	}
   194  	for _, tt := range tests {
   195  		t.Run(tt.name, func(t *testing.T) {
   196  			if got := Utoa16(tt.u); got != tt.want {
   197  				t.Errorf("Utoa16() = %v, want %v", got, tt.want)
   198  			}
   199  		})
   200  	}
   201  }
   202  
   203  func TestUtoa8(t *testing.T) {
   204  	tests := []struct {
   205  		name string
   206  		u    uint8
   207  		want string
   208  	}{
   209  		{"zero", 0, "0"},
   210  		{"one", 1, "1"},
   211  		{"max uint8", 255, "255"},
   212  	}
   213  	for _, tt := range tests {
   214  		t.Run(tt.name, func(t *testing.T) {
   215  			if got := Utoa8(tt.u); got != tt.want {
   216  				t.Errorf("Utoa8() = %v, want %v", got, tt.want)
   217  			}
   218  		})
   219  	}
   220  }
   221  
   222  func TestAtoi(t *testing.T) {
   223  	tests := []struct {
   224  		name    string
   225  		s       string
   226  		want    int
   227  		wantErr bool
   228  	}{
   229  		{"invalid char", "dac21c", 0, true},
   230  		{"invalid 1,024", "1,024", 0, true},
   231  		{"zero", "0", 0, false},
   232  		{"one", "1", 1, false},
   233  		{"min int32", "-2147483648", -2147483648, false},
   234  		{"< min int32", "-2147483650", -2147483650, false},
   235  		{"min int64", "-9223372036854775808", -9223372036854775808, false},
   236  		{"< min int64", "-9223372036854775809", -9223372036854775808, true},
   237  		{"max int32", "2147483647", 2147483647, false},
   238  		{"> max int32", "2147483649", 2147483649, false},
   239  		{"max int64", "9223372036854775807", 9223372036854775807, false},
   240  		{"> max int64", "9223372036854775808", 9223372036854775807, true},
   241  	}
   242  	for _, tt := range tests {
   243  		t.Run(tt.name, func(t *testing.T) {
   244  			got, err := Atoi(tt.s)
   245  			if (err != nil) != tt.wantErr {
   246  				t.Errorf("Atoi() error = %v, wantErr %v", err, tt.wantErr)
   247  				return
   248  			}
   249  			if got != tt.want {
   250  				t.Errorf("Atoi() got = %v, want %v", got, tt.want)
   251  			}
   252  		})
   253  	}
   254  }
   255  
   256  func TestAtoi64(t *testing.T) {
   257  	tests := []struct {
   258  		name    string
   259  		s       string
   260  		want    int64
   261  		wantErr bool
   262  	}{
   263  		{"invalid char", "dac21c", 0, true},
   264  		{"invalid 1,024", "1,024", 0, true},
   265  		{"zero", "0", 0, false},
   266  		{"one", "1", 1, false},
   267  		{"min int32", "-2147483648", -2147483648, false},
   268  		{"< min int32", "-2147483650", -2147483650, false},
   269  		{"min int64", "-9223372036854775808", -9223372036854775808, false},
   270  		{"< min int64", "-9223372036854775809", -9223372036854775808, true},
   271  		{"max int32", "2147483647", 2147483647, false},
   272  		{"> max int32", "2147483649", 2147483649, false},
   273  		{"max int64", "9223372036854775807", 9223372036854775807, false},
   274  		{"> max int64", "9223372036854775808", 9223372036854775807, true},
   275  	}
   276  	for _, tt := range tests {
   277  		t.Run(tt.name, func(t *testing.T) {
   278  			got, err := Atoi64(tt.s)
   279  			if (err != nil) != tt.wantErr {
   280  				t.Errorf("Atoi64() error = %v, wantErr %v", err, tt.wantErr)
   281  				return
   282  			}
   283  			if got != tt.want {
   284  				t.Errorf("Atoi64() got = %v, want %v", got, tt.want)
   285  			}
   286  		})
   287  	}
   288  }
   289  
   290  func TestAtoi32(t *testing.T) {
   291  	tests := []struct {
   292  		name    string
   293  		s       string
   294  		want    int32
   295  		wantErr bool
   296  	}{
   297  		{"invalid char", "dac21c", 0, true},
   298  		{"invalid 1,024", "1,024", 0, true},
   299  		{"zero", "0", 0, false},
   300  		{"one", "1", 1, false},
   301  		{"min int32", "-2147483648", -2147483648, false},
   302  		{"< min int32", "-2147483650", 0, true},
   303  		{"max int32", "2147483647", 2147483647, false},
   304  		{"> max int32", "2147483649", 0, true},
   305  	}
   306  	for _, tt := range tests {
   307  		t.Run(tt.name, func(t *testing.T) {
   308  			got, err := Atoi32(tt.s)
   309  			if (err != nil) != tt.wantErr {
   310  				t.Errorf("Atoi32() error = %v, wantErr %v", err, tt.wantErr)
   311  				return
   312  			}
   313  			if got != tt.want {
   314  				t.Errorf("Atoi32() got = %v, want %v", got, tt.want)
   315  			}
   316  		})
   317  	}
   318  }
   319  
   320  func TestAtoi16(t *testing.T) {
   321  	tests := []struct {
   322  		name    string
   323  		s       string
   324  		want    int16
   325  		wantErr bool
   326  	}{
   327  		{"invalid char", "dac21c", 0, true},
   328  		{"invalid 1,024", "1,024", 0, true},
   329  		{"zero", "0", 0, false},
   330  		{"one", "1", 1, false},
   331  		{"min int16", "-32768", -32768, false},
   332  		{"< min int16", "-32770", 0, true},
   333  		{"max int16", "32767", 32767, false},
   334  		{"> max int16", "32769", 0, true},
   335  	}
   336  	for _, tt := range tests {
   337  		t.Run(tt.name, func(t *testing.T) {
   338  			got, err := Atoi16(tt.s)
   339  			if (err != nil) != tt.wantErr {
   340  				t.Errorf("Atoi16() error = %v, wantErr %v", err, tt.wantErr)
   341  				return
   342  			}
   343  			if got != tt.want {
   344  				t.Errorf("Atoi16() got = %v, want %v", got, tt.want)
   345  			}
   346  		})
   347  	}
   348  }
   349  
   350  func TestAtoi8(t *testing.T) {
   351  	tests := []struct {
   352  		name    string
   353  		s       string
   354  		want    int8
   355  		wantErr bool
   356  	}{
   357  		{"invalid char", "dac21c", 0, true},
   358  		{"invalid 1,024", "1,024", 0, true},
   359  		{"zero", "0", 0, false},
   360  		{"one", "1", 1, false},
   361  		{"min int8", "-128", -128, false},
   362  		{"< min int8", "-130", 0, true},
   363  		{"max int8", "127", 127, false},
   364  		{"> max int8", "129", 0, true},
   365  	}
   366  	for _, tt := range tests {
   367  		t.Run(tt.name, func(t *testing.T) {
   368  			got, err := Atoi8(tt.s)
   369  			if (err != nil) != tt.wantErr {
   370  				t.Errorf("Atoi8() error = %v, wantErr %v", err, tt.wantErr)
   371  				return
   372  			}
   373  			if got != tt.want {
   374  				t.Errorf("Atoi8() got = %v, want %v", got, tt.want)
   375  			}
   376  		})
   377  	}
   378  }
   379  
   380  func TestAtou(t *testing.T) {
   381  	tests := []struct {
   382  		name    string
   383  		s       string
   384  		want    uint
   385  		wantErr bool
   386  	}{
   387  		{"invalid char", "dac21c", 0, true},
   388  		{"invalid 1,024", "1,024", 0, true},
   389  		{"zero", "0", 0, false},
   390  		{"one", "1", 1, false},
   391  		{"max uint32", "4294967295", 4294967295, false},
   392  		{"> max uint32", "4294967296", 4294967296, false},
   393  		{"max uint64", "18446744073709551615", 18446744073709551615, false},
   394  		{"> max uint64", "18446744073709551616", 0, true},
   395  	}
   396  	for _, tt := range tests {
   397  		t.Run(tt.name, func(t *testing.T) {
   398  			got, err := Atou(tt.s)
   399  			if (err != nil) != tt.wantErr {
   400  				t.Errorf("Atou() error = %v, wantErr %v", err, tt.wantErr)
   401  				return
   402  			}
   403  			if got != tt.want {
   404  				t.Errorf("Atou() got = %v, want %v", got, tt.want)
   405  			}
   406  		})
   407  	}
   408  }
   409  
   410  func TestAtou64(t *testing.T) {
   411  	tests := []struct {
   412  		name    string
   413  		s       string
   414  		want    uint64
   415  		wantErr bool
   416  	}{
   417  		{"invalid char", "dac21c", 0, true},
   418  		{"invalid 1,024", "1,024", 0, true},
   419  		{"zero", "0", 0, false},
   420  		{"one", "1", 1, false},
   421  		{"max uint32", "4294967295", 4294967295, false},
   422  		{"> max uint32", "4294967296", 4294967296, false},
   423  		{"max uint64", "18446744073709551615", 18446744073709551615, false},
   424  		{"> max uint64", "18446744073709551616", 18446744073709551615, true},
   425  	}
   426  	for _, tt := range tests {
   427  		t.Run(tt.name, func(t *testing.T) {
   428  			got, err := Atou64(tt.s)
   429  			if (err != nil) != tt.wantErr {
   430  				t.Errorf("Atou64() error = %v, wantErr %v", err, tt.wantErr)
   431  				return
   432  			}
   433  			if got != tt.want {
   434  				t.Errorf("Atou64() got = %v, want %v", got, tt.want)
   435  			}
   436  		})
   437  	}
   438  }
   439  
   440  func TestAtou32(t *testing.T) {
   441  	tests := []struct {
   442  		name    string
   443  		s       string
   444  		want    uint32
   445  		wantErr bool
   446  	}{
   447  		{"invalid char", "dac21c", 0, true},
   448  		{"invalid 1,024", "1,024", 0, true},
   449  		{"zero", "0", 0, false},
   450  		{"one", "1", 1, false},
   451  		{"max uint32", "4294967295", 4294967295, false},
   452  		{"> max uint32", "4294967296", 0, true},
   453  	}
   454  	for _, tt := range tests {
   455  		t.Run(tt.name, func(t *testing.T) {
   456  			got, err := Atou32(tt.s)
   457  			if (err != nil) != tt.wantErr {
   458  				t.Errorf("Atou32() error = %v, wantErr %v", err, tt.wantErr)
   459  				return
   460  			}
   461  			if got != tt.want {
   462  				t.Errorf("Atou32() got = %v, want %v", got, tt.want)
   463  			}
   464  		})
   465  	}
   466  }
   467  
   468  func TestAtou16(t *testing.T) {
   469  	tests := []struct {
   470  		name    string
   471  		s       string
   472  		want    uint16
   473  		wantErr bool
   474  	}{
   475  		{"invalid char", "dac21c", 0, true},
   476  		{"invalid 1,024", "1,024", 0, true},
   477  		{"zero", "0", 0, false},
   478  		{"one", "1", 1, false},
   479  		{"max uint16", "65535", 65535, false},
   480  		{"> max uint16", "65536", 0, true},
   481  	}
   482  	for _, tt := range tests {
   483  		t.Run(tt.name, func(t *testing.T) {
   484  			got, err := Atou16(tt.s)
   485  			if (err != nil) != tt.wantErr {
   486  				t.Errorf("Atou16() error = %v, wantErr %v", err, tt.wantErr)
   487  				return
   488  			}
   489  			if got != tt.want {
   490  				t.Errorf("Atou16() got = %v, want %v", got, tt.want)
   491  			}
   492  		})
   493  	}
   494  }
   495  
   496  func TestAtou8(t *testing.T) {
   497  	tests := []struct {
   498  		name    string
   499  		s       string
   500  		want    uint8
   501  		wantErr bool
   502  	}{
   503  		{"invalid char", "dac21c", 0, true},
   504  		{"invalid 1,024", "1,024", 0, true},
   505  		{"zero", "0", 0, false},
   506  		{"one", "1", 1, false},
   507  		{"max uint8", "255", 255, false},
   508  		{"> max uint8", "256", 0, true},
   509  	}
   510  	for _, tt := range tests {
   511  		t.Run(tt.name, func(t *testing.T) {
   512  			got, err := Atou8(tt.s)
   513  			if (err != nil) != tt.wantErr {
   514  				t.Errorf("Atou8() error = %v, wantErr %v", err, tt.wantErr)
   515  				return
   516  			}
   517  			if got != tt.want {
   518  				t.Errorf("Atou8() got = %v, want %v", got, tt.want)
   519  			}
   520  		})
   521  	}
   522  }
   523  
   524  func TestAtof64(t *testing.T) {
   525  	tests := []struct {
   526  		name    string
   527  		s       string
   528  		want    float64
   529  		wantErr bool
   530  	}{
   531  		{"invalid char", "dac21c", 0, true},
   532  		{"invalid 1,024", "1,024", 0, true},
   533  		{"zero", "0", 0, false},
   534  		{"one", "1", 1, false},
   535  		{"max float64", "1.7976931348623157e+308", 1.7976931348623157e+308, false},
   536  		{"> max float64", "1.7976931348623158e+309", 0, true},
   537  	}
   538  	for _, tt := range tests {
   539  		t.Run(tt.name, func(t *testing.T) {
   540  			got, err := Atof64(tt.s)
   541  			if (err != nil) != tt.wantErr {
   542  				t.Errorf("Atof64() error = %v, wantErr %v", err, tt.wantErr)
   543  				return
   544  			}
   545  			if got != tt.want {
   546  				t.Errorf("Atof64() got = %v, want %v", got, tt.want)
   547  			}
   548  		})
   549  	}
   550  }
   551  
   552  func TestAtof32(t *testing.T) {
   553  	tests := []struct {
   554  		name    string
   555  		s       string
   556  		want    float32
   557  		wantErr bool
   558  	}{
   559  		{"invalid char", "dac21c", 0, true},
   560  		{"invalid 1,024", "1,024", 0, true},
   561  		{"zero", "0", 0, false},
   562  		{"one", "1", 1, false},
   563  		{"max float32", "3.4028235e+38", 3.4028235e+38, false},
   564  		{"> max float32", "3.4028236e+38", 0, true},
   565  	}
   566  	for _, tt := range tests {
   567  		t.Run(tt.name, func(t *testing.T) {
   568  			got, err := Atof32(tt.s)
   569  			if (err != nil) != tt.wantErr {
   570  				t.Errorf("Atof32() error = %v, wantErr %v", err, tt.wantErr)
   571  				return
   572  			}
   573  			if got != tt.want {
   574  				t.Errorf("Atof32() got = %v, want %v", got, tt.want)
   575  			}
   576  		})
   577  	}
   578  }