}

    private PluginInfo extractPluginInfo(Artifact artifact) {
        // sanity: jar, no classifier and file exists
        if (artifact != null
                && "jar".equals(artifact.getExtension())
                && "".equals(artifact.getClassifier())
                && artifact.getPath() != null) {
            Path artifactPath = artifact.getPath();
            if (Files.isRegularFile(artifactPath)) {

    }

    private PluginInfo extractPluginInfo(Artifact artifact) {
        // sanity: jar, no classifier and file exists
        if (artifact != null
                && "jar".equals(artifact.getExtension())
                && "".equals(artifact.getClassifier())
                && artifact.getPath() != null) {
            Path artifactPath = artifact.getPath();
            if (Files.isRegularFile(artifactPath)) {

    def task = Mock(Task)
    def taskDependency = TestFiles.taskDependencyFactory().configurableDependency(ImmutableSet.of(task))
    def publishArtifact = Stub(PublishArtifact) {
        getName() >> 'name'
        getExtension() >> 'extension'
        getType() >> 'type'
        getFile() >> new File('foo')
        getBuildDependencies() >> taskDependency
    }
    def dependencies = Collections.singleton(Mock(Task))

    Language getLanguage();

    /**
     * Get the file extension of artifacts of this type.
     *
     * @return the file extension, never {@code null}.
     */
    @Nonnull
    String getExtension();

    /**
     * Get the default classifier associated to the dependency type.
     * The default classifier can be overridden when specifying
     * the {@link Dependency#getClassifier()}.
     *

            Artifact nodeArtifact = collectStepTrace.getNode().getArtifact();

            if (isInScope(resolvedArtifact, nodeArtifact) || "pom".equals(resolvedArtifact.getExtension())) {
                Dependency node = collectStepTrace.getNode();
                trackingData.add(resolvedArtifact.toString());
                indent += "  ";

                from 'dir2'
                from 'dir1'
            }
        """
    }

    ArchiveTestFixture archive(TestFile archiveFile) {
        String type = FilenameUtils.getExtension(archiveFile.name)
        if (type == 'zip') {
            new ZipTestFixture(archiveFile)
        } else {
            new TarTestFixture(archiveFile)
        }
    }

    def createTestFiles() {

                @Override
                String getName() {
                    return "customArtifact"
                }
                @Override
                String getExtension() {
                    return "jar"
                }
                @Override
                String getType() {
                    return "jar"
                }
                @Override

    def taskDependency = TestFiles.taskDependencyFactory().configurableDependency(dependencies)
    def fileNotationParser = Mock(NotationParser)
    def publishArtifact = Stub(PublishArtifact) {
        getExtension() >> 'extension'
        getClassifier() >> 'classifier'
        getFile() >> new File('foo')
        getBuildDependencies() >> taskDependency
    }

    NotationParser<Object, MavenArtifact> parser

        Artifact artifact = artifactFactory.createBuildArtifact("test", "test", version, type);
        artifact.setFile(new File(
                testData,
                "test-" + version + "." + artifact.getArtifactHandler().getExtension()));
        assertFalse(artifact.getFile().exists());
        return artifact;
    }

    private ArtifactRepository createStringRepo() {
        return artifactRepositoryFactory.createArtifactRepository(

			end = scan.acceptMinSize(3)
		}
	case 'x':
		end = scan.acceptMinSize(1)
	default:
		end = scan.acceptMinSize(2)
	}
	return end
}

// getExtension returns the name, body and end position of the extension.
func getExtension(s string, p int) (end int, ext string) {
	if s[p] == '-' {
		p++
	}
	if s[p] == 'x' {
		return len(s), s[p:]
	}
	end = nextExtension(s, p)
	return end, s[p:end]