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

package p

func _[P1 any, P2 ~byte](s1 P1, s2 P2) {
        _ = append(nil /* ERROR "first argument to append must be a slice; have untyped nil" */ , 0)
        _ = append(s1 /* ERRORx `s1 .* has no core type` */ , 0)
        _ = append(s2 /* ERRORx `s2 .* has core type byte` */ , 0)

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

package main

func main() {
	F[any]()
}

func F[T any]() I[T] {
	return (*S1[T])(nil)
}

type I[T any] interface{}

type S1[T any] struct {
	*S2[T]
}

type S2[T any] struct {
	S3 *S3[T]
}

type S3[T any] struct {
	x int

)

var dummyArch = LinkArch{Arch: sys.ArchAMD64}

func TestContentHash64(t *testing.T) {
	s1 := &LSym{P: []byte("A")}
	s2 := &LSym{P: []byte("A\x00\x00\x00")}
	s1.Set(AttrContentAddressable, true)
	s2.Set(AttrContentAddressable, true)
	h1 := contentHash64(s1)
	h2 := contentHash64(s2)
	if h1 != h2 {
		t.Errorf("contentHash64(s1)=%x, contentHash64(s2)=%x, expect equal", h1, h2)
	}

	ctxt := Linknew(&dummyArch) // little endian

	return b
}

// Equal reports whether two slices are equal: the same length and all
// elements equal. All floating point NaNs are considered equal.
func Equal[Elem comparable](s1, s2 []Elem) bool {
	if len(s1) != len(s2) {
		return false
	}
	for i, v1 := range s1 {
		v2 := s2[i]
		if v1 != v2 {
			isNaN := func(f Elem) bool { return f != f }
			if !isNaN(v1) || !isNaN(v2) {
				return false
			}
		}
	}
	return true
}

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

			with: func(h Handler) Handler {
				return h.WithAttrs([]Attr{Int("p1", 1)}).
					WithGroup("s1").
					WithAttrs([]Attr{Int("p2", 2)}).
					WithGroup("s2").
					WithAttrs([]Attr{Int("p3", 3)})
			},
			attrs:    attrs,
			wantText: "msg=message p1=1 s1.p2=2 s1.s2.p3=3 s1.s2.a=one s1.s2.b=2",
			wantJSON: `{"msg":"message","p1":1,"s1":{"p2":2,"s2":{"p3":3,"a":"one","b":2}}}`,
		},
		{
			name:    "two with-groups",

	var k interface { m() float32 }
	_ = i == ii
	_ = i == k /* ERROR "mismatched types" */

	// interfaces vs values
	var s1 S1
	var s11 S11
	var s2 S2

	_ = i == 0 /* ERROR "cannot convert" */
	_ = i == s1 /* ERROR "mismatched types" */
	_ = i == &s1
	_ = i == &s11

	_ = i == s2 /* ERROR "mismatched types" */
	_ = i == & /* ERROR "mismatched types" */ s2

	// issue #28164

func F() {
	v := _S[I]{}
	if v.x != nil {
		panic(v)
	}
}

// Testing the various combinations of method expressions.
type S1 struct{}

func (*S1) M() {}

type S2 struct{}

func (S2) M() {}

func _F1[T interface{ M() }](t T) {
	_ = T.M
}

func F2() {
	_F1(&S1{})
	_F1(S2{})
	_F1(&S2{})
}

func main() {
	F()
	F2()

		{true, T3{i: b, s: "foo"}, T3{i: b, s: "bar"}},
		{false, T3{s: "foo", j: b}, T3{s: "bar", j: b}},
		{true, T3{i: b, s: "fooz"}, T3{i: b, s: "bar"}},
		{false, T3{s: "fooz", j: b}, T3{s: "bar", j: b}},
		{true, A{s1, s2}, A{s2, s1}},
		{true, s1, s2},
		{false, S4{[1000]byte{0}, func() {}}, S4{[1000]byte{1}, func() {}}},
	} {
		f := func() {
			defer func() {
				if recover() != nil {

func pstring(s *string) {
	println(*s)
}

func main() {
	all := []*string{
		&S1, &S2, &S3, &S4, &S5, &S6, &S7, &S8, &S9, &S10,
		&p.S1, &p.S2, &p.S3, &p.S4, &p.S5, &p.S6, &p.S7, &p.S8, &p.S9, &p.S10,
	}
	for _, ps := range all {
		pstring(ps)
	}
}

var S1 string
var S2 string
var S3 string
var S4 string
var S5 string
var S6 string
var S7 string
var S8 string