libgo/go/strconv/itoa_test.go

   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 }