// Copyright 2018 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.query2.testutil; import static com.google.common.truth.Truth.assertThat; import static com.google.devtools.build.lib.packages.Attribute.attr; import static com.google.devtools.build.lib.packages.BuildType.LABEL; import static com.google.devtools.build.lib.testutil.TestConstants.PLATFORM_LABEL; import static org.junit.Assert.assertThrows; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Iterables; import com.google.devtools.build.lib.analysis.config.BuildConfigurationValue; import com.google.devtools.build.lib.analysis.config.BuildOptions; import com.google.devtools.build.lib.analysis.config.BuildOptionsView; import com.google.devtools.build.lib.analysis.config.FragmentOptions; import com.google.devtools.build.lib.analysis.config.ToolchainTypeRequirement; import com.google.devtools.build.lib.analysis.config.transitions.PatchTransition; import com.google.devtools.build.lib.analysis.util.DummyTestFragment.DummyTestOptions; import com.google.devtools.build.lib.analysis.util.MockRule; import com.google.devtools.build.lib.cmdline.Label; import com.google.devtools.build.lib.cmdline.TargetParsingException; import com.google.devtools.build.lib.events.EventHandler; import com.google.devtools.build.lib.packages.Attribute; import com.google.devtools.build.lib.packages.AttributeMap; import com.google.devtools.build.lib.packages.Type; import com.google.devtools.build.lib.query2.PostAnalysisQueryEnvironment; import com.google.devtools.build.lib.query2.engine.QueryEnvironment.QueryFunction; import com.google.devtools.build.lib.query2.engine.QueryEnvironment.Setting; import com.google.devtools.build.lib.query2.engine.QueryException; import com.google.devtools.build.lib.query2.engine.QueryExpression; import com.google.devtools.build.lib.query2.engine.QueryParser; import com.google.devtools.build.lib.server.FailureDetails; import com.google.devtools.build.lib.server.FailureDetails.ConfigurableQuery.Code; import com.google.devtools.build.lib.server.FailureDetails.FailureDetail; import com.google.devtools.build.lib.testutil.TestConstants; import com.google.devtools.build.lib.testutil.TestUtils; import com.google.devtools.build.lib.util.FileTypeSet; import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedHashSet; import java.util.Set; import org.junit.Before; import org.junit.Test; /** Tests for {@link PostAnalysisQueryEnvironment}. */ public abstract class PostAnalysisQueryTest extends AbstractQueryTest { // Also filter out platform dependencies. @Override protected String getDependencyCorrection() { return " - deps(" + PLATFORM_LABEL + ")"; } static final String DEFAULT_UNIVERSE = "DEFAULT_UNIVERSE"; @Before public final void disableOrderedResults() { helper.setOrderedResults(false); } @Before public final void setMockToolsConfig() { this.mockToolsConfig = getHelper().getMockToolsConfig(); } /** * In production, cquery constructs the universe by parsing targets from the query expression and * building them at the top level. If this is not viable (e.g. component functions) or not desired * (e.g. somepath(//foo-built-in-target, //bar-built-in-host), the user must specify the * --universe_scope flag. Enforce the same behavior in this test by initializing universe scope to * an invalid target expression. */ @Override protected String getDefaultUniverseScope() { return DEFAULT_UNIVERSE; } protected PostAnalysisQueryHelper getHelper() { return (PostAnalysisQueryHelper) helper; } /** * At the end of each eval, reset the universe scope to the default if the test doesn't use a * single universe scope. */ @Override protected Set eval(String query) throws Exception { maybeParseUniverseScope(query); Set queryResult = super.eval(query); if (!getHelper().isWholeTestUniverse()) { helper.setUniverseScope(getDefaultUniverseScope()); } return queryResult; } @Override protected EvalThrowsResult evalThrows(String query, boolean unconditionallyThrows) throws Exception { maybeParseUniverseScope(query); EvalThrowsResult queryResult = super.evalThrows(query, unconditionallyThrows); if (!getHelper().isWholeTestUniverse()) { helper.setUniverseScope(getDefaultUniverseScope()); } return queryResult; } // Parse the universe if the universe has not been set manually through the helper. private void maybeParseUniverseScope(String query) throws Exception { if (!getHelper() .getUniverseScopeAsStringList() .equals(Collections.singletonList(getDefaultUniverseScope()))) { return; } QueryExpression expression = QueryParser.parse(query, getDefaultFunctions()); Set targetPatternSet = new LinkedHashSet<>(); expression.collectTargetPatterns(targetPatternSet); if (!targetPatternSet.isEmpty()) { StringBuilder universeScope = new StringBuilder(); for (String target : targetPatternSet) { universeScope.append(target).append(","); } helper.setUniverseScope(universeScope.toString()); } } protected abstract HashMap getDefaultFunctions(); protected abstract BuildConfigurationValue getConfiguration(T target); @Override protected boolean testConfigurableAttributes() { // ConfiguredTargetQuery knows the actual configuration, so it doesn't falsely overapproximate. return false; } @Override @Test public void testTargetLiteralWithMissingTargets() { getHelper().turnOffFailFast(); TargetParsingException e = assertThrows(TargetParsingException.class, super::testTargetLiteralWithMissingTargets); assertThat(e) .hasMessageThat() .isEqualTo( "no such target '//a:b': target 'b' not declared in package 'a' " + "defined by " + helper.getRootDirectory().getPathString() + "/a/BUILD (Tip: use `query \"//a:*\"` to see all the targets in that package)"); assertThat(e.getDetailedExitCode().getFailureDetail().getPackageLoading().getCode()) .isEqualTo(FailureDetails.PackageLoading.Code.TARGET_MISSING); } @Override @Test public void testBadTargetLiterals() throws Exception { getHelper().turnOffFailFast(); TargetParsingException e = assertThrows(TargetParsingException.class, super::testBadTargetLiterals); checkResultofBadTargetLiterals(e.getMessage(), e.getDetailedExitCode().getFailureDetail()); } @SuppressWarnings("TruthIncompatibleType") @Override @Test public void testNoImplicitDeps() throws Exception { MockRule ruleWithImplicitDeps = () -> MockRule.define( "implicit_deps_rule", attr("explicit", LABEL).allowedFileTypes(FileTypeSet.ANY_FILE), attr("explicit_with_default", LABEL) .value(Label.parseCanonicalUnchecked("//test:explicit_with_default")) .allowedFileTypes(FileTypeSet.ANY_FILE), attr("$implicit", LABEL).value(Label.parseCanonicalUnchecked("//test:implicit")), attr(":latebound", LABEL) .value( Attribute.LateBoundDefault.fromConstantForTesting( Label.parseCanonicalUnchecked("//test:latebound")))); helper.useRuleClassProvider(setRuleClassProviders(ruleWithImplicitDeps).build()); writeFile( "test/BUILD", "implicit_deps_rule(", " name = 'my_rule',", " explicit = ':explicit',", " explicit_with_default = ':explicit_with_default',", ")", "cc_library(name = 'explicit')", "cc_library(name = 'explicit_with_default')", "cc_library(name = 'implicit')", "cc_library(name = 'latebound')"); final String implicits = "//test:implicit + //test:latebound"; final String explicits = "//test:my_rule + //test:explicit + //test:explicit_with_default"; // Check for implicit dependencies (late bound attributes, implicit attributes, platforms) assertThat(evalToListOfStrings("deps(//test:my_rule)")) .containsAtLeastElementsIn( evalToListOfStrings(explicits + " + " + implicits + " + " + PLATFORM_LABEL)); helper.setQuerySettings(Setting.NO_IMPLICIT_DEPS); assertThat(evalToListOfStrings("deps(//test:my_rule)")) .containsAtLeastElementsIn(evalToListOfStrings(explicits)); assertThat(evalToListOfStrings("deps(//test:my_rule)")) .containsNoneIn(evalToListOfStrings(implicits)); } @Test public void testNoImplicitDeps_toolchains() throws Exception { MockRule ruleWithImplicitDeps = () -> MockRule.define( "implicit_toolchain_deps_rule", (builder, env) -> builder.addToolchainTypes( ToolchainTypeRequirement.create( Label.parseCanonicalUnchecked("//test:toolchain_type")))); helper.useRuleClassProvider(setRuleClassProviders(ruleWithImplicitDeps).build()); writeFile( "test/toolchain.bzl", "def _impl(ctx):", " toolchain = platform_common.ToolchainInfo()", " return [toolchain]", "test_toolchain = rule(", " implementation = _impl,", ")"); writeFile( "test/BUILD", "load(':toolchain.bzl', 'test_toolchain')", "implicit_toolchain_deps_rule(", " name = 'my_rule',", ")", "toolchain_type(name = 'toolchain_type')", "toolchain(", " name = 'toolchain',", " toolchain_type = ':toolchain_type',", " toolchain = ':toolchain_impl',", ")", "test_toolchain(name = 'toolchain_impl')"); ((PostAnalysisQueryHelper) helper).useConfiguration("--extra_toolchains=//test:toolchain"); String implicits = "//test:toolchain_impl"; String explicits = "//test:my_rule"; // Check for implicit toolchain dependencies assertThat(evalToListOfStrings("deps(//test:my_rule)")) .containsAtLeast(explicits, implicits, PLATFORM_LABEL); helper.setQuerySettings(Setting.NO_IMPLICIT_DEPS); ImmutableList filteredDeps = evalToListOfStrings("deps(//test:my_rule)"); assertThat(filteredDeps).contains(explicits); assertThat(filteredDeps).doesNotContain(implicits); } private void writeSimpleToolchain() throws Exception { writeFile( "test/toolchain_def.bzl", "def _impl(ctx):", " return [platform_common.ToolchainInfo()]", "test_toolchain = rule(", " implementation = _impl,", ")"); writeFile( "test/BUILD", "load('//test:toolchain_def.bzl', 'test_toolchain')", "toolchain_type(name = 'toolchain_type')", "toolchain(", " name = 'toolchain',", " toolchain_type = '//test:toolchain_type',", " toolchain = ':toolchain_impl'", ")", "test_toolchain(name = 'toolchain_impl')"); } @Test public void testNoImplicitDeps_starlark_toolchains() throws Exception { writeSimpleToolchain(); writeFile( "test/rule/rule.bzl", "def _impl(ctx):", " return []", "implicit_toolchain_deps_rule = rule(", " implementation = _impl,", " toolchains = ['//test:toolchain_type']", ")"); writeFile( "test/rule/BUILD", "load(':rule.bzl', 'implicit_toolchain_deps_rule')", "implicit_toolchain_deps_rule(", " name = 'my_rule',", ")"); ((PostAnalysisQueryHelper) helper).useConfiguration("--extra_toolchains=//test:toolchain"); String implicits = "//test:toolchain_impl"; String explicits = "//test/rule:my_rule"; // Check for implicit toolchain dependencies assertThat(evalToListOfStrings("deps(//test/rule:my_rule)")) .containsAtLeast(explicits, implicits); helper.setQuerySettings(Setting.NO_IMPLICIT_DEPS); ImmutableList filteredDeps = evalToListOfStrings("deps(//test/rule:my_rule)"); assertThat(filteredDeps).contains(explicits); assertThat(filteredDeps).doesNotContain(implicits); } @Test public void testNoImplicitDeps_cc_toolchains() throws Exception { writeFile( "test/toolchain/toolchain_config.bzl", "def _impl(ctx):", " return cc_common.create_cc_toolchain_config_info(", " ctx = ctx,", " toolchain_identifier = 'mock-llvm-toolchain-k8',", " host_system_name = 'mock-system-name-for-k8',", " target_system_name = 'mock-target-system-name-for-k8',", " target_cpu = 'k8',", " target_libc = 'mock-libc-for-k8',", " compiler = 'mock-compiler-for-k8',", " abi_libc_version = 'mock-abi-libc-for-k8',", " abi_version = 'mock-abi-version-for-k8')", "cc_toolchain_config = rule(", " implementation = _impl,", " attrs = {},", " provides = [CcToolchainConfigInfo],", ")"); writeFile( "test/toolchain/BUILD", "load(':toolchain_config.bzl', 'cc_toolchain_config')", "cc_toolchain_config(name = 'some-cc-toolchain-config')", "filegroup(name = 'nothing', srcs = [])", "cc_toolchain(", " name = 'some_cc_toolchain_impl',", " all_files = ':nothing',", " as_files = ':nothing',", " compiler_files = ':nothing',", " dwp_files = ':nothing',", " linker_files = ':nothing',", " objcopy_files = ':nothing',", " strip_files = ':nothing',", " toolchain_config = ':some-cc-toolchain-config',", ")", "toolchain(", " name = 'some_cc_toolchain',", " toolchain = ':some_cc_toolchain_impl',", " toolchain_type = '" + TestConstants.TOOLS_REPOSITORY + "//tools/cpp:toolchain_type',", ")"); writeFile( "test/BUILD", "cc_library(", " name = 'my_rule',", " srcs = ['whatever.cpp'],", ")"); ((PostAnalysisQueryHelper) helper) .useConfiguration("--extra_toolchains=//test/toolchain:some_cc_toolchain"); String implicits = "//test/toolchain:some_cc_toolchain_impl"; String explicits = "//test:my_rule"; // Check for implicit toolchain dependencies assertThat(evalToListOfStrings("deps(//test:my_rule)")) .containsAtLeast(explicits, implicits, PLATFORM_LABEL); helper.setQuerySettings(Setting.NO_IMPLICIT_DEPS); ImmutableList filteredDeps = evalToListOfStrings("deps(//test:my_rule)"); assertThat(filteredDeps).contains(explicits); assertThat(filteredDeps).doesNotContain(implicits); } // Regression test for b/148550864 @Test public void testNoImplicitDeps_platformDeps() throws Exception { MockRule simpleRule = () -> MockRule.define("simple_rule"); helper.useRuleClassProvider(setRuleClassProviders(simpleRule).build()); writeFile( "test/BUILD", "simple_rule(name = 'my_rule')", "platform(name = 'host_platform')", "platform(name = 'execution_platform')"); ((PostAnalysisQueryHelper) helper) .useConfiguration( "--host_platform=//test:host_platform", "--extra_execution_platforms=//test:execution_platform"); // Check for platform dependencies assertThat(evalToListOfStrings("deps(//test:my_rule)")) .containsAtLeastElementsIn( evalToListOfStrings("//test:execution_platform + //test:host_platform")); helper.setQuerySettings(Setting.NO_IMPLICIT_DEPS); assertThat(evalToListOfStrings("deps(//test:my_rule)")).containsExactly("//test:my_rule"); } // Regression test for b/275502129. @Test public void testNoImplicitDepsFromAutoExecGroups_autoExecGroupsEnabled() throws Exception { writeSimpleToolchain(); writeFile( "test/aeg/defs.bzl", "def _impl(ctx):", " return []", "custom_rule = rule(", " implementation = _impl,", " toolchains = ['//test:toolchain_type'],", ")"); writeFile( "test/aeg/BUILD", "load('//test/aeg:defs.bzl', 'custom_rule')", "custom_rule(name = 'custom_rule_name')"); ((PostAnalysisQueryHelper) helper) .useConfiguration("--incompatible_auto_exec_groups", "--extra_toolchains=//test:all"); String implicits = "//test:toolchain_impl"; String explicits = "//test/aeg:custom_rule_name"; // Check for implicit toolchain dependencies assertThat(evalToListOfStrings("deps(//test/aeg:custom_rule_name)")) .containsAtLeast(explicits, implicits); helper.setQuerySettings(Setting.NO_IMPLICIT_DEPS); ImmutableList filteredDeps = evalToListOfStrings("deps(//test/aeg:custom_rule_name)"); assertThat(filteredDeps).contains(explicits); assertThat(filteredDeps).doesNotContain(implicits); } // Regression test for b/275502129. @Test public void testNoImplicitDepsFromCustomExecGroups_autoExecGroupsEnabled() throws Exception { writeSimpleToolchain(); writeFile( "test/aeg/defs.bzl", "def _impl(ctx):", " return []", "custom_rule = rule(", " implementation = _impl,", " exec_groups = {", " 'custom_exec_group': exec_group(", " toolchains = ['//test:toolchain_type'],", " ),", " },", ")"); writeFile( "test/aeg/BUILD", "load('//test/aeg:defs.bzl', 'custom_rule')", "custom_rule(name = 'custom_rule_name')"); ((PostAnalysisQueryHelper) helper) .useConfiguration("--incompatible_auto_exec_groups", "--extra_toolchains=//test:all"); String implicits = "//test:toolchain_impl"; String explicits = "//test/aeg:custom_rule_name"; // Check for implicit toolchain dependencies assertThat(evalToListOfStrings("deps(//test/aeg:custom_rule_name)")) .containsAtLeast(explicits, implicits); helper.setQuerySettings(Setting.NO_IMPLICIT_DEPS); ImmutableList filteredDeps = evalToListOfStrings("deps(//test/aeg:custom_rule_name)"); assertThat(filteredDeps).contains(explicits); assertThat(filteredDeps).doesNotContain(implicits); } @Override @Test public void testNoImplicitDeps_computedDefault() throws Exception { MockRule computedDefaultRule = () -> MockRule.define( "computed_default_rule", attr("conspiracy", Type.STRING).value("space jam was a documentary"), attr("dep", LABEL) .allowedFileTypes(FileTypeSet.ANY_FILE) .value( new Attribute.ComputedDefault("conspiracy") { @Override public Object getDefault(AttributeMap rule) { return rule.get("conspiracy", Type.STRING) .equals("space jam was a documentary") ? Label.parseCanonicalUnchecked("//test:foo") : null; } })); helper.useRuleClassProvider(setRuleClassProviders(computedDefaultRule).build()); writeFile("test/BUILD", "cc_library(name = 'foo')", "computed_default_rule(name = 'my_rule')"); String target = "//test:my_rule"; assertThat(evalToListOfStrings("deps(" + target + ")")).contains("//test:foo"); helper.setQuerySettings(Setting.NO_IMPLICIT_DEPS); assertThat(eval("deps(" + target + ")")).isEqualTo(eval(target)); } @Override @Test public void testLet() throws Exception { getHelper().setWholeTestUniverseScope("//a,//b,//c,//d"); super.testLet(); } @Override @Test public void testSet() throws Exception { getHelper().setWholeTestUniverseScope("//a:*,//b:*,//c:*,//d:*"); super.testSet(); } /** PatchTransition on --foo */ public static class FooPatchTransition implements PatchTransition { String toOption; String name; public FooPatchTransition(String toOption, String name) { this.toOption = toOption; this.name = name; } public FooPatchTransition(String toOption) { this(toOption, "FooPatchTransition"); } @Override public String getName() { return this.name; } @Override public ImmutableSet> requiresOptionFragments() { return ImmutableSet.of(DummyTestOptions.class); } @Override public BuildOptions patch(BuildOptionsView options, EventHandler eventHandler) { BuildOptionsView result = options.clone(); result.get(DummyTestOptions.class).foo = toOption; return result.underlying(); } } @Test public void testMultipleTopLevelConfigurations() throws Exception { MockRule transitionedRule = () -> MockRule.define( "transitioned_rule", (builder, env) -> builder.cfg(new FooPatchTransition("SET BY PATCH")).build()); MockRule untransitionedRule = () -> MockRule.define("untransitioned_rule"); helper.useRuleClassProvider( setRuleClassProviders(transitionedRule, untransitionedRule).build()); writeFile( "test/BUILD", "transitioned_rule(name = 'transitioned_rule')", "untransitioned_rule(name = 'untransitioned_rule')"); Set result = eval("//test:transitioned_rule+//test:untransitioned_rule"); assertThat(result).hasSize(2); Iterator resultIterator = result.iterator(); assertThat(getConfiguration(resultIterator.next())) .isNotEqualTo(getConfiguration(resultIterator.next())); } @Test public abstract void testMultipleTopLevelConfigurations_nullConfigs() throws Exception; @Test public void testMultipleTopLevelConfigurations_multipleConfigsPrefersTopLevel() throws Exception { MockRule ruleWithTransitionAndDep = () -> MockRule.define( "rule_with_transition_and_dep", (builder, env) -> builder .cfg(new FooPatchTransition("SET BY PATCH")) .addAttribute( attr("dep", LABEL).allowedFileTypes(FileTypeSet.ANY_FILE).build()) .build()); MockRule simpleRule = () -> MockRule.define("simple_rule"); helper.useRuleClassProvider( setRuleClassProviders(ruleWithTransitionAndDep, simpleRule).build()); writeFile( "test/BUILD", "rule_with_transition_and_dep(name = 'top-level', dep = ':dep')", "simple_rule(name = 'dep')"); helper.setUniverseScope("//test:*"); assertThat(getConfiguration(Iterables.getOnlyElement(eval("//test:dep")))) .isNotEqualTo(getConfiguration(Iterables.getOnlyElement(eval("//test:top-level")))); } @Test public void inconsistentSkyQueryIncremental() throws Exception { getHelper().setSyscallCache(TestUtils.makeDisappearingFileCache("bar/BUILD")); getHelper().turnOffFailFast(); writeFile("foo/BUILD"); writeFile("bar/BUILD"); getHelper().setUniverseScope("//bar/..."); TargetParsingException targetParsingException = assertThrows(TargetParsingException.class, () -> eval("set()")); assertThat( targetParsingException .getDetailedExitCode() .getFailureDetail() .getPackageLoading() .getCode()) .isEqualTo(FailureDetails.PackageLoading.Code.TRANSIENT_INCONSISTENT_FILESYSTEM_ERROR); getHelper().setUniverseScope("//foo/..."); QueryException queryException = assertThrows(QueryException.class, () -> eval("bar")); assertThat(queryException.getFailureDetail().getTargetPatterns().getCode()) .isEqualTo(FailureDetails.TargetPatterns.Code.CANNOT_DETERMINE_TARGET_FROM_FILENAME); } private void writeSimpleTarget() throws Exception { MockRule simpleRule = () -> MockRule.define( "simple_rule", attr("dep", LABEL).allowedFileTypes(FileTypeSet.ANY_FILE)); helper.useRuleClassProvider(setRuleClassProviders(simpleRule).build()); writeFile("test/BUILD", "simple_rule(name = 'target')"); } @Test public void testVisibleFunctionDoesNotWork() throws Exception { writeSimpleTarget(); EvalThrowsResult result = evalThrows("visible(//test:target, //test:*)", true); assertThat(result.getMessage()).isEqualTo("visible() is not supported on configured targets"); assertConfigurableQueryCode(result.getFailureDetail(), Code.VISIBLE_FUNCTION_NOT_SUPPORTED); } @Test public void testSiblingsFunctionDoesNotWork() throws Exception { writeSimpleTarget(); EvalThrowsResult result = evalThrows("siblings(//test:target)", true); assertThat(result.getMessage()).isEqualTo("siblings() not supported for post analysis queries"); assertConfigurableQueryCode(result.getFailureDetail(), Code.SIBLINGS_FUNCTION_NOT_SUPPORTED); } @Test public void testBuildfilesFunctionDoesNotWork() throws Exception { writeSimpleTarget(); EvalThrowsResult result = evalThrows("buildfiles(//test:target)", true); assertThat(result.getMessage()) .isEqualTo("buildfiles() doesn't make sense for the configured target graph"); assertConfigurableQueryCode(result.getFailureDetail(), Code.BUILDFILES_FUNCTION_NOT_SUPPORTED); } @Override @Test public void testGenqueryScope() throws Exception { runGenqueryScopeTest(true); } // LabelListAttr not currently supported. @Override public void testLabelsOperator() {} // Wants to get the query environment without evaluation -- not worth it. @Override @Test public void testEqualityOfOrderedThreadSafeImmutableSet() {} // The actual crosstool-related targets depended on are not the nominal crosstool label the test // expects. // "Extended rules" don't play nicely with actual analysis. @Override public void testNoDepsOnAspectAttributeWhenAspectMissing() {} @Override public void testNoDepsOnAspectAttributeWithNoImpicitDeps() {} @Override public void testHaveDepsOnAspectsAttributes() {} // Can't handle loading-phase errors. @Override public void testStrictTestSuiteWithFile() {} @Override public void testTestsOperatorReportsMissingTargets() {} @Override public void testCycleInStarlark() {} @Override public void testCycleInStarlarkParentDir() {} @Override public void testCycleInSubpackage() {} @Override public void testRegression1309697() {} @Override public void badRuleInDeps() {} @Override public void boundedRdepsWithError() {} // Can't handle cycles. @Override public void testDotDotDotWithCycle() {} @Override public void testDotDotDotWithUnrelatedCycle() {} // ... @Override public void testQueryTimeLoadingTargetsBelowNonPackageDirectory() {} @Override public void testQueryTimeLoadingOfTargetsBelowPackageHappyPath() {} @Override public void testQueryTimeLoadingTargetsBelowMissingPackage() {} // These tests clear the universe, getting rid of mock tools that are needed for analysis. Disable // at least for now. Other than testSlashSlashDotDotDot, they're only testing visibility anyway. @Override public void testSlashSlashDotDotDot() {} @Override public void testVisible_default_private() {} @Override public void testVisible_default_public() {} @Override public void testPackageGroupAllBeneath() {} @Override public void testVisible_java_javatests() {} @Override public void testVisible_java_javatests_different_package() {} @Override public void testVisible_javatests_java() {} @Override public void testVisible_package_group() {} @Override public void testVisible_package_group_include() {} @Override public void testVisible_package_group_invisible() {} @Override public void testVisible_private_same_package() {} @Override public void testVisible_simple_different_subpackages() {} @Override public void testVisible_simple_package() {} @Override public void testVisible_simple_private() {} @Override public void testVisible_simple_public() {} @Override public void testVisible_simple_subpackages() {} // test_suite rules aren't supported, since they're not configured targets. @Override public void testTestsOperatorFiltersByNegativeTag() {} @Override public void testTestsOperatorCrossesPackages() {} @Override public void testTestsOperatorHandlesCyclesGracefully() {} @Override public void testTestSuiteInTestsAttributeAndViceVersa() {} @Override public void testAmbiguousAllResolvesToTestSuiteNamedAll() {} @Override public void testTestSuiteWithFile() {} @Override public void testTestsOperatorFiltersByTagSizeAndEnv() {} @Override public void testTestsOperatorExpandsTestsAndExcludesNonTests() {} // buildfiles() operator. @Override public void testBuildFiles() {} @Override public void testBuildFilesDoesNotReturnVisibilityOfBUILD() {} @Override public void testBuildFilesDoesNotReturnVisibilityOfRule() {} @Override public void testBuildfilesOfBuildfiles() {} @Override public void testBuildfilesWithDuplicates() {} @Override public void bzlPackageBadDueToBrokenLoad() {} @Override public void bzlPackageBadDueToBrokenSyntax() {} @Override public void buildfilesBazel() {} @Override public void testTargetsFromBuildfilesAndRealTargets() {} // siblings() operator. @Override public void testSiblings_duplicatePackages() {} @Override public void testSiblings_samePackageRdeps() {} @Override public void testSiblings_matchesTargetNamedAll() {} @Override public void testSiblings_simple() {} @Override public void testSiblings_withBuildfiles() {} // same_pkg_direct_rdeps() operator. @Override public void testSamePackageRdeps_simple() throws Exception {} @Override public void testSamePackageRdeps_duplicate() throws Exception {} @Override public void testSamePackageRdeps_two() throws Exception {} @Override public void testSamePackageRdeps_twoPackages() throws Exception {} @Override public void testSamePackageRdeps_crissCross() throws Exception {} // We eagerly load all packages, so can't test that we don't load one. @Override @Test public void testWildcardsDontLoadUnnecessaryPackages() {} @Override @Test public void boundedDepsWithError() {} // Query needs a graph. @Override @Test public void testGraphOrderOfWildcards() {} // Visibility is checked in the analysis phase, so the post-analysis query done in this unit test // would never occur because the visibility error would occur first. @Override @Test public void testVisibleWithNonPackageGroupVisibility() throws Exception {} // Visibility is checked in the analysis phase, so the post-analysis query done in this unit test // would never occur because the visibility error would occur first. @Override @Test public void testVisibleWithPackageGroupWithNonPackageGroupIncludes() throws Exception {} // We don't support --nodep_deps=false. @Override @Test public void testNodepDeps_false() throws Exception {} // package_group instances have a null configuration and are filtered out by --host_deps=false. @Override @Test public void testDefaultVisibilityReturnedInDeps_nonEmptyDependencyFilter() throws Exception {} protected static void assertConfigurableQueryCode(FailureDetail failureDetail, Code code) { assertThat(failureDetail.getConfigurableQuery().getCode()).isEqualTo(code); } }