new package: x/test

.github/codecov.yml

@@ -0,0 +1,4 @@
+coverage:
+  ignore:
+    - "test"
+    - "ts"

.github/workflows/go.yml

@@ -10,7 +10,7 @@ jobs:
   Test:
     strategy:
       matrix:
-        go-version: [1.17.x, 1.18.x, 1.20.x, 1.21.x]
+        go-version: [1.18.x, 1.20.x, 1.21.x]
         os: [ubuntu-latest, windows-latest, macos-latest]
     runs-on: ${{ matrix.os }}
     steps:

go.mod

@@ -1,6 +1,6 @@
 module github.com/qiniu/x
 
-go 1.13
+go 1.18
 
 retract (
     v7.0.0+incompatible

test/_match_test.go

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package test
+
+import (
+	"testing"
+)
+
+func TestBasic(t *testing.T) {
+}

test/case.go

@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package test
+
+import (
+	"testing"
+	"time"
+)
+
+// -----------------------------------------------------------------------------
+
+// CaseT is an interface that defines the methods for a test case.
+type CaseT interface {
+	// Name returns the name of the running (sub-) test or benchmark.
+	//
+	// The name will include the name of the test along with the names of
+	// any nested sub-tests. If two sibling sub-tests have the same name,
+	// Name will append a suffix to guarantee the returned name is unique.
+	Name() string
+
+	// Fail marks the function as having failed but continues execution.
+	Fail()
+
+	// Failed reports whether the function has failed.
+	Failed() bool
+
+	// FailNow marks the function as having failed and stops its execution
+	// by calling runtime.Goexit (which then runs all deferred calls in the
+	// current goroutine).
+	// Execution will continue at the next test or benchmark.
+	// FailNow must be called from the goroutine running the
+	// test or benchmark function, not from other goroutines
+	// created during the test. Calling FailNow does not stop
+	// those other goroutines.
+	FailNow()
+
+	// Log formats its arguments using default formatting, analogous to Println,
+	// and records the text in the error log. For tests, the text will be printed only if
+	// the test fails or the -test.v flag is set. For benchmarks, the text is always
+	// printed to avoid having performance depend on the value of the -test.v flag.
+	Log(args ...any)
+
+	// Logf formats its arguments according to the format, analogous to Printf, and
+	// records the text in the error log. A final newline is added if not provided. For
+	// tests, the text will be printed only if the test fails or the -test.v flag is
+	// set. For benchmarks, the text is always printed to avoid having performance
+	// depend on the value of the -test.v flag.
+	Logf(format string, args ...any)
+
+	// Errorln is equivalent to Log followed by Fail.
+	Errorln(args ...any)
+
+	// Errorf is equivalent to Logf followed by Fail.
+	Errorf(format string, args ...any)
+
+	// Fatal is equivalent to Log followed by FailNow.
+	Fatal(args ...any)
+
+	// Fatalf is equivalent to Logf followed by FailNow.
+	Fatalf(format string, args ...any)
+
+	// Skip is equivalent to Log followed by SkipNow.
+	Skip(args ...any)
+
+	// Skipf is equivalent to Logf followed by SkipNow.
+	Skipf(format string, args ...any)
+
+	// SkipNow marks the test as having been skipped and stops its execution
+	// by calling runtime.Goexit.
+	// If a test fails (see Error, Errorf, Fail) and is then skipped,
+	// it is still considered to have failed.
+	// Execution will continue at the next test or benchmark. See also FailNow.
+	// SkipNow must be called from the goroutine running the test, not from
+	// other goroutines created during the test. Calling SkipNow does not stop
+	// those other goroutines.
+	SkipNow()
+
+	// Skipped reports whether the test was skipped.
+	Skipped() bool
+
+	// Helper marks the calling function as a test helper function.
+	// When printing file and line information, that function will be skipped.
+	// Helper may be called simultaneously from multiple goroutines.
+	Helper()
+
+	// Cleanup registers a function to be called when the test (or subtest) and all its
+	// subtests complete. Cleanup functions will be called in last added,
+	// first called order.
+	Cleanup(f func())
+
+	// TempDir returns a temporary directory for the test to use.
+	// The directory is automatically removed by Cleanup when the test and
+	// all its subtests complete.
+	// Each subsequent call to t.TempDir returns a unique directory;
+	// if the directory creation fails, TempDir terminates the test by calling Fatal.
+	TempDir() string
+
+	// Run runs f as a subtest of t called name.
+	//
+	// Run may be called simultaneously from multiple goroutines, but all such calls
+	// must return before the outer test function for t returns.
+	Run(name string, f func()) bool
+
+	// Deadline reports the time at which the test binary will have
+	// exceeded the timeout specified by the -timeout flag.
+	//
+	// The ok result is false if the -timeout flag indicates “no timeout” (0).
+	Deadline() (deadline time.Time, ok bool)
+}
+
+// -----------------------------------------------------------------------------
+
+// TestingT is a wrapper for testing.T.
+// It implements the CaseT interface and provides methods to manage test state
+// and support formatted test logs.
+type TestingT struct {
+	*testing.T
+}
+
+// NewT creates a testing object.
+func NewT(t *testing.T) TestingT {
+	return TestingT{t}
+}
+
+// Errorln is equivalent to Log followed by Fail.
+func (p TestingT) Errorln(args ...any) {
+	t := p.T
+	t.Helper()
+	t.Error(args...)
+}
+
+// Run runs f as a subtest of t called name.
+//
+// Run may be called simultaneously from multiple goroutines, but all such calls
+// must return before the outer test function for t returns.
+func (p TestingT) Run(name string, doSth func()) bool {
+	return p.T.Run(name, func(t *testing.T) {
+		doSth()
+	})
+}
+
+// -----------------------------------------------------------------------------

test/logt/logt.go

@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package logt
+
+import (
+	"log"
+	"time"
+)
+
+type T struct {
+	name    string
+	fail    bool
+	skipped bool
+}
+
+func New() *T {
+	return &T{}
+}
+
+func (p *T) Name() string {
+	return p.name
+}
+
+// Fail marks the function as having failed but continues execution.
+func (p *T) Fail() {
+	p.fail = true
+}
+
+// Failed reports whether the function has failed.
+func (p *T) Failed() bool {
+	return p.fail
+}
+
+// FailNow marks the function as having failed and stops its execution
+// by calling runtime.Goexit (which then runs all deferred calls in the
+// current goroutine).
+// Execution will continue at the next test or benchmark.
+// FailNow must be called from the goroutine running the
+// test or benchmark function, not from other goroutines
+// created during the test. Calling FailNow does not stop
+// those other goroutines.
+func (p *T) FailNow() {
+	p.fail = true
+	panic("todo")
+}
+
+// Log formats its arguments using default formatting, analogous to Println,
+// and records the text in the error log. For tests, the text will be printed only if
+// the test fails or the -test.v flag is set. For benchmarks, the text is always
+// printed to avoid having performance depend on the value of the -test.v flag.
+func (p *T) Log(args ...any) {
+	log.Println(args...)
+}
+
+// Logf formats its arguments according to the format, analogous to Printf, and
+// records the text in the error log. A final newline is added if not provided. For
+// tests, the text will be printed only if the test fails or the -test.v flag is
+// set. For benchmarks, the text is always printed to avoid having performance
+// depend on the value of the -test.v flag.
+func (p *T) Logf(format string, args ...any) {
+	log.Printf(format, args...)
+}
+
+// Errorln is equivalent to Log followed by Fail.
+func (p *T) Errorln(args ...any) {
+	log.Println(args...)
+	p.Fail()
+}
+
+// Errorf is equivalent to Logf followed by Fail.
+func (p *T) Errorf(format string, args ...any) {
+	log.Printf(format, args...)
+	p.Fail()
+}
+
+// Fatal is equivalent to Log followed by FailNow.
+func (p *T) Fatal(args ...any) {
+	log.Panicln(args...)
+}
+
+// Fatalf is equivalent to Logf followed by FailNow.
+func (p *T) Fatalf(format string, args ...any) {
+	log.Panicf(format, args...)
+}
+
+// Skip is equivalent to Log followed by SkipNow.
+func (p *T) Skip(args ...any) {
+	log.Println(args...)
+	p.SkipNow()
+}
+
+// Skipf is equivalent to Logf followed by SkipNow.
+func (p *T) Skipf(format string, args ...any) {
+	log.Printf(format, args...)
+	p.SkipNow()
+}
+
+// SkipNow marks the test as having been skipped and stops its execution
+// by calling runtime.Goexit.
+// If a test fails (see Error, Errorf, Fail) and is then skipped,
+// it is still considered to have failed.
+// Execution will continue at the next test or benchmark. See also FailNow.
+// SkipNow must be called from the goroutine running the test, not from
+// other goroutines created during the test. Calling SkipNow does not stop
+// those other goroutines.
+func (p *T) SkipNow() {
+	p.skipped = true
+}
+
+// Skipped reports whether the test was skipped.
+func (p *T) Skipped() bool {
+	return p.skipped
+}
+
+// Helper marks the calling function as a test helper function.
+// When printing file and line information, that function will be skipped.
+// Helper may be called simultaneously from multiple goroutines.
+func (p *T) Helper() {
+}
+
+// Cleanup registers a function to be called when the test (or subtest) and all its
+// subtests complete. Cleanup functions will be called in last added,
+// first called order.
+func (p *T) Cleanup(f func()) {
+	// TODO(xsw):
+}
+
+// TempDir returns a temporary directory for the test to use.
+// The directory is automatically removed by Cleanup when the test and
+// all its subtests complete.
+// Each subsequent call to t.TempDir returns a unique directory;
+// if the directory creation fails, TempDir terminates the test by calling Fatal.
+func (p *T) TempDir() string {
+	panic("todo")
+}
+
+// Run runs f as a subtest of t called name.
+//
+// Run may be called simultaneously from multiple goroutines, but all such calls
+// must return before the outer test function for t returns.
+func (p *T) Run(name string, f func()) bool {
+	p.name = name
+	f()
+	return true
+}
+
+// Deadline reports the time at which the test binary will have
+// exceeded the timeout specified by the -timeout flag.
+//
+// The ok result is false if the -timeout flag indicates “no timeout” (0).
+func (p *T) Deadline() (deadline time.Time, ok bool) {
+	panic("todo")
+}