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

		{New(elements2...), New(elements...)},
	} {
		s1, s2 := sets[0], sets[1]
		if got := s1.Union(s2); !got.Equals(want) {
			t.Errorf("expected %v; got %v", want, got)
		}
	}
}

func TestDifference(t *testing.T) {
	s1 := New("a", "b", "c", "d")
	s2 := New("a", "b", "e")
	want := New("c", "d")

	t.Run("difference", func(t *testing.T) {
		d := s1.Difference(s2)
		if !want.Equals(d) {

// For example:
// s1 = {a1, a2, a3}
// s2 = {a1, a2, a4, a5}
// s1.SymmetricDifference(s2) = {a3, a4, a5}
// s2.SymmetricDifference(s1) = {a3, a4, a5}
func (s1 Set[T]) SymmetricDifference(s2 Set[T]) Set[T] {
	return s1.Difference(s2).Union(s2.Difference(s1))
}

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

func update(d digest, p []byte) digest {
	s1, s2 := uint32(d&0xffff), uint32(d>>16)
	for len(p) > 0 {
		var q []byte
		if len(p) > nmax {
			p, q = p[:nmax], p[nmax:]
		}
		for len(p) >= 4 {
			s1 += uint32(p[0])
			s2 += s1
			s1 += uint32(p[1])
			s2 += s1
			s1 += uint32(p[2])
			s2 += s1
			s1 += uint32(p[3])
			s2 += s1
			p = p[4:]
		}
		for _, x := range p {
			s1 += uint32(x)

		t0 = xk[k+0] ^ te0[uint8(s0>>24)] ^ te1[uint8(s1>>16)] ^ te2[uint8(s2>>8)] ^ te3[uint8(s3)]
		t1 = xk[k+1] ^ te0[uint8(s1>>24)] ^ te1[uint8(s2>>16)] ^ te2[uint8(s3>>8)] ^ te3[uint8(s0)]
		t2 = xk[k+2] ^ te0[uint8(s2>>24)] ^ te1[uint8(s3>>16)] ^ te2[uint8(s0>>8)] ^ te3[uint8(s1)]
		t3 = xk[k+3] ^ te0[uint8(s3>>24)] ^ te1[uint8(s0>>16)] ^ te2[uint8(s1>>8)] ^ te3[uint8(s2)]
		k += 4
		s0, s1, s2, s3 = t0, t1, t2, t3
	}

    }

    public boolean hasRoles(final String[] acceptedRoles) {
        return stream(user.getRoleNames())
                .get(stream -> stream.anyMatch(s1 -> stream(acceptedRoles).get(s3 -> s3.anyMatch(s2 -> s2.equals(s1)))));
    }

    public boolean hasGroup(final String group) {
        return stream(user.getGroupNames()).get(stream -> stream.anyMatch(s -> s.equals(group)));
    }

import (
	"fmt"
)

type E[T any] struct {
	v T
}

type S1 struct {
	E[int]
	v string
}

type Eint = E[int]
type Ebool = E[bool]
type Eint2 = Eint

type S2 struct {
	Eint
	Ebool
	v string
}

type S3 struct {
	*E[int]
}

func main() {
	s1 := S1{Eint{2}, "foo"}
	if got, want := s1.E.v, 2; got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

    assertTrue(Objects.equal(1, 1));
    assertTrue(Objects.equal(null, null));

    // test distinct string objects
    String s1 = "foobar";
    String s2 = new String(s1);
    assertTrue(Objects.equal(s1, s2));

    assertFalse(Objects.equal(s1, null));
    assertFalse(Objects.equal(null, s1));
    assertFalse(Objects.equal("foo", "bar"));
    assertFalse(Objects.equal("1", 1));
  }

// compile

// Copyright 2024 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

type (
	s  = struct{ f func(s1) }
	s1 = struct{ i I }
)

type I interface {
	S() *s

}

func _[P map[int]int]() {
	type A = P
	var m A
	clear(m) // don't report an error for m
}

type S1 struct {
	x int "S1.x"
}

type S2 struct {
	x int "S2.x"
}

func _[P1 S1, P2 S2]() {
	type A = P1
	var p A
	_ = P2(p) // conversion must be valid
}

func _[P1 S1, P2 S2]() {
	var p P1
	type A = P2
	_ = A(p) // conversion must be valid
}

func _[P int | string]() {