// The abstract class that all tests inherit from.
//
// In Google Test, a unit test program contains one or many TestCases, and
// each TestCase contains one or many Tests.
//
// When you define a test using the TEST macro, you don't need to
// explicitly derive from Test - the TEST macro automatically does
// this for you.
//
// The only time you derive from Test is when defining a test fixture

test ./...', and even 'go test .'). In this mode, go test compiles
and tests each of the packages listed on the command line. If a
package test passes, go test prints only the final 'ok' summary
line. If a package test fails, go test prints the full test output.
If invoked with the -bench or -v flag, go test prints the full
output even for passing package tests, in order to display the

		{"volatile-bucket-1", "test1", "", 0, 0, ListPartsInfo{}, BucketNotFound{Bucket: "volatile-bucket-1"}, false},
		{"volatile-bucket-2", "test1", "", 0, 0, ListPartsInfo{}, BucketNotFound{Bucket: "volatile-bucket-2"}, false},
		{"volatile-bucket-3", "test1", "", 0, 0, ListPartsInfo{}, BucketNotFound{Bucket: "volatile-bucket-3"}, false},
		// Test case for Asserting for invalid objectName (Test number 8).

// This makes it easy to run the TestServer from any of the tests.
// Using this interface, functionalities to be used in tests can be
// made generalized, and can be integrated in benchmarks/unit tests/go check suite tests.
type TestErrHandler interface {
	testing.TB
}

const (
	// ErasureSDStr is the string which is used as notation for Single node ObjectLayer in the unit tests.
	ErasureSDStr string = "ErasureSD"

					"plugins-distribution",
					"plugins-groovy",
					"plugins-java-base",
					"plugins-java-library",
					"plugins-jvm-test-fixtures",
					"plugins-jvm-test-suite",
					"plugins-test-report-aggregation",
					"plugins-version-catalog",
					"precondition-tester",
					"problems",
					"problems-api",
					"process-services",
					"publish",
					"reporting",
					"resources",

		},
	}
	for i := range successCases {
		test := successCases[i]
		err := PodMutateLimitFunc(&test.limitRange, &test.pod)
		if err != nil {
			t.Errorf("Unexpected error for pod: %s, %v", test.pod.Name, err)
		}
		err = PodValidateLimitFunc(&test.limitRange, &test.pod)
		if err != nil {
			t.Errorf("Unexpected error for pod: %s, %v", test.pod.Name, err)
		}
	}

	errorCases := []testCase{
		{

                implementation(libs.test1) {
                    because("reason1")

                    exclude(group: "test-group", module: "test-module")
                    artifact {
                        name = "test-name"
                        classifier = "test-classifier"
                        extension = "test-ext"
                        type = "test-type"
                        url = "test-url"

	{
		CaseName: Name(""),
		in:       `{"data":{"test1": "bob", "test2": 123}}`,
		ptr:      new(mapStringToStringData),
		err:      &UnmarshalTypeError{Value: "number", Type: reflect.TypeFor[string](), Offset: 37, Struct: "mapStringToStringData", Field: "data"},
	},
	{
		CaseName: Name(""),
		in:       `{"data":{"test1": 123, "test2": "bob"}}`,
		ptr:      new(mapStringToStringData),

// For example, using "matching" to mean "whose name contains":
//
//	go test -run ''        # Run all tests.
//	go test -run Foo       # Run top-level tests matching "Foo", such as "TestFooBar".
//	go test -run Foo/A=    # For top-level tests matching "Foo", run subtests matching "A=".
//	go test -run /A=1      # For all top-level tests, run subtests matching "A=1".
//	go test -fuzz FuzzFoo  # Fuzz the target matching "FuzzFoo"
//

	skipIfGccgo(t, "gccgo has no standard packages")
	tooSlow(t, "compiles and links a test binary")

	tg := testgo(t)
	defer tg.cleanup()
	tg.parallel()
	tg.makeTempdir()
	tg.run("test", "-c", "-o", tg.path("myerrors.test"+exeSuffix), "errors")
	tg.wantExecutable(tg.path("myerrors.test"+exeSuffix), "go test -c -o myerrors.test did not create myerrors.test")
}

func TestGoTestDashOWritesBinary(t *testing.T) {