switch {
			case testCase.expectedErr == nil:
				if err != nil {
					t.Errorf("error: expected = <nil>, got = %v", err)
				}
			case err == nil:
				t.Errorf("error: expected = %v, got = <nil>", testCase.expectedErr)
			case testCase.expectedErr.Error() != err.Error():
				t.Errorf("error: expected = %v, got = %v", testCase.expectedErr, err)
			}
		})
	}
}

			var expiration Expiration
			err := xml.Unmarshal([]byte(tc.inputXML), &expiration)
			if err != tc.expectedErr {
				t.Fatalf("%d: Expected %v but got %v", i+1, tc.expectedErr, err)
			}
		})
	}

	validationTestCases := []struct {
		inputXML    string
		expectedErr error
	}{
		{ // Expiration with a valid ISO 8601 date
			inputXML: `<Expiration>
                                    <Date>2019-04-20T00:00:00Z</Date>

        return outputs;
    }

    /**
     * Given some expectedText, assert that the output of this fixture contains it.
     *
     * @param expectedText the expected lines of expectedText
     * @return this fixture
     */
    public GroupedNodeFixture assertOutputContains(String expectedText) {
        return assertOutputContains(ComparisonFailureFormat.LINEWISE, expectedText);
    }

    /**

    }

    /**
     * Given some expectedText, assert that the output of this fixture contains it.
     *
     * @param expectedText the expected lines of expectedText
     * @return this fixture
     */
    public GroupedWorkOutputFixture assertOutputContains(String expectedText) {
        return assertOutputContains(ComparisonFailureFormat.LINEWISE, expectedText);
    }

    /**

		waitTime, err := cu.GetWaitTime(c.cert, c.now)
		if c.expectedErr != "" {
			if err == nil {
				t.Errorf("%s: no error is returned.", id)
			}
			if err.Error() != c.expectedErr {
				t.Errorf("%s: incorrect error message: %s VS %s", id, err.Error(), c.expectedErr)
			}
		} else {
			if err != nil {
				t.Errorf("%s: unexpected error: %v", id, err)
			}
			if int(waitTime.Seconds()) != c.expectedWaitTime {

			expectedExp: time.Time{},
			expectedErr: fmt.Errorf("failed to decode the JWT claims"),
		},
	}

	for id, tc := range testCases {
		t.Run(id, func(t *testing.T) {
			exp, err := GetExp(tc.jwt)
			if err != nil && tc.expectedErr == nil || err == nil && tc.expectedErr != nil {
				t.Errorf("%s: Got error \"%v\", expected error \"%v\"", id, err, tc.expectedErr)

		config      string
		expectedErr bool
		hash        string
	}{
		{
			config:      "testdata/config/1.yaml",
			expectedErr: false,
			hash:        "hash:02bf70285dc71f76",
		},
		{
			config:      "testdata/config/2.yaml",
			expectedErr: false,
			hash:        "hash:676d2da00f71f205",
		},
		{
			config:      "testdata/config/invalid.yaml",
			expectedErr: true,
		},
		{

		path           string
		expectedErr    error
		expectedConfig *config.KubeSchedulerConfiguration
	}{
		{
			name:           "Empty scheduler config file path",
			path:           "",
			expectedErr:    syscall.Errno(syscall.ENOENT),
			expectedConfig: nil,
		},
		{
			name:           "Correct scheduler config",
			path:           correctConfigFile,
			expectedErr:    nil,

		expectedKey string
		expectedVal string
		expectedErr bool
	}{
		{
			name:        "arg cannot be empty",
			arg:         "",
			expectedErr: true,
		},
		{
			name:        "arg must contain -- and =",
			arg:         "a",
			expectedErr: true,
		},
		{
			name:        "arg must contain -- and =",
			arg:         "a-z",
			expectedErr: true,
		},
		{

		topology      *topology.CPUTopology
		topoMgrPolicy string
		expectedErr   bool
	}{
		{
			description:   "Align by socket not enabled",
			policyOption:  map[string]string{FullPCPUsOnlyOption: "true"},
			topology:      topoDualSocketMultiNumaPerSocketHT,
			topoMgrPolicy: topologymanager.PolicySingleNumaNode,
			expectedErr:   false,
		},
		{