src/test/java/com/google/devtools/build/lib/analysis/RequiredConfigFragmentsTest.java

// Copyright 2020 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.analysis;

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_LIST;

import com.google.devtools.build.lib.actions.ActionConflictException;
import com.google.devtools.build.lib.analysis.config.BuildOptions;
import com.google.devtools.build.lib.analysis.config.CoreOptions.IncludeConfigFragmentsEnum;
import com.google.devtools.build.lib.analysis.config.Fragment;
import com.google.devtools.build.lib.analysis.config.FragmentOptions;
import com.google.devtools.build.lib.analysis.config.RequiresOptions;
import com.google.devtools.build.lib.analysis.util.BuildViewTestCase;
import com.google.devtools.build.lib.analysis.util.MockRule;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.cmdline.RepositoryName;
import com.google.devtools.build.lib.packages.AspectDefinition;
import com.google.devtools.build.lib.packages.AspectParameters;
import com.google.devtools.build.lib.packages.BuildType;
import com.google.devtools.build.lib.packages.NativeAspectClass;
import com.google.devtools.build.lib.packages.RuleClass;
import com.google.devtools.build.lib.rules.cpp.CppOptions;
import com.google.devtools.build.lib.rules.java.JavaConfiguration;
import com.google.devtools.build.lib.rules.java.JavaOptions;
import com.google.devtools.build.lib.testutil.TestConstants;
import com.google.devtools.build.lib.testutil.TestRuleClassProvider;
import com.google.devtools.build.lib.util.FileTypeSet;
import com.google.devtools.common.options.Option;
import com.google.devtools.common.options.OptionDocumentationCategory;
import com.google.devtools.common.options.OptionEffectTag;
import com.google.devtools.common.options.OptionsClass;
import com.google.testing.junit.testparameterinjector.TestParameter;
import com.google.testing.junit.testparameterinjector.TestParameterInjector;
import javax.annotation.Nullable;
import org.junit.Test;
import org.junit.runner.RunWith;

/** Tests for {@link RequiredConfigFragmentsProvider}. */
@RunWith(TestParameterInjector.class)
public final class RequiredConfigFragmentsTest extends BuildViewTestCase {

  @OptionsClass
  public abstract static class AOptions extends FragmentOptions {
    @Option(
        name = "a_option",
        defaultValue = "",
        documentationCategory = OptionDocumentationCategory.UNCATEGORIZED,
        effectTags = {OptionEffectTag.UNKNOWN})
    public abstract String getAOption();
  }

  /**
   * Public for {@link com.google.devtools.build.lib.analysis.config.FragmentFactory}'s
   * reflection-based construction.
   */
  @RequiresOptions(options = {AOptions.class})
  public static final class TestFragmentA extends Fragment {
    public TestFragmentA(BuildOptions options) {}
  }

  /**
   * Public for {@link com.google.devtools.build.lib.analysis.config.FragmentFactory}'s
   * reflection-based construction.
   */
  public static final class TestFragmentB extends Fragment {
    public TestFragmentB(BuildOptions options) {}
  }

  @Override
  protected ConfiguredRuleClassProvider createRuleClassProvider() {
    ConfiguredRuleClassProvider.Builder builder =
        new ConfiguredRuleClassProvider.Builder()
            .addRuleDefinition(new RuleThatAttachesAspect())
            .addRuleDefinition(REQUIRES_FRAGMENT_A)
            .addRuleDefinition(REQUIRES_FRAGMENT_B)
            .addNativeAspectClass(ASPECT_WITH_CONFIG_FRAGMENT_REQUIREMENTS)
            .addConfigurationFragment(TestFragmentA.class)
            .addConfigurationFragment(TestFragmentB.class);
    TestRuleClassProvider.addStandardRules(builder);
    return builder.build();
  }

  private static final MockRule REQUIRES_FRAGMENT_A =
      () ->
          MockRule.define(
              "requires_fragment_a",
              (builder, env) ->
                  builder
                      .add(
                          attr("deps", BuildType.LABEL_LIST).allowedFileTypes(FileTypeSet.ANY_FILE))
                      .requiresConfigurationFragments(TestFragmentA.class));

  private static final MockRule REQUIRES_FRAGMENT_B =
      () ->
          MockRule.define(
              "requires_fragment_b",
              (builder, env) -> builder.requiresConfigurationFragments(TestFragmentB.class));

  @Test
  public void provideTransitiveRequiredFragmentsMode() throws Exception {
    useConfiguration("--include_config_fragments_provider=transitive");
    scratch.file(
        "a/BUILD",
        """
        requires_fragment_b(name = "b")

        requires_fragment_a(
            name = "a",
            deps = [":b"],
        )
        """);

    RequiredConfigFragmentsProvider aTransitiveFragments =
        getConfiguredTarget("//a:a").getProvider(RequiredConfigFragmentsProvider.class);
    assertThat(aTransitiveFragments.fragmentClasses())
        .containsAtLeast(TestFragmentA.class, TestFragmentB.class);
  }

  @Test
  public void configSettingProvideTransitiveRequiresFragment() throws Exception {
    useConfiguration("--include_config_fragments_provider=transitive");
    scratch.file(
        "a/BUILD",
        """
        config_setting(
            name = "config_on_native",
            values = {"compilation_mode": "dbg"},
        )

        config_setting(
            name = "config_on_a",
            values = {"a_option": "foo"},
        )
        """);

    assertThat(
            getConfiguredTarget("//a:config_on_a")
                .getProvider(RequiredConfigFragmentsProvider.class)
                .optionsClasses())
        .contains(AOptions.class);
    assertThat(
            getConfiguredTarget("//a:config_on_native")
                .getProvider(RequiredConfigFragmentsProvider.class)
                .optionsClasses())
        .doesNotContain(AOptions.class);
  }

  @Test
  public void provideDirectRequiredFragmentsMode() throws Exception {
    useConfiguration("--include_config_fragments_provider=direct");
    scratch.file(
        "a/BUILD",
        """
        requires_fragment_b(name = "b")

        requires_fragment_a(
            name = "a",
            deps = [":b"],
        )
        """);

    RequiredConfigFragmentsProvider aDirectFragments =
        getConfiguredTarget("//a:a").getProvider(RequiredConfigFragmentsProvider.class);
    assertThat(aDirectFragments.fragmentClasses()).contains(TestFragmentA.class);
    assertThat(aDirectFragments.fragmentClasses()).doesNotContain(TestFragmentB.class);
  }

  @Test
  public void configSettingProvideDirectRequiresFragment() throws Exception {
    useConfiguration("--include_config_fragments_provider=direct");
    scratch.file(
        "a/BUILD",
        """
        config_setting(
            name = "config_on_native",
            values = {"compilation_mode": "dbg"},
        )

        config_setting(
            name = "config_on_a",
            values = {"a_option": "foo"},
        )
        """);

    assertThat(
            getConfiguredTarget("//a:config_on_a")
                .getProvider(RequiredConfigFragmentsProvider.class)
                .optionsClasses())
        .contains(AOptions.class);
    assertThat(
            getConfiguredTarget("//a:config_on_native")
                .getProvider(RequiredConfigFragmentsProvider.class)
                .optionsClasses())
        .doesNotContain(AOptions.class);
  }

  @Test
  public void requiresMakeVariablesSuppliedByDefine() throws Exception {
    useConfiguration("--include_config_fragments_provider=direct", "--define", "myvar=myval");
    scratch.file(
        "a/BUILD",
        """
        genrule(
            name = "myrule",
            srcs = [],
            outs = ["myrule.out"],
            cmd = "echo $(myvar) $(COMPILATION_MODE) > $@",
        )
        """);
    RequiredConfigFragmentsProvider requiredFragments =
        getConfiguredTarget("//a:myrule").getProvider(RequiredConfigFragmentsProvider.class);
    assertThat(requiredFragments.defines()).containsExactly("myvar");
  }

  @Test
  public void starlarkExpandMakeVariables() throws Exception {
    useConfiguration("--include_config_fragments_provider=direct", "--define=myvar=myval");
    scratch.file(
        "a/defs.bzl",
        """
        def _impl(ctx):
            print(ctx.expand_make_variables("dummy attribute", "string with $(myvar)!", {}))

        simple_rule = rule(
            implementation = _impl,
            attrs = {},
        )
        """);
    scratch.file(
        "a/BUILD",
        """
        load("//a:defs.bzl", "simple_rule")

        simple_rule(name = "simple")
        """);
    RequiredConfigFragmentsProvider requiredFragments =
        getConfiguredTarget("//a:simple").getProvider(RequiredConfigFragmentsProvider.class);
    assertThat(requiredFragments.defines()).containsExactly("myvar");
  }

  @Test
  public void starlarkCtxVar() throws Exception {
    useConfiguration(
        "--include_config_fragments_provider=direct", "--define=required_var=1,irrelevant_var=1");
    scratch.file(
        "a/defs.bzl",
        """
        def _impl(ctx):
            # Defined, so reported as required.
            if "required_var" not in ctx.var:
                fail("Missing required_var")

            # Not defined, so not reported as required.
            if "prohibited_var" in ctx.var:
                fail("Not allowed to set prohibited_var")

            # Present but not a define variable, so not reported as required.
            if "COMPILATION_MODE" not in ctx.var:
                fail("Missing COMPILATION_MODE")

        simple_rule = rule(
            implementation = _impl,
            attrs = {},
        )
        """);
    scratch.file(
        "a/BUILD",
        """
        load("//a:defs.bzl", "simple_rule")

        simple_rule(name = "simple")
        """);
    RequiredConfigFragmentsProvider requiredFragments =
        getConfiguredTarget("//a:simple").getProvider(RequiredConfigFragmentsProvider.class);
    assertThat(requiredFragments.defines()).containsExactly("required_var");
  }

  /**
   * Aspect that requires fragments both in its definition and through {@link
   * #addAspectImplSpecificRequiredConfigFragments}.
   */
  private static final class AspectWithConfigFragmentRequirements extends NativeAspectClass
      implements ConfiguredAspectFactory {
    private static final Class<JavaConfiguration> REQUIRED_FRAGMENT = JavaConfiguration.class;
    private static final String REQUIRED_DEFINE = "myvar";

    @Override
    public AspectDefinition getDefinition(AspectParameters params) {
      return new AspectDefinition.Builder(this)
          .requiresConfigurationFragments(REQUIRED_FRAGMENT)
          .build();
    }

    @Override
    public ConfiguredAspect create(
        Label targetLabel,
        ConfiguredTarget ct,
        RuleContext ruleContext,
        AspectParameters params,
        RepositoryName toolsRepository)
        throws ActionConflictException, InterruptedException {
      return new ConfiguredAspect.Builder(ruleContext).build();
    }

    @Override
    public void addAspectImplSpecificRequiredConfigFragments(
        RequiredConfigFragmentsProvider.Builder requiredFragments) {
      requiredFragments.addDefine(REQUIRED_DEFINE);
    }
  }

  private static final AspectWithConfigFragmentRequirements
      ASPECT_WITH_CONFIG_FRAGMENT_REQUIREMENTS = new AspectWithConfigFragmentRequirements();

  /** Rule that attaches {@link AspectWithConfigFragmentRequirements} to its deps. */
  public static final class RuleThatAttachesAspect
      implements RuleDefinition, RuleConfiguredTargetFactory {
    @Override
    public RuleClass build(RuleClass.Builder builder, RuleDefinitionEnvironment env) {
      return builder
          .add(
              attr("deps", LABEL_LIST)
                  .allowedFileTypes(FileTypeSet.NO_FILE)
                  .aspect(ASPECT_WITH_CONFIG_FRAGMENT_REQUIREMENTS))
          .build();
    }

    @Override
    public Metadata getMetadata() {
      return RuleDefinition.Metadata.builder()
          .name("rule_that_attaches_aspect")
          .ancestors(BaseRuleClasses.NativeBuildRule.class)
          .factoryClass(RuleThatAttachesAspect.class)
          .build();
    }

    @Override
    @Nullable
    public ConfiguredTarget create(RuleContext ruleContext)
        throws ActionConflictException, InterruptedException {
      return new RuleConfiguredTargetBuilder(ruleContext)
          .addProvider(RunfilesProvider.EMPTY)
          .build();
    }
  }

  @Test
  public void aspectRequiresFragments() throws Exception {
    scratch.file(
        "a/BUILD",
        """
        rule_that_attaches_aspect(
            name = "parent",
            deps = [":dep"],
        )

        rule_that_attaches_aspect(name = "dep")
        """);
    useConfiguration("--include_config_fragments_provider=transitive");
    RequiredConfigFragmentsProvider requiredFragments =
        getConfiguredTarget("//a:parent").getProvider(RequiredConfigFragmentsProvider.class);
    assertThat(requiredFragments.fragmentClasses())
        .contains(AspectWithConfigFragmentRequirements.REQUIRED_FRAGMENT);
    assertThat(requiredFragments.defines())
        .containsExactly(AspectWithConfigFragmentRequirements.REQUIRED_DEFINE);
  }

  private void writeStarlarkTransitionsAndAllowList() throws Exception {
    scratch.overwriteFile(
        "tools/allowlists/function_transition_allowlist/BUILD",
        """
        package_group(
            name = "function_transition_allowlist",
            packages = [
                "//a/...",
            ],
        )
        """);
    scratch.file(
        "transitions/defs.bzl",
        """
        def _java_write_transition_impl(settings, attr):
            return {"//command_line_option:javacopt": ["foo"]}

        java_write_transition = transition(
            implementation = _java_write_transition_impl,
            inputs = [],
            outputs = ["//command_line_option:javacopt"],
        )

        def _cpp_read_transition_impl(settings, attr):
            return {}

        cpp_read_transition = transition(
            implementation = _cpp_read_transition_impl,
            inputs = ["//command_line_option:copt"],
            outputs = [],
        )
        """);
    scratch.file("transitions/BUILD");
  }

  @Test
  public void starlarkRuleTransitionReadsFragment() throws Exception {
    writeStarlarkTransitionsAndAllowList();
    scratch.file(
        "a/defs.bzl",
        """
        load("//transitions:defs.bzl", "cpp_read_transition")

        def _impl(ctx):
            pass

        has_cpp_aware_rule_transition = rule(
            implementation = _impl,
            cfg = cpp_read_transition,
        )
        """);
    scratch.file(
        "a/BUILD",
        """
        load("//a:defs.bzl", "has_cpp_aware_rule_transition")

        has_cpp_aware_rule_transition(name = "cctarget")
        """);
    useConfiguration("--include_config_fragments_provider=direct");
    RequiredConfigFragmentsProvider requiredFragments =
        getConfiguredTarget("//a:cctarget").getProvider(RequiredConfigFragmentsProvider.class);
    assertThat(requiredFragments.optionsClasses()).contains(CppOptions.class);
    assertThat(requiredFragments.optionsClasses()).doesNotContain(JavaOptions.class);
  }

  @Test
  public void starlarkRuleTransitionWritesFragment() throws Exception {
    writeStarlarkTransitionsAndAllowList();
    scratch.file(
        "a/defs.bzl",
        """
        load("//transitions:defs.bzl", "java_write_transition")

        def _impl(ctx):
            pass

        has_java_aware_rule_transition = rule(
            implementation = _impl,
            cfg = java_write_transition,
        )
        """);
    scratch.file(
        "a/BUILD",
        """
        load("//a:defs.bzl", "has_java_aware_rule_transition")

        has_java_aware_rule_transition(name = "javatarget")
        """);
    useConfiguration("--include_config_fragments_provider=direct");
    RequiredConfigFragmentsProvider requiredFragments =
        getConfiguredTarget("//a:javatarget").getProvider(RequiredConfigFragmentsProvider.class);
    assertThat(requiredFragments.optionsClasses()).contains(JavaOptions.class);
    assertThat(requiredFragments.optionsClasses()).doesNotContain(CppOptions.class);
  }

  @Test
  public void starlarkAttrTransition() throws Exception {
    writeStarlarkTransitionsAndAllowList();
    scratch.file(
        "a/defs.bzl",
        """
        load("//transitions:defs.bzl", "cpp_read_transition", "java_write_transition")

        def _impl(ctx):
            pass

        has_java_aware_attr_transition = rule(
            implementation = _impl,
            attrs = {
                "deps": attr.label_list(cfg = java_write_transition),
            },
        )
        has_cpp_aware_rule_transition = rule(
            implementation = _impl,
            cfg = cpp_read_transition,
        )
        """);
    scratch.file(
        "a/BUILD",
        """
        load("//a:defs.bzl", "has_cpp_aware_rule_transition", "has_java_aware_attr_transition")

        has_cpp_aware_rule_transition(name = "ccchild")

        has_java_aware_attr_transition(
            name = "javaparent",
            deps = [":ccchild"],
        )
        """);
    useConfiguration("--include_config_fragments_provider=direct");
    RequiredConfigFragmentsProvider requiredFragments =
        getConfiguredTarget("//a:javaparent").getProvider(RequiredConfigFragmentsProvider.class);
    // We consider the attribute transition over the parent -> child edge a property of the parent.
    assertThat(requiredFragments.optionsClasses()).contains(JavaOptions.class);
    // But not the child's rule transition.
    assertThat(requiredFragments.optionsClasses()).doesNotContain(CppOptions.class);
  }

  @Test
  public void aspectInheritsTransitiveFragmentsFromBaseCT(
      @TestParameter({"DIRECT", "TRANSITIVE"}) IncludeConfigFragmentsEnum setting)
      throws Exception {
    writeStarlarkTransitionsAndAllowList();
    scratch.file(
        "a/defs.bzl",
        """
        A1Info = provider()

        def _a1_impl(target, ctx):
            return []

        a1 = aspect(implementation = _a1_impl)

        def _java_depender_impl(ctx):
            return []

        java_depender = rule(
            implementation = _java_depender_impl,
            fragments = ["java"],
            attrs = {},
        )

        def _r_impl(ctx):
            return []

        r = rule(
            implementation = _r_impl,
            attrs = {"dep": attr.label(aspects = [a1])},
        )
        """);
    scratch.file(
        "a/BUILD",
        """
        load(":defs.bzl", "java_depender", "r")

        java_depender(name = "lib")

        r(
            name = "r",
            dep = ":lib",
        )
        """);

    useConfiguration("--include_config_fragments_provider=" + setting);
    getConfiguredTarget("//a:r");
    RequiredConfigFragmentsProvider requiredFragments =
        getAspect("//a:defs.bzl%a1").getProvider(RequiredConfigFragmentsProvider.class);

    if (setting == IncludeConfigFragmentsEnum.TRANSITIVE) {
      assertThat(requiredFragments.fragmentClasses()).contains(JavaConfiguration.class);
    } else {
      assertThat(requiredFragments.fragmentClasses()).doesNotContain(JavaConfiguration.class);
    }
  }

  @Test
  public void aspectInheritsTransitiveFragmentsFromRequiredAspect(
      @TestParameter({"DIRECT", "TRANSITIVE"}) IncludeConfigFragmentsEnum setting)
      throws Exception {
    scratch.file(
        "a/defs.bzl",
        """
        A1Info = provider()

        def _a1_impl(target, ctx):
            return A1Info(var = ctx.var.get("my_var", "0"))

        a1 = aspect(implementation = _a1_impl, provides = [A1Info])

        A2Info = provider()

        def _a2_impl(target, ctx):
            return A2Info()

        a2 = aspect(implementation = _a2_impl, required_aspect_providers = [A1Info])

        def _simple_rule_impl(ctx):
            return []

        simple_rule = rule(
            implementation = _simple_rule_impl,
            attrs = {},
        )

        def _r_impl(ctx):
            return []

        r = rule(
            implementation = _r_impl,
            attrs = {"dep": attr.label(aspects = [a1, a2])},
        )
        """);
    scratch.file(
        "a/BUILD",
        """
        load(":defs.bzl", "r", "simple_rule")

        simple_rule(name = "lib")

        r(
            name = "r",
            dep = ":lib",
        )
        """);

    useConfiguration("--include_config_fragments_provider=" + setting, "--define", "my_var=1");
    getConfiguredTarget("//a:r");
    RequiredConfigFragmentsProvider requiredFragments =
        getAspect("//a:defs.bzl%a2").getProvider(RequiredConfigFragmentsProvider.class);

    if (setting == IncludeConfigFragmentsEnum.TRANSITIVE) {
      assertThat(requiredFragments.defines()).contains("my_var");
    } else {
      assertThat(requiredFragments.defines()).doesNotContain("my_var");
    }
  }

  @Test
  public void invalidStarlarkFragmentsFiltered() throws Exception {
    scratch.file(
        "a/defs.bzl",
        """
        def _my_rule_impl(ctx):
            pass

        my_rule = rule(implementation = _my_rule_impl, fragments = ["java", "doesnotexist"])
        """);
    scratch.file(
        "a/BUILD",
        """
        load(":defs.bzl", "my_rule")

        my_rule(name = "example")
        """);

    useConfiguration("--include_config_fragments_provider=direct");
    RequiredConfigFragmentsProvider requiredFragments =
        getConfiguredTarget("//a:example").getProvider(RequiredConfigFragmentsProvider.class);

    assertThat(requiredFragments.fragmentClasses()).contains(JavaConfiguration.class);
  }

  @Test
  public void aspectInErrorWithAllowAnalysisFailures() throws Exception {
    scratch.file(
        "a/defs.bzl",
        """
        def _error_aspect_impl(target, ctx):
            fail(ctx.var["FAIL_MESSAGE"])

        error_aspect = aspect(implementation = _error_aspect_impl)

        def _my_rule_impl(ctx):
            pass

        my_rule = rule(
            implementation = _my_rule_impl,
            attrs = {"dep": attr.label(aspects = [error_aspect])},
        )
        """);
    scratch.file(
        "a/BUILD",
        """
        load(":defs.bzl", "error_aspect", "my_rule")

        my_rule(name = "a")

        my_rule(
            name = "b",
            dep = ":a",
        )
        """);

    useConfiguration(
        "--allow_analysis_failures",
        "--define=FAIL_MESSAGE=abc",
        "--include_config_fragments_provider=direct");
    getConfiguredTarget("//a:b");
    RequiredConfigFragmentsProvider requiredFragments =
        getAspect("//a:defs.bzl%error_aspect").getProvider(RequiredConfigFragmentsProvider.class);

    assertThat(requiredFragments.defines()).containsExactly("FAIL_MESSAGE");
  }

  @Test
  public void configuredTargetInErrorWithAllowAnalysisFailures() throws Exception {
    scratch.file(
        "a/defs.bzl",
        """
        def _error_rule_impl(ctx):
            fail(ctx.var["FAIL_MESSAGE"])

        error_rule = rule(implementation = _error_rule_impl)
        """);
    scratch.file(
        "a/BUILD",
        """
        load(":defs.bzl", "error_rule")

        error_rule(name = "error")
        """);

    useConfiguration(
        "--allow_analysis_failures",
        "--define=FAIL_MESSAGE=abc",
        "--include_config_fragments_provider=direct");
    RequiredConfigFragmentsProvider requiredFragments =
        getConfiguredTarget("//a:error").getProvider(RequiredConfigFragmentsProvider.class);

    assertThat(requiredFragments.defines()).containsExactly("FAIL_MESSAGE");
  }

  @Test
  public void aliasWithSelectResolvesToConfigSetting() throws Exception {
    scratch.file(
        "a/BUILD",
        String.format(
            """
            config_setting(
                name = "define_x",
                define_values = {"x": "1"},
            )

            config_setting(
                name = "k8",
                constraint_values = ["%s"]
            )

            alias(
                name = "alias_to_setting",
                actual = select({":define_x": ":k8"}),
            )

            genrule(
                name = "gen",
                outs = ["gen.out"],
                cmd = select({":alias_to_setting": "touch $@"}),
            )
            """,
            TestConstants.CONSTRAINTS_PACKAGE_ROOT + "cpu:x86_64"));

    useConfiguration(
        "--define=x=1",
        "--platforms=" + TestConstants.PLATFORM_LABEL,
        "--include_config_fragments_provider=transitive");
    RequiredConfigFragmentsProvider requiredFragments =
        getConfiguredTarget("//a:gen").getProvider(RequiredConfigFragmentsProvider.class);

    assertThat(requiredFragments.defines()).containsExactly("x");
  }
}