@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);
}
public static HeaderSymlinkTree createHeaderSymlinkTree(
BuildRuleParams params,
BuildRuleResolver ruleResolver,
SourcePathResolver pathResolver,
CxxPlatform cxxPlatform,
boolean includeLexYaccHeaders,
ImmutableMap<String, SourcePath> lexSources,
ImmutableMap<String, SourcePath> yaccSources,
ImmutableMap<Path, SourcePath> headers,
HeaderVisibility headerVisibility) {
BuildTarget headerSymlinkTreeTarget =
CxxDescriptionEnhancer.createHeaderSymlinkTreeTarget(
params.getBuildTarget(), cxxPlatform.getFlavor(), headerVisibility);
Path headerSymlinkTreeRoot =
CxxDescriptionEnhancer.getHeaderSymlinkTreePath(
params.getBuildTarget(), cxxPlatform.getFlavor(), headerVisibility);
Optional<Path> headerMapLocation = Optional.absent();
if (cxxPlatform.getCpp().supportsHeaderMaps() && cxxPlatform.getCxxpp().supportsHeaderMaps()) {
headerMapLocation =
Optional.of(
getHeaderMapPath(params.getBuildTarget(), cxxPlatform.getFlavor(), headerVisibility));
}
CxxHeaderSourceSpec lexYaccSources;
if (includeLexYaccHeaders) {
lexYaccSources =
requireLexYaccSources(
params, ruleResolver, pathResolver, cxxPlatform, lexSources, yaccSources);
} else {
lexYaccSources = CxxHeaderSourceSpec.builder().build();
}
return CxxPreprocessables.createHeaderSymlinkTreeBuildRule(
pathResolver,
headerSymlinkTreeTarget,
params,
headerSymlinkTreeRoot,
headerMapLocation,
ImmutableMap.<Path, SourcePath>builder()
.putAll(headers)
.putAll(lexYaccSources.getCxxHeaders())
.build());
}