@Test public void testUberCompilationDatabase() throws IOException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "compilation_database", tmp); workspace.setUp(); BuildTarget target = BuildTargetFactory.newInstance("//:test#default,uber-compilation-database"); ProjectFilesystem filesystem = new FakeProjectFilesystem(); Path compilationDatabase = workspace.buildAndReturnOutput(target.getFullyQualifiedName()); Path rootPath = tmp.getRoot(); assertEquals( BuildTargets.getGenPath( filesystem, target, "uber-compilation-database-%s/compile_commands.json"), rootPath.relativize(compilationDatabase)); Path binaryHeaderSymlinkTreeFolder = BuildTargets.getGenPath( filesystem, target.withFlavors( ImmutableFlavor.of("default"), CxxDescriptionEnhancer.HEADER_SYMLINK_TREE_FLAVOR), "%s"); Path binaryExportedHeaderSymlinkTreeFolder = BuildTargets.getGenPath( filesystem, target.withFlavors( ImmutableFlavor.of("default"), CxxDescriptionEnhancer.EXPORTED_HEADER_SYMLINK_TREE_FLAVOR), "%s"); Map<String, CxxCompilationDatabaseEntry> fileToEntry = CxxCompilationDatabaseUtils.parseCompilationDatabaseJsonFile(compilationDatabase); assertEquals(1, fileToEntry.size()); assertHasEntry( fileToEntry, "test.cpp", new ImmutableList.Builder<String>() .add(COMPILER_PATH) .add("-fPIC") .add("-fPIC") .add("-I") .add(headerSymlinkTreePath(binaryHeaderSymlinkTreeFolder).toString()) .add("-I") .add(headerSymlinkTreePath(binaryExportedHeaderSymlinkTreeFolder).toString()) .addAll(getExtraFlagsForHeaderMaps(filesystem)) .addAll(COMPILER_SPECIFIC_FLAGS) .add("-x") .add("c++") .add("-c") .add("-o") .add( BuildTargets.getGenPath( filesystem, target.withFlavors( ImmutableFlavor.of("default"), ImmutableFlavor.of("compile-pic-" + sanitize("test.cpp.o"))), "%s/test.cpp.o") .toString()) .add(rootPath.resolve(Paths.get("test.cpp")).toRealPath().toString()) .build()); }
@Before public void initializeWorkspace() throws IOException { workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "compilation_database", tmp); workspace.setUp(); // cxx_test requires gtest_dep to be set workspace.writeContentsToPath("[cxx]\ngtest_dep = //:fake-gtest", ".buckconfig"); }
@Test public void javacOptionsChanged() throws Exception { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "diff_rulekeys_script", tmp); workspace.setUp(); writeBuckConfig(workspace, "6"); invokeBuckCommand(workspace, "buck-0.log"); writeBuckConfig(workspace, "7"); invokeBuckCommand(workspace, "buck-1.log"); String expectedResult = Joiner.on('\n') .join( "Change details for " + "[//:java_lib_2->compileStepFactory.appendableSubKey->javacOptions.appendableSubKey]", " (sourceLevel):", " -[string(\"6\")]", " +[string(\"7\")]", " (targetLevel):", " -[string(\"6\")]", " +[string(\"7\")]", ""); assertThat( runRuleKeyDiffer(workspace).getStdout(), Matchers.equalTo(Optional.of(expectedResult))); }
@Test public void resolveHeadersBehindSymlinkTreesInPreprocessedOutput() throws IOException { BuckConfig buckConfig = new FakeBuckConfig(); CxxPlatform cxxPlatform = DefaultCxxPlatforms.build(new CxxBuckConfig(buckConfig)); ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "resolved", tmp); workspace.setUp(); workspace.writeContentsToPath("", "lib2.h"); BuildTarget target = BuildTargetFactory.newInstance("//:bin"); CxxSourceRuleFactory cxxSourceRuleFactory = CxxSourceRuleFactoryHelper.of(target, cxxPlatform); workspace.runBuckCommand("build", target.toString()).assertSuccess(); // Verify that the preprocessed source contains no references to the symlink tree used to // setup the headers. BuildTarget ppTarget = cxxSourceRuleFactory.createPreprocessBuildTarget( "bin.cpp", CxxSource.Type.CXX, CxxSourceRuleFactory.PicType.PDC); Path output = cxxSourceRuleFactory.getPreprocessOutputPath(ppTarget, CxxSource.Type.CXX, "bin.cpp"); String contents = workspace.getFileContents(output.toString()); assertThat(contents, Matchers.not(Matchers.containsString(BuckConstant.SCRATCH_DIR))); assertThat(contents, Matchers.not(Matchers.containsString(BuckConstant.GEN_DIR))); assertThat(contents, Matchers.containsString("# 1 \"bin.h")); assertThat(contents, Matchers.containsString("# 1 \"lib1.h")); assertThat(contents, Matchers.containsString("# 1 \"lib2.h")); }
@Test public void fatJarWithExitCode() throws IOException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "fat_jar", tmp); workspace.setUp(); workspace.runBuckCommand("run", "//:bin-exit-code").assertSpecialExitCode("error", 5); }
@Test public void linkerFlags() throws IOException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "linker_flags", tmp); workspace.setUp(); workspace.runBuckBuild("//:binary_with_linker_flag").assertFailure("--bad-flag"); workspace.runBuckBuild("//:binary_with_library_dep").assertSuccess(); workspace.runBuckBuild("//:binary_with_exported_flags_library_dep").assertFailure("--bad-flag"); workspace.runBuckBuild("//:binary_with_prebuilt_library_dep").assertFailure("--bad-flag"); // Build binary that has unresolved symbols. Normally this would fail, but should work // with the proper linker flag. switch (Platform.detect()) { case MACOS: workspace.runBuckBuild("//:binary_with_unresolved_symbols_macos").assertSuccess(); break; case LINUX: workspace.runBuckBuild("//:binary_with_unresolved_symbols_linux").assertSuccess(); break; // $CASES-OMITTED$ default: break; } }
@Before public void setUp() throws IOException, InterruptedException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "query_command", tmp); workspace.setUp(); Cell cell = new TestCellBuilder().setFilesystem(new ProjectFilesystem(workspace.getDestPath())).build(); TestConsole console = new TestConsole(); CommandRunnerParams params = CommandRunnerParamsForTesting.createCommandRunnerParamsForTesting( console, cell, new FakeAndroidDirectoryResolver(), new NoopArtifactCache(), BuckEventBusFactory.newInstance(), FakeBuckConfig.builder().build(), Platform.detect(), ImmutableMap.copyOf(System.getenv()), new FakeJavaPackageFinder(), new ObjectMapper(), Optional.<WebServer>absent()); buckQueryEnvironment = new BuckQueryEnvironment(params, /* enableProfiling */ false); cellRoot = workspace.getDestPath(); executor = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor()); }
@Test public void testHeaderNamespace() throws IOException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "header_namespace", tmp); workspace.setUp(); workspace.runBuckCommand("build", "//:test").assertSuccess(); }
@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 testCxxBinaryWithGeneratedSourceAndHeader() throws IOException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "simple", tmp); workspace.setUp(); workspace.runBuckCommand("build", "//foo:binary_without_dep").assertFailure(); }
@Test public void testSimpleCxxBinaryMissingDependencyOnCxxLibraryWithHeader() throws IOException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "simple", tmp); workspace.setUp(); workspace.runBuckCommand("build", "//foo:binary_without_dep").assertFailure(); }
/** * Verifies that a client timeout will be detected by a Nailgun NGInputStream reading from a * blocking heartbeat stream. */ @Test(expected = InterruptedException.class) public void whenClientTimeoutDetectedThenMainThreadIsInterrupted() throws InterruptedException, IOException { final long timeoutMillis = 100; final long intervalMillis = timeoutMillis * 2; // Interval > timeout to trigger disconnection. final ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "exclusive_execution", tmp); workspace.setUp(); // Build an NGContext connected to an NGInputStream reading from a stream that will timeout. Thread.currentThread().setName("Test"); try (TestContext context = new TestContext( ImmutableMap.copyOf(System.getenv()), TestContext.createHeartBeatStream(intervalMillis), timeoutMillis)) { final Thread commandThread = Thread.currentThread(); context.addClientListener( new NGClientListener() { @Override public void clientDisconnected() throws InterruptedException { commandThread.interrupt(); } }); Thread.sleep(1000); fail("Should have been interrupted."); } }
@Test public void testSimpleCxxBinaryWithoutHeader() throws IOException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "simple", tmp); workspace.setUp(); workspace.runBuckCommand("build", "//foo:simple_without_header").assertFailure(); }
@Test public void fatJarLoadingNativeLibraries() throws IOException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "fat_jar", tmp); workspace.setUp(); workspace.runBuckCommand("run", "//:bin-fat").assertSuccess(); }
@Before public void setUp() throws IOException, InterruptedException { console = new TestConsole(); workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "target_command", tmp); workspace.setUp(); filesystem = new ProjectFilesystem(workspace.getDestPath().toRealPath().normalize()); Cell cell = new TestCellBuilder().setFilesystem(filesystem).build(); AndroidDirectoryResolver androidDirectoryResolver = new FakeAndroidDirectoryResolver(); ArtifactCache artifactCache = new NoopArtifactCache(); BuckEventBus eventBus = BuckEventBusFactory.newInstance(); objectMapper = new ObjectMapper(); targetsCommand = new TargetsCommand(); params = CommandRunnerParamsForTesting.createCommandRunnerParamsForTesting( console, cell, androidDirectoryResolver, artifactCache, eventBus, FakeBuckConfig.builder().build(), Platform.detect(), ImmutableMap.copyOf(System.getenv()), new FakeJavaPackageFinder(), objectMapper, Optional.<WebServer>absent()); executor = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor()); }
@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 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")); }
@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 testVariousSuccessTypesInReport() throws IOException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "keep_going", tmp).setUp(); ProcessResult result1 = buildTwoGoodRulesAndAssertSuccess(workspace); String expectedReport1 = "OK //:rule_with_output BUILT_LOCALLY " + GENRULE_OUTPUT + "\n" + "OK //:rule_without_output BUILT_LOCALLY\n"; assertThat(result1.getStderr(), containsString(expectedReport1)); ProcessResult result2 = buildTwoGoodRulesAndAssertSuccess(workspace); String expectedReport2 = "OK //:rule_with_output MATCHING_RULE_KEY " + GENRULE_OUTPUT + "\n" + "OK //:rule_without_output MATCHING_RULE_KEY\n"; assertThat(result2.getStderr(), containsString(expectedReport2)); workspace.runBuckCommand("clean").assertSuccess(); ProcessResult result3 = buildTwoGoodRulesAndAssertSuccess(workspace); String expectedReport3 = "OK //:rule_with_output FETCHED_FROM_CACHE " + GENRULE_OUTPUT + "\n" + "OK //:rule_without_output FETCHED_FROM_CACHE\n"; assertThat(result3.getStderr(), containsString(expectedReport3)); }
@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")); }
/** 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 genruleUsingBinaryUsingSharedLinkStyle() throws IOException { assumeThat(Platform.detect(), oneOf(Platform.LINUX, Platform.MACOS)); ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "shared_link_style", tmp); workspace.setUp(); workspace.runBuckBuild("//:gen").assertSuccess(); }
@Test public void buildBinaryWithSharedDependencies() throws IOException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "shared_library", tmp); workspace.setUp(); ProjectWorkspace.ProcessResult result = workspace.runBuckBuild("//:binary"); result.assertSuccess(); }
@Test public void testSimpleCxxBinaryWithHeader() throws IOException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "simple", tmp); workspace.setUp(); CxxPlatform cxxPlatform = DefaultCxxPlatforms.build(new CxxBuckConfig(new FakeBuckConfig())); BuildTarget target = BuildTargetFactory.newInstance("//foo:simple_with_header"); CxxSourceRuleFactory cxxSourceRuleFactory = CxxSourceRuleFactoryHelper.of(target, cxxPlatform); BuildTarget binaryTarget = CxxDescriptionEnhancer.createCxxLinkTarget(target); String sourceName = "simple_with_header.cpp"; String headerName = "simple_with_header.h"; String headerFull = "foo/" + headerName; BuildTarget preprocessTarget = cxxSourceRuleFactory.createPreprocessBuildTarget( sourceName, CxxSource.Type.CXX, CxxSourceRuleFactory.PicType.PDC); BuildTarget compileTarget = cxxSourceRuleFactory.createCompileBuildTarget(sourceName, CxxSourceRuleFactory.PicType.PDC); BuildTarget headerSymlinkTreeTarget = CxxDescriptionEnhancer.createHeaderSymlinkTreeTarget( target, cxxPlatform.getFlavor(), HeaderVisibility.PRIVATE); // Do a clean build, verify that it succeeds, and check that all expected targets built // successfully. workspace.runBuckCommand("build", target.toString()).assertSuccess(); BuckBuildLog buildLog = workspace.getBuildLog(); assertEquals( ImmutableSet.of( headerSymlinkTreeTarget, preprocessTarget, compileTarget, binaryTarget, target), buildLog.getAllTargets()); buildLog.assertTargetBuiltLocally(headerSymlinkTreeTarget.toString()); buildLog.assertTargetBuiltLocally(preprocessTarget.toString()); buildLog.assertTargetBuiltLocally(compileTarget.toString()); buildLog.assertTargetBuiltLocally(binaryTarget.toString()); buildLog.assertTargetBuiltLocally(target.toString()); // Clear for new build. workspace.resetBuildLogFile(); // Update the source file. workspace.replaceFileContents(headerFull, "blah = 5", "blah = 6"); // Check that running a build again makes the source get recompiled and the binary // re-linked, but does not cause the header rules to re-run. workspace.runBuckCommand("build", target.toString()).assertSuccess(); buildLog = workspace.getBuildLog(); assertEquals( ImmutableSet.of( headerSymlinkTreeTarget, preprocessTarget, compileTarget, binaryTarget, target), buildLog.getAllTargets()); buildLog.assertTargetHadMatchingRuleKey(headerSymlinkTreeTarget.toString()); buildLog.assertTargetBuiltLocally(preprocessTarget.toString()); buildLog.assertTargetBuiltLocally(compileTarget.toString()); assertThat( buildLog.getLogEntry(binaryTarget).getSuccessType().get(), Matchers.not(Matchers.equalTo(BuildRuleSuccessType.MATCHING_RULE_KEY))); buildLog.assertTargetBuiltLocally(target.toString()); }
@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 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 perFileFlagsUsedForPreprocessing() throws IOException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "preprocessing_per_file_flags", tmp); workspace.setUp(); ProjectWorkspace.ProcessResult result = workspace.runBuckBuild("//:bin"); 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); }