}

    public void setWhy(String why) {
        this.why = why;
    }

    public String getError() {
        return error;
    }

    public void setError(String error) {
        this.error = error;
    }

    public boolean isError() {
        return error == null;
    }

    public String getDependencyConflictId() {
        return groupId + ":" + artifactId;
    }

		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			sources, err := GetValidatedSources(test.sources)
			if test.errExpected {
				assert.Error(t, err)
			} else {
				assert.NoError(t, err)
			}
			assert.Len(t, sources, test.sourcesLen)
		})
	}
}

func TestGetPodSource(t *testing.T) {
	tests := []struct {
		name        string
		pod         *v1.Pod

				if tc.oldObj == nil {
					require.NoError(t, store.Add(claim))
				} else {
					require.NoError(t, store.Update(claim))
				}
			}
			actualHint, err := testCtx.p.isSchedulableAfterClaimChange(logger, tc.pod, tc.oldObj, tc.newObj)
			if tc.expectedErr {
				require.Error(t, err)
				return
			}

			require.NoError(t, err)
			require.Equal(t, tc.expectedHint, actualHint)
		})

			upgrade:          "websocket",
			version:          "",
			expectTranslator: false,
		},
	}
	for name, test := range tests {
		req, err := http.NewRequest("GET", "http://www.example.com/", nil)
		require.NoError(t, err)
		if test.upgrade != "" {
			req.Header.Add("Connection", "Upgrade")
			req.Header.Add("Upgrade", test.upgrade)
		}
		if len(test.version) > 0 {
			req.Header.Add(wsstream.WebSocketProtocolHeader, test.version)

	msg, err := handlerRunner.Run(ctx, containerID, &pod, &container, container.Lifecycle.PostStart)
	if err == nil {
		t.Errorf("expected error: %v", expectedErr)
	}
	if msg != expectedErrMsg {
		t.Errorf("unexpected error message: %q; expected %q", msg, expectedErrMsg)
	}
}

	Sec  int64
	Nsec int64
}

type Timeval struct {
	Sec  int64
	Usec int64
}

type Timex struct {
	Modes     uint32
	Pad_cgo_0 [4]byte
	Offset    int64
	Freq      int64
	Maxerror  int64
	Esterror  int64
	Status    int32
	Pad_cgo_1 [4]byte
	Constant  int64
	Precision int64
	Tolerance int64
	Time      Timeval
	Tick      int64
	Ppsfreq   int64
	Jitter    int64
	Shift     int32

		if err != nil {
			t.Fatalf("Failure in test case %v. Error %s", i, err)
		}
		err = ValidateIOPCAConfig(k8sClient, op)
		if !tt.expErr && err != nil {
			t.Fatalf("Failure in test case %v. Expected No Error. Got %s", i, err)
		} else if tt.expErr && err == nil {
			t.Fatalf("Failure in test case %v. Expected Error. Got No error", i)
		}
	}
}

func TestPrometheusPathAndPort(t *testing.T) {

 * to both the artifacts and the meta-data of the result.
 */
public interface ResolvedConfiguration {
    /**
     * Returns whether all dependencies were successfully retrieved or not.
     */
    boolean hasError();

    /**
     * Provides configuration that does not fail eagerly when some dependencies are not resolved.
     */
    LenientConfiguration getLenientConfiguration();

    /**

			serv.statusCode = testcase.code
			serv.called = 0

			_, ok, err := wh.AuthenticateToken(context.Background(), testcase.token)
			hasError := err != nil
			if hasError != testcase.expectError {
				t.Errorf("Webhook returned HTTP %d, expected error=%v, but got error %v", testcase.code, testcase.expectError, err)
			}
			if serv.called != testcase.expectCalls {

Bixia Zheng <******@****.***> 1583166655 -0800