runtime_test.go

Documentation: runtime

     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  	"flag"
     9  	"io"
    10  	. "runtime"
    11  	"runtime/debug"
    12  	"strings"
    13  	"testing"
    14  	"unsafe"
    15  )
    16  
    17  var flagQuick = flag.Bool("quick", false, "skip slow tests, for second run in all.bash")
    18  
    19  func init() {
    20  	// We're testing the runtime, so make tracebacks show things
    21  	// in the runtime. This only raises the level, so it won't
    22  	// override GOTRACEBACK=crash from the user.
    23  	SetTracebackEnv("system")
    24  }
    25  
    26  var errf error
    27  
    28  func errfn() error {
    29  	return errf
    30  }
    31  
    32  func errfn1() error {
    33  	return io.EOF
    34  }
    35  
    36  func BenchmarkIfaceCmp100(b *testing.B) {
    37  	for i := 0; i < b.N; i++ {
    38  		for j := 0; j < 100; j++ {
    39  			if errfn() == io.EOF {
    40  				b.Fatal("bad comparison")
    41  			}
    42  		}
    43  	}
    44  }
    45  
    46  func BenchmarkIfaceCmpNil100(b *testing.B) {
    47  	for i := 0; i < b.N; i++ {
    48  		for j := 0; j < 100; j++ {
    49  			if errfn1() == nil {
    50  				b.Fatal("bad comparison")
    51  			}
    52  		}
    53  	}
    54  }
    55  
    56  var efaceCmp1 interface{}
    57  var efaceCmp2 interface{}
    58  
    59  func BenchmarkEfaceCmpDiff(b *testing.B) {
    60  	x := 5
    61  	efaceCmp1 = &x
    62  	y := 6
    63  	efaceCmp2 = &y
    64  	for i := 0; i < b.N; i++ {
    65  		for j := 0; j < 100; j++ {
    66  			if efaceCmp1 == efaceCmp2 {
    67  				b.Fatal("bad comparison")
    68  			}
    69  		}
    70  	}
    71  }
    72  
    73  func BenchmarkEfaceCmpDiffIndirect(b *testing.B) {
    74  	efaceCmp1 = [2]int{1, 2}
    75  	efaceCmp2 = [2]int{1, 2}
    76  	for i := 0; i < b.N; i++ {
    77  		for j := 0; j < 100; j++ {
    78  			if efaceCmp1 != efaceCmp2 {
    79  				b.Fatal("bad comparison")
    80  			}
    81  		}
    82  	}
    83  }
    84  
    85  func BenchmarkDefer(b *testing.B) {
    86  	for i := 0; i < b.N; i++ {
    87  		defer1()
    88  	}
    89  }
    90  
    91  func defer1() {
    92  	defer func(x, y, z int) {
    93  		if recover() != nil || x != 1 || y != 2 || z != 3 {
    94  			panic("bad recover")
    95  		}
    96  	}(1, 2, 3)
    97  }
    98  
    99  func BenchmarkDefer10(b *testing.B) {
   100  	for i := 0; i < b.N/10; i++ {
   101  		defer2()
   102  	}
   103  }
   104  
   105  func defer2() {
   106  	for i := 0; i < 10; i++ {
   107  		defer func(x, y, z int) {
   108  			if recover() != nil || x != 1 || y != 2 || z != 3 {
   109  				panic("bad recover")
   110  			}
   111  		}(1, 2, 3)
   112  	}
   113  }
   114  
   115  func BenchmarkDeferMany(b *testing.B) {
   116  	for i := 0; i < b.N; i++ {
   117  		defer func(x, y, z int) {
   118  			if recover() != nil || x != 1 || y != 2 || z != 3 {
   119  				panic("bad recover")
   120  			}
   121  		}(1, 2, 3)
   122  	}
   123  }
   124  
   125  func BenchmarkPanicRecover(b *testing.B) {
   126  	for i := 0; i < b.N; i++ {
   127  		defer3()
   128  	}
   129  }
   130  
   131  func defer3() {
   132  	defer func(x, y, z int) {
   133  		if recover() == nil {
   134  			panic("failed recover")
   135  		}
   136  	}(1, 2, 3)
   137  	panic("hi")
   138  }
   139  
   140  // golang.org/issue/7063
   141  func TestStopCPUProfilingWithProfilerOff(t *testing.T) {
   142  	SetCPUProfileRate(0)
   143  }
   144  
   145  // Addresses to test for faulting behavior.
   146  // This is less a test of SetPanicOnFault and more a check that
   147  // the operating system and the runtime can process these faults
   148  // correctly. That is, we're indirectly testing that without SetPanicOnFault
   149  // these would manage to turn into ordinary crashes.
   150  // Note that these are truncated on 32-bit systems, so the bottom 32 bits
   151  // of the larger addresses must themselves be invalid addresses.
   152  // We might get unlucky and the OS might have mapped one of these
   153  // addresses, but probably not: they're all in the first page, very high
   154  // addresses that normally an OS would reserve for itself, or malformed
   155  // addresses. Even so, we might have to remove one or two on different
   156  // systems. We will see.
   157  
   158  var faultAddrs = []uint64{
   159  	// low addresses
   160  	0,
   161  	1,
   162  	0xfff,
   163  	// high (kernel) addresses
   164  	// or else malformed.
   165  	0xffffffffffffffff,
   166  	0xfffffffffffff001,
   167  	0xffffffffffff0001,
   168  	0xfffffffffff00001,
   169  	0xffffffffff000001,
   170  	0xfffffffff0000001,
   171  	0xffffffff00000001,
   172  	0xfffffff000000001,
   173  	0xffffff0000000001,
   174  	0xfffff00000000001,
   175  	0xffff000000000001,
   176  	0xfff0000000000001,
   177  	0xff00000000000001,
   178  	0xf000000000000001,
   179  	0x8000000000000001,
   180  }
   181  
   182  func TestSetPanicOnFault(t *testing.T) {
   183  	old := debug.SetPanicOnFault(true)
   184  	defer debug.SetPanicOnFault(old)
   185  
   186  	nfault := 0
   187  	for _, addr := range faultAddrs {
   188  		testSetPanicOnFault(t, uintptr(addr), &nfault)
   189  	}
   190  	if nfault == 0 {
   191  		t.Fatalf("none of the addresses faulted")
   192  	}
   193  }
   194  
   195  // testSetPanicOnFault tests one potentially faulting address.
   196  // It deliberately constructs and uses an invalid pointer,
   197  // so mark it as nocheckptr.
   198  //go:nocheckptr
   199  func testSetPanicOnFault(t *testing.T, addr uintptr, nfault *int) {
   200  	if GOOS == "js" {
   201  		t.Skip("js does not support catching faults")
   202  	}
   203  
   204  	defer func() {
   205  		if err := recover(); err != nil {
   206  			*nfault++
   207  		}
   208  	}()
   209  
   210  	// The read should fault, except that sometimes we hit
   211  	// addresses that have had C or kernel pages mapped there
   212  	// readable by user code. So just log the content.
   213  	// If no addresses fault, we'll fail the test.
   214  	v := *(*byte)(unsafe.Pointer(addr))
   215  	t.Logf("addr %#x: %#x\n", addr, v)
   216  }
   217  
   218  func eqstring_generic(s1, s2 string) bool {
   219  	if len(s1) != len(s2) {
   220  		return false
   221  	}
   222  	// optimization in assembly versions:
   223  	// if s1.str == s2.str { return true }
   224  	for i := 0; i < len(s1); i++ {
   225  		if s1[i] != s2[i] {
   226  			return false
   227  		}
   228  	}
   229  	return true
   230  }
   231  
   232  func TestEqString(t *testing.T) {
   233  	// This isn't really an exhaustive test of == on strings, it's
   234  	// just a convenient way of documenting (via eqstring_generic)
   235  	// what == does.
   236  	s := []string{
   237  		"",
   238  		"a",
   239  		"c",
   240  		"aaa",
   241  		"ccc",
   242  		"cccc"[:3], // same contents, different string
   243  		"1234567890",
   244  	}
   245  	for _, s1 := range s {
   246  		for _, s2 := range s {
   247  			x := s1 == s2
   248  			y := eqstring_generic(s1, s2)
   249  			if x != y {
   250  				t.Errorf(`("%s" == "%s") = %t, want %t`, s1, s2, x, y)
   251  			}
   252  		}
   253  	}
   254  }
   255  
   256  func TestTrailingZero(t *testing.T) {
   257  	// make sure we add padding for structs with trailing zero-sized fields
   258  	type T1 struct {
   259  		n int32
   260  		z [0]byte
   261  	}
   262  	if unsafe.Sizeof(T1{}) != 8 {
   263  		t.Errorf("sizeof(%#v)==%d, want 8", T1{}, unsafe.Sizeof(T1{}))
   264  	}
   265  	type T2 struct {
   266  		n int64
   267  		z struct{}
   268  	}
   269  	if unsafe.Sizeof(T2{}) != 8+unsafe.Sizeof(uintptr(0)) {
   270  		t.Errorf("sizeof(%#v)==%d, want %d", T2{}, unsafe.Sizeof(T2{}), 8+unsafe.Sizeof(uintptr(0)))
   271  	}
   272  	type T3 struct {
   273  		n byte
   274  		z [4]struct{}
   275  	}
   276  	if unsafe.Sizeof(T3{}) != 2 {
   277  		t.Errorf("sizeof(%#v)==%d, want 2", T3{}, unsafe.Sizeof(T3{}))
   278  	}
   279  	// make sure padding can double for both zerosize and alignment
   280  	type T4 struct {
   281  		a int32
   282  		b int16
   283  		c int8
   284  		z struct{}
   285  	}
   286  	if unsafe.Sizeof(T4{}) != 8 {
   287  		t.Errorf("sizeof(%#v)==%d, want 8", T4{}, unsafe.Sizeof(T4{}))
   288  	}
   289  	// make sure we don't pad a zero-sized thing
   290  	type T5 struct {
   291  	}
   292  	if unsafe.Sizeof(T5{}) != 0 {
   293  		t.Errorf("sizeof(%#v)==%d, want 0", T5{}, unsafe.Sizeof(T5{}))
   294  	}
   295  }
   296  
   297  func TestAppendGrowth(t *testing.T) {
   298  	var x []int64
   299  	check := func(want int) {
   300  		if cap(x) != want {
   301  			t.Errorf("len=%d, cap=%d, want cap=%d", len(x), cap(x), want)
   302  		}
   303  	}
   304  
   305  	check(0)
   306  	want := 1
   307  	for i := 1; i <= 100; i++ {
   308  		x = append(x, 1)
   309  		check(want)
   310  		if i&(i-1) == 0 {
   311  			want = 2 * i
   312  		}
   313  	}
   314  }
   315  
   316  var One = []int64{1}
   317  
   318  func TestAppendSliceGrowth(t *testing.T) {
   319  	var x []int64
   320  	check := func(want int) {
   321  		if cap(x) != want {
   322  			t.Errorf("len=%d, cap=%d, want cap=%d", len(x), cap(x), want)
   323  		}
   324  	}
   325  
   326  	check(0)
   327  	want := 1
   328  	for i := 1; i <= 100; i++ {
   329  		x = append(x, One...)
   330  		check(want)
   331  		if i&(i-1) == 0 {
   332  			want = 2 * i
   333  		}
   334  	}
   335  }
   336  
   337  func TestGoroutineProfileTrivial(t *testing.T) {
   338  	// Calling GoroutineProfile twice in a row should find the same number of goroutines,
   339  	// but it's possible there are goroutines just about to exit, so we might end up
   340  	// with fewer in the second call. Try a few times; it should converge once those
   341  	// zombies are gone.
   342  	for i := 0; ; i++ {
   343  		n1, ok := GoroutineProfile(nil) // should fail, there's at least 1 goroutine
   344  		if n1 < 1 || ok {
   345  			t.Fatalf("GoroutineProfile(nil) = %d, %v, want >0, false", n1, ok)
   346  		}
   347  		n2, ok := GoroutineProfile(make([]StackRecord, n1))
   348  		if n2 == n1 && ok {
   349  			break
   350  		}
   351  		t.Logf("GoroutineProfile(%d) = %d, %v, want %d, true", n1, n2, ok, n1)
   352  		if i >= 10 {
   353  			t.Fatalf("GoroutineProfile not converging")
   354  		}
   355  	}
   356  }
   357  
   358  func TestVersion(t *testing.T) {
   359  	// Test that version does not contain \r or \n.
   360  	vers := Version()
   361  	if strings.Contains(vers, "\r") || strings.Contains(vers, "\n") {
   362  		t.Fatalf("cr/nl in version: %q", vers)
   363  	}
   364  }
   365
View as plain text