File Manager

X7ROOT File Manager

Current Path: /opt/golang/1.19.4/src/cmd/compile/internal/test/testdata

opt / golang / 1.19.4 / src / cmd / compile / internal / test / testdata /

📁 ..
📄 addressed_test.go(4.42 KB)
📄 append_test.go(1.16 KB)
📄 arithBoundary_test.go(31.31 KB)
📄 arithConst_test.go(633.8 KB)
📄 arith_test.go(41.51 KB)
📄 array_test.go(3.09 KB)
📄 assert_test.go(2.54 KB)
📄 break_test.go(3.67 KB)
📄 chan_test.go(1.14 KB)
📄 closure_test.go(572 B)
📄 cmpConst_test.go(103.06 KB)
📄 cmp_test.go(903 B)
📄 compound_test.go(2.7 KB)
📄 copy_test.go(150.18 KB)
📄 ctl_test.go(2.33 KB)
📄 deferNoReturn_test.go(481 B)
📄 divbyzero_test.go(1.01 KB)
📄 dupLoad_test.go(1.51 KB)
📄 flowgraph_generator1.go(6.72 KB)
📄 fp_test.go(34.99 KB)
📁 gen
📄 loadstore_test.go(4.79 KB)
📄 map_test.go(721 B)
📁 mysort
📄 namedReturn_test.go(1.63 KB)
📄 phi_test.go(2.21 KB)
📄 ptrsort.go(633 B)
📄 ptrsort.out(77 B)
📄 regalloc_test.go(1.2 KB)
📁 reproducible
📄 short_test.go(1.48 KB)
📄 slice_test.go(850 B)
📄 sqrtConst_test.go(1.26 KB)
📄 string_test.go(4.46 KB)
📄 unsafe_test.go(2.96 KB)
📄 zero_test.go(49.6 KB)

Editing: string_test.go

// Copyright 2015 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.

// string_ssa.go tests string operations.
package main

import "testing"

//go:noinline
func testStringSlice1_ssa(a string, i, j int) string {
	return a[i:]
}

//go:noinline
func testStringSlice2_ssa(a string, i, j int) string {
	return a[:j]
}

//go:noinline
func testStringSlice12_ssa(a string, i, j int) string {
	return a[i:j]
}

func testStringSlice(t *testing.T) {
	tests := [...]struct {
		fn        func(string, int, int) string
		s         string
		low, high int
		want      string
	}{
		// -1 means the value is not used.
		{testStringSlice1_ssa, "foobar", 0, -1, "foobar"},
		{testStringSlice1_ssa, "foobar", 3, -1, "bar"},
		{testStringSlice1_ssa, "foobar", 6, -1, ""},
		{testStringSlice2_ssa, "foobar", -1, 0, ""},
		{testStringSlice2_ssa, "foobar", -1, 3, "foo"},
		{testStringSlice2_ssa, "foobar", -1, 6, "foobar"},
		{testStringSlice12_ssa, "foobar", 0, 6, "foobar"},
		{testStringSlice12_ssa, "foobar", 0, 0, ""},
		{testStringSlice12_ssa, "foobar", 6, 6, ""},
		{testStringSlice12_ssa, "foobar", 1, 5, "ooba"},
		{testStringSlice12_ssa, "foobar", 3, 3, ""},
		{testStringSlice12_ssa, "", 0, 0, ""},
	}

for i, test := range tests {
		if got := test.fn(test.s, test.low, test.high); test.want != got {
			t.Errorf("#%d %s[%d,%d] = %s, want %s", i, test.s, test.low, test.high, got, test.want)
		}
	}
}

type prefix struct {
	prefix string
}

func (p *prefix) slice_ssa() {
	p.prefix = p.prefix[:3]
}

//go:noinline
func testStructSlice(t *testing.T) {
	p := &prefix{"prefix"}
	p.slice_ssa()
	if "pre" != p.prefix {
		t.Errorf("wrong field slice: wanted %s got %s", "pre", p.prefix)
	}
}

func testStringSlicePanic(t *testing.T) {
	defer func() {
		if r := recover(); r != nil {
			//println("panicked as expected")
		}
	}()

str := "foobar"
	t.Errorf("got %s and expected to panic, but didn't", testStringSlice12_ssa(str, 3, 9))
}

const _Accuracy_name = "BelowExactAbove"

var _Accuracy_index = [...]uint8{0, 5, 10, 15}

//go:noinline
func testSmallIndexType_ssa(i int) string {
	return _Accuracy_name[_Accuracy_index[i]:_Accuracy_index[i+1]]
}

func testSmallIndexType(t *testing.T) {
	tests := []struct {
		i    int
		want string
	}{
		{0, "Below"},
		{1, "Exact"},
		{2, "Above"},
	}

for i, test := range tests {
		if got := testSmallIndexType_ssa(test.i); got != test.want {
			t.Errorf("#%d got %s wanted %s", i, got, test.want)
		}
	}
}

//go:noinline
func testInt64Index_ssa(s string, i int64) byte {
	return s[i]
}

//go:noinline
func testInt64Slice_ssa(s string, i, j int64) string {
	return s[i:j]
}

func testInt64Index(t *testing.T) {
	tests := []struct {
		i int64
		j int64
		b byte
		s string
	}{
		{0, 5, 'B', "Below"},
		{5, 10, 'E', "Exact"},
		{10, 15, 'A', "Above"},
	}

str := "BelowExactAbove"
	for i, test := range tests {
		if got := testInt64Index_ssa(str, test.i); got != test.b {
			t.Errorf("#%d got %d wanted %d", i, got, test.b)
		}
		if got := testInt64Slice_ssa(str, test.i, test.j); got != test.s {
			t.Errorf("#%d got %s wanted %s", i, got, test.s)
		}
	}
}

func testInt64IndexPanic(t *testing.T) {
	defer func() {
		if r := recover(); r != nil {
			//println("panicked as expected")
		}
	}()

str := "foobar"
	t.Errorf("got %d and expected to panic, but didn't", testInt64Index_ssa(str, 1<<32+1))
}

func testInt64SlicePanic(t *testing.T) {
	defer func() {
		if r := recover(); r != nil {
			//println("panicked as expected")
		}
	}()

str := "foobar"
	t.Errorf("got %s and expected to panic, but didn't", testInt64Slice_ssa(str, 1<<32, 1<<32+1))
}

//go:noinline
func testStringElem_ssa(s string, i int) byte {
	return s[i]
}

func testStringElem(t *testing.T) {
	tests := []struct {
		s string
		i int
		n byte
	}{
		{"foobar", 3, 98},
		{"foobar", 0, 102},
		{"foobar", 5, 114},
	}
	for _, test := range tests {
		if got := testStringElem_ssa(test.s, test.i); got != test.n {
			t.Errorf("testStringElem \"%s\"[%d] = %d, wanted %d", test.s, test.i, got, test.n)
		}
	}
}

//go:noinline
func testStringElemConst_ssa(i int) byte {
	s := "foobar"
	return s[i]
}

func testStringElemConst(t *testing.T) {
	if got := testStringElemConst_ssa(3); got != 98 {
		t.Errorf("testStringElemConst= %d, wanted 98", got)
	}
}

func TestString(t *testing.T) {
	testStringSlice(t)
	testStringSlicePanic(t)
	testStructSlice(t)
	testSmallIndexType(t)
	testStringElem(t)
	testStringElemConst(t)
	testInt64Index(t)
	testInt64IndexPanic(t)
	testInt64SlicePanic(t)
}

X7ROOT File Manager

Editing: string_test.go

Upload File

Create Folder