blob: 88b840b96639f442c16a36fed669c1e14be19ce6 [file] [log] [blame]
// 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 com.google.devtools.build.lib.analysis.actions.CustomCommandLine.builder;
import static com.google.devtools.build.lib.testutil.MoreAsserts.assertThrows;
import static org.junit.Assert.fail;
import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
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.Artifact.TreeFileArtifact;
import com.google.devtools.build.lib.actions.util.ActionsTestUtil;
import com.google.devtools.build.lib.analysis.actions.CustomCommandLine;
import com.google.devtools.build.lib.analysis.actions.CustomCommandLine.VectorArg;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.collect.nestedset.NestedSet;
import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
import com.google.devtools.build.lib.collect.nestedset.Order;
import com.google.devtools.build.lib.testutil.Scratch;
import com.google.devtools.build.lib.util.Fingerprint;
import com.google.devtools.build.lib.util.LazyString;
import com.google.devtools.build.lib.vfs.PathFragment;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
/**
* Tests for CustomCommandLine.
*/
@RunWith(JUnit4.class)
public class CustomCommandLineTest {
private Scratch scratch;
private ArtifactRoot rootDir;
private Artifact artifact1;
private Artifact artifact2;
@Before
public void createArtifacts() throws Exception {
scratch = new Scratch();
rootDir = ArtifactRoot.asDerivedRoot(scratch.dir("/exec/root"), scratch.dir("/exec/root/dir"));
artifact1 = ActionsTestUtil.createArtifact(rootDir, scratch.file("/exec/root/dir/file1.txt"));
artifact2 = ActionsTestUtil.createArtifact(rootDir, scratch.file("/exec/root/dir/file2.txt"));
}
@Test
public void testScalarAdds() throws Exception {
assertThat(builder().add("--arg").build().arguments()).containsExactly("--arg").inOrder();
assertThat(builder().addDynamicString("--arg").build().arguments())
.containsExactly("--arg")
.inOrder();
assertThat(
builder().addLabel(Label.parseAbsolute("//a:b", ImmutableMap.of())).build().arguments())
.containsExactly("//a:b")
.inOrder();
assertThat(builder().addPath(PathFragment.create("path")).build().arguments())
.containsExactly("path")
.inOrder();
assertThat(builder().addExecPath(artifact1).build().arguments())
.containsExactly("dir/file1.txt")
.inOrder();
assertThat(
builder()
.addLazyString(
new LazyString() {
@Override
public String toString() {
return "foo";
}
})
.build()
.arguments())
.containsExactly("foo")
.inOrder();
assertThat(builder().add("--arg", "val").build().arguments())
.containsExactly("--arg", "val")
.inOrder();
assertThat(
builder()
.addLabel("--arg", Label.parseAbsolute("//a:b", ImmutableMap.of()))
.build()
.arguments())
.containsExactly("--arg", "//a:b")
.inOrder();
assertThat(builder().addPath("--arg", PathFragment.create("path")).build().arguments())
.containsExactly("--arg", "path")
.inOrder();
assertThat(builder().addExecPath("--arg", artifact1).build().arguments())
.containsExactly("--arg", "dir/file1.txt")
.inOrder();
assertThat(
builder()
.addLazyString(
"--arg",
new LazyString() {
@Override
public String toString() {
return "foo";
}
})
.build()
.arguments())
.containsExactly("--arg", "foo")
.inOrder();
}
@Test
public void testAddFormatted() throws Exception {
assertThat(builder().addFormatted("%s%s", "hello", "world").build().arguments())
.containsExactly("helloworld")
.inOrder();
}
@Test
public void testAddPrefixed() throws Exception {
assertThat(builder().addPrefixed("prefix-", "foo").build().arguments())
.containsExactly("prefix-foo")
.inOrder();
assertThat(
builder()
.addPrefixedLabel("prefix-", Label.parseAbsolute("//a:b", ImmutableMap.of()))
.build()
.arguments())
.containsExactly("prefix-//a:b")
.inOrder();
assertThat(
builder().addPrefixedPath("prefix-", PathFragment.create("path")).build().arguments())
.containsExactly("prefix-path")
.inOrder();
assertThat(builder().addPrefixedExecPath("prefix-", artifact1).build().arguments())
.containsExactly("prefix-dir/file1.txt")
.inOrder();
}
@Test
public void testVectorAdds() throws Exception {
assertThat(builder().addAll(list("val1", "val2")).build().arguments())
.containsExactly("val1", "val2")
.inOrder();
assertThat(builder().addAll(nestedSet("val1", "val2")).build().arguments())
.containsExactly("val1", "val2")
.inOrder();
assertThat(
builder()
.addPaths(list(PathFragment.create("path1"), PathFragment.create("path2")))
.build()
.arguments())
.containsExactly("path1", "path2")
.inOrder();
assertThat(
builder()
.addPaths(nestedSet(PathFragment.create("path1"), PathFragment.create("path2")))
.build()
.arguments())
.containsExactly("path1", "path2")
.inOrder();
assertThat(builder().addExecPaths(list(artifact1, artifact2)).build().arguments())
.containsExactly("dir/file1.txt", "dir/file2.txt")
.inOrder();
assertThat(builder().addExecPaths(nestedSet(artifact1, artifact2)).build().arguments())
.containsExactly("dir/file1.txt", "dir/file2.txt")
.inOrder();
assertThat(
builder()
.addAll(VectorArg.of(list(foo("1"), foo("2"))).mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("1", "2")
.inOrder();
assertThat(
builder()
.addAll(VectorArg.of(nestedSet(foo("1"), foo("2"))).mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("1", "2")
.inOrder();
assertThat(builder().addAll("--arg", list("val1", "val2")).build().arguments())
.containsExactly("--arg", "val1", "val2")
.inOrder();
assertThat(builder().addAll("--arg", nestedSet("val1", "val2")).build().arguments())
.containsExactly("--arg", "val1", "val2")
.inOrder();
assertThat(
builder()
.addPaths("--arg", list(PathFragment.create("path1"), PathFragment.create("path2")))
.build()
.arguments())
.containsExactly("--arg", "path1", "path2")
.inOrder();
assertThat(
builder()
.addPaths(
"--arg", nestedSet(PathFragment.create("path1"), PathFragment.create("path2")))
.build()
.arguments())
.containsExactly("--arg", "path1", "path2")
.inOrder();
assertThat(builder().addExecPaths("--arg", list(artifact1, artifact2)).build().arguments())
.containsExactly("--arg", "dir/file1.txt", "dir/file2.txt")
.inOrder();
assertThat(builder().addExecPaths("--arg", nestedSet(artifact1, artifact2)).build().arguments())
.containsExactly("--arg", "dir/file1.txt", "dir/file2.txt")
.inOrder();
assertThat(
builder()
.addAll("--arg", VectorArg.of(list(foo("1"), foo("2"))).mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("--arg", "1", "2")
.inOrder();
assertThat(
builder()
.addAll(
"--arg", VectorArg.of(nestedSet(foo("1"), foo("2"))).mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("--arg", "1", "2")
.inOrder();
}
@Test
public void testAddJoined() throws Exception {
assertThat(builder().addAll(VectorArg.join(":").each(list("val1", "val2"))).build().arguments())
.containsExactly("val1:val2")
.inOrder();
assertThat(
builder()
.addAll(VectorArg.join(":").each(nestedSet("val1", "val2")))
.build()
.arguments())
.containsExactly("val1:val2")
.inOrder();
assertThat(
builder()
.addPaths(
VectorArg.join(":")
.each(list(PathFragment.create("path1"), PathFragment.create("path2"))))
.build()
.arguments())
.containsExactly("path1:path2")
.inOrder();
assertThat(
builder()
.addPaths(
VectorArg.join(":")
.each(
nestedSet(PathFragment.create("path1"), PathFragment.create("path2"))))
.build()
.arguments())
.containsExactly("path1:path2")
.inOrder();
assertThat(
builder()
.addExecPaths(VectorArg.join(":").each(list(artifact1, artifact2)))
.build()
.arguments())
.containsExactly("dir/file1.txt:dir/file2.txt")
.inOrder();
assertThat(
builder()
.addExecPaths(VectorArg.join(":").each(nestedSet(artifact1, artifact2)))
.build()
.arguments())
.containsExactly("dir/file1.txt:dir/file2.txt")
.inOrder();
assertThat(
builder()
.addAll(VectorArg.join(":").each(list(foo("1"), foo("2"))).mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("1:2")
.inOrder();
assertThat(
builder()
.addAll(
VectorArg.join(":")
.each(nestedSet(foo("1"), foo("2")))
.mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("1:2")
.inOrder();
assertThat(
builder()
.addAll("--arg", VectorArg.join(":").each(list("val1", "val2")))
.build()
.arguments())
.containsExactly("--arg", "val1:val2")
.inOrder();
assertThat(
builder()
.addAll("--arg", VectorArg.join(":").each(nestedSet("val1", "val2")))
.build()
.arguments())
.containsExactly("--arg", "val1:val2")
.inOrder();
assertThat(
builder()
.addPaths(
"--arg",
VectorArg.join(":")
.each(list(PathFragment.create("path1"), PathFragment.create("path2"))))
.build()
.arguments())
.containsExactly("--arg", "path1:path2")
.inOrder();
assertThat(
builder()
.addPaths(
"--arg",
VectorArg.join(":")
.each(
nestedSet(PathFragment.create("path1"), PathFragment.create("path2"))))
.build()
.arguments())
.containsExactly("--arg", "path1:path2")
.inOrder();
assertThat(
builder()
.addExecPaths("--arg", VectorArg.join(":").each(list(artifact1, artifact2)))
.build()
.arguments())
.containsExactly("--arg", "dir/file1.txt:dir/file2.txt")
.inOrder();
assertThat(
builder()
.addExecPaths("--arg", VectorArg.join(":").each(nestedSet(artifact1, artifact2)))
.build()
.arguments())
.containsExactly("--arg", "dir/file1.txt:dir/file2.txt")
.inOrder();
assertThat(
builder()
.addAll(
"--arg",
VectorArg.join(":").each(list(foo("1"), foo("2"))).mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("--arg", "1:2")
.inOrder();
assertThat(
builder()
.addAll(
"--arg",
VectorArg.join(":")
.each(nestedSet(foo("1"), foo("2")))
.mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("--arg", "1:2")
.inOrder();
}
@Test
public void testAddFormatEach() throws Exception {
assertThat(
builder()
.addAll(VectorArg.format("-D%s").each(list("val1", "val2")))
.build()
.arguments())
.containsExactly("-Dval1", "-Dval2")
.inOrder();
assertThat(
builder()
.addAll(VectorArg.format("-D%s").each(nestedSet("val1", "val2")))
.build()
.arguments())
.containsExactly("-Dval1", "-Dval2")
.inOrder();
assertThat(
builder()
.addPaths(
VectorArg.format("-D%s")
.each(list(PathFragment.create("path1"), PathFragment.create("path2"))))
.build()
.arguments())
.containsExactly("-Dpath1", "-Dpath2")
.inOrder();
assertThat(
builder()
.addPaths(
VectorArg.format("-D%s")
.each(
nestedSet(PathFragment.create("path1"), PathFragment.create("path2"))))
.build()
.arguments())
.containsExactly("-Dpath1", "-Dpath2")
.inOrder();
assertThat(
builder()
.addExecPaths(VectorArg.format("-D%s").each(list(artifact1, artifact2)))
.build()
.arguments())
.containsExactly("-Ddir/file1.txt", "-Ddir/file2.txt")
.inOrder();
assertThat(
builder()
.addExecPaths(VectorArg.format("-D%s").each(nestedSet(artifact1, artifact2)))
.build()
.arguments())
.containsExactly("-Ddir/file1.txt", "-Ddir/file2.txt")
.inOrder();
assertThat(
builder()
.addAll(
VectorArg.format("-D%s")
.each(list(foo("1"), foo("2")))
.mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("-D1", "-D2")
.inOrder();
assertThat(
builder()
.addAll(
VectorArg.format("-D%s")
.each(nestedSet(foo("1"), foo("2")))
.mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("-D1", "-D2")
.inOrder();
assertThat(
builder()
.addAll("--arg", VectorArg.format("-D%s").each(list("val1", "val2")))
.build()
.arguments())
.containsExactly("--arg", "-Dval1", "-Dval2")
.inOrder();
assertThat(
builder()
.addAll("--arg", VectorArg.format("-D%s").each(nestedSet("val1", "val2")))
.build()
.arguments())
.containsExactly("--arg", "-Dval1", "-Dval2")
.inOrder();
assertThat(
builder()
.addPaths(
"--arg",
VectorArg.format("-D%s")
.each(list(PathFragment.create("path1"), PathFragment.create("path2"))))
.build()
.arguments())
.containsExactly("--arg", "-Dpath1", "-Dpath2")
.inOrder();
assertThat(
builder()
.addPaths(
"--arg",
VectorArg.format("-D%s")
.each(
nestedSet(PathFragment.create("path1"), PathFragment.create("path2"))))
.build()
.arguments())
.containsExactly("--arg", "-Dpath1", "-Dpath2")
.inOrder();
assertThat(
builder()
.addExecPaths("--arg", VectorArg.format("-D%s").each(list(artifact1, artifact2)))
.build()
.arguments())
.containsExactly("--arg", "-Ddir/file1.txt", "-Ddir/file2.txt")
.inOrder();
assertThat(
builder()
.addExecPaths(
"--arg", VectorArg.format("-D%s").each(nestedSet(artifact1, artifact2)))
.build()
.arguments())
.containsExactly("--arg", "-Ddir/file1.txt", "-Ddir/file2.txt")
.inOrder();
assertThat(
builder()
.addAll(
"--arg",
VectorArg.format("-D%s")
.each(list(foo("1"), foo("2")))
.mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("--arg", "-D1", "-D2")
.inOrder();
assertThat(
builder()
.addAll(
"--arg",
VectorArg.format("-D%s")
.each(nestedSet(foo("1"), foo("2")))
.mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("--arg", "-D1", "-D2")
.inOrder();
}
@Test
public void testAddFormatEachJoined() throws Exception {
assertThat(
builder()
.addAll(VectorArg.format("-D%s").join(":").each(list("val1", "val2")))
.build()
.arguments())
.containsExactly("-Dval1:-Dval2")
.inOrder();
assertThat(
builder()
.addAll(VectorArg.format("-D%s").join(":").each(nestedSet("val1", "val2")))
.build()
.arguments())
.containsExactly("-Dval1:-Dval2")
.inOrder();
assertThat(
builder()
.addPaths(
VectorArg.format("-D%s")
.join(":")
.each(list(PathFragment.create("path1"), PathFragment.create("path2"))))
.build()
.arguments())
.containsExactly("-Dpath1:-Dpath2")
.inOrder();
assertThat(
builder()
.addPaths(
VectorArg.format("-D%s")
.join(":")
.each(
nestedSet(PathFragment.create("path1"), PathFragment.create("path2"))))
.build()
.arguments())
.containsExactly("-Dpath1:-Dpath2")
.inOrder();
assertThat(
builder()
.addExecPaths(VectorArg.format("-D%s").join(":").each(list(artifact1, artifact2)))
.build()
.arguments())
.containsExactly("-Ddir/file1.txt:-Ddir/file2.txt")
.inOrder();
assertThat(
builder()
.addExecPaths(
VectorArg.format("-D%s").join(":").each(nestedSet(artifact1, artifact2)))
.build()
.arguments())
.containsExactly("-Ddir/file1.txt:-Ddir/file2.txt")
.inOrder();
assertThat(
builder()
.addAll(
VectorArg.format("-D%s")
.join(":")
.each(list(foo("1"), foo("2")))
.mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("-D1:-D2")
.inOrder();
assertThat(
builder()
.addAll(
VectorArg.format("-D%s")
.join(":")
.each(nestedSet(foo("1"), foo("2")))
.mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("-D1:-D2")
.inOrder();
assertThat(
builder()
.addAll("--arg", VectorArg.format("-D%s").join(":").each(list("val1", "val2")))
.build()
.arguments())
.containsExactly("--arg", "-Dval1:-Dval2")
.inOrder();
assertThat(
builder()
.addAll("--arg", VectorArg.format("-D%s").join(":").each(nestedSet("val1", "val2")))
.build()
.arguments())
.containsExactly("--arg", "-Dval1:-Dval2")
.inOrder();
assertThat(
builder()
.addPaths(
"--arg",
VectorArg.format("-D%s")
.join(":")
.each(list(PathFragment.create("path1"), PathFragment.create("path2"))))
.build()
.arguments())
.containsExactly("--arg", "-Dpath1:-Dpath2")
.inOrder();
assertThat(
builder()
.addPaths(
"--arg",
VectorArg.format("-D%s")
.join(":")
.each(
nestedSet(PathFragment.create("path1"), PathFragment.create("path2"))))
.build()
.arguments())
.containsExactly("--arg", "-Dpath1:-Dpath2")
.inOrder();
assertThat(
builder()
.addExecPaths(
"--arg", VectorArg.format("-D%s").join(":").each(list(artifact1, artifact2)))
.build()
.arguments())
.containsExactly("--arg", "-Ddir/file1.txt:-Ddir/file2.txt")
.inOrder();
assertThat(
builder()
.addExecPaths(
"--arg",
VectorArg.format("-D%s").join(":").each(nestedSet(artifact1, artifact2)))
.build()
.arguments())
.containsExactly("--arg", "-Ddir/file1.txt:-Ddir/file2.txt")
.inOrder();
assertThat(
builder()
.addAll(
"--arg",
VectorArg.format("-D%s")
.join(":")
.each(list(foo("1"), foo("2")))
.mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("--arg", "-D1:-D2")
.inOrder();
assertThat(
builder()
.addAll(
"--arg",
VectorArg.format("-D%s")
.join(":")
.each(nestedSet(foo("1"), foo("2")))
.mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("--arg", "-D1:-D2")
.inOrder();
}
@Test
public void testAddBeforeEach() throws Exception {
assertThat(
builder()
.addAll(VectorArg.addBefore("-D").each(list("val1", "val2")))
.build()
.arguments())
.containsExactly("-D", "val1", "-D", "val2")
.inOrder();
assertThat(
builder()
.addAll(VectorArg.addBefore("-D").each(nestedSet("val1", "val2")))
.build()
.arguments())
.containsExactly("-D", "val1", "-D", "val2")
.inOrder();
assertThat(
builder()
.addPaths(
VectorArg.addBefore("-D")
.each(list(PathFragment.create("path1"), PathFragment.create("path2"))))
.build()
.arguments())
.containsExactly("-D", "path1", "-D", "path2")
.inOrder();
assertThat(
builder()
.addPaths(
VectorArg.addBefore("-D")
.each(
nestedSet(PathFragment.create("path1"), PathFragment.create("path2"))))
.build()
.arguments())
.containsExactly("-D", "path1", "-D", "path2")
.inOrder();
assertThat(
builder()
.addExecPaths(VectorArg.addBefore("-D").each(list(artifact1, artifact2)))
.build()
.arguments())
.containsExactly("-D", "dir/file1.txt", "-D", "dir/file2.txt")
.inOrder();
assertThat(
builder()
.addExecPaths(VectorArg.addBefore("-D").each(nestedSet(artifact1, artifact2)))
.build()
.arguments())
.containsExactly("-D", "dir/file1.txt", "-D", "dir/file2.txt")
.inOrder();
assertThat(
builder()
.addAll(
VectorArg.addBefore("-D")
.each(list(foo("1"), foo("2")))
.mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("-D", "1", "-D", "2")
.inOrder();
assertThat(
builder()
.addAll(
VectorArg.addBefore("-D")
.each(nestedSet(foo("1"), foo("2")))
.mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("-D", "1", "-D", "2")
.inOrder();
}
@Test
public void testAddBeforeEachFormatted() throws Exception {
assertThat(
builder()
.addAll(VectorArg.addBefore("-D").format("D%s").each(list("val1", "val2")))
.build()
.arguments())
.containsExactly("-D", "Dval1", "-D", "Dval2")
.inOrder();
assertThat(
builder()
.addAll(VectorArg.addBefore("-D").format("D%s").each(nestedSet("val1", "val2")))
.build()
.arguments())
.containsExactly("-D", "Dval1", "-D", "Dval2")
.inOrder();
assertThat(
builder()
.addPaths(
VectorArg.addBefore("-D")
.format("D%s")
.each(list(PathFragment.create("path1"), PathFragment.create("path2"))))
.build()
.arguments())
.containsExactly("-D", "Dpath1", "-D", "Dpath2")
.inOrder();
assertThat(
builder()
.addPaths(
VectorArg.addBefore("-D")
.format("D%s")
.each(
nestedSet(PathFragment.create("path1"), PathFragment.create("path2"))))
.build()
.arguments())
.containsExactly("-D", "Dpath1", "-D", "Dpath2")
.inOrder();
assertThat(
builder()
.addExecPaths(
VectorArg.addBefore("-D").format("D%s").each(list(artifact1, artifact2)))
.build()
.arguments())
.containsExactly("-D", "Ddir/file1.txt", "-D", "Ddir/file2.txt")
.inOrder();
assertThat(
builder()
.addExecPaths(
VectorArg.addBefore("-D").format("D%s").each(nestedSet(artifact1, artifact2)))
.build()
.arguments())
.containsExactly("-D", "Ddir/file1.txt", "-D", "Ddir/file2.txt")
.inOrder();
assertThat(
builder()
.addAll(
VectorArg.addBefore("-D")
.format("D%s")
.each(list(foo("1"), foo("2")))
.mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("-D", "D1", "-D", "D2")
.inOrder();
assertThat(
builder()
.addAll(
VectorArg.addBefore("-D")
.format("D%s")
.each(nestedSet(foo("1"), foo("2")))
.mapped(Foo::expandToStr))
.build()
.arguments())
.containsExactly("-D", "D1", "-D", "D2")
.inOrder();
}
@Test
public void testCombinedArgs() {
CustomCommandLine cl =
builder()
.add("--arg")
.addAll("--args", ImmutableList.of("abc"))
.addExecPaths("--path1", ImmutableList.of(artifact1))
.addExecPath("--path2", artifact2)
.build();
assertThat(cl.arguments())
.containsExactly(
"--arg", "--args", "abc", "--path1", "dir/file1.txt", "--path2", "dir/file2.txt")
.inOrder();
}
@Test
public void testAddNulls() throws Exception {
Artifact treeArtifact = createTreeArtifact("myTreeArtifact");
assertThat(treeArtifact).isNotNull();
CustomCommandLine cl =
builder()
.addDynamicString(null)
.addLabel(null)
.addPath(null)
.addExecPath(null)
.addLazyString(null)
.add("foo", null)
.addLabel("foo", null)
.addPath("foo", null)
.addExecPath("foo", null)
.addLazyString("foo", null)
.addPrefixed("prefix", null)
.addPrefixedLabel("prefix", null)
.addPrefixedPath("prefix", null)
.addPrefixedExecPath("prefix", null)
.addAll((ImmutableList<String>) null)
.addAll(ImmutableList.of())
.addPaths((ImmutableList<PathFragment>) null)
.addPaths(ImmutableList.of())
.addExecPaths((ImmutableList<Artifact>) null)
.addExecPaths(ImmutableList.of())
.addAll((NestedSet<String>) null)
.addAll(NestedSetBuilder.emptySet(Order.STABLE_ORDER))
.addPaths((NestedSet<PathFragment>) null)
.addPaths(NestedSetBuilder.emptySet(Order.STABLE_ORDER))
.addExecPaths((NestedSet<Artifact>) null)
.addExecPaths(NestedSetBuilder.emptySet(Order.STABLE_ORDER))
.addAll(VectorArg.of((NestedSet<String>) null))
.addAll(VectorArg.of(NestedSetBuilder.<String>emptySet(Order.STABLE_ORDER)))
.addAll("foo", (ImmutableList<String>) null)
.addAll("foo", ImmutableList.of())
.addPaths("foo", (ImmutableList<PathFragment>) null)
.addPaths("foo", ImmutableList.of())
.addExecPaths("foo", (ImmutableList<Artifact>) null)
.addExecPaths("foo", ImmutableList.of())
.addAll("foo", (NestedSet<String>) null)
.addAll("foo", NestedSetBuilder.emptySet(Order.STABLE_ORDER))
.addPaths("foo", (NestedSet<PathFragment>) null)
.addPaths("foo", NestedSetBuilder.emptySet(Order.STABLE_ORDER))
.addExecPaths("foo", (NestedSet<Artifact>) null)
.addExecPaths("foo", NestedSetBuilder.emptySet(Order.STABLE_ORDER))
.addAll("foo", VectorArg.of((NestedSet<String>) null))
.addAll("foo", VectorArg.of(NestedSetBuilder.<String>emptySet(Order.STABLE_ORDER)))
.addPlaceholderTreeArtifactExecPath("foo", null)
.build();
assertThat(cl.arguments()).isEmpty();
}
@Test
public void testTreeFileArtifactExecPathArgs() {
SpecialArtifact treeArtifactOne = createTreeArtifact("myArtifact/treeArtifact1");
SpecialArtifact treeArtifactTwo = createTreeArtifact("myArtifact/treeArtifact2");
CustomCommandLine commandLineTemplate =
builder()
.addPlaceholderTreeArtifactExecPath("--argOne", treeArtifactOne)
.addPlaceholderTreeArtifactExecPath("--argTwo", treeArtifactTwo)
.build();
TreeFileArtifact treeFileArtifactOne =
ActionsTestUtil.createTreeFileArtifactWithNoGeneratingAction(
treeArtifactOne, "children/child1");
TreeFileArtifact treeFileArtifactTwo =
ActionsTestUtil.createTreeFileArtifactWithNoGeneratingAction(
treeArtifactTwo, "children/child2");
CustomCommandLine commandLine = commandLineTemplate.evaluateTreeFileArtifacts(
ImmutableList.of(treeFileArtifactOne, treeFileArtifactTwo));
assertThat(commandLine.arguments())
.containsExactly(
"--argOne",
"dir/myArtifact/treeArtifact1/children/child1",
"--argTwo",
"dir/myArtifact/treeArtifact2/children/child2")
.inOrder();
}
@Test
public void testKeyComputation() {
NestedSet<String> values = NestedSetBuilder.<String>stableOrder().add("a").add("b").build();
ImmutableList<CustomCommandLine> commandLines =
ImmutableList.<CustomCommandLine>builder()
.add(builder().add("arg").build())
.add(builder().addFormatted("--foo=%s", "arg").build())
.add(builder().addPrefixed("--foo=%s", "arg").build())
.add(builder().addAll(values).build())
.add(builder().addAll(VectorArg.addBefore("--foo=%s").each(values)).build())
.add(builder().addAll(VectorArg.join("--foo=%s").each(values)).build())
.add(builder().addAll(VectorArg.format("--foo=%s").each(values)).build())
.add(
builder()
.addAll(VectorArg.of(values).mapped((s, args) -> args.accept(s + "_mapped")))
.build())
.build();
// Ensure all these command lines have distinct keys
ActionKeyContext actionKeyContext = new ActionKeyContext();
Map<String, CustomCommandLine> digests = new HashMap<>();
for (CustomCommandLine commandLine : commandLines) {
Fingerprint fingerprint = new Fingerprint();
commandLine.addToFingerprint(actionKeyContext, fingerprint);
String digest = fingerprint.hexDigestAndReset();
CustomCommandLine previous = digests.putIfAbsent(digest, commandLine);
if (previous != null) {
fail(
String.format(
"Found two command lines with identical digest %s: '%s' and '%s'",
digest,
Joiner.on(' ').join(previous.arguments()),
Joiner.on(' ').join(commandLine.arguments())));
}
}
}
@Test
public void testTreeFileArtifactArgThrowWithoutSubstitution() {
Artifact treeArtifactOne = createTreeArtifact("myArtifact/treeArtifact1");
Artifact treeArtifactTwo = createTreeArtifact("myArtifact/treeArtifact2");
CustomCommandLine commandLineTemplate =
builder()
.addPlaceholderTreeArtifactExecPath("--argOne", treeArtifactOne)
.addPlaceholderTreeArtifactExecPath("--argTwo", treeArtifactTwo)
.build();
assertThrows(NullPointerException.class, () -> commandLineTemplate.arguments());
}
private SpecialArtifact createTreeArtifact(String rootRelativePath) {
PathFragment relpath = PathFragment.create(rootRelativePath);
return new SpecialArtifact(
rootDir,
rootDir.getExecPath().getRelative(relpath),
ActionsTestUtil.NULL_ACTION_LOOKUP_DATA.getActionLookupKey(),
SpecialArtifactType.TREE);
}
private static <T> ImmutableList<T> list(T... objects) {
return ImmutableList.<T>builder().addAll(Arrays.asList(objects)).build();
}
private static <T> NestedSet<T> nestedSet(T... objects) {
return NestedSetBuilder.<T>stableOrder().addAll(Arrays.asList(objects)).build();
}
private static Foo foo(String str) {
return new Foo(str);
}
private static class Foo {
private final String str;
Foo(String str) {
this.str = str;
}
static void expandToStr(Foo foo, Consumer<String> args) {
args.accept(foo.str);
}
}
}