To(Equal(uint32(expected.Tcp.TcpKeepalive.Time.Seconds)))
					g.Expect(cluster.UpstreamConnectionOptions.TcpKeepalive.KeepaliveInterval.Value).
						To(Equal(uint32(expected.Tcp.TcpKeepalive.Interval.Seconds)))
					g.Expect(cluster.ConnectTimeout).NotTo(BeNil())
					g.Expect(cluster.ConnectTimeout.Seconds).To(Equal(expected.Tcp.ConnectTimeout.Seconds))

					g.Expect(thresholds.MaxConnections).NotTo(BeNil())

	testCases := []struct {
		name   string
		errs   []error
		expect string
	}{
		{
			name: "two errors",
			errs: []error{
				errors.New(errMsg1),
				errors.New(errMsg2),
			},
			expect: "\t- " + errMsg1 + "\n" + "\t- " + errMsg2 + "\n",
		},
		{
			name: "one error",
			errs: []error{
				errors.New(errMsg1),
			},
			expect: "\t- " + errMsg1 + "\n",
		},
	}

Klaus Post <******@****.***> 1457448890 +0100

        b.toURL().text == "hi"

        when:
        server.stop()

        then:
        noExceptionThrown()
    }

    def "succeeds when expected serial requests are made"() {
        given:
        server.expect("a")
        server.expect("b")
        server.expect("c")
        server.start()

        when:
        succeeds("a")
        succeeds("b")
        succeeds("c")
        server.stop()

		ref := []OtherInterface{existing}
		err := act(&ref, tracked)
		g.Expect(err).To(BeNil())
		g.Expect(ref).To(HaveLen(2))
		g.Expect(existing).To(Equal(ref[0]))
		g.Expect(tracked).To(Equal(ref[1]))
	})
	t.Run("non pointer ref", func(t *testing.T) {
		g := NewWithT(t)
		err := act(resource.FakeResource{}, &resource.FakeResource{})
		g.Expect(err).NotTo(BeNil())
	})
}

func TestDeriveSuiteName(t *testing.T) {

Christian Wansart <******@****.***> 1573139799 +0100

Christian Wansart <******@****.***> 1573139799 +0100

        static class B extends RuleSource {}

        static class A extends RuleSource {}
    }

    def "find model rule sources - #clazz"() {
        expect:
        detector.getDeclaredSources(clazz).toList() == expected

        where:
        clazz         | expected
        String        | []
        HasOneSource  | [HasOneSource.Source]
        HasTwoSources | [HasTwoSources.SourceOne, HasTwoSources.SourceTwo]

	}
	tests := []struct {
		name   string
		args   []args
		expect []string
	}{
		{
			name:   "empty",
			args:   []args{},
			expect: nil,
		},
		{
			name:   "empty values",
			args:   []args{{agent: "", text: ""}},
			expect: nil,
		},
		{
			name:   "empty agent",
			args:   []args{{agent: "", text: "mytext"}},
			expect: []string{`299 - "mytext"`},
		},
		{
			name:   "simple",

			typ := TypeOf(test.val)
			fields := VisibleFields(typ)
			if got, want := len(fields), len(test.expect); got != want {
				t.Fatalf("unexpected field count; got %d want %d", got, want)
			}

			for j, field := range fields {
				expect := test.expect[j]
				t.Logf("field %d: %s", j, expect.name)
				gotField := typ.FieldByIndex(field.Index)
				// Unfortunately, FieldByIndex does not return