}

		if ldr.SymSect(symp) != nil {
			xldr.Lrsecnm = f.getXCOFFscnum(ldr.SymSect(symp))
		}

		reloctab = append(reloctab, xldr)
	}

	off += uint64(16 * len(dynimpreloc))
	reloctab = append(reloctab, dynimpreloc...)

	hdr.Lnreloc = int32(len(reloctab))
	hdr.Limpoff = off

	/* Import */
	// Default import: /usr/lib:/lib
	ldimpf := &XcoffLdImportFile64{

                    entry.name.substring(0, name.lastIndexOf('/')).replace('/', '.')
                }
                .collect(Collectors.toSet())
        }
    }
// tag::artifact-transform-relocate[]
}
// end::artifact-transform-relocate[]

configurations.create("externalClasspath")

def usage = Attribute.of('usage', String)
def artifactType = Attribute.of('artifactType', String)

dependencies {

                    entry.name.substringBeforeLast('/').replace('/', '.')
                }
                .collect(Collectors.toSet())
        }
    }
// tag::artifact-transform-relocate[]
}
// end::artifact-transform-relocate[]

configurations.create("externalClasspath")

val usage = Attribute.of("usage", String::class.java)
val artifactType = Attribute.of("artifactType", String::class.java)

dependencies {

    /**
     * Returns {@link Artifact} instance where to relocate to, or {@code null}.
     *
     * @param session The session, never {@code null}.
     * @param result The artifact descriptor result, never {@code null}.
     * @param model The artifact model, never {@code null}.
     * @return The {@link Artifact} to relocate to, or {@code null} if no relocation wanted.
     */

    }

    @ToBeFixedForConfigurationCache
    def "relocate _main symbol with main.<ext>"() {
        makeSingleProject()
        componentUnderTest.writeToProject(testDirectory)

        when:
        succeeds("unexport")
        then:
        assertMainSymbolIsNotExported(objectFile("build/relocated/main"))
    }

    @ToBeFixedForConfigurationCache
    def "relocate _main symbol with notMain.<ext>"() {

    /**
     * Returns {@link Artifact} instance where to relocate to, or {@code null}.
     *
     * @param session The session, never {@code null}.
     * @param result The artifact descriptor result, never {@code null}.
     * @param model The artifact model, never {@code null}.
     * @return The {@link Artifact} to relocate to, or {@code null} if no relocation wanted.
     */

"""

        when:
        succeeds("test")

        then:
        result.assertTasksExecuted(tasks.debug.compile, tasks.test.relocate, tasks.test.allToInstall, ":xcTest", ":test")
        result.assertTasksSkipped(tasks.debug.compile, tasks.test.relocate, tasks.test.allToInstall, ":xcTest", ":test")
    }

    @ToBeFixedForConfigurationCache

    }

    @Override
    protected String[] getTasksToBuildAndRunUnitTest(String architecture) {
        return super.getTasksToBuildAndRunUnitTest(architecture) + tasks.withArchitecture(architecture).test.relocate
    }

    @Override
    protected String[] getTasksToCompileComponentUnderTest(String architecture) {
        def debugTasks = tasks.withArchitecture(architecture).debug
        return [debugTasks.compile]
    }

        ])

        when:
        def relocated = directorySnapshot.relocate(targetDir.absolutePath, stringInterner).get()
        def index = SnapshotUtil.indexByAbsolutePath(relocated)

        then:
        index.keySet() == [
            targetDir.absolutePath,

        def targetFile = temporaryFolder.file("target.txt")
        def sourceSnapshot = createInitialRootNode(sourceFile.absolutePath, DIRECT)

        when:
        def targetSnapshot = sourceSnapshot.relocate(targetFile.absolutePath, stringInterner)

        then:
        targetSnapshot.present
        targetSnapshot.get().absolutePath == targetFile.absolutePath
        targetSnapshot.get().name == targetFile.name