Source file src/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  	"runtime"
     9  	"strconv"
    10  	"strings"
    11  	"testing"
    12  	"unicode/utf8"
    13  )
    14  
    15  // Strings and slices that don't escape and fit into tmpBuf are stack allocated,
    16  // which defeats using AllocsPerRun to test other optimizations.
    17  const sizeNoStack = 100
    18  
    19  func BenchmarkCompareStringEqual(b *testing.B) {
    20  	bytes := []byte("Hello Gophers!")
    21  	s1, s2 := string(bytes), string(bytes)
    22  	for i := 0; i < b.N; i++ {
    23  		if s1 != s2 {
    24  			b.Fatal("s1 != s2")
    25  		}
    26  	}
    27  }
    28  
    29  func BenchmarkCompareStringIdentical(b *testing.B) {
    30  	s1 := "Hello Gophers!"
    31  	s2 := s1
    32  	for i := 0; i < b.N; i++ {
    33  		if s1 != s2 {
    34  			b.Fatal("s1 != s2")
    35  		}
    36  	}
    37  }
    38  
    39  func BenchmarkCompareStringSameLength(b *testing.B) {
    40  	s1 := "Hello Gophers!"
    41  	s2 := "Hello, Gophers"
    42  	for i := 0; i < b.N; i++ {
    43  		if s1 == s2 {
    44  			b.Fatal("s1 == s2")
    45  		}
    46  	}
    47  }
    48  
    49  func BenchmarkCompareStringDifferentLength(b *testing.B) {
    50  	s1 := "Hello Gophers!"
    51  	s2 := "Hello, Gophers!"
    52  	for i := 0; i < b.N; i++ {
    53  		if s1 == s2 {
    54  			b.Fatal("s1 == s2")
    55  		}
    56  	}
    57  }
    58  
    59  func BenchmarkCompareStringBigUnaligned(b *testing.B) {
    60  	bytes := make([]byte, 0, 1<<20)
    61  	for len(bytes) < 1<<20 {
    62  		bytes = append(bytes, "Hello Gophers!"...)
    63  	}
    64  	s1, s2 := string(bytes), "hello"+string(bytes)
    65  	for i := 0; i < b.N; i++ {
    66  		if s1 != s2[len("hello"):] {
    67  			b.Fatal("s1 != s2")
    68  		}
    69  	}
    70  	b.SetBytes(int64(len(s1)))
    71  }
    72  
    73  func BenchmarkCompareStringBig(b *testing.B) {
    74  	bytes := make([]byte, 0, 1<<20)
    75  	for len(bytes) < 1<<20 {
    76  		bytes = append(bytes, "Hello Gophers!"...)
    77  	}
    78  	s1, s2 := string(bytes), string(bytes)
    79  	for i := 0; i < b.N; i++ {
    80  		if s1 != s2 {
    81  			b.Fatal("s1 != s2")
    82  		}
    83  	}
    84  	b.SetBytes(int64(len(s1)))
    85  }
    86  
    87  func BenchmarkConcatStringAndBytes(b *testing.B) {
    88  	s1 := []byte("Gophers!")
    89  	for i := 0; i < b.N; i++ {
    90  		_ = "Hello " + string(s1)
    91  	}
    92  }
    93  
    94  var escapeString string
    95  
    96  func BenchmarkSliceByteToString(b *testing.B) {
    97  	buf := []byte{'!'}
    98  	for n := 0; n < 8; n++ {
    99  		b.Run(strconv.Itoa(len(buf)), func(b *testing.B) {
   100  			for i := 0; i < b.N; i++ {
   101  				escapeString = string(buf)
   102  			}
   103  		})
   104  		buf = append(buf, buf...)
   105  	}
   106  }
   107  
   108  var stringdata = []struct{ name, data string }{
   109  	{"ASCII", "01234567890"},
   110  	{"Japanese", "日本語日本語日本語"},
   111  	{"MixedLength", "$Ѐࠀက퀀𐀀\U00040000\U0010FFFF"},
   112  }
   113  
   114  var sinkInt int
   115  
   116  func BenchmarkRuneCount(b *testing.B) {
   117  	// Each sub-benchmark counts the runes in a string in a different way.
   118  	b.Run("lenruneslice", func(b *testing.B) {
   119  		for _, sd := range stringdata {
   120  			b.Run(sd.name, func(b *testing.B) {
   121  				for i := 0; i < b.N; i++ {
   122  					sinkInt += len([]rune(sd.data))
   123  				}
   124  			})
   125  		}
   126  	})
   127  	b.Run("rangeloop", func(b *testing.B) {
   128  		for _, sd := range stringdata {
   129  			b.Run(sd.name, func(b *testing.B) {
   130  				for i := 0; i < b.N; i++ {
   131  					n := 0
   132  					for range sd.data {
   133  						n++
   134  					}
   135  					sinkInt += n
   136  				}
   137  			})
   138  		}
   139  	})
   140  	b.Run("utf8.RuneCountInString", func(b *testing.B) {
   141  		for _, sd := range stringdata {
   142  			b.Run(sd.name, func(b *testing.B) {
   143  				for i := 0; i < b.N; i++ {
   144  					sinkInt += utf8.RuneCountInString(sd.data)
   145  				}
   146  			})
   147  		}
   148  	})
   149  }
   150  
   151  func BenchmarkRuneIterate(b *testing.B) {
   152  	b.Run("range", func(b *testing.B) {
   153  		for _, sd := range stringdata {
   154  			b.Run(sd.name, func(b *testing.B) {
   155  				for i := 0; i < b.N; i++ {
   156  					for range sd.data {
   157  					}
   158  				}
   159  			})
   160  		}
   161  	})
   162  	b.Run("range1", func(b *testing.B) {
   163  		for _, sd := range stringdata {
   164  			b.Run(sd.name, func(b *testing.B) {
   165  				for i := 0; i < b.N; i++ {
   166  					for range sd.data {
   167  					}
   168  				}
   169  			})
   170  		}
   171  	})
   172  	b.Run("range2", func(b *testing.B) {
   173  		for _, sd := range stringdata {
   174  			b.Run(sd.name, func(b *testing.B) {
   175  				for i := 0; i < b.N; i++ {
   176  					for range sd.data {
   177  					}
   178  				}
   179  			})
   180  		}
   181  	})
   182  }
   183  
   184  func BenchmarkArrayEqual(b *testing.B) {
   185  	a1 := [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
   186  	a2 := [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
   187  	b.ResetTimer()
   188  	for i := 0; i < b.N; i++ {
   189  		if a1 != a2 {
   190  			b.Fatal("not equal")
   191  		}
   192  	}
   193  }
   194  
   195  func TestStringW(t *testing.T) {
   196  	strings := []string{
   197  		"hello",
   198  		"a\u5566\u7788b",
   199  	}
   200  
   201  	for _, s := range strings {
   202  		var b []uint16
   203  		for _, c := range s {
   204  			b = append(b, uint16(c))
   205  			if c != rune(uint16(c)) {
   206  				t.Errorf("bad test: stringW can't handle >16 bit runes")
   207  			}
   208  		}
   209  		b = append(b, 0)
   210  		r := runtime.GostringW(b)
   211  		if r != s {
   212  			t.Errorf("gostringW(%v) = %s, want %s", b, r, s)
   213  		}
   214  	}
   215  }
   216  
   217  func TestLargeStringConcat(t *testing.T) {
   218  	output := runTestProg(t, "testprog", "stringconcat")
   219  	want := "panic: " + strings.Repeat("0", 1<<10) + strings.Repeat("1", 1<<10) +
   220  		strings.Repeat("2", 1<<10) + strings.Repeat("3", 1<<10)
   221  	if !strings.HasPrefix(output, want) {
   222  		t.Fatalf("output does not start with %q:\n%s", want, output)
   223  	}
   224  }
   225  
   226  func TestCompareTempString(t *testing.T) {
   227  	s := strings.Repeat("x", sizeNoStack)
   228  	b := []byte(s)
   229  	n := testing.AllocsPerRun(1000, func() {
   230  		if string(b) != s {
   231  			t.Fatalf("strings are not equal: '%v' and '%v'", string(b), s)
   232  		}
   233  		if string(b) == s {
   234  		} else {
   235  			t.Fatalf("strings are not equal: '%v' and '%v'", string(b), s)
   236  		}
   237  	})
   238  	if n != 0 {
   239  		t.Fatalf("want 0 allocs, got %v", n)
   240  	}
   241  }
   242  
   243  func TestStringIndexHaystack(t *testing.T) {
   244  	// See issue 25864.
   245  	haystack := []byte("hello")
   246  	needle := "ll"
   247  	n := testing.AllocsPerRun(1000, func() {
   248  		if strings.Index(string(haystack), needle) != 2 {
   249  			t.Fatalf("needle not found")
   250  		}
   251  	})
   252  	if n != 0 {
   253  		t.Fatalf("want 0 allocs, got %v", n)
   254  	}
   255  }
   256  
   257  func TestStringIndexNeedle(t *testing.T) {
   258  	// See issue 25864.
   259  	haystack := "hello"
   260  	needle := []byte("ll")
   261  	n := testing.AllocsPerRun(1000, func() {
   262  		if strings.Index(haystack, string(needle)) != 2 {
   263  			t.Fatalf("needle not found")
   264  		}
   265  	})
   266  	if n != 0 {
   267  		t.Fatalf("want 0 allocs, got %v", n)
   268  	}
   269  }
   270  
   271  func TestStringOnStack(t *testing.T) {
   272  	s := ""
   273  	for i := 0; i < 3; i++ {
   274  		s = "a" + s + "b" + s + "c"
   275  	}
   276  
   277  	if want := "aaabcbabccbaabcbabccc"; s != want {
   278  		t.Fatalf("want: '%v', got '%v'", want, s)
   279  	}
   280  }
   281  
   282  func TestIntString(t *testing.T) {
   283  	// Non-escaping result of intstring.
   284  	s := ""
   285  	for i := rune(0); i < 4; i++ {
   286  		s += string(i+'0') + string(i+'0'+1)
   287  	}
   288  	if want := "01122334"; s != want {
   289  		t.Fatalf("want '%v', got '%v'", want, s)
   290  	}
   291  
   292  	// Escaping result of intstring.
   293  	var a [4]string
   294  	for i := rune(0); i < 4; i++ {
   295  		a[i] = string(i + '0')
   296  	}
   297  	s = a[0] + a[1] + a[2] + a[3]
   298  	if want := "0123"; s != want {
   299  		t.Fatalf("want '%v', got '%v'", want, s)
   300  	}
   301  }
   302  
   303  func TestIntStringAllocs(t *testing.T) {
   304  	unknown := '0'
   305  	n := testing.AllocsPerRun(1000, func() {
   306  		s1 := string(unknown)
   307  		s2 := string(unknown + 1)
   308  		if s1 == s2 {
   309  			t.Fatalf("bad")
   310  		}
   311  	})
   312  	if n != 0 {
   313  		t.Fatalf("want 0 allocs, got %v", n)
   314  	}
   315  }
   316  
   317  func TestRangeStringCast(t *testing.T) {
   318  	s := strings.Repeat("x", sizeNoStack)
   319  	n := testing.AllocsPerRun(1000, func() {
   320  		for i, c := range []byte(s) {
   321  			if c != s[i] {
   322  				t.Fatalf("want '%c' at pos %v, got '%c'", s[i], i, c)
   323  			}
   324  		}
   325  	})
   326  	if n != 0 {
   327  		t.Fatalf("want 0 allocs, got %v", n)
   328  	}
   329  }
   330  
   331  func isZeroed(b []byte) bool {
   332  	for _, x := range b {
   333  		if x != 0 {
   334  			return false
   335  		}
   336  	}
   337  	return true
   338  }
   339  
   340  func isZeroedR(r []rune) bool {
   341  	for _, x := range r {
   342  		if x != 0 {
   343  			return false
   344  		}
   345  	}
   346  	return true
   347  }
   348  
   349  func TestString2Slice(t *testing.T) {
   350  	// Make sure we don't return slices that expose
   351  	// an unzeroed section of stack-allocated temp buf
   352  	// between len and cap. See issue 14232.
   353  	s := "foož"
   354  	b := ([]byte)(s)
   355  	if !isZeroed(b[len(b):cap(b)]) {
   356  		t.Errorf("extra bytes not zeroed")
   357  	}
   358  	r := ([]rune)(s)
   359  	if !isZeroedR(r[len(r):cap(r)]) {
   360  		t.Errorf("extra runes not zeroed")
   361  	}
   362  }
   363  
   364  const intSize = 32 << (^uint(0) >> 63)
   365  
   366  type atoi64Test struct {
   367  	in  string
   368  	out int64
   369  	ok  bool
   370  }
   371  
   372  var atoi64tests = []atoi64Test{
   373  	{"", 0, false},
   374  	{"0", 0, true},
   375  	{"-0", 0, true},
   376  	{"1", 1, true},
   377  	{"-1", -1, true},
   378  	{"12345", 12345, true},
   379  	{"-12345", -12345, true},
   380  	{"012345", 12345, true},
   381  	{"-012345", -12345, true},
   382  	{"12345x", 0, false},
   383  	{"-12345x", 0, false},
   384  	{"98765432100", 98765432100, true},
   385  	{"-98765432100", -98765432100, true},
   386  	{"20496382327982653440", 0, false},
   387  	{"-20496382327982653440", 0, false},
   388  	{"9223372036854775807", 1<<63 - 1, true},
   389  	{"-9223372036854775807", -(1<<63 - 1), true},
   390  	{"9223372036854775808", 0, false},
   391  	{"-9223372036854775808", -1 << 63, true},
   392  	{"9223372036854775809", 0, false},
   393  	{"-9223372036854775809", 0, false},
   394  }
   395  
   396  func TestAtoi(t *testing.T) {
   397  	switch intSize {
   398  	case 32:
   399  		for i := range atoi32tests {
   400  			test := &atoi32tests[i]
   401  			out, ok := runtime.Atoi(test.in)
   402  			if test.out != int32(out) || test.ok != ok {
   403  				t.Errorf("atoi(%q) = (%v, %v) want (%v, %v)",
   404  					test.in, out, ok, test.out, test.ok)
   405  			}
   406  		}
   407  	case 64:
   408  		for i := range atoi64tests {
   409  			test := &atoi64tests[i]
   410  			out, ok := runtime.Atoi(test.in)
   411  			if test.out != int64(out) || test.ok != ok {
   412  				t.Errorf("atoi(%q) = (%v, %v) want (%v, %v)",
   413  					test.in, out, ok, test.out, test.ok)
   414  			}
   415  		}
   416  	}
   417  }
   418  
   419  type atoi32Test struct {
   420  	in  string
   421  	out int32
   422  	ok  bool
   423  }
   424  
   425  var atoi32tests = []atoi32Test{
   426  	{"", 0, false},
   427  	{"0", 0, true},
   428  	{"-0", 0, true},
   429  	{"1", 1, true},
   430  	{"-1", -1, true},
   431  	{"12345", 12345, true},
   432  	{"-12345", -12345, true},
   433  	{"012345", 12345, true},
   434  	{"-012345", -12345, true},
   435  	{"12345x", 0, false},
   436  	{"-12345x", 0, false},
   437  	{"987654321", 987654321, true},
   438  	{"-987654321", -987654321, true},
   439  	{"2147483647", 1<<31 - 1, true},
   440  	{"-2147483647", -(1<<31 - 1), true},
   441  	{"2147483648", 0, false},
   442  	{"-2147483648", -1 << 31, true},
   443  	{"2147483649", 0, false},
   444  	{"-2147483649", 0, false},
   445  }
   446  
   447  func TestAtoi32(t *testing.T) {
   448  	for i := range atoi32tests {
   449  		test := &atoi32tests[i]
   450  		out, ok := runtime.Atoi32(test.in)
   451  		if test.out != out || test.ok != ok {
   452  			t.Errorf("atoi32(%q) = (%v, %v) want (%v, %v)",
   453  				test.in, out, ok, test.out, test.ok)
   454  		}
   455  	}
   456  }
   457  
   458  func TestParseByteCount(t *testing.T) {
   459  	for _, test := range []struct {
   460  		in  string
   461  		out int64
   462  		ok  bool
   463  	}{
   464  		// Good numeric inputs.
   465  		{"1", 1, true},
   466  		{"12345", 12345, true},
   467  		{"012345", 12345, true},
   468  		{"98765432100", 98765432100, true},
   469  		{"9223372036854775807", 1<<63 - 1, true},
   470  
   471  		// Good trivial suffix inputs.
   472  		{"1B", 1, true},
   473  		{"12345B", 12345, true},
   474  		{"012345B", 12345, true},
   475  		{"98765432100B", 98765432100, true},
   476  		{"9223372036854775807B", 1<<63 - 1, true},
   477  
   478  		// Good binary suffix inputs.
   479  		{"1KiB", 1 << 10, true},
   480  		{"05KiB", 5 << 10, true},
   481  		{"1MiB", 1 << 20, true},
   482  		{"10MiB", 10 << 20, true},
   483  		{"1GiB", 1 << 30, true},
   484  		{"100GiB", 100 << 30, true},
   485  		{"1TiB", 1 << 40, true},
   486  		{"99TiB", 99 << 40, true},
   487  
   488  		// Good zero inputs.
   489  		//
   490  		// -0 is an edge case, but no harm in supporting it.
   491  		{"-0", 0, true},
   492  		{"0", 0, true},
   493  		{"0B", 0, true},
   494  		{"0KiB", 0, true},
   495  		{"0MiB", 0, true},
   496  		{"0GiB", 0, true},
   497  		{"0TiB", 0, true},
   498  
   499  		// Bad inputs.
   500  		{"", 0, false},
   501  		{"-1", 0, false},
   502  		{"a12345", 0, false},
   503  		{"a12345B", 0, false},
   504  		{"12345x", 0, false},
   505  		{"0x12345", 0, false},
   506  
   507  		// Bad numeric inputs.
   508  		{"9223372036854775808", 0, false},
   509  		{"9223372036854775809", 0, false},
   510  		{"18446744073709551615", 0, false},
   511  		{"20496382327982653440", 0, false},
   512  		{"18446744073709551616", 0, false},
   513  		{"18446744073709551617", 0, false},
   514  		{"9999999999999999999999", 0, false},
   515  
   516  		// Bad trivial suffix inputs.
   517  		{"9223372036854775808B", 0, false},
   518  		{"9223372036854775809B", 0, false},
   519  		{"18446744073709551615B", 0, false},
   520  		{"20496382327982653440B", 0, false},
   521  		{"18446744073709551616B", 0, false},
   522  		{"18446744073709551617B", 0, false},
   523  		{"9999999999999999999999B", 0, false},
   524  
   525  		// Bad binary suffix inputs.
   526  		{"1Ki", 0, false},
   527  		{"05Ki", 0, false},
   528  		{"10Mi", 0, false},
   529  		{"100Gi", 0, false},
   530  		{"99Ti", 0, false},
   531  		{"22iB", 0, false},
   532  		{"B", 0, false},
   533  		{"iB", 0, false},
   534  		{"KiB", 0, false},
   535  		{"MiB", 0, false},
   536  		{"GiB", 0, false},
   537  		{"TiB", 0, false},
   538  		{"-120KiB", 0, false},
   539  		{"-891MiB", 0, false},
   540  		{"-704GiB", 0, false},
   541  		{"-42TiB", 0, false},
   542  		{"99999999999999999999KiB", 0, false},
   543  		{"99999999999999999MiB", 0, false},
   544  		{"99999999999999GiB", 0, false},
   545  		{"99999999999TiB", 0, false},
   546  		{"555EiB", 0, false},
   547  
   548  		// Mistaken SI suffix inputs.
   549  		{"0KB", 0, false},
   550  		{"0MB", 0, false},
   551  		{"0GB", 0, false},
   552  		{"0TB", 0, false},
   553  		{"1KB", 0, false},
   554  		{"05KB", 0, false},
   555  		{"1MB", 0, false},
   556  		{"10MB", 0, false},
   557  		{"1GB", 0, false},
   558  		{"100GB", 0, false},
   559  		{"1TB", 0, false},
   560  		{"99TB", 0, false},
   561  		{"1K", 0, false},
   562  		{"05K", 0, false},
   563  		{"10M", 0, false},
   564  		{"100G", 0, false},
   565  		{"99T", 0, false},
   566  		{"99999999999999999999KB", 0, false},
   567  		{"99999999999999999MB", 0, false},
   568  		{"99999999999999GB", 0, false},
   569  		{"99999999999TB", 0, false},
   570  		{"99999999999TiB", 0, false},
   571  		{"555EB", 0, false},
   572  	} {
   573  		out, ok := runtime.ParseByteCount(test.in)
   574  		if test.out != out || test.ok != ok {
   575  			t.Errorf("parseByteCount(%q) = (%v, %v) want (%v, %v)",
   576  				test.in, out, ok, test.out, test.ok)
   577  		}
   578  	}
   579  }
   580  

View as plain text