libgo/go/runtime/string_test.go

   1 // Copyright 2012 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 runtime_test
   6
   7 import (
   8         "strings"
   9         "testing"
  10 )
  11
  12 func BenchmarkCompareStringEqual(b *testing.B) {
  13         bytes := []byte("Hello Gophers!")
  14         s1, s2 := string(bytes), string(bytes)
  15         for i := 0; i < b.N; i++ {
  16                 if s1 != s2 {
  17                         b.Fatal("s1 != s2")
  18                 }
  19         }
  20 }
  21
  22 func BenchmarkCompareStringIdentical(b *testing.B) {
  23         s1 := "Hello Gophers!"
  24         s2 := s1
  25         for i := 0; i < b.N; i++ {
  26                 if s1 != s2 {
  27                         b.Fatal("s1 != s2")
  28                 }
  29         }
  30 }
  31
  32 func BenchmarkCompareStringSameLength(b *testing.B) {
  33         s1 := "Hello Gophers!"
  34         s2 := "Hello, Gophers"
  35         for i := 0; i < b.N; i++ {
  36                 if s1 == s2 {
  37                         b.Fatal("s1 == s2")
  38                 }
  39         }
  40 }
  41
  42 func BenchmarkCompareStringDifferentLength(b *testing.B) {
  43         s1 := "Hello Gophers!"
  44         s2 := "Hello, Gophers!"
  45         for i := 0; i < b.N; i++ {
  46                 if s1 == s2 {
  47                         b.Fatal("s1 == s2")
  48                 }
  49         }
  50 }
  51
  52 func BenchmarkCompareStringBigUnaligned(b *testing.B) {
  53         bytes := make([]byte, 0, 1<<20)
  54         for len(bytes) < 1<<20 {
  55                 bytes = append(bytes, "Hello Gophers!"...)
  56         }
  57         s1, s2 := string(bytes), "hello"+string(bytes)
  58         for i := 0; i < b.N; i++ {
  59                 if s1 != s2[len("hello"):] {
  60                         b.Fatal("s1 != s2")
  61                 }
  62         }
  63         b.SetBytes(int64(len(s1)))
  64 }
  65
  66 func BenchmarkCompareStringBig(b *testing.B) {
  67         bytes := make([]byte, 0, 1<<20)
  68         for len(bytes) < 1<<20 {
  69                 bytes = append(bytes, "Hello Gophers!"...)
  70         }
  71         s1, s2 := string(bytes), string(bytes)
  72         for i := 0; i < b.N; i++ {
  73                 if s1 != s2 {
  74                         b.Fatal("s1 != s2")
  75                 }
  76         }
  77         b.SetBytes(int64(len(s1)))
  78 }
  79
  80 func BenchmarkRuneIterate(b *testing.B) {
  81         bytes := make([]byte, 100)
  82         for i := range bytes {
  83                 bytes[i] = byte('A')
  84         }
  85         s := string(bytes)
  86         for i := 0; i < b.N; i++ {
  87                 for range s {
  88                 }
  89         }
  90 }
  91
  92 func BenchmarkRuneIterate2(b *testing.B) {
  93         bytes := make([]byte, 100)
  94         for i := range bytes {
  95                 bytes[i] = byte('A')
  96         }
  97         s := string(bytes)
  98         for i := 0; i < b.N; i++ {
  99                 for range s {
 100                 }
 101         }
 102 }
 103
 104 /*
 105 func TestStringW(t *testing.T) {
 106         strings := []string{
 107                 "hello",
 108                 "a\u5566\u7788b",
 109         }
 110
 111         for _, s := range strings {
 112                 var b []uint16
 113                 for _, c := range s {
 114                         b = append(b, uint16(c))
 115                         if c != rune(uint16(c)) {
 116                                 t.Errorf("bad test: stringW can't handle >16 bit runes")
 117                         }
 118                 }
 119                 b = append(b, 0)
 120                 r := runtime.GostringW(b)
 121                 if r != s {
 122                         t.Errorf("gostringW(%v) = %s, want %s", b, r, s)
 123                 }
 124         }
 125 }
 126 */
 127
 128 func TestLargeStringConcat(t *testing.T) {
 129         output := runTestProg(t, "testprog", "stringconcat")
 130         want := "panic: " + strings.Repeat("0", 1<<10) + strings.Repeat("1", 1<<10) +
 131                 strings.Repeat("2", 1<<10) + strings.Repeat("3", 1<<10)
 132         if !strings.HasPrefix(output, want) {
 133                 t.Fatalf("output does not start with %q:\n%s", want, output)
 134         }
 135 }
 136
 137 /*
 138 func TestGostringnocopy(t *testing.T) {
 139         max := *runtime.Maxstring
 140         b := make([]byte, max+10)
 141         for i := uintptr(0); i < max+9; i++ {
 142                 b[i] = 'a'
 143         }
 144         _ = runtime.Gostringnocopy(&b[0])
 145         newmax := *runtime.Maxstring
 146         if newmax != max+9 {
 147                 t.Errorf("want %d, got %d", max+9, newmax)
 148         }
 149 }
 150 */
 151
 152 func TestCompareTempString(t *testing.T) {
 153         s := "foo"
 154         b := []byte(s)
 155         n := testing.AllocsPerRun(1000, func() {
 156                 if string(b) != s {
 157                         t.Fatalf("strings are not equal: '%v' and '%v'", string(b), s)
 158                 }
 159                 if string(b) == s {
 160                 } else {
 161                         t.Fatalf("strings are not equal: '%v' and '%v'", string(b), s)
 162                 }
 163         })
 164         if n != 0 {
 165                 t.Fatalf("want 0 allocs, got %v", n)
 166         }
 167 }
 168
 169 func TestStringOnStack(t *testing.T) {
 170         s := ""
 171         for i := 0; i < 3; i++ {
 172                 s = "a" + s + "b" + s + "c"
 173         }
 174
 175         if want := "aaabcbabccbaabcbabccc"; s != want {
 176                 t.Fatalf("want: '%v', got '%v'", want, s)
 177         }
 178 }
 179
 180 func TestIntString(t *testing.T) {
 181         // Non-escaping result of intstring.
 182         s := ""
 183         for i := 0; i < 4; i++ {
 184                 s += string(i+'0') + string(i+'0'+1)
 185         }
 186         if want := "01122334"; s != want {
 187                 t.Fatalf("want '%v', got '%v'", want, s)
 188         }
 189
 190         // Escaping result of intstring.
 191         var a [4]string
 192         for i := 0; i < 4; i++ {
 193                 a[i] = string(i + '0')
 194         }
 195         s = a[0] + a[1] + a[2] + a[3]
 196         if want := "0123"; s != want {
 197                 t.Fatalf("want '%v', got '%v'", want, s)
 198         }
 199 }
 200
 201 func TestIntStringAllocs(t *testing.T) {
 202         unknown := '0'
 203         n := testing.AllocsPerRun(1000, func() {
 204                 s1 := string(unknown)
 205                 s2 := string(unknown + 1)
 206                 if s1 == s2 {
 207                         t.Fatalf("bad")
 208                 }
 209         })
 210         if n != 0 {
 211                 t.Fatalf("want 0 allocs, got %v", n)
 212         }
 213 }
 214
 215 func TestRangeStringCast(t *testing.T) {
 216         s := "abc"
 217         n := testing.AllocsPerRun(1000, func() {
 218                 for i, c := range []byte(s) {
 219                         if c != s[i] {
 220                                 t.Fatalf("want '%c' at pos %v, got '%c'", s[i], i, c)
 221                         }
 222                 }
 223         })
 224         if n != 0 {
 225                 t.Fatalf("want 0 allocs, got %v", n)
 226         }
 227 }
 228
 229 func TestString2Slice(t *testing.T) {
 230         // Make sure we don't return slices that expose
 231         // an unzeroed section of stack-allocated temp buf
 232         // between len and cap.  See issue 14232.
 233         s := "foož"
 234         b := ([]byte)(s)
 235         if cap(b) != 5 {
 236                 t.Errorf("want cap of 5, got %d", cap(b))
 237         }
 238         r := ([]rune)(s)
 239         if cap(r) != 4 {
 240                 t.Errorf("want cap of 4, got %d", cap(r))
 241         }
 242 }