@Test
public void testPathsUnderDirectories() throws CmdLineException, IOException {
ProjectFilesystem projectFilesystem = new FakeProjectFilesystem();
Path resDir = Paths.get("some/resources/dir");
BuildTarget androidResourceTarget = BuildTargetFactory.newInstance("//:res");
TargetNode<?> androidResourceNode =
AndroidResourceBuilder.createBuilder(androidResourceTarget).setRes(resDir).build();
Path genSrc = resDir.resolve("foo.txt");
BuildTarget genTarget = BuildTargetFactory.newInstance("//:res");
TargetNode<?> genNode =
GenruleBuilder.newGenruleBuilder(genTarget)
.setSrcs(ImmutableList.<SourcePath>of(new PathSourcePath(projectFilesystem, genSrc)))
.build();
TargetGraph targetGraph = TargetGraphFactory.newInstance(androidResourceNode, genNode);
SortedMap<String, TargetNode<?>> matchingBuildRules;
// Specifying a resource under the resource directory causes a match.
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(ImmutableSet.of(resDir.resolve("some_resource.txt"))),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
false,
"BUCK");
assertEquals(ImmutableSet.of(androidResourceTarget.toString()), matchingBuildRules.keySet());
// Specifying a resource with the same string-like common prefix, but not under the above
// resource dir, should not trigger a match.
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(
ImmutableSet.of(
Paths.get(resDir.toString() + "_extra").resolve("some_resource.txt"))),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
false,
"BUCK");
assertTrue(matchingBuildRules.isEmpty());
// Specifying a resource with the same string-like common prefix, but not under the above
// resource dir, should not trigger a match.
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(ImmutableSet.of(genSrc)),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
false,
"BUCK");
assertEquals(
ImmutableSet.of(androidResourceTarget.toString(), genTarget.toString()),
matchingBuildRules.keySet());
}
@Test
public void testCreateBuildRule() throws Exception {
// Set up a #halide-compiler rule, then set up a halide_library rule, and
// check that the library rule depends on the compiler rule.
BuildTarget compilerTarget =
BuildTargetFactory.newInstance("//:rule")
.withFlavors(HalideLibraryDescription.HALIDE_COMPILER_FLAVOR);
BuildTarget libTarget = BuildTargetFactory.newInstance("//:rule");
ProjectFilesystem filesystem = new FakeProjectFilesystem();
HalideLibraryBuilder compilerBuilder = new HalideLibraryBuilder(compilerTarget);
compilerBuilder.setSrcs(
ImmutableSortedSet.of(SourceWithFlags.of(new FakeSourcePath("main.cpp"))));
HalideLibraryBuilder libBuilder = new HalideLibraryBuilder(libTarget);
TargetGraph targetGraph =
TargetGraphFactory.newInstance(compilerBuilder.build(), libBuilder.build());
BuildRuleResolver resolver =
new BuildRuleResolver(targetGraph, new BuildTargetNodeToBuildRuleTransformer());
CxxBinary compiler = (CxxBinary) compilerBuilder.build(resolver, filesystem, targetGraph);
HalideLibrary lib = (HalideLibrary) libBuilder.build(resolver, filesystem, targetGraph);
// Check that we picked up the implicit dependency on the #halide-compiler
// version of the rule.
assertEquals(lib.getDeps(), ImmutableSortedSet.<BuildRule>of(compiler));
// Check that the library rule has the correct preprocessor input.
CxxPlatform cxxPlatform = CxxLibraryBuilder.createDefaultPlatform();
String headerName = "rule.h";
Path headerPath = BuildTargets.getGenPath(libTarget, "%s/" + headerName);
Path headerRoot =
CxxDescriptionEnhancer.getHeaderSymlinkTreePath(
libTarget, cxxPlatform.getFlavor(), HeaderVisibility.PUBLIC);
assertEquals(
CxxPreprocessorInput.builder()
.addRules(
CxxDescriptionEnhancer.createHeaderSymlinkTreeTarget(
libTarget, cxxPlatform.getFlavor(), HeaderVisibility.PUBLIC))
.setIncludes(
CxxHeaders.builder()
.putNameToPathMap(
Paths.get(headerName), new BuildTargetSourcePath(libTarget, headerPath))
.putFullNameToPathMap(
headerRoot.resolve(headerName),
new BuildTargetSourcePath(libTarget, headerPath))
.build())
.addSystemIncludeRoots(headerRoot)
.build(),
lib.getCxxPreprocessorInput(cxxPlatform, HeaderVisibility.PUBLIC));
// Check that the library rule has the correct native linkable input.
NativeLinkableInput input =
lib.getNativeLinkableInput(cxxPlatform, Linker.LinkableDepType.STATIC);
BuildRule buildRule =
FluentIterable.from(input.getArgs())
.transformAndConcat(Arg.getDepsFunction(new SourcePathResolver(resolver)))
.get(0);
assertTrue(buildRule instanceof HalideLibrary);
}
@Test
public void testGetMatchingAppleTestBuildTarget() throws CmdLineException, IOException {
BuildTarget libraryTarget = BuildTargetFactory.newInstance("//foo:lib");
TargetNode<?> libraryNode =
AppleLibraryBuilder.createBuilder(libraryTarget)
.setSrcs(
Optional.of(
ImmutableSortedSet.of(SourceWithFlags.of(new FakeSourcePath("foo/foo.m")))))
.build();
BuildTarget testTarget = BuildTargetFactory.newInstance("//foo:xctest");
TargetNode<?> testNode =
AppleTestBuilder.createBuilder(testTarget)
.setExtension(Either.<AppleBundleExtension, String>ofLeft(AppleBundleExtension.XCTEST))
.setSrcs(
Optional.of(
ImmutableSortedSet.of(SourceWithFlags.of(new FakeSourcePath("foo/testfoo.m")))))
.setDeps(Optional.of(ImmutableSortedSet.of(libraryTarget)))
.build();
ImmutableSet<TargetNode<?>> nodes = ImmutableSet.of(libraryNode, testNode);
TargetGraph targetGraph = TargetGraphFactory.newInstance(nodes);
// No target depends on the referenced file.
SortedMap<String, TargetNode<?>> matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(ImmutableSet.of(Paths.get("foo/bar.m"))),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
false,
"BUCK");
assertTrue(matchingBuildRules.isEmpty());
// Both AppleLibrary nodes, AppleBundle, and AppleTest match the referenced file.
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(ImmutableSet.of(Paths.get("foo/foo.m"))),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
false,
"BUCK");
assertEquals(ImmutableSet.of("//foo:lib", "//foo:xctest"), matchingBuildRules.keySet());
// The test AppleLibrary, AppleBundle and AppleTest match the referenced file.
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(ImmutableSet.of(Paths.get("foo/testfoo.m"))),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
false,
"BUCK");
assertEquals(ImmutableSet.of("//foo:xctest"), matchingBuildRules.keySet());
}
@Test
public void compilerFlags() throws Exception {
BuildTarget target = BuildTargetFactory.newInstance("//:rule");
String flag = "-compiler-flag";
HaskellBinaryBuilder builder =
new HaskellBinaryBuilder(target).setCompilerFlags(ImmutableList.of(flag));
BuildRuleResolver resolver =
new BuildRuleResolver(
TargetGraphFactory.newInstance(builder.build()),
new DefaultTargetNodeToBuildRuleTransformer());
builder.build(resolver);
BuildTarget compileTarget =
HaskellDescriptionUtils.getCompileBuildTarget(
target, CxxPlatformUtils.DEFAULT_PLATFORM, Linker.LinkableDepType.STATIC);
HaskellCompileRule rule = resolver.getRuleWithType(compileTarget, HaskellCompileRule.class);
assertThat(rule.getFlags(), Matchers.hasItem(flag));
}
@Test
public void testGetMatchingAppleLibraryBuildTarget() throws CmdLineException, IOException {
BuildTarget libraryTarget = BuildTargetFactory.newInstance("//foo:lib");
TargetNode<?> libraryNode =
AppleLibraryBuilder.createBuilder(libraryTarget)
.setSrcs(
Optional.of(
ImmutableSortedSet.of(SourceWithFlags.of(new FakeSourcePath("foo/foo.m")))))
.build();
ImmutableSet<TargetNode<?>> nodes = ImmutableSet.<TargetNode<?>>of(libraryNode);
TargetGraph targetGraph = TargetGraphFactory.newInstance(nodes);
// No target depends on the referenced file.
SortedMap<String, TargetNode<?>> matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(ImmutableSet.of(Paths.get("foo/bar.m"))),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
false,
"BUCK");
assertTrue(matchingBuildRules.isEmpty());
// The AppleLibrary matches the referenced file.
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(ImmutableSet.of(Paths.get("foo/foo.m"))),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
false,
"BUCK");
assertEquals(ImmutableSet.of("//foo:lib"), matchingBuildRules.keySet());
}
@Test
public void testDetectTestChanges() throws CmdLineException, IOException {
BuildTarget libraryTarget = BuildTargetFactory.newInstance("//foo:lib");
BuildTarget libraryTestTarget1 = BuildTargetFactory.newInstance("//foo:xctest1");
BuildTarget libraryTestTarget2 = BuildTargetFactory.newInstance("//foo:xctest2");
BuildTarget testLibraryTarget = BuildTargetFactory.newInstance("//testlib:testlib");
BuildTarget testLibraryTestTarget = BuildTargetFactory.newInstance("//testlib:testlib-xctest");
TargetNode<?> libraryNode =
AppleLibraryBuilder.createBuilder(libraryTarget)
.setSrcs(
Optional.of(
ImmutableSortedSet.of(SourceWithFlags.of(new FakeSourcePath("foo/foo.m")))))
.setTests(Optional.of(ImmutableSortedSet.of(libraryTestTarget1, libraryTestTarget2)))
.build();
TargetNode<?> libraryTestNode1 =
AppleTestBuilder.createBuilder(libraryTestTarget1)
.setExtension(Either.<AppleBundleExtension, String>ofLeft(AppleBundleExtension.XCTEST))
.setSrcs(
Optional.of(
ImmutableSortedSet.of(
SourceWithFlags.of(new FakeSourcePath("foo/testfoo1.m")))))
.setDeps(Optional.of(ImmutableSortedSet.of(libraryTarget)))
.build();
TargetNode<?> libraryTestNode2 =
AppleTestBuilder.createBuilder(libraryTestTarget2)
.setExtension(Either.<AppleBundleExtension, String>ofLeft(AppleBundleExtension.XCTEST))
.setSrcs(
Optional.of(
ImmutableSortedSet.of(
SourceWithFlags.of(new FakeSourcePath("foo/testfoo2.m")))))
.setDeps(Optional.of(ImmutableSortedSet.of(testLibraryTarget)))
.build();
TargetNode<?> testLibraryNode =
AppleLibraryBuilder.createBuilder(testLibraryTarget)
.setSrcs(
Optional.of(
ImmutableSortedSet.of(
SourceWithFlags.of(new FakeSourcePath("testlib/testlib.m")))))
.setTests(Optional.of(ImmutableSortedSet.of(testLibraryTestTarget)))
.build();
TargetNode<?> testLibraryTestNode =
AppleTestBuilder.createBuilder(testLibraryTestTarget)
.setExtension(Either.<AppleBundleExtension, String>ofLeft(AppleBundleExtension.XCTEST))
.setSrcs(
Optional.of(
ImmutableSortedSet.of(
SourceWithFlags.of(new FakeSourcePath("testlib/testlib-test.m")))))
.setDeps(Optional.of(ImmutableSortedSet.of(testLibraryTarget)))
.build();
ImmutableSet<TargetNode<?>> nodes =
ImmutableSet.of(
libraryNode, libraryTestNode1, libraryTestNode2, testLibraryNode, testLibraryTestNode);
TargetGraph targetGraph = TargetGraphFactory.newInstance(nodes);
// No target depends on the referenced file.
SortedMap<String, TargetNode<?>> matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(ImmutableSet.of(Paths.get("foo/bar.m"))),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
true,
"BUCK");
assertTrue(matchingBuildRules.isEmpty());
// Test1, test2 and the library depend on the referenced file.
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(ImmutableSet.of(Paths.get("foo/testfoo1.m"))),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
true,
"BUCK");
assertEquals(ImmutableSet.of("//foo:lib", "//foo:xctest1"), matchingBuildRules.keySet());
// Test1, test2 and the library depend on the referenced file.
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(ImmutableSet.of(Paths.get("foo/testfoo2.m"))),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
true,
"BUCK");
assertEquals(
ImmutableSet.of("//foo:lib", "//foo:xctest1", "//foo:xctest2"),
matchingBuildRules.keySet());
// Library, test1, test2, test library and its test depend on the referenced file.
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(ImmutableSet.of(Paths.get("testlib/testlib.m"))),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
true,
"BUCK");
assertEquals(
ImmutableSet.of(
"//foo:lib",
"//foo:xctest1",
"//foo:xctest2",
"//testlib:testlib",
"//testlib:testlib-xctest"),
matchingBuildRules.keySet());
// Library, test1, test2, test library and its test depend on the referenced file.
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(ImmutableSet.of(Paths.get("testlib/testlib-test.m"))),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
true,
"BUCK");
assertEquals(
ImmutableSet.of(
"//foo:lib",
"//foo:xctest1",
"//foo:xctest2",
"//testlib:testlib",
"//testlib:testlib-xctest"),
matchingBuildRules.keySet());
}
@Test
public void testGetMatchingBuildTargets() throws CmdLineException, IOException {
BuildTarget prebuiltJarTarget = BuildTargetFactory.newInstance("//empty:empty");
TargetNode<?> prebuiltJarNode =
PrebuiltJarBuilder.createBuilder(prebuiltJarTarget)
.setBinaryJar(Paths.get("spoof"))
.build();
BuildTarget javaLibraryTarget = BuildTargetFactory.newInstance("//javasrc:java-library");
TargetNode<?> javaLibraryNode =
JavaLibraryBuilder.createBuilder(javaLibraryTarget)
.addSrc(Paths.get("javasrc/JavaLibrary.java"))
.addDep(prebuiltJarTarget)
.build();
BuildTarget javaTestTarget = BuildTargetFactory.newInstance("//javatest:test-java-library");
TargetNode<?> javaTestNode =
JavaTestBuilder.createBuilder(javaTestTarget)
.addSrc(Paths.get("javatest/TestJavaLibrary.java"))
.addDep(javaLibraryTarget)
.build();
ImmutableSet<TargetNode<?>> nodes =
ImmutableSet.of(prebuiltJarNode, javaLibraryNode, javaTestNode);
TargetGraph targetGraph = TargetGraphFactory.newInstance(nodes);
ImmutableSet<Path> referencedFiles;
// No target depends on the referenced file.
referencedFiles = ImmutableSet.of(Paths.get("excludesrc/CannotFind.java"));
SortedMap<String, TargetNode<?>> matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(referencedFiles),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
false,
"BUCK");
assertTrue(matchingBuildRules.isEmpty());
// Only test-android-library target depends on the referenced file.
referencedFiles = ImmutableSet.of(Paths.get("javatest/TestJavaLibrary.java"));
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(referencedFiles),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
false,
"BUCK");
assertEquals(ImmutableSet.of("//javatest:test-java-library"), matchingBuildRules.keySet());
// The test-android-library target indirectly depends on the referenced file,
// while test-java-library target directly depends on the referenced file.
referencedFiles = ImmutableSet.of(Paths.get("javasrc/JavaLibrary.java"));
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(referencedFiles),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
false,
"BUCK");
assertEquals(
ImmutableSet.of("//javatest:test-java-library", "//javasrc:java-library"),
matchingBuildRules.keySet());
// Verify that BUCK files show up as referenced files.
referencedFiles = ImmutableSet.of(Paths.get("javasrc/BUCK"));
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(referencedFiles),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
false,
"BUCK");
assertEquals(
ImmutableSet.of("//javatest:test-java-library", "//javasrc:java-library"),
matchingBuildRules.keySet());
// Output target only need to depend on one referenced file.
referencedFiles =
ImmutableSet.of(
Paths.get("javatest/TestJavaLibrary.java"), Paths.get("othersrc/CannotFind.java"));
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(referencedFiles),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
false,
"BUCK");
assertEquals(ImmutableSet.of("//javatest:test-java-library"), matchingBuildRules.keySet());
// If no referenced file, means this filter is disabled, we can find all targets.
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.<ImmutableSet<Path>>absent(),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.<ImmutableSet<BuildRuleType>>absent(),
false,
"BUCK");
assertEquals(
ImmutableSet.of("//javatest:test-java-library", "//javasrc:java-library", "//empty:empty"),
matchingBuildRules.keySet());
// Specify java_test, java_library as type filters.
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.<ImmutableSet<Path>>absent(),
Optional.<ImmutableSet<BuildTarget>>absent(),
Optional.of(ImmutableSet.of(JavaTestDescription.TYPE, JavaLibraryDescription.TYPE)),
false,
"BUCK");
assertEquals(
ImmutableSet.of("//javatest:test-java-library", "//javasrc:java-library"),
matchingBuildRules.keySet());
// Specify java_test, java_library, and a rule name as type filters.
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.<ImmutableSet<Path>>absent(),
Optional.of(ImmutableSet.of(BuildTargetFactory.newInstance("//javasrc:java-library"))),
Optional.of(ImmutableSet.of(JavaTestDescription.TYPE, JavaLibraryDescription.TYPE)),
false,
"BUCK");
assertEquals(ImmutableSet.of("//javasrc:java-library"), matchingBuildRules.keySet());
// Only filter by BuildTarget
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.<ImmutableSet<Path>>absent(),
Optional.of(ImmutableSet.of(BuildTargetFactory.newInstance("//javasrc:java-library"))),
Optional.<ImmutableSet<BuildRuleType>>absent(),
false,
"BUCK");
assertEquals(ImmutableSet.of("//javasrc:java-library"), matchingBuildRules.keySet());
// Filter by BuildTarget and Referenced Files
matchingBuildRules =
targetsCommand.getMatchingNodes(
targetGraph,
Optional.of(ImmutableSet.of(Paths.get("javatest/TestJavaLibrary.java"))),
Optional.of(ImmutableSet.of(BuildTargetFactory.newInstance("//javasrc:java-library"))),
Optional.<ImmutableSet<BuildRuleType>>absent(),
false,
"BUCK");
assertEquals(ImmutableSet.<String>of(), matchingBuildRules.keySet());
}