Method m = Baz.class.getMethod("rawMap", Map.class);
        assertThat(MethodUtil.getValueTypeOfMapFromReturnType(m), is(nullValue()));

        m = Baz.class.getMethod("genericMap", Map.class);
        assertThat(MethodUtil.getValueTypeOfMapFromReturnType(m), is(sameClass(Class.class)));
    }

    /**
     *
     */
    public interface Baz {

        /**

    Object[] array = collection.toArray();
    assertEquals(Object[].class, array.getClass());
  }

  public void testToArray_emptyArray() {
    E[] empty = getSubjectGenerator().createArray(0);
    E[] array = collection.toArray(empty);
    assertEquals(
        "toArray(emptyT[]) should return an array of type T", empty.getClass(), array.getClass());
    assertEquals("toArray(emptyT[]).length:", getNumElements(), array.length);

Diagnostics from elements:
  for PSI element of type KtClass at (6,1-11)
    ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED      text ranges: [(62,69)]
      PSI: KtClass at (6,1-11)
  for PSI element of type KtNamedFunction at (4,3-21)
    ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS      text ranges: [(41,49)]
      PSI: KtNamedFunction at (4,3-21)
  for PSI element of type KtTypeReference at (6,10-11)
    FINAL_SUPERTYPE      text ranges: [(71,72)]

        if (obj == null) {
            return false;
        }

        return Objects.equal(obj.getClass(), getClass());
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(getClass());
    }

                    assert MyAgent.class.getClassLoader() == ClassLoader.getSystemClassLoader().getParent() : "MyAgent is not loaded via the system classloader: " + MyAgent.class.getClassLoader().getClass().getName();
                }
            }
        """.stripIndent()
        file('src/test/java/org/gradle/JUnitTest.java') << """

      assertThrows(IllegalArgumentException.class, () -> Resources.getResource("no such resource"));
    } finally {
      Thread.currentThread().setContextClassLoader(oldContextLoader);
    }
  }

  @AndroidIncompatible // .class files aren't available
  public void testNulls() {
    new NullPointerTester()
        .setDefault(URL.class, classfile(ResourcesTest.class))
        .testAllPublicStaticMethods(Resources.class);

    }

    /**
     *
     */
    @Test
    public void testGetWrapperClassIfWrapper() {
        assertThat(ClassUtil.getWrapperClassIfPrimitive(int.class), is(sameClass(Integer.class)));
        assertThat(ClassUtil.getWrapperClassIfPrimitive(String.class), is(sameClass(String.class)));
        assertThat(ClassUtil.getWrapperClassIfPrimitive(byte.class), is(sameClass(Byte.class)));
    }

import kotlin.reflect.KClass


/**
 * Utility [TypeDiscovery] implementation that allows introducing [discoverClasses] as soon as [keyClass] is encountered in type discovery.
 */
internal
class FixedTypeDiscovery(private val keyClass: KClass<*>, private val discoverClasses: List<KClass<*>>) : TypeDiscovery {
    override fun getClassesToVisitFrom(kClass: KClass<*>): Iterable<KClass<*>> =
        when (kClass) {

    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType"), Pattern.compile("^(.+)\\.kts$"), null, true);
  }

  @Nested
  @TestMetadata("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/approximatedLocalClasses")
  @TestDataPath("$PROJECT_ROOT")
  public class ApproximatedLocalClasses {
    @Test

    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType"), Pattern.compile("^(.+)\\.kts$"), null, true);
  }

  @Nested
  @TestMetadata("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/approximatedLocalClasses")
  @TestDataPath("$PROJECT_ROOT")
  public class ApproximatedLocalClasses {
    @Test