mock := &MockDevicesProvider{ctrl: ctrl}
	mock.recorder = &MockDevicesProviderMockRecorder{mock}
	return mock
}

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

// GetAllocatableDevices mocks base method.

}

// writeReadExpect writes ss, then reads stdout and stderr until something
// that matches expectRE appears.  expectRE should not be ""
func (s *ioState) writeReadExpect(ss, expectRE string) tstring {
	if *verbose {
		fmt.Printf("=> %s", ss)
	}
	if expectRE == "" {
		panic("expectRE should not be empty; use .* instead")
	}
	_, err := io.WriteString(s.stdin, ss)
	if err != nil {

						// TODO(nmittler): Why does passthrough not work?
						ConditionallyTo(echotest.SameNetwork).
						Run(func(t framework.TestContext, from echo.Instance, to echo.Target) {
							for _, expect := range tc.expected {
								expect := expect
								p := expect.port
								opts := echo.CallOptions{
									// Do not set To, otherwise fillInCallOptions() will
									// complain with port does not match.

		{Namespace: "foo", Name: "bar", Username: "foo:bar", Expect: false},
		{Namespace: "foo", Name: "bar", Username: "", Expect: false},

		{Namespace: "foo2", Name: "bar", Username: "system:serviceaccount:foo:bar", Expect: false},
		{Namespace: "foo", Name: "bar2", Username: "system:serviceaccount:foo:bar", Expect: false},
		{Namespace: "foo:", Name: "bar", Username: "system:serviceaccount:foo:bar", Expect: false},

commands: [{
  executable: gradle
  args: "--rerun-tasks someTask -DsomeDestination=dest"
  expect-failure: true
  expected-output-file: fail.out
  allow-additional-output: true
  allow-disordered-output: true
},{
  executable: gradle
  args: "--rerun-tasks --configuration-cache-problems=warn someTask -DsomeDestination=dest"
  expect-failure: false
  expected-output-file: store.out
  allow-additional-output: true
}, {
  executable: gradle

        def file = new File("a.txt")

        expect:
        pathNotationParser.parseNotation(file) == file.path
    }

    def "with Number"() {
        expect:
        expected == pathNotationParser.parseNotation(input);
        where:
        input << [1, 1.5, -1]
        expected << ["1", "1.5", "-1"]
    }

    def "with Boolean"() {
        expect:
        expected == pathNotationParser.parseNotation(input);

        def candidates = permutation.candidates
        def expected = permutation.expectedSingle

        expect:
        resolver(permutation.conflicts).resolve(candidates) == expected

        where:
        permutation << SCENARIOS_SINGLE
    }

    def "resolve pair #permutation (batch 1)"() {
        given:
        def candidates = permutation.candidates
        def expected = permutation.expectedSingle

        expect:

	}
}

func TestDeletedAtUnMarshal(t *testing.T) {
	expected := &gorm.Model{}
	b, _ := json.Marshal(expected)

	result := &gorm.Model{}
	_ = json.Unmarshal(b, result)
	if result.DeletedAt != expected.DeletedAt {
		t.Errorf("Failed, result.DeletedAt: %v is not same as expected.DeletedAt: %v", result.DeletedAt, expected.DeletedAt)
	}
}

func TestDeletedAtOneOr(t *testing.T) {

			request:   &model.PushRequest{Full: true},
			expect:    map[string]Expected{},
		},
		{
			name:      "multiple",
			proxy:     &model.Proxy{VerifiedIdentity: &spiffe.Identity{Namespace: "istio-system"}, Type: model.Router},
			resources: allResources,
			request:   &model.PushRequest{Full: true},
			expect: map[string]Expected{
				"kubernetes://generic": {
					Key:  string(genericCert.Data[credentials.GenericScrtKey]),

                @Internal
                List<String> expected = []

                @TaskAction
                void validate() {
                    def actual = prop.getOrNull()
                    println 'Actual: ' + actual
                    println 'Expected: ' + expected
                    assert expected == actual
                    actual.each { assert it instanceof String }
                }