panic(fmt.Sprintf("a.Equal(%v, %v) = false, want true", s1, s2))
	}
	s1.Add("hello")
	s1.Add("world")
	if got := s1.Len(); got != 2 {
		panic(fmt.Sprintf("(%v).Len() == %d, want 2", s1, got))
	}
	if a.Equal(s1, s2) {
		panic(fmt.Sprintf("a.Equal(%v, %v) = true, want false", s1, s2))
	}
}

func TestCopy() {
	s1 := a.Make[float64]()
	s1.Add(0)
	s2 := s1.Copy()
	if !a.Equal(s1, s2) {

	}
	return i
}

func TestEqual() {
	s1 := []int{1, 2, 3}
	if !_Equal(s1, s1) {
		panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s1, s1))
	}
	s2 := []int{1, 2, 3}
	if !_Equal(s1, s2) {
		panic(fmt.Sprintf("_Equal(%v, %v) = false, want true", s1, s2))
	}
	s2 = append(s2, 4)
	if _Equal(s1, s2) {
		panic(fmt.Sprintf("_Equal(%v, %v) = true, want false", s1, s2))
	}

	s3 := []float64{1, 2, math.NaN()}

// s2.SymmetricDifference(s1) = {a3, a4, a5}
func (s1 Int) SymmetricDifference(s2 Int) Int {
	return Int(cast(s1).SymmetricDifference(cast(s2)))
}

// Union returns a new set which includes items in either s1 or s2.
// For example:
// s1 = {a1, a2}
// s2 = {a3, a4}
// s1.Union(s2) = {a1, a2, a3, a4}
// s2.Union(s1) = {a1, a2, a3, a4}
func (s1 Int) Union(s2 Int) Int {
	return Int(cast(s1).Union(cast(s2)))
}

func f07[S2 ~[]E2, E2 ~byte, S1 ~[]E1, E1 ~byte](S1, S2) {}
func f08[S1 ~[]E1, E2 ~byte, S2 ~[]E2, E1 ~byte](S1, S2) {}
func f09[E2 ~byte, S1 ~[]E1, S2 ~[]E2, E1 ~byte](S1, S2) {}
func f10[S2 ~[]E2, S1 ~[]E1, E2 ~byte, E1 ~byte](S1, S2) {}
func f11[S1 ~[]E1, S2 ~[]E2, E2 ~byte, E1 ~byte](S1, S2) {}
func f12[S1 ~[]E1, E1 ~byte, E2 ~byte, S2 ~[]E2](S1, S2) {}
func f13[E1 ~byte, S1 ~[]E1, E2 ~byte, S2 ~[]E2](S1, S2) {}

// s2.SymmetricDifference(s1) = {a3, a4, a5}
func (s1 Int32) SymmetricDifference(s2 Int32) Int32 {
	return Int32(cast(s1).SymmetricDifference(cast(s2)))
}

// Union returns a new set which includes items in either s1 or s2.
// For example:
// s1 = {a1, a2}
// s2 = {a3, a4}
// s1.Union(s2) = {a1, a2, a3, a4}
// s2.Union(s1) = {a1, a2, a3, a4}
func (s1 Int32) Union(s2 Int32) Int32 {
	return Int32(cast(s1).Union(cast(s2)))
}

	s1 := _Make[int]()
	s1.Add(1)
	s1.Add(2)
	s1.Add(3)
	s1.Add(4)
	tot := 0
	s1.Iterate(func(i int) { tot += i })
	if tot != 10 {
		panic(fmt.Sprintf("total of %v == %d, want 10", s1, tot))
	}
}

func TestFilter() {
	s1 := _Make[int]()
	s1.Add(1)
	s1.Add(2)
	s1.Add(3)
	s1.Filter(func(v int) bool { return v%2 == 0 })
	if vals, want := s1.Values(), []int{2}; !_SliceEqual(vals, want) {

        assertFalse(kuromojiItem1.equals(new KuromojiItem(1, "t1", "s1", "R1", "p1")));
        assertFalse(kuromojiItem1.equals(new KuromojiItem(1, "t1", "s1", "r1", "P1")));
    }

    public void test_toLineString() {
        assertEquals("t1,s1,r1,p1", new KuromojiItem(1, "t1", "s1", "r1", "p1").toLineString());
        assertEquals("t\"\"1,s\"\"1,r\"\"1,p\"\"1", new KuromojiItem(1, "t\"1", "s\"1", "r\"1", "p\"1").toLineString());

			t.Errorf("Equal(%v, %v, equalNaN[float64]) = %t, want %t", test.s1, test.s2, got, test.wantEqualNaN)
		}
	}

	s1 := []int{1, 2, 3}
	s2 := []int{2, 3, 4}
	if EqualFunc(s1, s1, offByOne) {
		t.Errorf("EqualFunc(%v, %v, offByOne) = true, want false", s1, s1)
	}
	if !EqualFunc(s1, s2, offByOne) {
		t.Errorf("EqualFunc(%v, %v, offByOne) = false, want true", s1, s2)
	}

    def accept(String s1, String s2) {
        return getSelector(s1).accept(s2)
    }

    def accept(String s1, ComponentMetadata cmd) {
        return getSelector(s1).accept(cmd)
    }

    def isDynamic(String s1) {
        return getSelector(s1).isDynamic()
    }

    def requiresMetadata(String s1) {
        return getSelector(s1).requiresMetadata()
    }

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build ignore

package main

/*
struct S1 { int f1; };
struct S2 { struct S1 s1; };
typedef struct S1 S1Type;
typedef struct S2 S2Type;
*/
import "C"

type S1 C.S1Type