@Override
              public SortedSet<String> create(String[] elements) {
                SortedSet<String> set = new TreeSet<>(arbitraryNullFriendlyComparator());
                Collections.addAll(set, elements);
                return set;
              }
            })
        .named("TreeSet, with comparator")
        .withFeatures(
            SetFeature.GENERAL_PURPOSE,

         */
        public Collection<Dependency> getDependencies() {
            Collection<Dependency> dependencies = new LinkedHashSet<>();
            dependencies.addAll(projectDependencies);
            dependencies.addAll(moduleDependencies);
            dependencies.addAll(fileDependencies);
            return dependencies;
        }

        public Map<ComponentSelector, UnresolvedDependencyResult> getUnresolvedDependencies() {

        public void add(@Nullable Object value, ImmutableCollection.Builder<Object> dest) {
            dest.add(value);
        }

        @Override
        public void addAll(Iterable<?> values, ImmutableCollection.Builder<Object> dest) {
            dest.addAll(values);
        }
    };
    private static final ValueCollector<Object> STRING_VALUE_COLLECTOR = new ValueCollector<Object>() {
        @Override

            subject.add(input1.get())
            subject.addAll(input2.keySet().collect({ it.toString() }))
            subject.addAll(input2.values())
            subject.addAll(input3.collect({ it.toString() }))
        }
    }

    def "fails to create rule action for invalid rule source"() {
        when:

    // Define a preprocessor macro for every binary
    macros.put("NDEBUG", null)

    // Define a compiler options
    compilerArgs.add '-W3'

    // Define toolchain-specific compiler options
    compilerArgs.addAll toolChain.map { toolChain ->
        if (toolChain in [ Gcc, Clang ]) {
            return ['-O2', '-fno-access-control']
        } else if (toolChain in VisualCpp) {
            return ['/Zi']
        }
        return []

    public abstract SourceElement getSources();

    @Override
    public List<SourceFile> getFiles() {
        List<SourceFile> files = new ArrayList<SourceFile>();
        files.addAll(getSources().getFiles());
        files.addAll(getHeaders().getFiles());
        return files;
    }

    public List<String> getSourceFileNamesWithoutHeaders() {
        return CollectionUtils.filter(getSourceFileNames(), new Spec<String>() {

    @Override
    public List<SomeToolingModel> execute(BuildController controller) {
        List<SomeToolingModel> result = new ArrayList<>();
        result.addAll(new FetchCustomModelForEachProject().execute(controller));
        result.addAll(new FetchCustomModelForEachProject().execute(controller));
        return result;
    }

    private final List<Object> params = new ArrayList<>();

    @Override
    public void params(Object... params) {
        Collections.addAll(this.params, params);
    }

    @Override
    public void setParams(Object... params) {
        this.params.clear();
        Collections.addAll(this.params, params);
    }

    @Override
    public Object[] getParams() {
        return this.params.toArray();
    }

        }

        if (!caseInsensitiveMatches.isEmpty()) {
            matches.addAll(caseInsensitiveMatches);
        } else if (!caseSensitiveCamelCaseMatches.isEmpty()) {
            matches.addAll(caseSensitiveCamelCaseMatches);
        } else if (kebabCaseMatches.isEmpty() && kebabCasePrefixMatches.isEmpty()) {
            matches.addAll(caseInsensitiveCamelCaseMatches);
        }

        if (!kebabCaseMatches.isEmpty()) {

	args = &Args{7, 8}
	mulReply := new(Reply)
	mulCall := client.Go("Arith.Mul", args, mulReply, nil)
	addReply := new(Reply)
	addCall := client.Go("Arith.Add", args, addReply, nil)

	addCall = <-addCall.Done
	if addCall.Error != nil {
		t.Errorf("Add: expected no error but got string %q", addCall.Error.Error())
	}
	if addReply.C != args.A+args.B {
		t.Errorf("Add: got %d expected %d", addReply.C, args.A+args.B)
	}