}
	return a[i].Data.(string) < a[j].Data.(string)
}

func verifyEvents(t *testing.T, expected, actual []*PodLifecycleEvent) {
	sort.Sort(sortableEvents(expected))
	sort.Sort(sortableEvents(actual))
	if !reflect.DeepEqual(expected, actual) {
		t.Errorf("Actual events differ from the expected; diff:\n %v", cmp.Diff(expected, actual))
	}
}

func TestRelisting(t *testing.T) {
	testPleg := newTestGenericPLEG()

				}
				if expected, ok := test.expectErr(err); !ok {
					t.Errorf("[%s]expect:\n %v\n but got:\n %v\n", test.name, expected, err)
				}
				return
			}

			if test.expectErr != nil {
				t.Errorf("[%s]expect:\n error\n but got:\n no error\n", test.name)
				return
			}

			if test.expectOut != buffer.String() {
				t.Errorf("[%s]expect:\n %v\n but got:\n %v\n", test.name, test.expectOut, buffer.String())
			}
		})
	}

            }
            '''.stripIndent()

        expect:
        succeeds('verify')
    }

    def "has no value when providing a null map to a map property"() {
        given:
        buildFile << '''
            verify {
                prop.putAll(project.provider { null })
                expected = null
            }
            '''.stripIndent()

        expect:

func NewMockPodManager(ctrl *gomock.Controller) *MockPodManager {
	mock := &MockPodManager{ctrl: ctrl}
	mock.recorder = &MockPodManagerMockRecorder{mock}
	return mock
}

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

// GetMirrorPodByPod mocks base method.
func (m *MockPodManager) GetMirrorPodByPod(arg0 *v1.Pod) (*v1.Pod, bool) {

			g := NewWithT(t)

			_, err := c.b.Build()
			if c.expectError {
				g.Expect(err).ToNot(BeNil())
			} else {
				g.Expect(err).To(BeNil())
			}
		})
	}
}

func TestCanonicalName(t *testing.T) {
	cases := []struct {
		name     string
		s        Schema
		expected string
	}{
		{
			name: "group",
			s: Builder{
				Group:        "g",
				Version:      "v",

  if (!num_outs)
    return switchn.emitOpError() << "expects a `num_outs` integer attribute";

  // Expect num_outs results + 1 control output.
  if (switchn.getNumResults() != num_outs.getInt() + 1)
    return switchn.emitOpError()
           << "expect `num_outs` (" << num_outs.getInt() << ") results but got "
           << (switchn.getNumResults() - 1);

	}()

	expectErrorEvent(t, dw) // expect error is plumbed and doesn't force close the watcher
	expectPodEvent(t, dw, watch.Added)
	expectErrorEvent(t, dw) // expect error is plumbed and doesn't force close the watcher
	expectPodEvent(t, dw, watch.Modified)
	expectErrorEvent(t, dw) // expect error is plumbed and doesn't force close the watcher
	expectPodEvent(t, dw, watch.Deleted)

        expectProperty("org.gradle.internal.xcode.bridge.ACTION", "myaction")

        expect:
        xcodePropertyAdapter.action == "" // default value
        xcodePropertyAdapter.action == "myaction"
    }

    def "getProductName"() {
        expectProperty("org.gradle.internal.xcode.bridge.PRODUCT_NAME", "myproduct")

        expect:
        xcodePropertyAdapter.productName == "" // default value

    flags: "--quiet"
    expected-output-file: dependencyReport.out
    expect-failure: false
},{
    executable: gradle
    args: "dependencyInsight --configuration compileClasspath --dependency log4j -Preplace"
    flags: "--quiet"
    expected-output-file: dependencyReportReplaced.out
    expect-failure: false

			"authorizers":[{"type":"Webhook"}]}`
		expect := &api.AuthorizationConfiguration{
			Authorizers: []api.AuthorizerConfiguration{{Type: "Webhook"}},
		}

		config, err := LoadFromFile(writeTempFile(t, input))
		if err != nil {
			t.Fatalf("unexpected err: %v", err)
		}
		if !reflect.DeepEqual(config, expect) {
			t.Fatalf("unexpected config:\n%s", cmp.Diff(expect, config))
		}
	}

	// missing file
	{