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
  55         {16, 17, "g"},
  56         {25, 25, "10"},
  57         {(((((17*35+24)*35+21)*35+34)*35+12)*35+24)*35 + 32, 35, "holycow"},
  58         {(((((17*36+24)*36+21)*36+34)*36+12)*36+24)*36 + 32, 36, "holycow"},
  59 }
  60
  61 func TestItoa(t *testing.T) {
  62         for _, test := range itob64tests {
  63                 s := FormatInt(test.in, test.base)
  64                 if s != test.out {
  65                         t.Errorf("FormatInt(%v, %v) = %v want %v",
  66                                 test.in, test.base, s, test.out)
  67                 }
  68                 x := AppendInt([]byte("abc"), test.in, test.base)
  69                 if string(x) != "abc"+test.out {
  70                         t.Errorf("AppendInt(%q, %v, %v) = %q want %v",
  71                                 "abc", test.in, test.base, x, test.out)
  72                 }
  73
  74                 if test.in >= 0 {
  75                         s := FormatUint(uint64(test.in), test.base)
  76                         if s != test.out {
  77                                 t.Errorf("FormatUint(%v, %v) = %v want %v",
  78                                         test.in, test.base, s, test.out)
  79                         }
  80                         x := AppendUint(nil, uint64(test.in), test.base)
  81                         if string(x) != test.out {
  82                                 t.Errorf("AppendUint(%q, %v, %v) = %q want %v",
  83                                         "abc", uint64(test.in), test.base, x, test.out)
  84                         }
  85                 }
  86
  87                 if test.base == 10 && int64(int(test.in)) == test.in {
  88                         s := Itoa(int(test.in))
  89                         if s != test.out {
  90                                 t.Errorf("Itoa(%v) = %v want %v",
  91                                         test.in, s, test.out)
  92                         }
  93                 }
  94         }
  95 }
  96
  97 type uitob64Test struct {
  98         in   uint64
  99         base int
 100         out  string
 101 }
 102
 103 var uitob64tests = []uitob64Test{
 104         {1<<63 - 1, 10, "9223372036854775807"},
 105         {1 << 63, 10, "9223372036854775808"},
 106         {1<<63 + 1, 10, "9223372036854775809"},
 107         {1<<64 - 2, 10, "18446744073709551614"},
 108         {1<<64 - 1, 10, "18446744073709551615"},
 109         {1<<64 - 1, 2, "1111111111111111111111111111111111111111111111111111111111111111"},
 110 }
 111
 112 func TestUitoa(t *testing.T) {
 113         for _, test := range uitob64tests {
 114                 s := FormatUint(test.in, test.base)
 115                 if s != test.out {
 116                         t.Errorf("FormatUint(%v, %v) = %v want %v",
 117                                 test.in, test.base, s, test.out)
 118                 }
 119                 x := AppendUint([]byte("abc"), test.in, test.base)
 120                 if string(x) != "abc"+test.out {
 121                         t.Errorf("AppendUint(%q, %v, %v) = %q want %v",
 122                                 "abc", test.in, test.base, x, test.out)
 123                 }
 124
 125         }
 126 }
 127
 128 func BenchmarkFormatInt(b *testing.B) {
 129         for i := 0; i < b.N; i++ {
 130                 for _, test := range itob64tests {
 131                         FormatInt(test.in, test.base)
 132                 }
 133         }
 134 }
 135
 136 func BenchmarkAppendInt(b *testing.B) {
 137         dst := make([]byte, 0, 30)
 138         for i := 0; i < b.N; i++ {
 139                 for _, test := range itob64tests {
 140                         AppendInt(dst, test.in, test.base)
 141                 }
 142         }
 143 }
 144
 145 func BenchmarkFormatUint(b *testing.B) {
 146         for i := 0; i < b.N; i++ {
 147                 for _, test := range uitob64tests {
 148                         FormatUint(test.in, test.base)
 149                 }
 150         }
 151 }
 152
 153 func BenchmarkAppendUint(b *testing.B) {
 154         dst := make([]byte, 0, 30)
 155         for i := 0; i < b.N; i++ {
 156                 for _, test := range uitob64tests {
 157                         AppendUint(dst, test.in, test.base)
 158                 }
 159         }
 160 }