err error
}

func (f *fakeReporter) AsObject(err error) runtime.Object {
	f.err = err
	return runtime.Unstructured(nil)
}

func TestStreamWatcher(t *testing.T) {
	table := []Event{
		{Type: Added, Object: testType("foo")},
	}

	fd := fakeDecoder{items: make(chan Event, 5)}
	sw := NewStreamWatcher(fd, nil)

	for _, item := range table {
		fd.items <- item
		got, open := <-sw.ResultChan()
		if !open {

            </tr>
            <tr>
                <td>sources</td>
            </tr>
            <tr>
                <td>targets</td>
            </tr>
            <tr>
                <td>testType</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>

    def "#type has type variable: #hasTypeVariable"() {
        expect:
        JavaPropertyReflectionUtil.hasTypeVariable(type) == hasTypeVariable

        where:
        testType << testedTypes
        type = testType.first
        hasTypeVariable = testType.second
    }

    def "#method.genericReturnType resolves to #expectedResolvedReturnType"() {

}

version = '1.0.2'
group = 'org.gradle.sample'

repositories {
    mavenCentral()
}

// tag::configure-type[]
testing {
    suites {
        secondaryTest(JvmTestSuite) {
            testType = TestSuiteType.INTEGRATION_TEST // <1>
        }
    }
}

version = "1.0.2"
group = "org.gradle.sample"

repositories {
    mavenCentral()
}

// tag::configure-type[]
testing {
    suites {
        val secondaryTest by registering(JvmTestSuite::class) {
            testType = TestSuiteType.INTEGRATION_TEST // <1>
        }
    }
}

	if e, a := metav1.StatusReasonUnknown, ReasonForError(nil); e != a {
		t.Errorf("unexpected reason type: %#v", a)
	}
}

type TestType struct{}

func (obj *TestType) GetObjectKind() schema.ObjectKind { return schema.EmptyObjectKind }
func (obj *TestType) DeepCopyObject() runtime.Object {
	if obj == nil {
		return nil
	}
	clone := *obj
	return &clone
}

func TestFromObject(t *testing.T) {

                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>reportTask</td>
            </tr>
            <tr>
                <td>testType</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>

	}
}

func TestAll(t *testing.T) {
	testType(t, 1, TypeOf((int8)(0)), "int8")
	testType(t, 2, TypeOf((*int8)(nil)).Elem(), "int8")

	typ := TypeOf((*struct {
		c chan *int32
		d float32
	})(nil))
	testType(t, 3, typ, "*struct { c chan *int32; d float32 }")
	etyp := typ.Elem()
	testType(t, 4, etyp, "struct { c chan *int32; d float32 }")
}

            plugins { id("jacoco-report-aggregation") }

            reporting {
                reports {
                    val testCodeCoverageReport by creating(JacocoCoverageReport::class) {
                        testType = TestSuiteType.UNIT_TEST
                    }
                }
            }

            dependencies {
                jacocoAggregation(project(":plugin"))
            }
        '''

        when:
        def metadata = store.getTypeAnnotationMetadata(TypeWithAnnotations)

        then:
        metadata.annotations*.annotationType() == [TestType]
    }

    @TestType
    @Irrelevant
    interface TypeWithAnnotations {}

    def "warns about annotations on non-getter methods"() {
        expect:
        assertProperties TypeWithAnnotatedNonGetterMethods, [:], [