v.Set(vx)
	return v.Int()
}

func set3(v reflect.Value, x int) { // ERROR "v does not escape"
	v.SetInt(int64(x))
}

func set4(x int) int {
	var a int
	v := reflect.ValueOf(&a).Elem() // a should not escape, no error printed
	v.SetInt(int64(x))
	return int(v.Int())
}

func set5(v reflect.Value, x string) { // ERROR "v does not escape" "leaking param: x$"
	v.SetString(x)

   * equivalence relations, for example if {@code set1} is a {@link HashSet} and {@code set2} is a
   * {@link TreeSet} or the {@link Map#keySet} of an {@code IdentityHashMap}.
   *
   * @since 3.0
   */
  public static <E extends @Nullable Object> SetView<E> symmetricDifference(
      final Set<? extends E> set1, final Set<? extends E> set2) {
    checkNotNull(set1, "set1");

   * {@link TreeSet} or the {@link Map#keySet} of an {@code IdentityHashMap}.
   */
  public static <E extends @Nullable Object> SetView<E> union(
      final Set<? extends E> set1, final Set<? extends E> set2) {
    checkNotNull(set1, "set1");
    checkNotNull(set2, "set2");

    return new SetView<E>() {
      @Override
      public int size() {
        int size = set1.size();

	set1 := newStatefulSet(3)
	set2 := newStatefulSet(3)
	set2.Name = "foo2"
	set3 := newStatefulSet(3)
	set3.Name = "foo3"
	set3.Spec.Selector.MatchLabels = map[string]string{"foo3": "bar"}
	pod := newStatefulSetPod(set1, 0)
	om.setsIndexer.Add(set1)
	om.setsIndexer.Add(set2)
	om.setsIndexer.Add(set3)

	// Make pod an orphan. Expect matching sets to be queued.
	pod.OwnerReferences = nil

    def "can concatenate attribute to a singleton set"() {
        when:
        def set1 = factory.of(FOO, "foo")
        def set2 = factory.concat(set1, BAR, "bar")

        then:
        set2.keySet() == [FOO, BAR] as Set

        and:
        set2.getAttribute(FOO) == 'foo'
        set2.getAttribute(BAR) == 'bar'
    }

    def "can concatenate attribute to multiple value set"() {
        given:

        CompositeResolvedArtifactSet.of([ResolvedArtifactSet.EMPTY, set, ResolvedArtifactSet.EMPTY]) == set
    }

    def "visits each set in turn"() {
        def set1 = Mock(ResolvedArtifactSet)
        def set2 = Mock(ResolvedArtifactSet)

        def asyncListener = Mock(ResolvedArtifactSet.Visitor)

        when:
        CompositeResolvedArtifactSet.of([set1, set2]).visit(asyncListener)

        def visitor = Mock(ResolvedArtifactSet.Visitor)
        def set1 = of([])

        when:
        set1.artifacts.visit(visitor)

        then:
        0 * _
    }

    def "visits local artifacts of empty variant"() {
        def visitor = Mock(ResolvedArtifactSet.TransformSourceVisitor)
        def set1 = of([])

        when:
        set1.artifacts.visitTransformSources(visitor)

        then:

    def "provides stores"() {
        def set1 = f.createStoreSet()
        def set2 = f.createStoreSet()

        expect:
        set1.oldModelCache().load(() -> "1") == "1"
        set1.oldModelCache().load(() -> "2") == "1"
        set2.oldModelCache().load(() -> "3") == "3"

        set1.newModelCache().load(() -> "1") == "1"
        set1.newModelCache().load(() -> "2") == "1"
        set2.newModelCache().load(() -> "3") == "3"
    }

              }
            });
  }

  public void testEquals() {
    SortedMultiset<String> set1 = ImmutableSortedMultiset.of("one");
    SortedMultiset<String> set2 = ImmutableSortedMultiset.of("two");
    new EqualsTester()
        .addEqualityGroup(set1, wrap(set1), wrap(set1))
        .addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

        def action1 = Mock(Action)
        def action2 = Mock(Action)

        expect:
        def set = ImmutableActionSet.of(action1, action2)
        set.add(action1).is(set)
        set.add(action2).is(set)
        set.add(ImmutableActionSet.of(action1)).is(set)
        set.add(ImmutableActionSet.of(action2)).is(set)
        ImmutableActionSet.of(action1).add(set).is(set)
    }