def "can add empty set to singleton set"() {
        def action = Mock(Action)

        expect:
        def set = ImmutableActionSet.empty().add(action)
        set.add(ImmutableActionSet.empty()).is(set)
    }

    def "can add duplicate action to singleton set"() {
        def action = Mock(Action)

        expect:
        def set = ImmutableActionSet.empty().add(action)
        set.add(action).is(set)

	f.Add([]byte(`-lextra\ fun\ arg\\`))
	f.Add([]byte("\textra     whitespace\r"))
	f.Add([]byte("     \r      "))
	f.Add([]byte(`"-r:foo" "-L/usr/white space/lib" "-lfoo bar" "-lbar baz"`))
	f.Add([]byte(`"-lextra fun arg\\"`))
	f.Add([]byte(`"     \r\n\      "`))
	f.Add([]byte(`""`))
	f.Add([]byte(``))
	f.Add([]byte(`"\\"`))
	f.Add([]byte(`"\x"`))
	f.Add([]byte(`"\\x"`))
	f.Add([]byte(`'\\'`))
	f.Add([]byte(`'\x'`))

        registration.add(GradleEnterpriseAutoAppliedPluginRegistry.class);
        registration.add(GradleEnterprisePluginAutoAppliedStatus.class);
        registration.add(DefaultGradleEnterprisePluginServiceRef.class);
        registration.add(DefaultGradleEnterprisePluginBuildState.class);
        registration.add(DefaultGradleEnterprisePluginConfig.class);

    queryBuilder.add(Range.<Integer>all());

    for (int i = MIN_BOUND; i <= MAX_BOUND; i++) {
      for (BoundType boundType : BoundType.values()) {
        queryBuilder.add(Range.upTo(i, boundType));
        queryBuilder.add(Range.downTo(i, boundType));
      }
      queryBuilder.add(Range.singleton(i));
      queryBuilder.add(Range.openClosed(i, i));
      queryBuilder.add(Range.closedOpen(i, i));

	f3 := func() { println("blek") }
	f4 := func() { println("blub") }
	f5 := func() { println("blat") }
	exithook.Add(exithook.Hook{F: f1})
	exithook.Add(exithook.Hook{F: f2, RunOnFailure: true})
	exithook.Add(exithook.Hook{F: f3})
	exithook.Add(exithook.Hook{F: f4, RunOnFailure: true})
	exithook.Add(exithook.Hook{F: f5})
	os.Exit(1)
}

func testPanics() {
	f1 := func() { println("ok") }

        b.addLink c

        when:
        graph.add(a)
        graph.add(b)
        graph.add(c)
        graph.addListener(listener)

        then:
        1 * listener.onDiscovered(b)
        1 * listener.onDiscovered(c)
        0 * listener.onDiscovered(_)

        when:
        graph.add(d)
        graph.add(e)
        graph.add(f)

        then:
        1 * listener.onDiscovered(d)

      int x = 1 << exponent;
      intValues.add(x, x + 1, x - 1);
    }
    intValues.add(9999).add(10000).add(10001).add(1000000); // near powers of 10
    intValues.add(5792).add(5793); // sqrt(2^25) rounded up and down
    POSITIVE_INTEGER_CANDIDATES = intValues.build();
    NEGATIVE_INTEGER_CANDIDATES =
        ImmutableList.copyOf(
            Iterables.concat(

        container.realizeNow()

        when:
        container.add(Stub(SwiftBinary))

        then:
        def e = thrown(IllegalStateException)
        e.message == 'Cannot add an element to this collection as it has already been realized.'
    }

    def "cannot add elements while collection is realizing"() {
        given:
        container.add(Stub(SwiftBinary))

    }

    @Override
    public void add(String problem) {
        problems.add(problem);
    }

    @Override
    public void add(Field field, String problem) {
        problems.add(field, problem);
    }

    @Override
    public void add(WeaklyTypeReferencingMethod<?, ?> method, String problem) {
        add(method.getMethod(), problem);
    }

    @Override

    }

    def "listIterator can add elements"() {
        given:
        source.add("foo")
        source.addPending(provider("bar"))
        source.addPendingCollection(listProvider("baz", "buzz"))
        source.add("fizz")

        when:
        def iterator = source.listIterator()
        iterator.next()
        iterator.add("fuzz")

        then: