assertHasClassCoverage(clazz, 0)
    }

    void assertDoesNotContainClass(String clazz) {
        assert findClass(clazz) == null
    }

    Coverage findClass(String clazz) {
        def searchFor = clazz.replace('.', '/')
        return classes.find(candidate -> candidate.name == searchFor)
    }

    @Immutable
    static class Coverage {
        String name

        super(name, parent, urls);
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        if (!shouldTransform(name)) {
            return super.findClass(name);
        }

        String resourceName = name.replace('.', '/') + ".class";
        URL resource = findResource(resourceName);

        byte[] bytes;

 * <pre>
 * <code>
 *
 * private final TransformErrorHandler handler = new TransformErrorHandler("loader-name")
 *
 * protected Class&lt;?&gt; findClass(String name) throws ClassNotFoundException {
 *     handler.enterClassLoadingScope(name);
 *     Class&lt;?&gt; result;
 *     try {
 *         result = super.findClass(name);
 *     } catch (Throwable th) {

        findLoadedClass(name)
            ?: tryToLoadLocally(name)
            ?: super.loadClass(name, resolve)

    private
    fun tryToLoadLocally(name: String): Class<*>? =
        try {
            findClass(name)
        } catch (e: ClassNotFoundException) {
            null
        }

                } catch (FileNotFoundException) {
                    // Ignore
                }
            }
        }
        return null
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String resource = name.replace('.', '/') + '.class'
        URL url = findResource(resource)
        if (url == null) {

        }

        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            errorHandler.enterClassLoadingScope(name);
            Class<?> loadedClass;
            try {
                loadedClass = super.findClass(name);
            } catch (Throwable e) {
                throw errorHandler.exitClassLoadingScopeWithException(e);

        if (shouldLoadTransformedClass.test(name)) {
            Class<?> result = findLoadedClass(name);
            if (result == null) {
                result = findClass(name);
            }
            if (resolve) {
                resolveClass(result);
            }
            return result;
        }
        return super.loadClass(name, resolve);
    }

    @Override

        }

        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            errorHandler.enterClassLoadingScope(name);
            Class<?> loadedClass;
            try {
                loadedClass = super.findClass(name);
            } catch (Throwable e) {
                throw errorHandler.exitClassLoadingScopeWithException(e);

              synchronized (loadedClasses) {
                Class<?> toReturn = loadedClasses.get(name);
                if (toReturn == null) {
                  toReturn = super.findClass(name);
                  loadedClasses.put(name, toReturn);
                }
                return toReturn;
              }
            }
            return super.loadClass(name);
          }
        };

        }
        if (name.startsWith(concurrentPackage)) {
          Class<?> c = findLoadedClass(name);
          if (c == null) {
            return super.findClass(name);
          }
          return c;
        }
        return super.loadClass(name);
      }
    };
  }