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

	}
}

func TestStandardLibPackage(t *testing.T) {
	s1 := Sym{Name: "io.(*LimitedReader).Read"}
	s2 := Sym{Name: "io.NewSectionReader"}
	assertString(t, fmt.Sprintf("package of %q", s1.Name), s1.PackageName(), "io")
	assertString(t, fmt.Sprintf("package of %q", s2.Name), s2.PackageName(), "io")
	assertString(t, fmt.Sprintf("receiver of %q", s1.Name), s1.ReceiverName(), "(*LimitedReader)")

        def single = from(dir1)

        expect:
        def s1 = single.plus(dir2)
        s1.contains(dir1)
        s1.contains(child)
        s1.contains(dir2)
        !s1.contains(dir3)
        !s1.contains(tooFew)
        !s1.contains(tooMany)
        !s1.contains(parent)
        flatten(s1) == [parent.path, "1:dir1", "1:dir2"]

        def s2 = single.plus(dir1)

	}
}

const funcsTestFile = `
package funcs

func F() {}

type S1 struct {
	S2  // embedded, exported
	s3  // embedded, unexported
}

func NewS1()  S1 {return S1{} }
func NewS1p() *S1 { return &S1{} }

func (S1) M1() {}
func (r S1) M2() {}
func(S1) m3() {}		// unexported not shown
func (*S1) P1() {}		// pointer receiver

type S2 int
func (S2) M3() {}		// shown on S2

)

type P struct {
	x, y int
}

type S struct {
	s1, s2 P
}

func TestNoRaceComp(t *testing.T) {
	c := make(chan bool, 1)
	var s S
	go func() {
		s.s2.x = 1
		c <- true
	}()
	s.s2.y = 2
	<-c
}

func TestNoRaceComp2(t *testing.T) {
	c := make(chan bool, 1)
	var s S
	go func() {
		s.s1.x = 1
		c <- true
	}()
	s.s1.y = 2
	<-c
}

func TestRaceComp(t *testing.T) {

}

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

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

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

	xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xA0-0xAF
	xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xB0-0xBF
	xx, xx, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xC0-0xCF
	s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xD0-0xDF
	s2, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s4, s3, s3, // 0xE0-0xEF
	s5, s6, s6, s6, s7, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xF0-0xFF