private final List<File> classpath

    TestClassLoader(ClassLoader classLoader, List<File> classpath) {
        super(classLoader)
        this.classpath = classpath
    }

    @Override
    protected URL findResource(String name) {
        for (File file : classpath) {
            if (file.directory) {
                def classFile = new File(file, name)
                if (classFile.exists()) {

        resources.findResource("permissions.zip").copyTo(archiveFile);

        final Map<String, Integer> expected = new HashMap<>();
        expected.put("file", 0644);
        expected.put("folder", 0755);

        assertVisitsPermissions(tree, expected);
    }

    @Test
    public void expectedDefaultForNoModeZips() {
        resources.findResource("nomodeinfos.zip").copyTo(archiveFile);

        resources.findResource("permissions.tar").copyTo(archiveFile);

        final Map<String, Integer> expected = new HashMap<>();
        expected.put("file", 0644);
        expected.put("folder", 0755);

        assertVisitsPermissions(tree, expected);
    }

    @Test
    public void readsTarFileWithNullPermissions() {
        resources.findResource("nullpermissions.tar").copyTo(archiveFile);

     *
     * Also asserts that the resource exists.
     */
    public TestFile getResource(String name) {
        assertNotNull(declaringTestClass);
        TestFile file = findResource(name);
        assertNotNull(String.format("Could not locate resource '%s' for test class %s.", name, declaringTestClass.getName()), file);
        return file;
    }

    /**

        if (!shouldTransform(name)) {
            return super.findClass(name);
        }

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

        byte[] bytes;
        CodeSource codeSource;
        try {
            if (resource != null) {
                bytes = loadBytecode(resource);
                bytes = transform(name, bytes);

            if (resolve) {
                resolveClass(result);
            }
            return result;
        }
        return super.loadClass(name, resolve);
    }

    @Override
    public URL findResource(String name) {
        return source.getResource(name);
    }

    @Override
    protected @Nonnull byte[] transform(String className, @Nonnull byte[] bytes) {

        // Below is a dirty way to strip the added content
        if (resource.contains(" ")) {
            resource = resource.substring(0, resource.indexOf(' '));
        }
        TestFile dir = resources.findResource(resource);
        if (dir != null) {
            logger.debug("Copying test resource '{}' from {} to test directory.", resource, dir);
            dir.copyTo(getDir());
        } else {

        }

        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            String resource = name.replace('.', '/') + '.class'
            URL url = findResource(resource)
            if (url == null) {
                throw new ClassNotFoundException("Could not find class '${name}'")
            }
            def byteCode = url.bytes

            // avoid parsing the entire class file and any referenced classes.
            String path = className.replace('.', '/').concat(".class");
            return classLoader.findResource(path) != null;
        }

        @Override
        public void close() throws IOException {
            classLoader.close();
        }
    }

	return slice[:s.Length]
}

func (s *NTString) String() string {
	return ByteSliceToString(s.Slice())
}

// FindResource resolves a resource of the given name and resource type.
func FindResource(module Handle, name, resType ResourceIDOrString) (Handle, error) {
	var namePtr, resTypePtr uintptr
	var name16, resType16 *uint16
	var err error