params, err := option.NewTemplateParams(c.option)
			if c.expectError {
				g.Expect(err).ToNot(BeNil())
			} else {
				g.Expect(err).To(BeNil())
				actual, ok := params[c.key]
				if c.expected == nil {
					g.Expect(ok).To(BeFalse())
				} else {
					g.Expect(ok).To(BeTrue())
					g.Expect(actual).To(Equal(c.expected))
				}
			}
		})
	}

			r := NewResource(test.resourceList)
			if !reflect.DeepEqual(test.expected, r) {
				t.Errorf("expected: %#v, got: %#v", test.expected, r)
			}
		})
	}
}

func TestResourceClone(t *testing.T) {
	tests := []struct {
		resource *Resource
		expected *Resource
	}{
		{
			resource: &Resource{},
			expected: &Resource{},
		},
		{
			resource: &Resource{
				MilliCPU:         4,

func NewMockVersion(ctrl *gomock.Controller) *MockVersion {
	mock := &MockVersion{ctrl: ctrl}
	mock.recorder = &MockVersionMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVersion) EXPECT() *MockVersionMockRecorder {
	return m.recorder
}

// Compare mocks base method.
func (m *MockVersion) Compare(other string) (int, error) {
	m.ctrl.T.Helper()

	tests := []struct {
		app    echo.Instance
		expect bool
	}{
		{app: a1, expect: true},
		{app: b1, expect: true},
		{app: vm1, expect: false},
		{app: naked1, expect: false},
		{app: external1, expect: false},
		{app: headless1, expect: false},
	}
	for _, tt := range tests {
		t.Run(tt.app.Config().Service, func(t *testing.T) {
			if got := match.RegularPod(tt.app); got != tt.expect {
				t.Errorf("got %v expected %v", got, tt.expect)

)

func TestStartWithError(t *testing.T) {
	g := NewWithT(t)

	inst := server.New()
	expected := errors.New("fake")
	inst.RunComponent("fake", func(stop <-chan struct{}) error {
		return expected
	})

	stop := newReclosableChannel()
	t.Cleanup(stop.Close)
	g.Expect(inst.Start(stop.c)).To(Equal(expected))
}

func TestStartWithNoError(t *testing.T) {
	g := NewWithT(t)

	inst := server.New()

    def "accepts valid input"() {
        def event = new SelectOptionPromptEvent(123, "question", ["1", "2", "3", "4"], 1)

        expect:
        def result = event.convert(input)
        result.response == expected
        result.newPrompt == null

        where:
        input | expected
        '1'   | 0
        '4'   | 3
        ' 1 ' | 0
    }

    def "uses default value on empty input"() {

					}
					if cluster.LoadAssignment.Endpoints[i].Priority != tt.expected[i].Priority {
						t.Errorf("Got unexpected priority %v expected %v", cluster.LoadAssignment.Endpoints[i].Priority, tt.expected[i].Priority)
					}
				}
			})
		}
	})

	t.Run("FailoverPriority with Failover", func(t *testing.T) {

        expect:
        featureUsage.formattedMessage() == expected

        where:
        summary   | removalDetails   | advice   | contextualAdvice   | documentationReference                       | expected

        expect:
        try {
            def result = dep.selectVariants(variantSelector, attributes(queryAttributes), toComponent, attributesSchema, [] as Set).variants.name as Set
            if (expected == null && result) {
                throw new Exception("Expected an ambiguous result, but got $result")
            }
            assert result == [expected] as Set

			}
		})
	}

}

func toBe(expected ...string) func(warnings []admissionregistrationv1.ExpressionWarning, t *testing.T) {
	return func(warnings []admissionregistrationv1.ExpressionWarning, t *testing.T) {
		if len(expected) != len(warnings) {
			t.Fatalf("mismatched length, expect %d, got %d", len(expected), len(warnings))
		}
		for i := range expected {
			if expected[i] != warnings[i].FieldRef {