# define TYPED_TEST(CaseName, TestName) \
  template <typename gtest_TypeParam_> \
  class GTEST_TEST_CLASS_NAME_(CaseName, TestName) \
      : public CaseName<gtest_TypeParam_> { \
   private: \
    typedef CaseName<gtest_TypeParam_> TestFixture; \
    typedef gtest_TypeParam_ TypeParam; \
    virtual void TestBody(); \
  }; \
  bool gtest_##CaseName##_##TestName##_registered_ GTEST_ATTRIBUTE_UNUSED_ = \

)

func TestRecycleSlices(t *testing.T) {
	testCases := []struct {
		testName       string
		startingSlices *slicesByAction
		expectedSlices *slicesByAction
	}{{
		testName:       "Empty slices",
		startingSlices: &slicesByAction{},
		expectedSlices: &slicesByAction{},
	}, {
		testName: "1 to create and 1 to delete",
		startingSlices: &slicesByAction{

        return packages.values();
    }

    public TestResult addTest(long classId, String className, String testName, long duration) {
        return addTest(classId, className, className, testName, testName, duration);
    }

    public TestResult addTest(long classId, String className, String classDisplayName, String testName, String testDisplayName, long duration) {
        PackageTestResults packageResults = addPackageForClass(className);

	tests := []struct {
		testName  string
		input     []string
		whitelist []string
		expected  bool
	}{
		{
			testName:  "equal input and whitelist",
			input:     []string{"foo-bar-nosched", "foo-baz-nosched"},
			whitelist: []string{"foo-bar-nosched", "foo-baz-nosched"},
			expected:  true,
		},
		{
			testName:  "duplicate input allowed",

    @Test
    public void testInit() {
        String testName = "name";
        String testType = "type";
        String testExtension = "ext";
        String testClassifier = "classifier";
        String testUrl = "url";
        DependencyArtifact artifact = new DefaultDependencyArtifact(testName, testType, testExtension, testClassifier, testUrl);
        assertEquals(testName, artifact.getName());

        return classes.values();
    }

    public TestResult addTest(long classId, String className, String testName, long duration) {
        return addTest(classId, className, className, testName, testName, duration);
    }

    public TestResult addTest(long classId, String className, String classDisplayName, String testName, String testDisplayName, long duration) {

		},
	}
	for testName, testCase := range testCases {
		t.Run(testName, func(t *testing.T) {
			featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.RecoverVolumeExpansionFailure, testCase.enableRecoverFromExpansion)
			actual, err := evaluator.Usage(testCase.pvc)
			if err != nil {
				t.Errorf("%s unexpected error: %v", testName, err)
			}

            useDefaultListeners == source.useDefaultListeners
            threadPoolFactoryClass == source.threadPoolFactoryClass
            suiteName == source.suiteName
            testName == source.testName
            suiteXmlFiles == source.suiteXmlFiles
            preserveOrder == source.preserveOrder
            groupByInstances == source.groupByInstances
        }
    }

	"os"
	"path/filepath"
	"testing"
)

const asmData = `
GLOBL zeros<>(SB),8,$64
TEXT ·testASM(SB),4,$0
VMOVUPS zeros<>(SB), %s // PC relative relocation is off by 1, for Y8-Y15, Z8-15 and Z24-Z31
RET
`

const goData = `
package main

func testASM()

func main() {
	testASM()
}
`

func objdumpOutput(t *testing.T, mname, source string) []byte {
	tmpdir, err := os.MkdirTemp("", mname)

		expectedClientActions    int
		expectedMetrics          *expectedMetrics
	}{{
		testName:               "Endpoints with no subsets",
		subsets:                []corev1.EndpointSubset{},
		existingEndpointSlices: []*discovery.EndpointSlice{},
		expectedNumSlices:      0,
		expectedClientActions:  0,
		expectedMetrics:        &expectedMetrics{},
	}, {
		testName: "Endpoints with no addresses",
		subsets: []corev1.EndpointSubset{{