}
            });
  }

  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) {

	}
	return true
}

// A _Set is a set of elements of some type.
type _Set[Elem comparable] struct {
	m map[Elem]struct{}
}

// _Make makes a new set.
func _Make[Elem comparable]() _Set[Elem] {
	return _Set[Elem]{m: make(map[Elem]struct{})}
}

// Add adds an element to a set.
func (s _Set[Elem]) Add(v Elem) {
	s.m[v] = struct{}{}
}

// Delete removes an element from a set. If the element is not present

package clause

import "sort"

type Set []Assignment

type Assignment struct {
	Column Column
	Value  interface{}
}

func (set Set) Name() string {
	return "SET"
}

func (set Set) Build(builder Builder) {
	if len(set) > 0 {
		for idx, assignment := range set {
			if idx > 0 {
				builder.WriteByte(',')
			}
			builder.WriteQuoted(assignment.Column)
			builder.WriteByte('=')

// Package set implements sets of any type.
package set

type Set[Elem comparable] map[Elem]struct{}

func Make[Elem comparable]() Set[Elem] {
	return make(Set(Elem))
}

func (s Set[Elem]) Add(v Elem) {
	s[v] = struct{}{}
}

func (s Set[Elem]) Delete(v Elem) {
	delete(s, v)
}

func (s Set[Elem]) Contains(v Elem) bool {
	_, ok := s[v]
	return ok
}

func (s Set[Elem]) Len() int {
	return len(s)
}

func (s Set[T]) Delete(item T) Set[T] {
	delete(s, item)
	return s
}

// DeleteAll removes items from the set.
func (s Set[T]) DeleteAll(items ...T) Set[T] {
	for _, item := range items {
		delete(s, item)
	}
	return s
}

// Merge a set of objects that are in s2 into s
// For example:
// s = {a1, a2, a3}
// s2 = {a3, a4, a5}
// s.Merge(s2) = {a1, a2, a3, a4, a5}
func (s Set[T]) Merge(s2 Set[T]) Set[T] {

	return ret
}

// Insert adds items to the set.
func (s Set[T]) Insert(items ...T) Set[T] {
	for _, item := range items {
		s[item] = Empty{}
	}
	return s
}

func Insert[T comparable](set Set[T], items ...T) Set[T] {
	return set.Insert(items...)
}

// Delete removes all items from the set.
func (s Set[T]) Delete(items ...T) Set[T] {
	for _, item := range items {
		delete(s, item)
	}
	return s
}

type bitset8 uint8

func (f *bitset8) set(mask uint8, b bool) {
	if b {
		*(*uint8)(f) |= mask
	} else {
		*(*uint8)(f) &^= mask
	}
}

func (f bitset8) get2(shift uint8) uint8 {
	return uint8(f>>shift) & 3
}

// set2 sets two bits in f using the bottom two bits of b.
func (f *bitset8) set2(shift uint8, b uint8) {
	// Clear old bits.
	*(*uint8)(f) &^= 3 << shift
	// Set new bits.
	*(*uint8)(f) |= uint8(b&3) << shift

    private final UnionFileTree set = new UnionFileTree(TestFiles.taskDependencyFactory(), "<display name>")

    def setup() {
        NativeServicesTestFixture.initialize()
    }

    def canAddFileTree() {
        FileTreeInternal set1 = Mock(FileTreeInternal)
        when:
        set.addToUnion(set1)

        then:
        set.sourceCollections == [set1]
    }

    def cannotAddFileCollection() {

		items2 = append(items2, fmt.Sprint(i))
	}
	b.Run("Set", func(b *testing.B) {
		set1000 := sets.New(items1000...)
		set100 := sets.New(items100...)
		set2 := sets.New(items2...)
		b.Run("New/1", func(b *testing.B) {
			for range b.N {
				_ = sets.New("a")
			}
		})
		b.Run("New/1000", func(b *testing.B) {
			for range b.N {
				_ = sets.New(items1000...)
			}
		})