1 files changed, 0 insertions, 236 deletions
diff --git a/src/pkg/runtime/gc_test.go b/src/pkg/runtime/gc_test.go
deleted file mode 100644
index 58717ecf7..000000000
--- a/src/pkg/runtime/gc_test.go
+++ /dev/null
@@ -1,236 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package runtime_test
-
-import (
-	"os"
-	"runtime"
-	"runtime/debug"
-	"testing"
-	"time"
-)
-
-func TestGcSys(t *testing.T) {
-	if os.Getenv("GOGC") == "off" {
-		t.Skip("skipping test; GOGC=off in environment")
-	}
-	data := struct{ Short bool }{testing.Short()}
-	got := executeTest(t, testGCSysSource, &data)
-	want := "OK\n"
-	if got != want {
-		t.Fatalf("expected %q, but got %q", want, got)
-	}
-}
-
-const testGCSysSource = `
-package main
-
-import (
-	"fmt"
-	"runtime"
-)
-
-func main() {
-	runtime.GOMAXPROCS(1)
-	memstats := new(runtime.MemStats)
-	runtime.GC()
-	runtime.ReadMemStats(memstats)
-	sys := memstats.Sys
-
-	runtime.MemProfileRate = 0 // disable profiler
-
-	itercount := 1000000
-{{if .Short}}
-	itercount = 100000
-{{end}}
-	for i := 0; i < itercount; i++ {
-		workthegc()
-	}
-
-	// Should only be using a few MB.
-	// We allocated 100 MB or (if not short) 1 GB.
-	runtime.ReadMemStats(memstats)
-	if sys > memstats.Sys {
-		sys = 0
-	} else {
-		sys = memstats.Sys - sys
-	}
-	if sys > 16<<20 {
-		fmt.Printf("using too much memory: %d bytes\n", sys)
-		return
-	}
-	fmt.Printf("OK\n")
-}
-
-func workthegc() []byte {
-	return make([]byte, 1029)
-}
-`
-
-func TestGcDeepNesting(t *testing.T) {
-	type T [2][2][2][2][2][2][2][2][2][2]*int
-	a := new(T)
-
-	// Prevent the compiler from applying escape analysis.
-	// This makes sure new(T) is allocated on heap, not on the stack.
-	t.Logf("%p", a)
-
-	a[0][0][0][0][0][0][0][0][0][0] = new(int)
-	*a[0][0][0][0][0][0][0][0][0][0] = 13
-	runtime.GC()
-	if *a[0][0][0][0][0][0][0][0][0][0] != 13 {
-		t.Fail()
-	}
-}
-
-func TestGcHashmapIndirection(t *testing.T) {
-	defer debug.SetGCPercent(debug.SetGCPercent(1))
-	runtime.GC()
-	type T struct {
-		a [256]int
-	}
-	m := make(map[T]T)
-	for i := 0; i < 2000; i++ {
-		var a T
-		a.a[0] = i
-		m[a] = T{}
-	}
-}
-
-func TestGcArraySlice(t *testing.T) {
-	type X struct {
-		buf     [1]byte
-		nextbuf []byte
-		next    *X
-	}
-	var head *X
-	for i := 0; i < 10; i++ {
-		p := &X{}
-		p.buf[0] = 42
-		p.next = head
-		if head != nil {
-			p.nextbuf = head.buf[:]
-		}
-		head = p
-		runtime.GC()
-	}
-	for p := head; p != nil; p = p.next {
-		if p.buf[0] != 42 {
-			t.Fatal("corrupted heap")
-		}
-	}
-}
-
-func TestGcRescan(t *testing.T) {
-	type X struct {
-		c     chan error
-		nextx *X
-	}
-	type Y struct {
-		X
-		nexty *Y
-		p     *int
-	}
-	var head *Y
-	for i := 0; i < 10; i++ {
-		p := &Y{}
-		p.c = make(chan error)
-		if head != nil {
-			p.nextx = &head.X
-		}
-		p.nexty = head
-		p.p = new(int)
-		*p.p = 42
-		head = p
-		runtime.GC()
-	}
-	for p := head; p != nil; p = p.nexty {
-		if *p.p != 42 {
-			t.Fatal("corrupted heap")
-		}
-	}
-}
-
-func TestGcLastTime(t *testing.T) {
-	ms := new(runtime.MemStats)
-	t0 := time.Now().UnixNano()
-	runtime.GC()
-	t1 := time.Now().UnixNano()
-	runtime.ReadMemStats(ms)
-	last := int64(ms.LastGC)
-	if t0 > last || last > t1 {
-		t.Fatalf("bad last GC time: got %v, want [%v, %v]", last, t0, t1)
-	}
-}
-
-func BenchmarkSetTypeNoPtr1(b *testing.B) {
-	type NoPtr1 struct {
-		p uintptr
-	}
-	var p *NoPtr1
-	for i := 0; i < b.N; i++ {
-		p = &NoPtr1{}
-	}
-	_ = p
-}
-func BenchmarkSetTypeNoPtr2(b *testing.B) {
-	type NoPtr2 struct {
-		p, q uintptr
-	}
-	var p *NoPtr2
-	for i := 0; i < b.N; i++ {
-		p = &NoPtr2{}
-	}
-	_ = p
-}
-func BenchmarkSetTypePtr1(b *testing.B) {
-	type Ptr1 struct {
-		p *byte
-	}
-	var p *Ptr1
-	for i := 0; i < b.N; i++ {
-		p = &Ptr1{}
-	}
-	_ = p
-}
-func BenchmarkSetTypePtr2(b *testing.B) {
-	type Ptr2 struct {
-		p, q *byte
-	}
-	var p *Ptr2
-	for i := 0; i < b.N; i++ {
-		p = &Ptr2{}
-	}
-	_ = p
-}
-
-func BenchmarkAllocation(b *testing.B) {
-	type T struct {
-		x, y *byte
-	}
-	ngo := runtime.GOMAXPROCS(0)
-	work := make(chan bool, b.N+ngo)
-	result := make(chan *T)
-	for i := 0; i < b.N; i++ {
-		work <- true
-	}
-	for i := 0; i < ngo; i++ {
-		work <- false
-	}
-	for i := 0; i < ngo; i++ {
-		go func() {
-			var x *T
-			for <-work {
-				for i := 0; i < 1000; i++ {
-					x = &T{}
-				}
-			}
-			result <- x
-		}()
-	}
-	for i := 0; i < ngo; i++ {
-		<-result
-	}
-}