github.com/yanyiwu/go@v0.0.0-20150106053140-03d6637dbb7f/src/strconv/itoa_test.go (about)

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package strconv_test
     6  
     7  import (
     8  	. "strconv"
     9  	"testing"
    10  )
    11  
    12  type itob64Test struct {
    13  	in   int64
    14  	base int
    15  	out  string
    16  }
    17  
    18  var itob64tests = []itob64Test{
    19  	{0, 10, "0"},
    20  	{1, 10, "1"},
    21  	{-1, 10, "-1"},
    22  	{12345678, 10, "12345678"},
    23  	{-987654321, 10, "-987654321"},
    24  	{1<<31 - 1, 10, "2147483647"},
    25  	{-1<<31 + 1, 10, "-2147483647"},
    26  	{1 << 31, 10, "2147483648"},
    27  	{-1 << 31, 10, "-2147483648"},
    28  	{1<<31 + 1, 10, "2147483649"},
    29  	{-1<<31 - 1, 10, "-2147483649"},
    30  	{1<<32 - 1, 10, "4294967295"},
    31  	{-1<<32 + 1, 10, "-4294967295"},
    32  	{1 << 32, 10, "4294967296"},
    33  	{-1 << 32, 10, "-4294967296"},
    34  	{1<<32 + 1, 10, "4294967297"},
    35  	{-1<<32 - 1, 10, "-4294967297"},
    36  	{1 << 50, 10, "1125899906842624"},
    37  	{1<<63 - 1, 10, "9223372036854775807"},
    38  	{-1<<63 + 1, 10, "-9223372036854775807"},
    39  	{-1 << 63, 10, "-9223372036854775808"},
    40  
    41  	{0, 2, "0"},
    42  	{10, 2, "1010"},
    43  	{-1, 2, "-1"},
    44  	{1 << 15, 2, "1000000000000000"},
    45  
    46  	{-8, 8, "-10"},
    47  	{057635436545, 8, "57635436545"},
    48  	{1 << 24, 8, "100000000"},
    49  
    50  	{16, 16, "10"},
    51  	{-0x123456789abcdef, 16, "-123456789abcdef"},
    52  	{1<<63 - 1, 16, "7fffffffffffffff"},
    53  	{1<<63 - 1, 2, "111111111111111111111111111111111111111111111111111111111111111"},
    54  	{-1 << 63, 2, "-1000000000000000000000000000000000000000000000000000000000000000"},
    55  
    56  	{16, 17, "g"},
    57  	{25, 25, "10"},
    58  	{(((((17*35+24)*35+21)*35+34)*35+12)*35+24)*35 + 32, 35, "holycow"},
    59  	{(((((17*36+24)*36+21)*36+34)*36+12)*36+24)*36 + 32, 36, "holycow"},
    60  }
    61  
    62  func TestItoa(t *testing.T) {
    63  	for _, test := range itob64tests {
    64  		s := FormatInt(test.in, test.base)
    65  		if s != test.out {
    66  			t.Errorf("FormatInt(%v, %v) = %v want %v",
    67  				test.in, test.base, s, test.out)
    68  		}
    69  		x := AppendInt([]byte("abc"), test.in, test.base)
    70  		if string(x) != "abc"+test.out {
    71  			t.Errorf("AppendInt(%q, %v, %v) = %q want %v",
    72  				"abc", test.in, test.base, x, test.out)
    73  		}
    74  
    75  		if test.in >= 0 {
    76  			s := FormatUint(uint64(test.in), test.base)
    77  			if s != test.out {
    78  				t.Errorf("FormatUint(%v, %v) = %v want %v",
    79  					test.in, test.base, s, test.out)
    80  			}
    81  			x := AppendUint(nil, uint64(test.in), test.base)
    82  			if string(x) != test.out {
    83  				t.Errorf("AppendUint(%q, %v, %v) = %q want %v",
    84  					"abc", uint64(test.in), test.base, x, test.out)
    85  			}
    86  		}
    87  
    88  		if test.base == 10 && int64(int(test.in)) == test.in {
    89  			s := Itoa(int(test.in))
    90  			if s != test.out {
    91  				t.Errorf("Itoa(%v) = %v want %v",
    92  					test.in, s, test.out)
    93  			}
    94  		}
    95  	}
    96  }
    97  
    98  type uitob64Test struct {
    99  	in   uint64
   100  	base int
   101  	out  string
   102  }
   103  
   104  var uitob64tests = []uitob64Test{
   105  	{1<<63 - 1, 10, "9223372036854775807"},
   106  	{1 << 63, 10, "9223372036854775808"},
   107  	{1<<63 + 1, 10, "9223372036854775809"},
   108  	{1<<64 - 2, 10, "18446744073709551614"},
   109  	{1<<64 - 1, 10, "18446744073709551615"},
   110  	{1<<64 - 1, 2, "1111111111111111111111111111111111111111111111111111111111111111"},
   111  }
   112  
   113  func TestUitoa(t *testing.T) {
   114  	for _, test := range uitob64tests {
   115  		s := FormatUint(test.in, test.base)
   116  		if s != test.out {
   117  			t.Errorf("FormatUint(%v, %v) = %v want %v",
   118  				test.in, test.base, s, test.out)
   119  		}
   120  		x := AppendUint([]byte("abc"), test.in, test.base)
   121  		if string(x) != "abc"+test.out {
   122  			t.Errorf("AppendUint(%q, %v, %v) = %q want %v",
   123  				"abc", test.in, test.base, x, test.out)
   124  		}
   125  
   126  	}
   127  }
   128  
   129  func BenchmarkFormatInt(b *testing.B) {
   130  	for i := 0; i < b.N; i++ {
   131  		for _, test := range itob64tests {
   132  			FormatInt(test.in, test.base)
   133  		}
   134  	}
   135  }
   136  
   137  func BenchmarkAppendInt(b *testing.B) {
   138  	dst := make([]byte, 0, 30)
   139  	for i := 0; i < b.N; i++ {
   140  		for _, test := range itob64tests {
   141  			AppendInt(dst, test.in, test.base)
   142  		}
   143  	}
   144  }
   145  
   146  func BenchmarkFormatUint(b *testing.B) {
   147  	for i := 0; i < b.N; i++ {
   148  		for _, test := range uitob64tests {
   149  			FormatUint(test.in, test.base)
   150  		}
   151  	}
   152  }
   153  
   154  func BenchmarkAppendUint(b *testing.B) {
   155  	dst := make([]byte, 0, 30)
   156  	for i := 0; i < b.N; i++ {
   157  		for _, test := range uitob64tests {
   158  			AppendUint(dst, test.in, test.base)
   159  		}
   160  	}
   161  }