assertThat(GenericsUtil.getActualClass(method.getGenericReturnType(), map), is(sameClass(Long.class)));

        method = Hoge.class.getMethod("array");
        assertThat(GenericsUtil.getActualClass(method.getGenericReturnType(), map), is(sameClass(String[].class)));

        method = Hoge.class.getMethod("list");

class SomeClass

class OtherClass {
    class NestedClass {
        @Suppress("CONFLICTING_OVERLOADS")
        fun someFun(): SomeClass {
            return SomeClass()
        }

        @Suppress("CONFLICTING_OVERLOADS")
        fun someFun() {
        }
    }

        assertThat(ClassUtil.getPrimitiveClassIfWrapper(String.class), is(sameClass(String.class)));
        assertThat(ClassUtil.getPrimitiveClassIfWrapper(Byte.class), is(sameClass(byte.class)));
    }

    /**
     *
     */
    @Test
    public void testGetWrapperClass() {
        assertThat(ClassUtil.getWrapperClass(int.class), is(sameClass(Integer.class)));

     */
    public void testGetKeyTypeOfMap() throws Exception {
        final Field f = ClassUtil.getField(Baz.class, "map");
        assertThat(FieldUtil.getKeyTypeOfMap(f), is(sameClass(String.class)));
        assertThat(FieldUtil.getValueTypeOfMap(f), is(sameClass(Integer.class)));
    }

    /**
     *
     */
    public static class Baz {

        /** */
        @SuppressWarnings("rawtypes")

        'unknown classloader for class'              | { -> ImplementationSnapshot.of("SomeClass", null) }
        'unknown classloader for lambda'             | { -> ImplementationSnapshot.of('SomeClass$$Lambda/23501234324', null) }
        'unknown lambda'                             | { -> ImplementationSnapshot.of('SomeClass$$Lambda/23501234324', SHARED_CLASSLOADER_HASH) }

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is(sameClass(Integer.class)));

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is(sameClass(Number.class)));

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is(sameClass(Object.class)));

        assertThat(it.hasNext(), is(not(true)));
    }

    /**

class SomeClass

@Suppress("CONFLICTING_OVERLOADS")
fun someFun(): SomeClass {
    return SomeClass()
}

@Suppress("CONFLICTING_OVERLOADS")
fun someFun() {

class SomeClass

class OtherClass {
    @Suppress("CONFLICTING_OVERLOADS")
    fun someFun(): SomeClass {
        return SomeClass()
    }

    @Suppress("CONFLICTING_OVERLOADS")
    fun someFun() {
    }

                                              // AccessedFromPrivateClassPublicField.name, // would be in ClassAnalysis for SomeClass$Foo
                                              SomeClass.name + '$Foo',
                                              SomeClass.name + '$1'] as Set
    }

    def "knows basic class dependencies of a groovy class"() {

        when:
        componentUnderTest.applyModificationToClassAccessedFromPrivateMethod()
        run language.compileTaskName

        then:
        outputs.recompiledClasses 'AccessedFromPrivateMethod', 'SomeClass', 'SomeClass$Foo'
    }

    def "change to class accessed from private method body only recompile that class and the direct consumer"() {
        def componentUnderTest = new IncrementalLib()