p := e.b
				t.clear()
				t.addAll(s.live[p.ID])
				t.addAll(live.contents())
				t.addAll(spillLive[p.ID])
				for _, v := range phis {
					a := v.Args[i]
					if s.values[a.ID].needSlot {
						t.add(a.ID)
					}
					if spill := s.values[a.ID].spill; spill != nil {
						//TODO: remove?  Subsumed by SpillUse?
						t.add(spill.ID)
					}
				}
				if t.size() == len(s.live[p.ID]) {

    oneValueAccumulatorByAddAllEmptyStats.addAll(Stats.of());

    twoValuesAccumulator = new StatsAccumulator();
    twoValuesAccumulator.addAll(TWO_VALUES);

    twoValuesAccumulatorByAddAllStats = new StatsAccumulator();
    twoValuesAccumulatorByAddAllStats.addAll(Stats.of(ONE_VALUE));
    twoValuesAccumulatorByAddAllStats.addAll(Stats.of(OTHER_ONE_VALUE));

        list == ['a']
    }

    def "can add collection at given index"() {
        when:
        list.addAll(0, ['a', 'b'])

        then:
        list == ['a', 'b']

        when:
        list.addAll(1, ['c', 'd'])

        then:
        list == ['a', 'c', 'd', 'b']
    }

    def "fires events when elements are added"() {

        assertThat(ArrayUtil.addAll((Object[]) null, (Object[]) null), is(nullValue()));
        assertThat(ArrayUtil.addAll(null, emptyArray).length, is(0));
        assertThat(ArrayUtil.addAll(emptyArray, null), is(sameInstance(emptyArray)));
        assertThat(ArrayUtil.addAll(emptyArray, null), is(sameInstance(emptyArray)));
        assertThat(ArrayUtil.addAll(emptyArray, emptyArray), is(sameInstance(emptyArray)));

            SetWithFewActions<T> compositeSet = Cast.uncheckedNonnullCast(action);
            return addAll(compositeSet);
        }
        if (action instanceof SetWithManyActions) {
            SetWithManyActions<T> compositeSet = Cast.uncheckedNonnullCast(action);
            return addAll(compositeSet);
        }
        return addOne(action);
    }

        expect:
        def dispatch1 = BroadcastDispatch.empty(TestListener)
        dispatch1.addAll([]).is(dispatch1)

        def dispatch2 = dispatch1.add(listener1)
        dispatch2.addAll([listener1, listener1]).is(dispatch2)

        def dispatch3 = dispatch2.add(listener2)
        dispatch3.addAll([listener2, listener1]).is(dispatch3)
    }

    def "can remove multiple listeners as a batch"() {

  }

  /**
   * Adds the given values to the dataset. The stream will be completely consumed by this method.
   *
   * @param values a series of values
   * @since 28.2
   */
  public void addAll(IntStream values) {
    addAll(values.collect(StatsAccumulator::new, StatsAccumulator::add, StatsAccumulator::addAll));
  }

  /**

    public final void addAll(T... elements) {
        getConfigurer(false).addAll(elements);
    }

    @Override
    public void addAll(Iterable<? extends T> elements) {
        getConfigurer(false).addAll(elements);
    }

    @Override
    public void addAll(Provider<? extends Iterable<? extends T>> provider) {
        getConfigurer(false).addAll(provider);
    }

    @Override

        then:
        thrown(NullPointerException)
    }

    def "addAll from iterable"() {
        expect:
        addAll([], [1, 2, 3] as Iterable) == [1, 2, 3]
        addAll([] as Set, [1, 2, 3, 1] as Iterable) == [1, 2, 3] as Set
    }

    def "addAll from array"() {
        expect:
        addAll([], 1, 2, 3) == [1, 2, 3]
        addAll([] as Set, 1, 2, 3, 1) == [1, 2, 3] as Set
    }

    emptyAccumulatorByAddAllEmptyPairedStats.addAll(emptyAccumulator.snapshot());

    oneValueAccumulator = new PairedStatsAccumulator();
    oneValueAccumulator.add(ONE_VALUE, OTHER_ONE_VALUE);

    oneValueAccumulatorByAddAllEmptyPairedStats = new PairedStatsAccumulator();
    oneValueAccumulatorByAddAllEmptyPairedStats.add(ONE_VALUE, OTHER_ONE_VALUE);
    oneValueAccumulatorByAddAllEmptyPairedStats.addAll(emptyAccumulator.snapshot());