| // Copyright 2015 The Bazel Authors. All rights reserved. | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| package com.google.devtools.build.lib.actions; | |
| import static com.google.common.truth.Truth.assertThat; | |
| import static org.junit.Assert.assertThrows; | |
| import static org.mockito.Mockito.mock; | |
| import com.google.common.collect.ImmutableClassToInstanceMap; | |
| import com.google.common.collect.Lists; | |
| import com.google.common.testing.EqualsTester; | |
| import com.google.devtools.build.lib.actions.Artifact.ArchivedTreeArtifact; | |
| import com.google.devtools.build.lib.actions.Artifact.SourceArtifact; | |
| import com.google.devtools.build.lib.actions.Artifact.SpecialArtifact; | |
| import com.google.devtools.build.lib.actions.Artifact.SpecialArtifactType; | |
| import com.google.devtools.build.lib.actions.ArtifactResolver.ArtifactResolverSupplier; | |
| import com.google.devtools.build.lib.actions.ArtifactRoot.RootType; | |
| import com.google.devtools.build.lib.actions.MutableActionGraph.ActionConflictException; | |
| import com.google.devtools.build.lib.actions.util.ActionsTestUtil; | |
| import com.google.devtools.build.lib.actions.util.LabelArtifactOwner; | |
| import com.google.devtools.build.lib.cmdline.Label; | |
| import com.google.devtools.build.lib.cmdline.LabelConstants; | |
| import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder; | |
| import com.google.devtools.build.lib.collect.nestedset.Order; | |
| import com.google.devtools.build.lib.rules.cpp.CppFileTypes; | |
| import com.google.devtools.build.lib.rules.java.JavaSemantics; | |
| import com.google.devtools.build.lib.skyframe.serialization.AutoRegistry; | |
| import com.google.devtools.build.lib.skyframe.serialization.ObjectCodecs; | |
| import com.google.devtools.build.lib.skyframe.serialization.testutils.SerializationDepsUtils; | |
| import com.google.devtools.build.lib.skyframe.serialization.testutils.SerializationTester; | |
| import com.google.devtools.build.lib.testutil.Scratch; | |
| import com.google.devtools.build.lib.util.FileType; | |
| import com.google.devtools.build.lib.util.FileTypeSet; | |
| import com.google.devtools.build.lib.vfs.FileSystem; | |
| import com.google.devtools.build.lib.vfs.Path; | |
| import com.google.devtools.build.lib.vfs.PathFragment; | |
| import com.google.devtools.build.lib.vfs.Root; | |
| import com.google.devtools.build.skyframe.SkyFunctionName; | |
| import java.io.IOException; | |
| import java.util.ArrayList; | |
| import java.util.List; | |
| import org.junit.Before; | |
| import org.junit.Test; | |
| import org.junit.runner.RunWith; | |
| import org.junit.runners.JUnit4; | |
| /** Test for {@link Artifact} class. */ | |
| @RunWith(JUnit4.class) | |
| public class ArtifactTest { | |
| private Scratch scratch; | |
| private Path execDir; | |
| private ArtifactRoot rootDir; | |
| private final ActionKeyContext actionKeyContext = new ActionKeyContext(); | |
| @Before | |
| public final void setRootDir() throws Exception { | |
| scratch = new Scratch(); | |
| execDir = scratch.dir("/base/exec"); | |
| rootDir = ArtifactRoot.asDerivedRoot(execDir, RootType.Output, "root"); | |
| } | |
| @Test | |
| public void testConstruction_badRootDir() throws IOException { | |
| Path f1 = scratch.file("/exec/dir/file.ext"); | |
| assertThrows( | |
| IllegalArgumentException.class, | |
| () -> | |
| ActionsTestUtil.createArtifactWithExecPath( | |
| ArtifactRoot.asDerivedRoot(execDir, RootType.Output, "bogus"), | |
| f1.relativeTo(execDir)) | |
| .getRootRelativePath()); | |
| } | |
| private static long getUsedMemory() { | |
| System.gc(); | |
| System.gc(); | |
| System.runFinalization(); | |
| System.gc(); | |
| System.gc(); | |
| return Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory(); | |
| } | |
| @Test | |
| public void testMemoryUsage() throws IOException { | |
| ArtifactRoot root = ArtifactRoot.asSourceRoot(Root.fromPath(scratch.dir("/foo"))); | |
| PathFragment aPath = PathFragment.create("src/a"); | |
| int arrSize = 1 << 20; | |
| Object[] arr = new Object[arrSize]; | |
| long usedMemory = getUsedMemory(); | |
| for (int i = 0; i < arrSize; i++) { | |
| arr[i] = ActionsTestUtil.createArtifactWithExecPath(root, aPath); | |
| } | |
| assertThat((getUsedMemory() - usedMemory) / arrSize).isAtMost(34L); | |
| } | |
| @Test | |
| public void testEquivalenceRelation() throws Exception { | |
| PathFragment aPath = PathFragment.create("src/a"); | |
| PathFragment bPath = PathFragment.create("src/b"); | |
| assertThat(ActionsTestUtil.createArtifactWithRootRelativePath(rootDir, aPath)) | |
| .isEqualTo(ActionsTestUtil.createArtifactWithRootRelativePath(rootDir, aPath)); | |
| assertThat(ActionsTestUtil.createArtifactWithRootRelativePath(rootDir, bPath)) | |
| .isEqualTo(ActionsTestUtil.createArtifactWithRootRelativePath(rootDir, bPath)); | |
| assertThat( | |
| ActionsTestUtil.createArtifactWithRootRelativePath(rootDir, aPath) | |
| .equals(ActionsTestUtil.createArtifactWithRootRelativePath(rootDir, bPath))) | |
| .isFalse(); | |
| } | |
| @Test | |
| public void testComparison() { | |
| PathFragment aPath = PathFragment.create("src/a"); | |
| PathFragment bPath = PathFragment.create("src/b"); | |
| Artifact aArtifact = ActionsTestUtil.createArtifactWithRootRelativePath(rootDir, aPath); | |
| Artifact bArtifact = ActionsTestUtil.createArtifactWithRootRelativePath(rootDir, bPath); | |
| assertThat(Artifact.EXEC_PATH_COMPARATOR.compare(aArtifact, bArtifact)).isEqualTo(-1); | |
| assertThat(Artifact.EXEC_PATH_COMPARATOR.compare(aArtifact, aArtifact)).isEqualTo(0); | |
| assertThat(Artifact.EXEC_PATH_COMPARATOR.compare(bArtifact, bArtifact)).isEqualTo(0); | |
| assertThat(Artifact.EXEC_PATH_COMPARATOR.compare(bArtifact, aArtifact)).isEqualTo(1); | |
| } | |
| @Test | |
| public void testGetFilename() throws Exception { | |
| ArtifactRoot root = ArtifactRoot.asSourceRoot(Root.fromPath(scratch.dir("/foo"))); | |
| Artifact javaFile = ActionsTestUtil.createArtifact(root, scratch.file("/foo/Bar.java")); | |
| Artifact generatedHeader = | |
| ActionsTestUtil.createArtifact(root, scratch.file("/foo/bar.proto.h")); | |
| Artifact generatedCc = ActionsTestUtil.createArtifact(root, scratch.file("/foo/bar.proto.cc")); | |
| Artifact aCPlusPlusFile = ActionsTestUtil.createArtifact(root, scratch.file("/foo/bar.cc")); | |
| assertThat(JavaSemantics.JAVA_SOURCE.matches(javaFile.getFilename())).isTrue(); | |
| assertThat(CppFileTypes.CPP_HEADER.matches(generatedHeader.getFilename())).isTrue(); | |
| assertThat(CppFileTypes.CPP_SOURCE.matches(generatedCc.getFilename())).isTrue(); | |
| assertThat(CppFileTypes.CPP_SOURCE.matches(aCPlusPlusFile.getFilename())).isTrue(); | |
| } | |
| @Test | |
| public void testGetExtension() throws Exception { | |
| ArtifactRoot root = ArtifactRoot.asSourceRoot(Root.fromPath(scratch.dir("/foo"))); | |
| Artifact javaFile = ActionsTestUtil.createArtifact(root, scratch.file("/foo/Bar.java")); | |
| assertThat(javaFile.getExtension()).isEqualTo("java"); | |
| } | |
| @Test | |
| public void testIsFileType() throws Exception { | |
| ArtifactRoot root = ArtifactRoot.asSourceRoot(Root.fromPath(scratch.dir("/foo"))); | |
| Artifact javaFile = ActionsTestUtil.createArtifact(root, scratch.file("/foo/Bar.java")); | |
| assertThat(javaFile.isFileType(FileType.of("java"))).isTrue(); | |
| assertThat(javaFile.isFileType(FileType.of("cc"))).isFalse(); | |
| } | |
| @Test | |
| public void testIsFileTypeSet() throws Exception { | |
| ArtifactRoot root = ArtifactRoot.asSourceRoot(Root.fromPath(scratch.dir("/foo"))); | |
| Artifact javaFile = ActionsTestUtil.createArtifact(root, scratch.file("/foo/Bar.java")); | |
| assertThat(javaFile.isFileType(FileTypeSet.of(FileType.of("cc"), FileType.of("java")))) | |
| .isTrue(); | |
| assertThat(javaFile.isFileType(FileTypeSet.of(FileType.of("py"), FileType.of("js")))).isFalse(); | |
| assertThat(javaFile.isFileType(FileTypeSet.of())).isFalse(); | |
| } | |
| @Test | |
| public void testMangledPath() { | |
| String path = "dir/sub_dir/name:end"; | |
| assertThat(Actions.escapedPath(path)).isEqualTo("dir_Ssub_Udir_Sname_Cend"); | |
| } | |
| private List<Artifact> getFooBarArtifacts(MutableActionGraph actionGraph, boolean collapsedList) | |
| throws Exception { | |
| ArtifactRoot root = ArtifactRoot.asSourceRoot(Root.fromPath(scratch.dir("/foo"))); | |
| Artifact aHeader1 = ActionsTestUtil.createArtifact(root, scratch.file("/foo/bar1.h")); | |
| Artifact aHeader2 = ActionsTestUtil.createArtifact(root, scratch.file("/foo/bar2.h")); | |
| Artifact aHeader3 = ActionsTestUtil.createArtifact(root, scratch.file("/foo/bar3.h")); | |
| ArtifactRoot middleRoot = | |
| ArtifactRoot.asDerivedRoot( | |
| scratch.dir("/foo"), RootType.Middleman, PathFragment.create("out")); | |
| Artifact middleman = ActionsTestUtil.createArtifact(middleRoot, "middleman"); | |
| MiddlemanAction.create( | |
| new ActionRegistry() { | |
| @Override | |
| public void registerAction(ActionAnalysisMetadata action) { | |
| try { | |
| actionGraph.registerAction(action); | |
| } catch (ActionConflictException e) { | |
| throw new IllegalStateException(e); | |
| } catch (InterruptedException e) { | |
| Thread.currentThread().interrupt(); | |
| throw new IllegalStateException("Didn't expect interrupt in test", e); | |
| } | |
| } | |
| @Override | |
| public ActionLookupKey getOwner() { | |
| throw new UnsupportedOperationException(); | |
| } | |
| }, | |
| ActionsTestUtil.NULL_ACTION_OWNER, | |
| NestedSetBuilder.create(Order.STABLE_ORDER, aHeader1, aHeader2, aHeader3), | |
| middleman, | |
| "desc", | |
| MiddlemanType.AGGREGATING_MIDDLEMAN); | |
| return collapsedList ? Lists.newArrayList(aHeader1, middleman) : | |
| Lists.newArrayList(aHeader1, aHeader2, middleman); | |
| } | |
| @Test | |
| public void testAddExecPaths() throws Exception { | |
| List<String> paths = new ArrayList<>(); | |
| MutableActionGraph actionGraph = new MapBasedActionGraph(actionKeyContext); | |
| Artifact.addExecPaths(getFooBarArtifacts(actionGraph, false), paths); | |
| assertThat(paths).containsExactly("bar1.h", "bar2.h"); | |
| } | |
| @Test | |
| public void testAddExpandedArtifacts() throws Exception { | |
| List<Artifact> expanded = new ArrayList<>(); | |
| MutableActionGraph actionGraph = new MapBasedActionGraph(actionKeyContext); | |
| List<Artifact> original = getFooBarArtifacts(actionGraph, true); | |
| Artifact.addExpandedArtifacts(original, expanded, | |
| ActionInputHelper.actionGraphArtifactExpander(actionGraph)); | |
| List<Artifact> manuallyExpanded = new ArrayList<>(); | |
| for (Artifact artifact : original) { | |
| ActionAnalysisMetadata action = actionGraph.getGeneratingAction(artifact); | |
| if (artifact.isMiddlemanArtifact()) { | |
| manuallyExpanded.addAll(action.getInputs().toList()); | |
| } else { | |
| manuallyExpanded.add(artifact); | |
| } | |
| } | |
| assertThat(expanded).containsExactlyElementsIn(manuallyExpanded); | |
| } | |
| @Test | |
| public void testAddExecPathsNewActionGraph() throws Exception { | |
| List<String> paths = new ArrayList<>(); | |
| MutableActionGraph actionGraph = new MapBasedActionGraph(actionKeyContext); | |
| Artifact.addExecPaths(getFooBarArtifacts(actionGraph, false), paths); | |
| assertThat(paths).containsExactly("bar1.h", "bar2.h"); | |
| } | |
| @Test | |
| public void testRootRelativePathIsSameAsExecPath() throws Exception { | |
| ArtifactRoot root = ArtifactRoot.asSourceRoot(Root.fromPath(scratch.dir("/foo"))); | |
| Artifact a = ActionsTestUtil.createArtifact(root, scratch.file("/foo/bar1.h")); | |
| assertThat(a.getRootRelativePath()).isSameInstanceAs(a.getExecPath()); | |
| } | |
| @Test | |
| public void testToDetailString() throws Exception { | |
| Path execRoot = scratch.getFileSystem().getPath("/execroot/workspace"); | |
| Artifact a = | |
| ActionsTestUtil.createArtifact( | |
| ArtifactRoot.asDerivedRoot(execRoot, RootType.Output, "b"), "c"); | |
| assertThat(a.toDetailString()).isEqualTo("[[<execution_root>]b]c"); | |
| } | |
| @Test | |
| public void testWeirdArtifact() { | |
| Path execRoot = scratch.getFileSystem().getPath("/"); | |
| assertThrows( | |
| IllegalArgumentException.class, | |
| () -> | |
| ActionsTestUtil.createArtifactWithExecPath( | |
| ArtifactRoot.asDerivedRoot(execRoot, RootType.Output, "a"), | |
| PathFragment.create("c")) | |
| .getRootRelativePath()); | |
| } | |
| @Test | |
| public void testCodec() throws Exception { | |
| Artifact.DerivedArtifact artifact = | |
| (Artifact.DerivedArtifact) ActionsTestUtil.createArtifact(rootDir, "src/a"); | |
| artifact.setGeneratingActionKey(ActionsTestUtil.NULL_ACTION_LOOKUP_DATA); | |
| ArtifactRoot anotherRoot = | |
| ArtifactRoot.asDerivedRoot(scratch.getFileSystem().getPath("/"), RootType.Output, "src"); | |
| Artifact.DerivedArtifact anotherArtifact = | |
| new Artifact.DerivedArtifact( | |
| anotherRoot, | |
| anotherRoot.getExecPath().getRelative("src/c"), | |
| ActionsTestUtil.NULL_ARTIFACT_OWNER); | |
| anotherArtifact.setGeneratingActionKey(ActionsTestUtil.NULL_ACTION_LOOKUP_DATA); | |
| new SerializationTester(artifact, anotherArtifact) | |
| .addDependency(FileSystem.class, scratch.getFileSystem()) | |
| .addDependency( | |
| Root.RootCodecDependencies.class, new Root.RootCodecDependencies(anotherRoot.getRoot())) | |
| .addDependencies(SerializationDepsUtils.SERIALIZATION_DEPS_FOR_TEST) | |
| .runTests(); | |
| } | |
| @Test | |
| public void testCodecRecyclesSourceArtifactInstances() throws Exception { | |
| Root root = Root.fromPath(scratch.dir("/")); | |
| ArtifactRoot artifactRoot = ArtifactRoot.asSourceRoot(root); | |
| ArtifactFactory artifactFactory = | |
| new ArtifactFactory(execDir.getParentDirectory(), "blaze-out"); | |
| ArtifactResolverSupplier artifactResolverSupplierForTest = | |
| new ArtifactResolverSupplier() { | |
| @Override | |
| public Artifact.DerivedArtifact intern(Artifact.DerivedArtifact original) { | |
| return original; | |
| } | |
| @Override | |
| public ArtifactResolver get() { | |
| return artifactFactory; | |
| } | |
| }; | |
| ObjectCodecs objectCodecs = | |
| new ObjectCodecs( | |
| AutoRegistry.get() | |
| .getBuilder() | |
| .addReferenceConstant(scratch.getFileSystem()) | |
| .setAllowDefaultCodec(true) | |
| .build(), | |
| ImmutableClassToInstanceMap.builder() | |
| .put(FileSystem.class, scratch.getFileSystem()) | |
| .put(ArtifactResolverSupplier.class, artifactResolverSupplierForTest) | |
| .put( | |
| Root.RootCodecDependencies.class, | |
| new Root.RootCodecDependencies(artifactRoot.getRoot())) | |
| .build()); | |
| PathFragment pathFragment = PathFragment.create("src/foo.cc"); | |
| ArtifactOwner owner = new LabelArtifactOwner(Label.parseAbsoluteUnchecked("//foo:bar")); | |
| SourceArtifact sourceArtifact = new SourceArtifact(artifactRoot, pathFragment, owner); | |
| SourceArtifact deserialized1 = | |
| (SourceArtifact) objectCodecs.deserialize(objectCodecs.serialize(sourceArtifact)); | |
| SourceArtifact deserialized2 = | |
| (SourceArtifact) objectCodecs.deserialize(objectCodecs.serialize(sourceArtifact)); | |
| assertThat(deserialized1).isSameInstanceAs(deserialized2); | |
| Artifact sourceArtifactFromFactory = | |
| artifactFactory.getSourceArtifact(pathFragment, root, owner); | |
| Artifact deserialized = | |
| (Artifact) objectCodecs.deserialize(objectCodecs.serialize(sourceArtifactFromFactory)); | |
| assertThat(sourceArtifactFromFactory).isSameInstanceAs(deserialized); | |
| } | |
| @Test | |
| public void testLongDirname() throws Exception { | |
| String dirName = createDirNameArtifact().getDirname(); | |
| assertThat(dirName).isEqualTo("aaa/bbb/ccc"); | |
| } | |
| @Test | |
| public void testDirnameInExecutionDir() throws Exception { | |
| Artifact artifact = | |
| ActionsTestUtil.createArtifact( | |
| ArtifactRoot.asSourceRoot(Root.fromPath(scratch.dir("/foo"))), | |
| scratch.file("/foo/bar.txt")); | |
| assertThat(artifact.getDirname()).isEqualTo("."); | |
| } | |
| @Test | |
| public void testCanConstructPathFromDirAndFilename() throws Exception { | |
| Artifact artifact = createDirNameArtifact(); | |
| String constructed = | |
| String.format("%s/%s", artifact.getDirname(), artifact.getFilename()); | |
| assertThat(constructed).isEqualTo("aaa/bbb/ccc/ddd"); | |
| } | |
| @Test | |
| public void testIsSourceArtifact() throws Exception { | |
| assertThat( | |
| new Artifact.SourceArtifact( | |
| ArtifactRoot.asSourceRoot(Root.fromPath(scratch.dir("/"))), | |
| PathFragment.create("src/foo.cc"), | |
| ArtifactOwner.NULL_OWNER) | |
| .isSourceArtifact()) | |
| .isTrue(); | |
| assertThat( | |
| ActionsTestUtil.createArtifact( | |
| ArtifactRoot.asDerivedRoot(scratch.dir("/genfiles"), RootType.Output, "aaa"), | |
| scratch.file("/genfiles/aaa/bar.out")) | |
| .isSourceArtifact()) | |
| .isFalse(); | |
| } | |
| @Test | |
| public void testGetRoot() throws Exception { | |
| Path execRoot = scratch.getFileSystem().getPath("/"); | |
| ArtifactRoot root = ArtifactRoot.asDerivedRoot(execRoot, RootType.Output, "newRoot"); | |
| assertThat(ActionsTestUtil.createArtifact(root, scratch.file("/newRoot/foo")).getRoot()) | |
| .isEqualTo(root); | |
| } | |
| @Test | |
| public void hashCodeAndEquals() { | |
| Path execRoot = scratch.getFileSystem().getPath("/"); | |
| ArtifactRoot root = ArtifactRoot.asDerivedRoot(execRoot, RootType.Output, "newRoot"); | |
| ActionLookupKey firstOwner = | |
| new ActionLookupKey() { | |
| @Override | |
| public Label getLabel() { | |
| return null; | |
| } | |
| @Override | |
| public SkyFunctionName functionName() { | |
| return null; | |
| } | |
| }; | |
| ActionLookupKey secondOwner = | |
| new ActionLookupKey() { | |
| @Override | |
| public Label getLabel() { | |
| return null; | |
| } | |
| @Override | |
| public SkyFunctionName functionName() { | |
| return null; | |
| } | |
| }; | |
| Artifact.DerivedArtifact derived1 = | |
| new Artifact.DerivedArtifact(root, PathFragment.create("newRoot/shared"), firstOwner); | |
| derived1.setGeneratingActionKey(ActionLookupData.create(firstOwner, 0)); | |
| Artifact.DerivedArtifact derived2 = | |
| new Artifact.DerivedArtifact(root, PathFragment.create("newRoot/shared"), secondOwner); | |
| derived2.setGeneratingActionKey(ActionLookupData.create(secondOwner, 0)); | |
| ArtifactRoot sourceRoot = ArtifactRoot.asSourceRoot(Root.fromPath(root.getRoot().asPath())); | |
| Artifact source1 = new SourceArtifact(sourceRoot, PathFragment.create("shared"), firstOwner); | |
| Artifact source2 = new SourceArtifact(sourceRoot, PathFragment.create("shared"), secondOwner); | |
| new EqualsTester() | |
| .addEqualityGroup(derived1) | |
| .addEqualityGroup(derived2) | |
| .addEqualityGroup(source1, source2) | |
| .testEquals(); | |
| assertThat(derived1.hashCode()).isEqualTo(derived2.hashCode()); | |
| assertThat(derived1.hashCode()).isNotEqualTo(source1.hashCode()); | |
| assertThat(source1.hashCode()).isEqualTo(source2.hashCode()); | |
| Artifact.OwnerlessArtifactWrapper wrapper1 = new Artifact.OwnerlessArtifactWrapper(derived1); | |
| Artifact.OwnerlessArtifactWrapper wrapper2 = new Artifact.OwnerlessArtifactWrapper(derived2); | |
| Artifact.OwnerlessArtifactWrapper wrapper3 = new Artifact.OwnerlessArtifactWrapper(source1); | |
| Artifact.OwnerlessArtifactWrapper wrapper4 = new Artifact.OwnerlessArtifactWrapper(source2); | |
| new EqualsTester() | |
| .addEqualityGroup(wrapper1, wrapper2) | |
| .addEqualityGroup(wrapper3, wrapper4) | |
| .testEquals(); | |
| Path path1 = derived1.getPath(); | |
| Path path2 = derived2.getPath(); | |
| Path path3 = source1.getPath(); | |
| Path path4 = source2.getPath(); | |
| new EqualsTester().addEqualityGroup(path1, path2, path3, path4).testEquals(); | |
| } | |
| private Artifact createDirNameArtifact() throws Exception { | |
| return ActionsTestUtil.createArtifact( | |
| ArtifactRoot.asSourceRoot(Root.fromPath(scratch.dir("/"))), | |
| scratch.file("/aaa/bbb/ccc/ddd")); | |
| } | |
| @Test | |
| public void canDeclareContentBasedOutput() { | |
| Path execRoot = scratch.getFileSystem().getPath("/"); | |
| ArtifactRoot root = ArtifactRoot.asDerivedRoot(execRoot, RootType.Output, "newRoot"); | |
| assertThat( | |
| new Artifact.DerivedArtifact( | |
| root, | |
| PathFragment.create("newRoot/my.output"), | |
| ActionsTestUtil.NULL_ARTIFACT_OWNER, | |
| /*contentBasedPath=*/ true) | |
| .contentBasedPath()) | |
| .isTrue(); | |
| } | |
| @Test | |
| public void testGetRepositoryRelativePathExternalSourceArtifacts() throws IOException { | |
| ArtifactRoot externalRoot = | |
| ArtifactRoot.asExternalSourceRoot( | |
| Root.fromPath( | |
| scratch | |
| .dir("/output_base") | |
| .getRelative(LabelConstants.EXTERNAL_REPOSITORY_LOCATION) | |
| .getRelative("foo"))); | |
| // --experimental_sibling_repository_layout not set | |
| assertThat( | |
| new Artifact.SourceArtifact( | |
| externalRoot, | |
| LabelConstants.EXTERNAL_PATH_PREFIX.getRelative("foo/bar/baz.cc"), | |
| ArtifactOwner.NULL_OWNER) | |
| .getRepositoryRelativePath()) | |
| .isEqualTo(PathFragment.create("bar/baz.cc")); | |
| // --experimental_sibling_repository_layout set | |
| assertThat( | |
| new Artifact.SourceArtifact( | |
| externalRoot, | |
| LabelConstants.EXPERIMENTAL_EXTERNAL_PATH_PREFIX.getRelative("foo/bar/baz.cc"), | |
| ArtifactOwner.NULL_OWNER) | |
| .getRepositoryRelativePath()) | |
| .isEqualTo(PathFragment.create("bar/baz.cc")); | |
| } | |
| @Test | |
| public void archivedTreeArtifact_create_returnsArtifactInArchivedRoot() { | |
| ArtifactRoot root = | |
| ArtifactRoot.asDerivedRoot(execDir, RootType.Output, "blaze-out", "fastbuild"); | |
| SpecialArtifact tree = createTreeArtifact(root, "tree"); | |
| ArchivedTreeArtifact archivedTreeArtifact = | |
| ArchivedTreeArtifact.create(tree, PathFragment.create("blaze-out")); | |
| assertThat(archivedTreeArtifact.getParent()).isSameInstanceAs(tree); | |
| assertThat(archivedTreeArtifact.getArtifactOwner()) | |
| .isSameInstanceAs(ActionsTestUtil.NULL_ARTIFACT_OWNER); | |
| assertThat(archivedTreeArtifact.getExecPathString()) | |
| .isEqualTo("blaze-out/:archived_tree_artifacts/fastbuild/tree.zip"); | |
| assertThat(archivedTreeArtifact.getRoot().getExecPathString()) | |
| .isEqualTo("blaze-out/:archived_tree_artifacts/fastbuild"); | |
| } | |
| @Test | |
| public void archivedTreeArtifact_create_returnsArtifactWithGeneratingActionFromParent() { | |
| ActionLookupKey actionLookupKey = mock(ActionLookupKey.class); | |
| ActionLookupData actionLookupData = ActionLookupData.create(actionLookupKey, 0); | |
| SpecialArtifact tree = createTreeArtifact(rootDir, "tree", actionLookupData); | |
| ArchivedTreeArtifact archivedTreeArtifact = | |
| ArchivedTreeArtifact.create(tree, PathFragment.create("root")); | |
| assertThat(archivedTreeArtifact.getExecPathString()) | |
| .isEqualTo("root/:archived_tree_artifacts/tree.zip"); | |
| assertThat(archivedTreeArtifact.getArtifactOwner()).isSameInstanceAs(actionLookupKey); | |
| assertThat(archivedTreeArtifact.getGeneratingActionKey()).isSameInstanceAs(actionLookupData); | |
| } | |
| @Test | |
| public void archivedTreeArtifact_createWithLongerDerivedPrefix_returnsArtifactWithCorrectPath() { | |
| ArtifactRoot root = | |
| ArtifactRoot.asDerivedRoot(execDir, RootType.Output, "dir1", "dir2", "dir3"); | |
| SpecialArtifact tree = createTreeArtifact(root, "tree"); | |
| ArchivedTreeArtifact archivedTreeArtifact = | |
| ArchivedTreeArtifact.create(tree, PathFragment.create("dir1/dir2")); | |
| assertThat(archivedTreeArtifact.getExecPathString()) | |
| .isEqualTo("dir1/dir2/:archived_tree_artifacts/dir3/tree.zip"); | |
| assertThat(archivedTreeArtifact.getRoot().getExecPathString()) | |
| .isEqualTo("dir1/dir2/:archived_tree_artifacts/dir3"); | |
| } | |
| @Test | |
| public void archivedTreeArtifact_create_failsForWrongDerivedPrefix() { | |
| ArtifactRoot root = | |
| ArtifactRoot.asDerivedRoot(execDir, RootType.Output, "blaze-out", "fastbuild"); | |
| SpecialArtifact tree = createTreeArtifact(root, "tree"); | |
| PathFragment wrongPrefix = PathFragment.create("notAPrefix"); | |
| assertThrows( | |
| IllegalArgumentException.class, () -> ArchivedTreeArtifact.create(tree, wrongPrefix)); | |
| } | |
| @Test | |
| public void archivedTreeArtifact_create_failsForDerivedPrefixOutsideOfArtifactRoot() { | |
| ArtifactRoot root = ArtifactRoot.asDerivedRoot(execDir, RootType.Output, "dir1", "dir2"); | |
| SpecialArtifact tree = createTreeArtifact(root, "dir3/tree"); | |
| PathFragment prefixOutsideOfRoot = PathFragment.create("dir1/dir2/dir3"); | |
| assertThrows( | |
| IllegalArgumentException.class, | |
| () -> ArchivedTreeArtifact.create(tree, prefixOutsideOfRoot)); | |
| } | |
| @Test | |
| public void archivedTreeArtifact_createWithCustomDerivedTreeRoot_returnsArtifactWithCustomRoot() { | |
| ArtifactRoot root = | |
| ArtifactRoot.asDerivedRoot(execDir, RootType.Output, "blaze-out", "fastbuild"); | |
| SpecialArtifact tree = createTreeArtifact(root, "dir/tree"); | |
| ArchivedTreeArtifact archivedTreeArtifact = | |
| ArchivedTreeArtifact.createWithCustomDerivedTreeRoot( | |
| tree, | |
| PathFragment.create("blaze-out"), | |
| PathFragment.create("custom/custom2"), | |
| PathFragment.create("treePath/file.xyz")); | |
| assertThat(archivedTreeArtifact.getParent()).isSameInstanceAs(tree); | |
| assertThat(archivedTreeArtifact.getExecPathString()) | |
| .isEqualTo("blaze-out/custom/custom2/fastbuild/treePath/file.xyz"); | |
| assertThat(archivedTreeArtifact.getRoot().getExecPathString()) | |
| .isEqualTo("blaze-out/custom/custom2/fastbuild"); | |
| } | |
| @Test | |
| public void archivedTreeArtifact_codec_roundTripsArchivedArtifact() throws Exception { | |
| ArchivedTreeArtifact artifact1 = createArchivedTreeArtifact(rootDir, "tree1"); | |
| ArtifactRoot anotherRoot = | |
| ArtifactRoot.asDerivedRoot(scratch.getFileSystem().getPath("/"), RootType.Output, "src"); | |
| ArchivedTreeArtifact artifact2 = createArchivedTreeArtifact(anotherRoot, "tree2"); | |
| new SerializationTester(artifact1, artifact2) | |
| .addDependency(FileSystem.class, scratch.getFileSystem()) | |
| .addDependency( | |
| Root.RootCodecDependencies.class, new Root.RootCodecDependencies(anotherRoot.getRoot())) | |
| .addDependencies(SerializationDepsUtils.SERIALIZATION_DEPS_FOR_TEST) | |
| .<ArchivedTreeArtifact>setVerificationFunction( | |
| (original, deserialized) -> { | |
| assertThat(original).isEqualTo(deserialized); | |
| assertThat(original.getGeneratingActionKey()) | |
| .isEqualTo(deserialized.getGeneratingActionKey()); | |
| }) | |
| .runTests(); | |
| } | |
| @Test | |
| public void archivedTreeArtifact_getExecPathWithinArchivedArtifactsTree_returnsCorrectPath() { | |
| assertThat( | |
| ArchivedTreeArtifact.getExecPathWithinArchivedArtifactsTree( | |
| PathFragment.create("bazel-out"), | |
| PathFragment.create("bazel-out/k8-fastbuild/bin/dir/subdir"))) | |
| .isEqualTo( | |
| PathFragment.create("bazel-out/:archived_tree_artifacts/k8-fastbuild/bin/dir/subdir")); | |
| } | |
| @Test | |
| public void archivedTreeArtifact_getExecPathWithinArchivedArtifactsTree_wrongPrefix_fails() { | |
| assertThrows( | |
| IllegalArgumentException.class, | |
| () -> | |
| ArchivedTreeArtifact.getExecPathWithinArchivedArtifactsTree( | |
| PathFragment.create("wrongPrefix"), | |
| PathFragment.create("bazel-out/k8-fastbuild/bin/dir/subdir"))); | |
| } | |
| private static SpecialArtifact createTreeArtifact(ArtifactRoot root, String relativePath) { | |
| return createTreeArtifact(root, relativePath, ActionsTestUtil.NULL_ACTION_LOOKUP_DATA); | |
| } | |
| private static SpecialArtifact createTreeArtifact( | |
| ArtifactRoot root, String relativePath, ActionLookupData actionLookupData) { | |
| SpecialArtifact treeArtifact = | |
| new SpecialArtifact( | |
| root, | |
| root.getExecPath().getRelative(relativePath), | |
| actionLookupData.getActionLookupKey(), | |
| SpecialArtifactType.TREE); | |
| treeArtifact.setGeneratingActionKey(actionLookupData); | |
| return treeArtifact; | |
| } | |
| private static ArchivedTreeArtifact createArchivedTreeArtifact( | |
| ArtifactRoot root, String treeRelativePath) { | |
| return ArchivedTreeArtifact.create( | |
| createTreeArtifact(root, treeRelativePath), root.getExecPath().subFragment(0, 1)); | |
| } | |
| } |