}
	mc = a.Copy(m1)
	a.Sub(mc, map[int]int{1: 0})
	want := map[int]int{2: 4, 4: 8, 8: 16}
	if !a.Equal(mc, want) {
		panic(fmt.Sprintf("a.Sub result = %v, want %v", mc, want))
	}
}

func TestIntersect() {
	mc := a.Copy(m1)
	a.Intersect(mc, mc)
	if !a.Equal(mc, m1) {
		panic(fmt.Sprintf("a.Intersect(%v, %v) = %v, want %v", m1, m1, mc, m1))
	}
	a.Intersect(mc, map[int]int{1: 0, 2: 0})

		panic(fmt.Sprintf("(%v).Len() == %d, want 1", s1, got))
	}
	if vals, want := s1.Values(), []int{1}; !a.SliceEqual(vals, want) {
		panic(fmt.Sprintf("after SubSet got %v, want %v", vals, want))
	}
}

func TestIntersect() {
	s1 := a.Make[int]()
	s1.Add(1)
	s1.Add(2)
	s2 := a.Make[int]()
	s2.Add(2)
	s2.Add(3)
	s1.Intersect(s2)
	if got := s1.Len(); got != 1 {
		panic(fmt.Sprintf("(%v).Len() == %d, want 1", s1, got))

See the License for the specific language governing permissions and
limitations under the License.
*/

package authenticator

import (
	"reflect"
	"testing"
)

func TestIntersect(t *testing.T) {
	cs := []struct {
		auds, tauds Audiences
		expected    Audiences
	}{
		{
			auds:     nil,
			tauds:    nil,
			expected: Audiences{},
		},
		{
			auds:     nil,

	}
	mc = _Copy(m1)
	_Sub(mc, map[int]int{1: 0})
	want := map[int]int{2: 4, 4: 8, 8: 16}
	if !_Equal(mc, want) {
		panic(fmt.Sprintf("_Sub result = %v, want %v", mc, want))
	}
}

func TestIntersect() {
	mc := _Copy(m1)
	_Intersect(mc, mc)
	if !_Equal(mc, m1) {
		panic(fmt.Sprintf("_Intersect(%v, %v) = %v, want %v", m1, m1, mc, m1))
	}
	_Intersect(mc, map[int]int{1: 0, 2: 0})

		panic(fmt.Sprintf("(%v).Len() == %d, want 1", s1, got))
	}
	if vals, want := s1.Values(), []int{1}; !_SliceEqual(vals, want) {
		panic(fmt.Sprintf("after SubSet got %v, want %v", vals, want))
	}
}

func TestIntersect() {
	s1 := _Make[int]()
	s1.Add(1)
	s1.Add(2)
	s2 := _Make[int]()
	s2.Add(2)
	s2.Add(3)
	s1.Intersect(s2)
	if got := s1.Len(); got != 1 {
		panic(fmt.Sprintf("(%v).Len() == %d, want 1", s1, got))

		testTextfmt(t, s)
	})
	t.Run("Subtract", func(t *testing.T) {
		t.Parallel()
		testSubtract(t, s)
	})
	t.Run("Intersect", func(t *testing.T) {
		t.Parallel()
		testIntersect(t, s, s.outdirs[0], s.outdirs[1], "set")
		testIntersect(t, s, s.outdirs[2], s.outdirs[3], "atomic")
	})
	t.Run("CounterClash", func(t *testing.T) {
		t.Parallel()
		testCounterClash(t, s)
	})
	t.Run("TestEmpty", func(t *testing.T) {