}

]]

// 6.1.3.3 Tuple helper classes.

template <typename Tuple> struct tuple_size;


$for j [[
template <GTEST_$(j)_TYPENAMES_(T)>
struct tuple_size<GTEST_$(j)_TUPLE_(T) > {
  static const int value = $j;
};


]]
template <int k, class Tuple>
struct tuple_element {
  typedef typename gtest_internal::TupleElement<

package lookup

import "math/big" // provides big.Float struct with unexported fields and methods

func _() {
	var s struct {
		x, aBc int
	}
	_ = s.x
	_ = s /* ERROR "invalid operation: cannot call non-function s.x (variable of type int)" */ .x()
	_ = s.X // ERROR "s.X undefined (type struct{x int; aBc int} has no field or method X, but does have field x)"

			}
		})
	}
}

type reclosableChannel struct {
	c      chan struct{}
	closed bool
}

func newReclosableChannel() *reclosableChannel {
	return &reclosableChannel{
		c: make(chan struct{}),
	}
}

func (c *reclosableChannel) Close() {
	if !c.closed {
		c.closed = true
		close(c.c)
	}
}

type fakeComponent struct {
	started   *atomic.Bool
	completed *atomic.Bool

type doNothingQuotaConfiguration struct{}

func (doNothingQuotaConfiguration) IgnoredResources() map[schema.GroupResource]struct{} { return nil }

func (doNothingQuotaConfiguration) Evaluators() []quota.Evaluator { return nil }

type WantsQuotaConfigurationAdmissionPlugin struct {
	doNothingAdmission
	doNothingPluginInitialization
	config quota.Configuration
}

type BootstrapToken struct {
	metav1.TypeMeta

	bootstraptokenv1.BootstrapToken
}

// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

// Images represents information for the output produced by 'kubeadm config images list'
type Images struct {
	metav1.TypeMeta

	Images []string
}

	{"type t[P any] struct{f P}", "t", "type p.t[P any] struct{f P}", false},
	{"type t[P any] struct{f P}", "t.P", "type parameter P any", false},
	{"type C interface{m()}; type t[P C] struct{}", "t.P", "type parameter P p.C", false},

	{"type t = struct{f int}", "t", "type p.t = struct{f int}", false},
	{"type t = func(int)", "t", "type p.t = func(int)", false},
	{"type A = B; type B = int", "A", "type p.A = p.B", true},

// Verify that follow-on errors due to conflicting
// struct field and method names are suppressed.

package p

type T struct {
	a, b, c int
	E
}

type E struct{}

func (T) b()  {} // ERROR "field and method named b|redeclares struct field name|field and method with the same name b"
func (*T) E() {} // ERROR "field and method named E|redeclares struct field name|field and method with the same name E"

func _() {

		// is the same as unsafe.Alignof(x[0]), but at least 1."
		return s.Alignof(t.elem)
	case *Struct:
		if len(t.fields) == 0 && _IsSyncAtomicAlign64(T) {
			// Special case: sync/atomic.align64 is an
			// empty struct we recognize as a signal that
			// the struct it contains must be
			// 64-bit-aligned.
			//
			// This logic is equivalent to the logic in

var _ = http.Server{DoneChan: nil}  // ERROR "unknown field DoneChan in struct literal of type http.Server$|unknown field .?DoneChan.? in .?http.Server"

type foo struct {
	bar int
}

				t.Errorf("ParseIPsSplitToV4V6() got %v %v, want %v %v", ipv4, ipv6, tt.ipv4(), tt.ipv6())
			}
		})
	}
}

func TestIsValidIPAddress(t *testing.T) {
	type args struct {
		ip string
	}
	tests := []struct {
		name string
		args args
		want bool
	}{
		{
			name: "test is a valid ipv4 address",
			args: args{
				ip: "10.10.1.1",
			},
			want: true,
		},
		{