if (descriptor == null) {
            throw new ClassNotFoundException(aClass.getName());
        }
        return descriptor;
    }

    @Override
    protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
        return desc.forClass();
    }

    private Class<?> readClass() throws IOException, ClassNotFoundException {
        short id = readShort();

    public DeserializeMap newDeserializeSession() {
        final DeserializeMap delegateSession = delegate.newDeserializeSession();
        return new DeserializeMap() {
            @Override
            public Class<?> resolveClass(ClassLoaderDetails classLoaderDetails, String className) throws ClassNotFoundException {
                if (classLoaderDetails.spec instanceof KnownClassLoaderSpec) {

        return loader;
    }

    @Override
    protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
        try {
            return Class.forName(desc.getName(), false, loader);
        } catch (ClassNotFoundException e) {
            return super.resolveClass(desc);
        } catch (UnsupportedClassVersionError e) {
            try {

            // protected, but we can do the same by hand (the classloader instance
            // from which we call resolveClass does not matter).
            Class<?> c = sbtLoader.loadClass(className);
            if (resolve) {
                resolveClass(c);
            }
            return c;
        } else {
            return super.loadClass(className, resolve);
        }
    }

 * limitations under the License.
 */

package org.gradle.tooling.internal.provider.serialization;

public interface DeserializeMap {
    /**
     * Loads a serialized Class.
     */
    Class<?> resolveClass(ClassLoaderDetails classLoaderDetails, String className) throws ClassNotFoundException;

      // Force Finalizer to load from this class loader, not its parent.
      if (name.equals(Finalizer.class.getName())) {
        Class<?> clazz = findClass(name);
        if (resolve) {
          resolveClass(clazz);
        }
        return clazz;
      }

      return super.loadClass(name, resolve);
    }
  }

  public void testGetFinalizerUrl() {

    public DeserializeMap newDeserializeSession() {
        final DeserializeMap deserializeMap = delegate.newDeserializeSession();
        return new DeserializeMap() {
            @Override
            public Class<?> resolveClass(ClassLoaderDetails classLoaderDetails, String className) throws ClassNotFoundException {
                Set<ClassLoader> candidates = getClassLoaders(classLoaderDetails);
                if (candidates != null) {

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

    @Override
    public URL findResource(String name) {

            }
        };
    }

    @Override
    public DeserializeMap newDeserializeSession() {
        return new DeserializeMap() {
            @Override
            public Class<?> resolveClass(ClassLoaderDetails classLoaderDetails, String className) throws ClassNotFoundException {
                ClassLoader classLoader = getClassLoader(classLoaderDetails);

        if (!classAllowed(name)) {
            throw new ClassNotFoundException(name + " not found.");
        }

        Class<?> cl = super.loadClass(name, false);
        if (resolve) {
            resolveClass(cl);
        }

        return cl;
    }

    @Nullable
    @SuppressWarnings("deprecation")
    @Override
    protected Package getPackage(String name) {