Alternatively, new values can be allocated and initialized with factory
functions of the form:

	func NewT(v V) *T

For instance, [NewInt](x) returns an *[Int] set to the value of the int64
argument x, [NewRat](a, b) returns a *[Rat] set to the fraction a/b where
a and b are int64 values, and [NewFloat](f) returns a *[Float] initialized
to the float64 argument f. More flexibility is provided with explicit
setters, for instance:

    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();
  }

              }
            });
  }

  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();
  }

              }
            });
  }

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

  private static <T> SortedSet<T> wrap(final SortedSet<T> delegate) {

              }
            });
  }

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

  private static <T> NavigableSet<T> wrap(final NavigableSet<T> delegate) {

		if _, exist := set[e]; !exist {
			t.Errorf("%s is not in set %v", e, set)
		}
	}
}

func TestUnion(t *testing.T) {
	elements := []string{"a", "b", "c", "d"}
	elements2 := []string{"a", "b", "e"}
	want := New("a", "b", "c", "d", "e")
	for _, sets := range [][]Set[string]{
		{New(elements...), New(elements2...)},
		{New(elements2...), New(elements...)},
	} {
		s1, s2 := sets[0], sets[1]
		if got := s1.Union(s2); !got.Equals(want) {