then:
        1 * execOperations.exec(_) >> { Action<? super ExecSpec> action -> action.execute(spec) }
        spec.environment == System.getenv() + [FOO: "BAR"]
    }

    def "specifying both full and additional environment is an error"() {
        given:
        def spec = specFactory.newExecAction()
        execOperations.exec(_ as Action<? super ExecSpec>) >> { Action<? super ExecSpec> action -> action.execute(spec) }

        when:

    Builder(int initCapacity) {
      super(initCapacity);
    }

    @CanIgnoreReturnValue
    @Override
    public Builder<K, V> put(K key, V value) {
      super.put(key, value);
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    public Builder<K, V> put(Entry<? extends K, ? extends V> entry) {
      super.put(entry);
      return this;
    }

            } else {
                return super.getDisplayName();
            }
        }

        @Override
        public void set(@Nullable T value) {
            onlyIfMutable(() -> super.set(value));
        }

        @Override
        public void set(Provider<? extends T> provider) {
            onlyIfMutable(() -> super.set(provider));
        }

        @Override

        return get(elementType, element -> element.getName().equals(name));
    }

    @Override
    public BinaryProvider<T> get(Spec<? super T> spec) {
        return get(elementType, spec);
    }

    @Override
    public void whenElementKnown(Action<? super T> action) {
        if (state != State.Collecting) {

example: * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre> */ @Factory public static <T> Matcher<T> allOf(Matcher<? super T> first, Matcher<? super T> second, Matcher<? super T> third, Matcher<? super T> fourth, Matcher<? super T> fifth, Matcher<? super T> sixth) { List<Matcher<? super T>> matchers = new ArrayList<Matcher<? super T>>(6); matchers.add(first); matchers.add(second); matchers.add(third); matchers.add(fourth); matchers.add(fifth); matchers.add(sixth); return...

    private final ImmutableAttributesFactory attributesFactory;
    private final List<Action<? super VariantVersionMappingStrategy>> mappingsForAllVariants = Lists.newArrayListWithExpectedSize(2);
    private final Map<ImmutableAttributes, String> defaultConfigurations = new HashMap<>();
    private final Multimap<ImmutableAttributes, Action<? super VariantVersionMappingStrategy>> attributeBasedMappings = ArrayListMultimap.create();

    @Inject

        super(capacity);
    }

    /**
     * キーが含まれているかどうかを返します。
     *
     * @param key
     *            キー
     * @return キーが含まれているかどうか
     */
    public boolean containsKey(final String key) {
        return super.containsKey(convertKey(key));
    }

    @Override
    public V get(final Object key) {
        return super.get(convertKey(key));
    }

    @Override

        if (variantAttributesRules == null) {
            variantAttributesRules = new VariantAttributesRules(attributesFactory);
        }
        variantAttributesRules.addAttributesAction(action);
    }

    public void addCapabilitiesAction(VariantAction<? super MutableCapabilitiesMetadata> action) {

    private final Spec<SpecRuleAction<? super ComponentSelection>> withNoInputs = element -> element.getAction().getInputTypes().isEmpty();
    private final Spec<SpecRuleAction<? super ComponentSelection>> withInputs = Specs.negate(withNoInputs);

    void apply(ComponentSelectionInternal selection, Collection<SpecRuleAction<? super ComponentSelection>> specRuleActions, MetadataProvider metadataProvider) {

    public LifecycleExecutionException(String message) {
        super(message);
    }

    public LifecycleExecutionException(Throwable cause) {
        super(cause);
    }

    public LifecycleExecutionException(String message, Throwable cause) {
        super(message, cause);
    }

    public LifecycleExecutionException(String message, MavenProject project) {
        super(message);
        this.project = project;
    }