return null;
        }
    }

    public static <T> ModelType<T> typeOf(T instance) {
        // TODO: should validate that clazz is of a non parameterized type
        @SuppressWarnings("unchecked") Class<T> clazz = (Class<T>) instance.getClass();
        return of(clazz);
    }

    public static ModelType<?> of(Type type) {
        return Simple.typed(type);
    }

    /**

 *
 * @author koichik
 */
class JulLoggerAdapterFactory implements LoggerAdapterFactory {

    @Override
    public LoggerAdapter getLoggerAdapter(final Class<?> clazz) {
        return new JulLoggerAdapter(clazz);
    }

    @Override
    public void releaseAll() {
    }

                Class<?> clazz = (Class<?>) args[0];
                Closure<?> closure = (Closure<?>) args[1];
                getChildPath(name).register(clazz, closure);
                return null;
            } else if (args.length == 1 && args[0] instanceof Class) {
                Class<?> clazz = (Class<?>) args[0];
                getChildPath(name).register(clazz, Actions.doNothing());
                return null;

       * trivially, but it's enough to skip these ones.
       */
      ) {
        continue;
      }
      Class<?> clazz = info.load();
      try {
        Method unused = clazz.getDeclaredMethod("writeReplace");
        continue; // It overrides writeReplace, so it's safe.
      } catch (NoSuchMethodException e) {

    protected final String sourceClass;

    protected final java.util.logging.Logger logger;

    public JulLoggerAdapter(final Class<?> clazz) {
        sourceClass = clazz.getName();
        logger = java.util.logging.Logger.getLogger(clazz.getName());
    }

    @Override
    public boolean isFatalEnabled() {
        return logger.isLoggable(Level.SEVERE);
    }

    @Override

        }
    }

    protected static TextResource utf8ClassPathResource(final Class<?> clazz, final String filename) {
        return new CharSourceBackedTextResource("Classpath resource '" + filename + "'", new CharSource() {
            @Override
            public Reader openStream() throws IOException {
                InputStream stream = clazz.getResourceAsStream(filename);
                if (stream == null) {

  }

  private fun registerStandardClass(
    access: Feature.BeforeAnalysisAccess,
    name: String,
  ) {
    val clazz: Class<*> = access.findClassByName(name) ?: throw IllegalStateException("Missing class $name")
    RuntimeReflection.register(clazz)
    clazz.declaredConstructors.forEach {
      RuntimeReflection.register(it)
    }
  }

        TestResult smallerName = new TestResult('a', 0, class1)
        TestResult largerName = new TestResult('z', 0, class1)

        expect:
        [result, largerName, smallerClass, largerClass, smallerName].sort() == [smallerClass, smallerName, result, largerName, largerClass]
    }

    def doesNotDiscardDuplicatesWhenSorting() {
        ClassTestResults class1 = Mock()
        _ * class1.name >> 'name'

        fails "test"

        then:
        def xmlReport = new JUnitXmlTestExecutionResult(testDirectory)
        def clazz = xmlReport.testClass("SomeTest")
        clazz.testCount == 6
        (clazz as JUnitTestClassExecutionResult).testCasesCount == 2
        clazz.assertTestPassed("testFlaky[]")
        clazz.assertTestFailed("testFailing[]", CoreMatchers.anything())
    }

    // TODO: remove in Gradle 9.0

    }

    private static Class<?> getDeclaredTaskType(Task original) {
        Class<?> clazz = new DslObject(original).getDeclaredType();
        if (clazz.equals(DefaultTask.class)) {
            return org.gradle.api.Task.class;
        } else {
            return clazz;
        }
    }