bind/testdata/testpkg/testpkg.go - mobile - Git at Google

 // Copyright 2014 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 testpkg contains bound functions for testing the cgo-JNI interface.
 // This is used in tests of golang.org/x/mobile/bind/java.
 package testpkg

 //go:generate gobind -lang=go -outdir=go_testpkg .
 //go:generate gobind -lang=java -outdir=. .
 import (
 	"context"
 	"errors"
 	"fmt"
 	"io/ioutil"
 	"log"
 	"math"
 	"os"
 	"runtime"
 	"syscall"
 	"time"

 	"golang.org/x/mobile/asset"

 	"golang.org/x/mobile/bind/testdata/testpkg/secondpkg"
 	"golang.org/x/mobile/bind/testdata/testpkg/simplepkg"
 	"golang.org/x/mobile/bind/testdata/testpkg/unboundpkg"
 )

 const (
 	AString = "a string"
 	AnInt   = 7
 	ABool   = true
 	AFloat  = 0.12345

 	MinInt32               int32   = math.MinInt32
 	MaxInt32               int32   = math.MaxInt32
 	MinInt64                       = math.MinInt64
 	MaxInt64                       = math.MaxInt64
 	SmallestNonzeroFloat64         = math.SmallestNonzeroFloat64
 	MaxFloat64                     = math.MaxFloat64
 	SmallestNonzeroFloat32 float32 = math.SmallestNonzeroFloat64
 	MaxFloat32             float32 = math.MaxFloat32
 	Log2E                          = math.Log2E
 )

 var (
 	StringVar     = "a string var"
 	IntVar        = 77
 	StructVar     = &S{name: "a struct var"}
 	InterfaceVar  I
 	InterfaceVar2 I2
 	NodeVar       = &Node{V: "a struct var"}
 )

 type Nummer interface {
 	Num()
 }

 type I interface {
 	F()

 	E() error
 	V() int
 	VE() (int, error)
 	I() I
 	S() *S
 	StoString(seq *S) string

 	String() string
 }

 func CallF(i I) {
 	i.F()
 }

 func CallE(i I) error {
 	return i.E()
 }

 func CallV(i I) int {
 	return i.V()
 }

 func CallVE(i I) (int, error) {
 	return i.VE()
 }

 func CallI(i I) I {
 	return i
 }

 func CallS(i I) *S {
 	return &S{}
 }

 var keep []I

 func Keep(i I) {
 	keep = append(keep, i)
 }

 var numSCollected int

 type S struct {
 	// *S already has a finalizer, so we need another object
 	// to count successful collections.
 	innerObj *int

 	name string
 }

 func (s *S) F() {
 	fmt.Printf("called F on *S{%s}\n", s.name)
 }

 func (s *S) String() string {
 	return s.name
 }

 func finalizeInner(a *int) {
 	numSCollected++
 }

 var seq = 0

 func New() *S {
 	s := &S{innerObj: new(int), name: fmt.Sprintf("new%d", seq)}
 	runtime.SetFinalizer(s.innerObj, finalizeInner)
 	return s
 }

 func GC() {
 	runtime.GC()
 	time.Sleep(10 * time.Millisecond)
 	runtime.GC()
 }

 func Add(x, y int) int {
 	return x + y
 }

 func NumSCollected() int {
 	return numSCollected
 }

 func I2Dup(i I2) I2 {
 	return i
 }

 func IDup(i I) I {
 	return i
 }

 func StrDup(s string) string {
 	return s
 }

 func Negate(x bool) bool {
 	return !x
 }

 func Err(s string) error {
 	if s != "" {
 		return errors.New(s)
 	}
 	return nil
 }

 func BytesAppend(a []byte, b []byte) []byte {
 	return append(a, b...)
 }

 func AppendToString(str string, someBytes []byte) []byte {
 	a := []byte(str)
 	fmt.Printf("str=%q (len=%d), someBytes=%v (len=%d)\n", str, len(str), someBytes, len(someBytes))
 	return append(a, someBytes...)
 }

 func UnnamedParams(_, _ int, p0 string) int {
 	return len(p0)
 }

 type Node struct {
 	V    string
 	Next *Node
 	Err  error
 }

 func NewNode(name string) *Node {
 	return &Node{V: name}
 }

 func (a *Node) String() string {
 	if a == nil {
 		return "<end>"
 	}
 	return a.V + ":" + a.Next.String()
 }

 type Receiver interface {
 	Hello(message string)
 }

 func Hello(r Receiver, name string) {
 	r.Hello(fmt.Sprintf("Hello, %s!\n", name))
 }

 func GarbageCollect() {
 	runtime.GC()
 }

 type (
 	Concrete struct{}

 	Interface interface {
 		F()
 	}
 )

 func (_ *Concrete) F() {
 }

 func NewConcrete() *Concrete {
 	return new(Concrete)
 }

 func ReadAsset() string {
 	rc, err := asset.Open("hello.txt")
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer rc.Close()

 	b, err := ioutil.ReadAll(rc)
 	if err != nil {
 		log.Fatal(err)
 	}
 	return string(b)
 }

 type GoCallback interface {
 	VarUpdate()
 }

 func CallWithCallback(gcb GoCallback) {
 	for i := 0; i < 1000; i++ {
 		gcb.VarUpdate()
 	}
 }

 type NullTest interface {
 	Null() NullTest
 }

 func NewNullInterface() I {
 	return nil
 }

 func NewNullStruct() *S {
 	return nil
 }

 func CallWithNull(_null NullTest, nuller NullTest) bool {
 	return _null == nil && nuller.Null() == nil
 }

 type Issue20330 struct{}

 func NewIssue20330() *Issue20330 {
 	return new(Issue20330)
 }

 func (i *Issue20330) CallWithNull(_null *Issue20330) bool {
 	return _null == nil
 }

 type Issue14168 interface {
 	F(seq int32)
 }

 func ReadIntoByteArray(s []byte) (int, error) {
 	if len(s) != cap(s) {
 		return 0, fmt.Errorf("cap %d != len %d", cap(s), len(s))
 	}
 	for i := 0; i < len(s); i++ {
 		s[i] = byte(i)
 	}
 	return len(s), nil
 }

 type B interface {
 	B(b []byte)
 }

 func PassByteArray(b B) {
 	b.B([]byte{1, 2, 3, 4})
 }

 func GoroutineCallback(r Receiver) {
 	done := make(chan struct{})
 	go func() {
 		// Run it multiple times to increase the chance that the goroutine
 		// will use different threads for the call. Use a long argument string to
 		// make sure the JNI calls take more time.
 		for i := 0; i < 100000; i++ {
 			r.Hello("HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello")
 		}
 		close(done)
 	}()
 	<-done
 }

 func Hi() {
 	fmt.Println("Hi")
 }

 func Int(x int32) {
 	fmt.Println("Received int32", x)
 }

 type I2 interface {
 	Times(v int32) int64
 	Error(triggerError bool) error

 	StringError(s string) (string, error)
 }

 type myI2 struct{}

 func (_ *myI2) Times(v int32) int64 {
 	return int64(v) * 10
 }

 func (_ *myI2) Error(e bool) error {
 	if e {
 		return errors.New("some error")
 	}
 	return nil
 }

 func (_ *myI2) StringError(s string) (string, error) {
 	return s, nil
 }

 func CallIError(i I2, triggerError bool) error {
 	return i.Error(triggerError)
 }

 func CallIStringError(i I2, s string) (string, error) {
 	return i.StringError(s)
 }

 func NewI() I2 {
 	return &myI2{}
 }

 var pinnedI = make(map[int32]I2)

 func RegisterI(idx int32, i I2) {
 	pinnedI[idx] = i
 }

 func UnregisterI(idx int32) {
 	delete(pinnedI, idx)
 }

 func Multiply(idx int32, val int32) int64 {
 	i, ok := pinnedI[idx]
 	if !ok {
 		panic(fmt.Sprintf("unknown I2 with index %d", idx))
 	}
 	return i.Times(val)
 }

 func AppendHello(s string) string {
 	return fmt.Sprintf("Hello, %s!", s)
 }

 func ReturnsError(b bool) (string, error) {
 	if b {
 		return "", errors.New("Error")
 	}
 	return "OK", nil
 }

 var collectS2 = make(chan struct{}, 100)

 func finalizeS(a *S2) {
 	collectS2 <- struct{}{}
 }

 func CollectS2(want, timeoutSec int) int {
 	runtime.GC()

 	tick := time.NewTicker(time.Duration(timeoutSec) * time.Second)
 	defer tick.Stop()

 	for i := 0; i < want; i++ {
 		select {
 		case <-collectS2:
 		case <-tick.C:
 			fmt.Println("CollectS: timed out")
 			return i
 		}
 	}
 	return want
 }

 type S2 struct {
 	X, Y       float64
 	unexported bool
 }

 func NewS2(x, y float64) *S2 {
 	s := &S2{X: x, Y: y}
 	runtime.SetFinalizer(s, finalizeS)
 	return s
 }

 func (_ *S2) TryTwoStrings(first, second string) string {
 	return first + second
 }

 func (s *S2) Sum() float64 {
 	return s.X + s.Y
 }

 func CallSSum(s *S2) float64 {
 	return s.Sum()
 }

 // Issue #13033
 type NullFieldStruct struct {
 	F *S
 }

 func NewNullFieldStruct() *NullFieldStruct {
 	return &NullFieldStruct{}
 }

 var (
 	ImportedVarI secondpkg.I  = NewImportedI()
 	ImportedVarS *secondpkg.S = NewImportedS()
 )

 type (
 	ImportedFields struct {
 		I secondpkg.I
 		S *secondpkg.S
 	}

 	ImportedI interface {
 		F(_ secondpkg.I)
 	}

 	AnSer struct{}
 )

 func (_ *AnSer) S(_ *secondpkg.S) {
 }

 func NewImportedFields() *ImportedFields {
 	return &ImportedFields{
 		I: NewImportedI(),
 		S: NewImportedS(),
 	}
 }

 func NewImportedI() secondpkg.I {
 	return NewImportedS()
 }

 func NewImportedS() *secondpkg.S {
 	return new(secondpkg.S)
 }

 func WithImportedI(i secondpkg.I) secondpkg.I {
 	return i
 }

 func WithImportedS(s *secondpkg.S) *secondpkg.S {
 	return s
 }

 func CallImportedI(i secondpkg.I) {
 	i.F(0)
 }

 func NewSer() *AnSer {
 	return nil
 }

 func NewSimpleS() *simplepkg.S {
 	return nil
 }

 func UnboundS(_ *unboundpkg.S) {
 }

 func UnboundI(_ unboundpkg.I) {
 }

 type (
 	InterfaceDupper interface {
 		IDup(i Interface) Interface
 	}

 	ConcreteDupper interface {
 		CDup(c *Concrete) *Concrete
 	}
 )

 func CallIDupper(d InterfaceDupper) bool {
 	var want Interface = new(Concrete)
 	got := d.IDup(want)
 	return got == want
 }

 func CallCDupper(d ConcreteDupper) bool {
 	want := new(Concrete)
 	got := d.CDup(want)
 	return got == want
 }

 type EmptyErrorer interface {
 	EmptyError() error
 }

 func EmptyError() error {
 	return errors.New("")
 }

 func CallEmptyError(c EmptyErrorer) error {
 	return c.EmptyError()
 }

 func Init() {}

 type InitCaller struct{}

 func NewInitCaller() *InitCaller {
 	return new(InitCaller)
 }

 func (ic *InitCaller) Init() {}

 type Issue17073 interface {
 	OnError(err error)
 }

 func ErrorMessage(err error) string {
 	return err.Error()
 }

 var GlobalErr error = errors.New("global err")

 func IsGlobalErr(err error) bool {
 	return GlobalErr == err
 }

 type S3 struct {
 }

 type S4 struct {
 	I int
 }

 func NewS4WithInt(i int) *S4 {
 	return &S4{i}
 }

 func NewS4WithFloat(f float64) *S4 {
 	return &S4{int(f)}
 }

 func NewS4WithBoolAndError(b bool) (*S4, error) {
 	if b {
 		return nil, errors.New("some error")
 	}
 	return new(S4), nil
 }

 // Lifted from TestEPIPE in package os.
 func TestSIGPIPE() {
 	r, w, err := os.Pipe()
 	if err != nil {
 		panic(err)
 	}
 	if err := r.Close(); err != nil {
 		panic(err)
 	}

 	_, err = w.Write([]byte("hi"))
 	if err == nil {
 		panic("unexpected success of Write to broken pipe")
 	}
 	if pe, ok := err.(*os.PathError); ok {
 		err = pe.Err
 	}
 	if se, ok := err.(*os.SyscallError); ok {
 		err = se.Err
 	}
 	if err != syscall.EPIPE {
 		panic(fmt.Errorf("got %v, expected EPIPE", err))
 	}
 }

 // Testpkg is an empty interface with the same name as its package.
 type Testpkg interface{}

 func ClashingParameterFromOtherPackage(_ *secondpkg.Secondpkg) {}

 type MyStruct struct {
 }

 // Test that constructors with incompatible signatures are ignored.
 func NewMyStruct(ctx context.Context) *MyStruct {
 	return nil
 }

 type Int32Constructed struct{}

 // Test that constuctors that clash with the internal proxy constructor
 // are skipped.
 func NewInt32Constructed(i int32) *Int32Constructed {
 	return nil
 }
	// Copyright 2014 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 testpkg contains bound functions for testing the cgo-JNI interface.
	// This is used in tests of golang.org/x/mobile/bind/java.
	package testpkg

	//go:generate gobind -lang=go -outdir=go_testpkg .
	//go:generate gobind -lang=java -outdir=. .
	import (
	"context"
	"errors"
	"fmt"
	"io/ioutil"
	"log"
	"math"
	"os"
	"runtime"
	"syscall"
	"time"

	"golang.org/x/mobile/asset"

	"golang.org/x/mobile/bind/testdata/testpkg/secondpkg"
	"golang.org/x/mobile/bind/testdata/testpkg/simplepkg"
	"golang.org/x/mobile/bind/testdata/testpkg/unboundpkg"
	)

	const (
	AString = "a string"
	AnInt = 7
	ABool = true
	AFloat = 0.12345

	MinInt32 int32 = math.MinInt32
	MaxInt32 int32 = math.MaxInt32
	MinInt64 = math.MinInt64
	MaxInt64 = math.MaxInt64
	SmallestNonzeroFloat64 = math.SmallestNonzeroFloat64
	MaxFloat64 = math.MaxFloat64
	SmallestNonzeroFloat32 float32 = math.SmallestNonzeroFloat64
	MaxFloat32 float32 = math.MaxFloat32
	Log2E = math.Log2E
	)

	var (
	StringVar = "a string var"
	IntVar = 77
	StructVar = &S{name: "a struct var"}
	InterfaceVar I
	InterfaceVar2 I2
	NodeVar = &Node{V: "a struct var"}
	)

	type Nummer interface {
	Num()
	}

	type I interface {
	F()

	E() error
	V() int
	VE() (int, error)
	I() I
	S() *S
	StoString(seq *S) string

	String() string
	}

	func CallF(i I) {
	i.F()
	}

	func CallE(i I) error {
	return i.E()
	}

	func CallV(i I) int {
	return i.V()
	}

	func CallVE(i I) (int, error) {
	return i.VE()
	}

	func CallI(i I) I {
	return i
	}

	func CallS(i I) *S {
	return &S{}
	}

	var keep []I

	func Keep(i I) {
	keep = append(keep, i)
	}

	var numSCollected int

	type S struct {
	// *S already has a finalizer, so we need another object
	// to count successful collections.
	innerObj *int

	name string
	}

	func (s *S) F() {
	fmt.Printf("called F on *S{%s}\n", s.name)
	}

	func (s *S) String() string {
	return s.name
	}

	func finalizeInner(a *int) {
	numSCollected++
	}

	var seq = 0

	func New() *S {
	s := &S{innerObj: new(int), name: fmt.Sprintf("new%d", seq)}
	runtime.SetFinalizer(s.innerObj, finalizeInner)
	return s
	}

	func GC() {
	runtime.GC()
	time.Sleep(10 * time.Millisecond)
	runtime.GC()
	}

	func Add(x, y int) int {
	return x + y
	}

	func NumSCollected() int {
	return numSCollected
	}

	func I2Dup(i I2) I2 {
	return i
	}

	func IDup(i I) I {
	return i
	}

	func StrDup(s string) string {
	return s
	}

	func Negate(x bool) bool {
	return !x
	}

	func Err(s string) error {
	if s != "" {
	return errors.New(s)
	}
	return nil
	}

	func BytesAppend(a []byte, b []byte) []byte {
	return append(a, b...)
	}

	func AppendToString(str string, someBytes []byte) []byte {
	a := []byte(str)
	fmt.Printf("str=%q (len=%d), someBytes=%v (len=%d)\n", str, len(str), someBytes, len(someBytes))
	return append(a, someBytes...)
	}

	func UnnamedParams(_, _ int, p0 string) int {
	return len(p0)
	}

	type Node struct {
	V string
	Next *Node
	Err error
	}

	func NewNode(name string) *Node {
	return &Node{V: name}
	}

	func (a *Node) String() string {
	if a == nil {
	return "<end>"
	}
	return a.V + ":" + a.Next.String()
	}

	type Receiver interface {
	Hello(message string)
	}

	func Hello(r Receiver, name string) {
	r.Hello(fmt.Sprintf("Hello, %s!\n", name))
	}

	func GarbageCollect() {
	runtime.GC()
	}

	type (
	Concrete struct{}

	Interface interface {
	F()
	}
	)

	func (_ *Concrete) F() {
	}

	func NewConcrete() *Concrete {
	return new(Concrete)
	}

	func ReadAsset() string {
	rc, err := asset.Open("hello.txt")
	if err != nil {
	log.Fatal(err)
	}
	defer rc.Close()

	b, err := ioutil.ReadAll(rc)
	if err != nil {
	log.Fatal(err)
	}
	return string(b)
	}

	type GoCallback interface {
	VarUpdate()
	}

	func CallWithCallback(gcb GoCallback) {
	for i := 0; i < 1000; i++ {
	gcb.VarUpdate()
	}
	}

	type NullTest interface {
	Null() NullTest
	}

	func NewNullInterface() I {
	return nil
	}

	func NewNullStruct() *S {
	return nil
	}

	func CallWithNull(_null NullTest, nuller NullTest) bool {
	return _null == nil && nuller.Null() == nil
	}

	type Issue20330 struct{}

	func NewIssue20330() *Issue20330 {
	return new(Issue20330)
	}

	func (i Issue20330) CallWithNull(_null Issue20330) bool {
	return _null == nil
	}

	type Issue14168 interface {
	F(seq int32)
	}

	func ReadIntoByteArray(s []byte) (int, error) {
	if len(s) != cap(s) {
	return 0, fmt.Errorf("cap %d != len %d", cap(s), len(s))
	}
	for i := 0; i < len(s); i++ {
	s[i] = byte(i)
	}
	return len(s), nil
	}

	type B interface {
	B(b []byte)
	}

	func PassByteArray(b B) {
	b.B([]byte{1, 2, 3, 4})
	}

	func GoroutineCallback(r Receiver) {
	done := make(chan struct{})
	go func() {
	// Run it multiple times to increase the chance that the goroutine
	// will use different threads for the call. Use a long argument string to
	// make sure the JNI calls take more time.
	for i := 0; i < 100000; i++ {
	r.Hello("HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello")
	}
	close(done)
	}()
	<-done
	}

	func Hi() {
	fmt.Println("Hi")
	}

	func Int(x int32) {
	fmt.Println("Received int32", x)
	}

	type I2 interface {
	Times(v int32) int64
	Error(triggerError bool) error

	StringError(s string) (string, error)
	}

	type myI2 struct{}

	func (_ *myI2) Times(v int32) int64 {
	return int64(v) * 10
	}

	func (_ *myI2) Error(e bool) error {
	if e {
	return errors.New("some error")
	}
	return nil
	}

	func (_ *myI2) StringError(s string) (string, error) {
	return s, nil
	}

	func CallIError(i I2, triggerError bool) error {
	return i.Error(triggerError)
	}

	func CallIStringError(i I2, s string) (string, error) {
	return i.StringError(s)
	}

	func NewI() I2 {
	return &myI2{}
	}

	var pinnedI = make(map[int32]I2)

	func RegisterI(idx int32, i I2) {
	pinnedI[idx] = i
	}

	func UnregisterI(idx int32) {
	delete(pinnedI, idx)
	}

	func Multiply(idx int32, val int32) int64 {
	i, ok := pinnedI[idx]
	if !ok {
	panic(fmt.Sprintf("unknown I2 with index %d", idx))
	}
	return i.Times(val)
	}

	func AppendHello(s string) string {
	return fmt.Sprintf("Hello, %s!", s)
	}

	func ReturnsError(b bool) (string, error) {
	if b {
	return "", errors.New("Error")
	}
	return "OK", nil
	}

	var collectS2 = make(chan struct{}, 100)

	func finalizeS(a *S2) {
	collectS2 <- struct{}{}
	}

	func CollectS2(want, timeoutSec int) int {
	runtime.GC()

	tick := time.NewTicker(time.Duration(timeoutSec) * time.Second)
	defer tick.Stop()

	for i := 0; i < want; i++ {
	select {
	case <-collectS2:
	case <-tick.C:
	fmt.Println("CollectS: timed out")
	return i
	}
	}
	return want
	}

	type S2 struct {
	X, Y float64
	unexported bool
	}

	func NewS2(x, y float64) *S2 {
	s := &S2{X: x, Y: y}
	runtime.SetFinalizer(s, finalizeS)
	return s
	}

	func (_ *S2) TryTwoStrings(first, second string) string {
	return first + second
	}

	func (s *S2) Sum() float64 {
	return s.X + s.Y
	}

	func CallSSum(s *S2) float64 {
	return s.Sum()
	}

	// Issue #13033
	type NullFieldStruct struct {
	F *S
	}

	func NewNullFieldStruct() *NullFieldStruct {
	return &NullFieldStruct{}
	}

	var (
	ImportedVarI secondpkg.I = NewImportedI()
	ImportedVarS *secondpkg.S = NewImportedS()
	)

	type (
	ImportedFields struct {
	I secondpkg.I
	S *secondpkg.S
	}

	ImportedI interface {
	F(_ secondpkg.I)
	}

	AnSer struct{}
	)

	func (_ AnSer) S(_ secondpkg.S) {
	}

	func NewImportedFields() *ImportedFields {
	return &ImportedFields{
	I: NewImportedI(),
	S: NewImportedS(),
	}
	}

	func NewImportedI() secondpkg.I {
	return NewImportedS()
	}

	func NewImportedS() *secondpkg.S {
	return new(secondpkg.S)
	}

	func WithImportedI(i secondpkg.I) secondpkg.I {
	return i
	}

	func WithImportedS(s secondpkg.S) secondpkg.S {
	return s
	}

	func CallImportedI(i secondpkg.I) {
	i.F(0)
	}

	func NewSer() *AnSer {
	return nil
	}

	func NewSimpleS() *simplepkg.S {
	return nil
	}

	func UnboundS(_ *unboundpkg.S) {
	}

	func UnboundI(_ unboundpkg.I) {
	}

	type (
	InterfaceDupper interface {
	IDup(i Interface) Interface
	}

	ConcreteDupper interface {
	CDup(c Concrete) Concrete
	}
	)

	func CallIDupper(d InterfaceDupper) bool {
	var want Interface = new(Concrete)
	got := d.IDup(want)
	return got == want
	}

	func CallCDupper(d ConcreteDupper) bool {
	want := new(Concrete)
	got := d.CDup(want)
	return got == want
	}

	type EmptyErrorer interface {
	EmptyError() error
	}

	func EmptyError() error {
	return errors.New("")
	}

	func CallEmptyError(c EmptyErrorer) error {
	return c.EmptyError()
	}

	func Init() {}

	type InitCaller struct{}

	func NewInitCaller() *InitCaller {
	return new(InitCaller)
	}

	func (ic *InitCaller) Init() {}

	type Issue17073 interface {
	OnError(err error)
	}

	func ErrorMessage(err error) string {
	return err.Error()
	}

	var GlobalErr error = errors.New("global err")

	func IsGlobalErr(err error) bool {
	return GlobalErr == err
	}

	type S3 struct {
	}

	type S4 struct {
	I int
	}

	func NewS4WithInt(i int) *S4 {
	return &S4{i}
	}

	func NewS4WithFloat(f float64) *S4 {
	return &S4{int(f)}
	}

	func NewS4WithBoolAndError(b bool) (*S4, error) {
	if b {
	return nil, errors.New("some error")
	}
	return new(S4), nil
	}

	// Lifted from TestEPIPE in package os.
	func TestSIGPIPE() {
	r, w, err := os.Pipe()
	if err != nil {
	panic(err)
	}
	if err := r.Close(); err != nil {
	panic(err)
	}

	_, err = w.Write([]byte("hi"))
	if err == nil {
	panic("unexpected success of Write to broken pipe")
	}
	if pe, ok := err.(*os.PathError); ok {
	err = pe.Err
	}
	if se, ok := err.(*os.SyscallError); ok {
	err = se.Err
	}
	if err != syscall.EPIPE {
	panic(fmt.Errorf("got %v, expected EPIPE", err))
	}
	}

	// Testpkg is an empty interface with the same name as its package.
	type Testpkg interface{}

	func ClashingParameterFromOtherPackage(_ *secondpkg.Secondpkg) {}

	type MyStruct struct {
	}

	// Test that constructors with incompatible signatures are ignored.
	func NewMyStruct(ctx context.Context) *MyStruct {
	return nil
	}

	type Int32Constructed struct{}

	// Test that constuctors that clash with the internal proxy constructor
	// are skipped.
	func NewInt32Constructed(i int32) *Int32Constructed {
	return nil
	}