@Test
public void testAppleDynamicLibraryWithDsym() throws Exception {
assumeTrue(Platform.detect() == Platform.MACOS);
assumeTrue(AppleNativeIntegrationTestUtils.isApplePlatformAvailable(ApplePlatform.MACOSX));
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "apple_library_shared", tmp);
workspace.setUp();
ProjectFilesystem filesystem = new ProjectFilesystem(workspace.getDestPath());
ProjectWorkspace.ProcessResult result =
workspace.runBuckCommand(
"build",
"//Libraries/TestLibrary:TestLibrary#shared,macosx-x86_64,dwarf-and-dsym",
"--config",
"cxx.cflags=-g");
result.assertSuccess();
Path output =
tmp.getRoot()
.resolve(filesystem.getBuckPaths().getGenDir())
.resolve("Libraries/TestLibrary/TestLibrary#macosx-x86_64,shared")
.resolve("libLibraries_TestLibrary_TestLibrary.dylib");
assertThat(Files.exists(output), is(true));
Path dsymPath =
tmp.getRoot()
.resolve(filesystem.getBuckPaths().getGenDir())
.resolve("Libraries/TestLibrary")
.resolve("TestLibrary#apple-dsym,macosx-x86_64,shared.dSYM");
assertThat(Files.exists(dsymPath), is(true));
AppleDsymTestUtil.checkDsymFileHasDebugSymbol("+[TestClass answer]", workspace, dsymPath);
}
@Test
public void testAppleLibraryBuildsFramework() throws Exception {
assumeTrue(Platform.detect() == Platform.MACOS);
assumeTrue(
AppleNativeIntegrationTestUtils.isApplePlatformAvailable(
ApplePlatform.builder().setName(ApplePlatform.Name.MACOSX).build()));
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(
this, "apple_library_builds_something", tmp);
workspace.setUp();
ProjectWorkspace.ProcessResult result =
workspace.runBuckCommand(
"build", "//Libraries/TestLibrary:TestLibrary#framework,macosx-x86_64");
result.assertSuccess();
Path frameworkPath =
tmp.getRootPath()
.resolve(BuckConstant.GEN_DIR)
.resolve(
"Libraries/TestLibrary/TestLibrary#framework,macosx-x86_64/TestLibrary.framework");
assertThat(Files.exists(frameworkPath), is(true));
assertThat(Files.exists(frameworkPath.resolve("Contents/Info.plist")), is(true));
Path libraryPath = frameworkPath.resolve("Contents/MacOS/TestLibrary");
assertThat(Files.exists(libraryPath), is(true));
assertThat(
workspace.runCommand("file", libraryPath.toString()).getStdout().get(),
containsString("dynamically linked shared library"));
}
public Map<String, Path> buildMultipleAndReturnOutputs(String... args) throws IOException {
// Add in `--show-output` to the build, so we can parse the output paths after the fact.
ImmutableList<String> buildArgs =
ImmutableList.<String>builder().add("--show-output").add(args).build();
ProjectWorkspace.ProcessResult buildResult =
runBuckBuild(buildArgs.toArray(new String[buildArgs.size()]));
buildResult.assertSuccess();
// Grab the stdout lines, which have the build outputs.
List<String> lines =
Splitter.on(CharMatcher.anyOf(System.lineSeparator()))
.trimResults()
.omitEmptyStrings()
.splitToList(buildResult.getStdout());
// Skip the first line, which is just "The outputs are:".
assertThat(lines.get(0), Matchers.equalTo("The outputs are:"));
lines = lines.subList(1, lines.size());
Splitter lineSplitter = Splitter.on(' ').trimResults();
ImmutableMap.Builder<String, Path> builder = ImmutableMap.builder();
for (String line : lines) {
List<String> fields = lineSplitter.splitToList(line);
assertThat(fields, Matchers.hasSize(2));
builder.put(fields.get(0), getPath(fields.get(1)));
}
return builder.build();
}
@Test
public void testAppleLibraryBuildsFramework() throws Exception {
assumeTrue(Platform.detect() == Platform.MACOS);
assumeTrue(AppleNativeIntegrationTestUtils.isApplePlatformAvailable(ApplePlatform.MACOSX));
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(
this, "apple_library_builds_something", tmp);
workspace.setUp();
ProjectFilesystem filesystem = new ProjectFilesystem(workspace.getDestPath());
BuildTarget target =
BuildTargetFactory.newInstance(
"//Libraries/TestLibrary:TestLibrary#framework,macosx-x86_64,no-debug");
ProjectWorkspace.ProcessResult result =
workspace.runBuckCommand("build", target.getFullyQualifiedName());
result.assertSuccess();
Path frameworkPath =
workspace.getPath(
BuildTargets.getGenPath(
filesystem,
BuildTarget.builder(target)
.addFlavors(AppleDescriptions.INCLUDE_FRAMEWORKS_FLAVOR)
.build(),
"%s")
.resolve("TestLibrary.framework"));
assertThat(Files.exists(frameworkPath), is(true));
assertThat(Files.exists(frameworkPath.resolve("Resources/Info.plist")), is(true));
Path libraryPath = frameworkPath.resolve("TestLibrary");
assertThat(Files.exists(libraryPath), is(true));
assertThat(
workspace.runCommand("file", libraryPath.toString()).getStdout().get(),
containsString("dynamically linked shared library"));
}
@Test
public void frameworkDependenciesDoNotContainTransitiveDependencies() throws Exception {
assumeTrue(Platform.detect() == Platform.MACOS);
assumeTrue(AppleNativeIntegrationTestUtils.isApplePlatformAvailable(ApplePlatform.MACOSX));
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(
this, "apple_library_with_library_dependencies", tmp);
workspace.setUp();
ProjectFilesystem filesystem = new ProjectFilesystem(workspace.getDestPath());
BuildTarget target =
BuildTargetFactory.newInstance(
"//Libraries/TestLibrary:TestLibrary#framework,macosx-x86_64");
ProjectWorkspace.ProcessResult result =
workspace.runBuckCommand("build", target.getFullyQualifiedName());
result.assertSuccess();
Path frameworkPath =
workspace.getPath(
BuildTargets.getGenPath(
filesystem,
BuildTarget.builder(target)
.addFlavors(AppleDebugFormat.DWARF.getFlavor())
.addFlavors(AppleDescriptions.INCLUDE_FRAMEWORKS_FLAVOR)
.build(),
"%s")
.resolve("TestLibrary.framework"));
assertThat(Files.exists(frameworkPath), is(true));
Path frameworksPath = frameworkPath.resolve("Frameworks");
assertThat(Files.exists(frameworksPath), is(true));
Path depFrameworksPath = frameworksPath.resolve("TestLibraryDep.framework/Frameworks");
assertThat(Files.exists(depFrameworksPath), is(false));
}
@Test
public void noIncludeFrameworksDoesntContainFrameworkDependencies() throws Exception {
assumeTrue(Platform.detect() == Platform.MACOS);
assumeTrue(AppleNativeIntegrationTestUtils.isApplePlatformAvailable(ApplePlatform.MACOSX));
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(
this, "apple_library_with_library_dependencies", tmp);
workspace.setUp();
ProjectFilesystem filesystem = new ProjectFilesystem(workspace.getDestPath());
BuildTarget target =
BuildTargetFactory.newInstance(
"//Libraries/TestLibrary:TestLibrary#"
+ "dwarf-and-dsym,framework,macosx-x86_64,no-include-frameworks");
ProjectWorkspace.ProcessResult result =
workspace.runBuckCommand("build", target.getFullyQualifiedName());
result.assertSuccess();
Path frameworkPath =
workspace.getPath(
BuildTargets.getGenPath(filesystem, target, "%s").resolve("TestLibrary.framework"));
assertThat(Files.exists(frameworkPath), is(true));
assertThat(Files.exists(frameworkPath.resolve("Resources/Info.plist")), is(true));
Path libraryPath = frameworkPath.resolve("TestLibrary");
assertThat(Files.exists(libraryPath), is(true));
assertThat(
workspace.runCommand("file", libraryPath.toString()).getStdout().get(),
containsString("dynamically linked shared library"));
Path frameworksPath = frameworkPath.resolve("Contents/Frameworks");
assertThat(Files.exists(frameworksPath), is(false));
}
@Test
public void testCxxBinaryDepfileBuildWithAddedHeader() throws IOException {
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(
this, "cxx_binary_depfile_build_with_added_header", tmp);
workspace.setUp();
ProjectWorkspace.ProcessResult result = workspace.runBuckCommand("build", "//:bin");
result.assertSuccess();
BuckBuildLog buildLog = workspace.getBuildLog();
buildLog.assertTargetBuiltLocally("//:bin#binary");
buildLog.assertTargetBuiltLocally("//:bin#compile-bin.c.o,default");
buildLog.assertTargetBuiltLocally("//:lib1#default,static");
workspace.resetBuildLogFile();
workspace.replaceFileContents("BUCK", "['lib1.h']", "['lib1.h', 'lib2.h']");
result = workspace.runBuckCommand("build", "//:bin");
result.assertSuccess();
buildLog = workspace.getBuildLog();
buildLog.assertTargetHadMatchingInputRuleKey("//:bin#binary");
buildLog.assertTargetHadMatchingDepfileRuleKey("//:bin#compile-bin.c.o,default");
buildLog.assertTargetBuiltLocally("//:lib1#default,static");
}
@Test
public void testAppleLibraryExportedHeaderSymlinkTree() throws IOException {
assumeTrue(Platform.detect() == Platform.MACOS);
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(
this, "apple_library_header_symlink_tree", tmp);
workspace.setUp();
ProjectFilesystem filesystem = new ProjectFilesystem(workspace.getDestPath());
BuildTarget buildTarget =
BuildTargetFactory.newInstance(
"//Libraries/TestLibrary:TestLibrary#"
+ "default,"
+ CxxDescriptionEnhancer.EXPORTED_HEADER_SYMLINK_TREE_FLAVOR);
ProjectWorkspace.ProcessResult result =
workspace.runBuckCommand("build", buildTarget.getFullyQualifiedName());
result.assertSuccess();
Path inputPath = workspace.getPath(buildTarget.getBasePath()).toRealPath();
Path outputPath =
workspace.getPath(BuildTargets.getGenPath(filesystem, buildTarget, "%s")).toRealPath();
assertIsSymbolicLink(
outputPath.resolve("TestLibrary/PublicHeader.h"), inputPath.resolve("PublicHeader.h"));
}
@Test
public void buildBinaryWithSharedDependencies() throws IOException {
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "shared_library", tmp);
workspace.setUp();
ProjectWorkspace.ProcessResult result = workspace.runBuckBuild("//:binary");
result.assertSuccess();
}
/** Tests that a Test Rule without any tests to run does not fail. */
@Test
public void testEmptyTestRule() throws IOException {
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "empty_test", tmp);
workspace.setUp();
ProjectWorkspace.ProcessResult result = workspace.runBuckCommand("test", "//:test");
result.assertSuccess("An empty test rule should pass.");
}
@Test
public void buildBinaryWithPerFileFlags() throws IOException {
assumeThat(Platform.detect(), is(Platform.MACOS));
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "per_file_flags", tmp);
workspace.setUp();
ProjectWorkspace.ProcessResult result = workspace.runBuckBuild("//:binary");
result.assertSuccess();
}
@Test
@Ignore
public void hasBuckCompilerErrorOccurredThenEventsCalled()
throws IOException, InterruptedException {
final ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "buck_events/compiler_error", tmp);
workspace.setUp();
WebServerBuckEventListener webServerBuckEventListener =
createMock(WebServerBuckEventListener.class);
// Build started
webServerBuckEventListener.buildStarted(anyObject(BuildEvent.Started.class));
EasyMock.expectLastCall().times(1);
// Build progress Event
webServerBuckEventListener.buildProgressUpdated(
anyObject(ProgressEvent.BuildProgressUpdated.class));
EasyMock.expectLastCall().atLeastOnce();
// Build finished
webServerBuckEventListener.buildFinished(anyObject(BuildEvent.Finished.class));
EasyMock.expectLastCall().times(1);
// Parse started
webServerBuckEventListener.parseStarted(anyObject(ParseEvent.Started.class));
EasyMock.expectLastCall().times(1);
// Parse progress Event
webServerBuckEventListener.parsingProgressUpdated(
anyObject(ProgressEvent.ParsingProgressUpdated.class));
EasyMock.expectLastCall().atLeastOnce();
// Parse finished
webServerBuckEventListener.parseFinished(anyObject(ParseEvent.Finished.class));
EasyMock.expectLastCall().times(1);
// Compiler error
webServerBuckEventListener.compilerErrorEvent(anyObject(CompilerErrorEvent.class));
EasyMock.expectLastCall().times(1);
// Console event
webServerBuckEventListener.consoleEvent(anyObject(ConsoleEvent.class));
EasyMock.expectLastCall().times(1);
// Output trace
webServerBuckEventListener.outputTrace(anyObject(BuildId.class));
EasyMock.expectLastCall().times(1);
EasyMock.replay(webServerBuckEventListener);
ProjectWorkspace.ProcessResult build =
workspace.runBuckdCommand(new TestContext(), "build", "//:broken");
build.assertFailure();
verify(webServerBuckEventListener);
}
private void invokeBuckCommand(ProjectWorkspace workspace, String logOut) throws IOException {
ProjectWorkspace.ProcessResult buckCommandResult =
workspace.runBuckCommand("targets", "--show-rulekey", "//:java_lib_2");
buckCommandResult.assertSuccess();
String fullLogContents = workspace.getFileContents(LOG_FILE_PATH.toString());
String logContentsForThisInvocation = fullLogContents.substring(lastPositionInLog);
lastPositionInLog += logContentsForThisInvocation.length();
workspace.writeContentsToPath(logContentsForThisInvocation, logOut);
}
@Test
public void perFileFlagsUsedForPreprocessing() throws IOException {
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "preprocessing_per_file_flags", tmp);
workspace.setUp();
ProjectWorkspace.ProcessResult result = workspace.runBuckBuild("//:bin");
result.assertSuccess();
}
@Test
public void incorrectPerFileFlagsUsedForCompilation() throws IOException {
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "compiling_per_file_flags", tmp);
workspace.setUp();
ProjectWorkspace.ProcessResult result = workspace.runBuckBuild("//:broken-bin");
result.assertFailure();
}
@Test
public void buildABinaryIfACxxLibraryDepOnlyDeclaresHeaders() throws IOException {
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "cxx_binary_headers_only", tmp);
workspace.setUp();
ProjectWorkspace.ProcessResult result = workspace.runBuckBuild("//:binary");
result.assertSuccess();
}
private void platformLinkerFlags(ProjectWorkspace workspace, String target) throws IOException {
workspace.runBuckBuild("//:binary_matches_default_exactly_" + target).assertSuccess();
workspace.runBuckBuild("//:binary_matches_default_" + target).assertSuccess();
ProjectWorkspace.ProcessResult result = workspace.runBuckBuild("//:binary_no_match_" + target);
result.assertFailure();
assertThat(result.getStderr(), Matchers.containsString("reference"));
workspace.runBuckBuild("//:binary_with_library_matches_default_" + target).assertSuccess();
workspace
.runBuckBuild("//:binary_with_prebuilt_library_matches_default_" + target)
.assertSuccess();
}
@Test
public void platformPreprocessorFlags() throws IOException {
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "platform_preprocessor_flags", tmp);
workspace.setUp();
workspace.runBuckBuild("//:binary_matches_default_exactly").assertSuccess();
workspace.runBuckBuild("//:binary_matches_default").assertSuccess();
ProjectWorkspace.ProcessResult result = workspace.runBuckBuild("//:binary_no_match");
result.assertFailure();
assertThat(result.getStderr(), Matchers.containsString("#error"));
workspace.runBuckBuild("//:binary_with_library_matches_default").assertSuccess();
}
@Test
public void buildABinaryIfACxxBinaryTransitivelyDepOnlyDeclaresHeaders() throws IOException {
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "cxx_binary_headers_only", tmp);
workspace.setUp();
ProjectWorkspace.ProcessResult result = workspace.runBuckBuild("//:transitive");
System.out.println(result.getStdout());
System.err.println(result.getStderr());
result.assertSuccess();
}
public File buildAndReturnOutput(String target) throws IOException {
// Build the java_library.
ProjectWorkspace.ProcessResult buildResult = runBuckBuild(target.toString());
buildResult.assertSuccess();
// Use `buck targets` to find the output JAR file.
// TODO(jacko): This is going to overwrite the build.log. Maybe stash that and return it?
ProjectWorkspace.ProcessResult outputFileResult =
runBuckCommand("targets", "--show_output", target.toString());
outputFileResult.assertSuccess();
String pathToGeneratedJarFile = outputFileResult.getStdout().split(" ")[1].trim();
return getFile(pathToGeneratedJarFile);
}
@Test
public void platformSources() throws IOException {
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "platform_sources", tmp);
workspace.setUp();
workspace.writeContentsToPath("[cxx]\n cxxflags = -Wall -Werror", ".buckconfig");
workspace.runBuckBuild("//:binary_matches_default_exactly").assertSuccess();
workspace.runBuckBuild("//:binary_matches_default").assertSuccess();
ProjectWorkspace.ProcessResult result = workspace.runBuckBuild("//:binary_no_match");
result.assertFailure();
assertThat(result.getStderr(), Matchers.containsString("answer()"));
workspace.runBuckBuild("//:binary_with_library_matches_default").assertSuccess();
}
@Test
public void testAppleLibraryBuildsSomething() throws IOException {
assumeTrue(Platform.detect() == Platform.MACOS);
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(
this, "apple_library_builds_something", tmp);
workspace.setUp();
ProjectWorkspace.ProcessResult result =
workspace.runBuckCommand("build", "//Libraries/TestLibrary:TestLibrary#static,default");
result.assertSuccess();
assertTrue(Files.exists(tmp.getRootPath().resolve(BuckConstant.GEN_DIR)));
}
@Test
public void testAppleLibraryBuildsSomething() throws IOException {
assumeTrue(Platform.detect() == Platform.MACOS);
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(
this, "apple_library_builds_something", tmp);
workspace.setUp();
ProjectFilesystem filesystem = new ProjectFilesystem(workspace.getDestPath());
BuildTarget target =
BuildTargetFactory.newInstance("//Libraries/TestLibrary:TestLibrary#static,default");
ProjectWorkspace.ProcessResult result =
workspace.runBuckCommand("build", target.getFullyQualifiedName());
result.assertSuccess();
assertTrue(Files.exists(workspace.getPath(BuildTargets.getGenPath(filesystem, target, "%s"))));
}
@Test
@Ignore
public void hasBuckProjectGenerationStartedThenEventsCalled()
throws IOException, InterruptedException {
final ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "buck_events", tmp);
workspace.setUp();
WebServerBuckEventListener webServerBuckEventListener =
createMock(WebServerBuckEventListener.class);
// Parse started
webServerBuckEventListener.parseStarted(anyObject(ParseEvent.Started.class));
EasyMock.expectLastCall().times(1);
// Parse progress Event
webServerBuckEventListener.parsingProgressUpdated(
anyObject(ProgressEvent.ParsingProgressUpdated.class));
EasyMock.expectLastCall().atLeastOnce();
// Parse finished
webServerBuckEventListener.parseFinished(anyObject(ParseEvent.Finished.class));
EasyMock.expectLastCall().times(1);
// Project generation started
webServerBuckEventListener.projectGenerationStarted(
anyObject(ProjectGenerationEvent.Started.class));
EasyMock.expectLastCall().times(1);
// Project generation finished
webServerBuckEventListener.projectGenerationFinished(
anyObject(ProjectGenerationEvent.Finished.class));
EasyMock.expectLastCall().times(1);
// Output trace
webServerBuckEventListener.outputTrace(anyObject(BuildId.class));
EasyMock.expectLastCall().times(1);
EasyMock.replay(webServerBuckEventListener);
ProjectWorkspace.ProcessResult build =
workspace.runBuckdCommand(new TestContext(), "project", "//:foo");
build.assertSuccess();
verify(webServerBuckEventListener);
}
@Test
public void testBuildEmptySourceAppleLibrary() throws Exception {
assumeTrue(Platform.detect() == Platform.MACOS);
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "empty_source_targets", tmp);
workspace.setUp();
BuildTarget target = workspace.newBuildTarget("//:real-none#iphonesimulator-x86_64,shared");
ProjectWorkspace.ProcessResult result =
workspace.runBuckCommand("build", target.getFullyQualifiedName());
result.assertSuccess();
ProjectFilesystem filesystem = new ProjectFilesystem(workspace.getDestPath());
Path binaryOutput =
workspace.getPath(BuildTargets.getGenPath(filesystem, target, "%s/libreal-none.dylib"));
assertThat(Files.exists(binaryOutput), is(true));
}
@Test
public void testAppleLibraryBuildsForWatchSimulator() throws IOException {
assumeTrue(
AppleNativeIntegrationTestUtils.isApplePlatformAvailable(
ApplePlatform.builder().setName(ApplePlatform.Name.WATCHSIMULATOR).build()));
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(
this, "apple_library_builds_something", tmp);
workspace.setUp();
ProjectWorkspace.ProcessResult result =
workspace.runBuckCommand(
"build", "//Libraries/TestLibrary:TestLibrary#watchsimulator-i386,static");
result.assertSuccess();
assertTrue(Files.exists(tmp.getRootPath().resolve(BuckConstant.GEN_DIR)));
}
@Test
public void testAppleLibraryBuildsForWatchOS() throws IOException {
assumeTrue(AppleNativeIntegrationTestUtils.isApplePlatformAvailable(ApplePlatform.WATCHOS));
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(
this, "apple_library_builds_something", tmp);
workspace.setUp();
ProjectFilesystem filesystem = new ProjectFilesystem(workspace.getDestPath());
BuildTarget target =
BuildTargetFactory.newInstance("//Libraries/TestLibrary:TestLibrary#watchos-armv7k,static");
ProjectWorkspace.ProcessResult result =
workspace.runBuckCommand("build", target.getFullyQualifiedName());
result.assertSuccess();
assertTrue(Files.exists(workspace.getPath(BuildTargets.getGenPath(filesystem, target, "%s"))));
}
@Test
public void shouldPrintNeededSymbolsFromBuild() throws IOException {
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "symbol_finder", temporaryFolder);
workspace.setUp();
ProjectWorkspace.ProcessResult processResult = workspace.runBuckBuild("//java/com/example/b:b");
processResult.assertFailure("Build with missing dependencies should fail.");
String expectedDependencyOutput =
String.format(
"%s (:b) is missing deps:\n" + " ':moreb',\n" + " '//java/com/example/a:a',\n",
Paths.get("java/com/example/b/BUCK"));
assertThat(
"Output should describe the missing dependency.",
processResult.getStderr(),
containsString(expectedDependencyOutput));
}
@Test
public void testAppleLibraryBuildsSomethingUsingAppleCxxPlatform() throws IOException {
assumeTrue(Platform.detect() == Platform.MACOS);
assumeTrue(
AppleNativeIntegrationTestUtils.isApplePlatformAvailable(
ApplePlatform.builder().setName(ApplePlatform.Name.MACOSX).build()));
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(
this, "apple_library_builds_something", tmp);
workspace.setUp();
ProjectWorkspace.ProcessResult result =
workspace.runBuckCommand(
"build", "//Libraries/TestLibrary:TestLibrary#static,macosx-x86_64");
result.assertSuccess();
assertTrue(Files.exists(tmp.getRootPath().resolve(BuckConstant.GEN_DIR)));
}
@Test
public void shouldSerializeEventsToFile() throws IOException {
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "simple_project", temporaryFolder);
workspace.setUp();
File eventsOutputFile = workspace.getFile("events.json");
ProjectWorkspace.ProcessResult result =
workspace.runBuckCommand(
"build", ":something", "--output-events-to-file", eventsOutputFile.getAbsolutePath());
result.assertSuccess();
List<String> lines = Files.readAllLines(eventsOutputFile.toPath(), StandardCharsets.UTF_8);
assertFalse("The events output file should not be empty", lines.isEmpty());
assertThat(
"An event should have something JSON-like in it",
lines.get(0),
containsString("\"timestamp\":"));
}
