gotTotal, gotErr := validateIndexesFormat(tc.indexesString, tc.completions)
			if tc.wantError == nil && gotErr != nil {
				t.Errorf("unexpected error: %s", gotErr)
			} else if tc.wantError != nil && gotErr == nil {
				t.Errorf("missing error: %s", tc.wantError)
			} else if tc.wantError != nil && gotErr != nil {
				if diff := cmp.Diff(tc.wantError.Error(), gotErr.Error()); diff != "" {

			_, clusterCIDR, _ := netutils.ParseCIDRSloppy(tc.clusterCIDRStr)
			a, err := NewCIDRSet(clusterCIDR, tc.subNetMaskSize)
			if gotErr := err != nil; gotErr != tc.expectErr {
				t.Fatalf("NewCIDRSet(%v, %v) = %v, %v; gotErr = %t, want %t", clusterCIDR, tc.subNetMaskSize, a, err, gotErr, tc.expectErr)
			}
			if a == nil {
				return
			}
			p, err := a.AllocateNext()
			if err == nil && tc.expectErr {

type Winsize struct {
	Row    uint16
	Col    uint16
	Xpixel uint16
	Ypixel uint16
}

type PollFd struct {
	Fd      int32
	Events  uint16
	Revents uint16
}

const (
	POLLERR    = 0x4000
	POLLHUP    = 0x2000
	POLLIN     = 0x1
	POLLNVAL   = 0x8000
	POLLOUT    = 0x2
	POLLPRI    = 0x4
	POLLRDBAND = 0x20
	POLLRDNORM = 0x10
	POLLWRBAND = 0x40
	POLLWRNORM = 0x2
)

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			args := &PilotArgs{JwtRule: tt.jwtRule}

			_, err := initOIDC(args, nil)
			gotErr := err != nil
			if gotErr != tt.expectErr {
				t.Errorf("expect error is %v while actual error is %v", tt.expectErr, gotErr)
			}
		})
	}
}

func TestWatchDNSCertForK8sCA(t *testing.T) {
	tests := []struct {
		name        string
		certToWatch []byte

	AT_SYMLINK_NOFOLLOW = 0x2
	AT_SYMLINK_FOLLOW   = 0x4
	AT_REMOVEDIR        = 0x8
)

type PollFd struct {
	Fd      int32
	Events  int16
	Revents int16
}

const (
	POLLERR    = 0x8
	POLLHUP    = 0x10
	POLLIN     = 0x1
	POLLNVAL   = 0x20
	POLLOUT    = 0x4
	POLLPRI    = 0x2
	POLLRDBAND = 0x80
	POLLRDNORM = 0x40
	POLLWRBAND = 0x100
	POLLWRNORM = 0x4
)

	if celErr, ok := err.(*cel.Error); ok {
		switch celErr.Type {
		case cel.ErrorTypeRequired:
			return field.Required(fldPath, celErr.Detail)
		case cel.ErrorTypeInvalid:
			return field.Invalid(fldPath, expression.GetExpression(), celErr.Detail)
		case cel.ErrorTypeInternal:
			return field.InternalError(fldPath, celErr)
		}
	}

	NEGL	AX
	MOVL	AX, ret+24(FP)
	RET

// func fcntl(fd, cmd, arg int32) (int32, int32)
TEXT runtime·fcntl(SB),NOSPLIT,$-4
	MOVL	$SYS_fcntl, AX
	INT	$0x80
	JAE	noerr
	MOVL	$-1, ret+12(FP)
	MOVL	AX, errno+16(FP)
	RET
noerr:
	MOVL	AX, ret+12(FP)
	MOVL	$0, errno+16(FP)
	RET

// func issetugid() int32
TEXT runtime·issetugid(SB),NOSPLIT,$0
	MOVL	$SYS_issetugid, AX
	INT	$0x80

TEXT runtime·fcntl(SB),NOSPLIT,$0
	MOVW	fd+0(FP), R0	// fd
	MOVW	cmd+4(FP), R1	// cmd
	MOVW	arg+8(FP), R2	// arg
	SVC	$SYS_fcntl
	BCC	noerr
	MOVW	$-1, R1
	MOVW	R1, ret+16(FP)
	MOVW	R0, errno+20(FP)
	RET
noerr:
	MOVW	R0, ret+16(FP)
	MOVW	$0, errno+20(FP)
	RET

// func issetugid() int32
TEXT runtime·issetugid(SB),NOSPLIT|NOFRAME,$0
	SVC $SYS_issetugid

}

type Winsize struct {
	Row    uint16
	Col    uint16
	Xpixel uint16
	Ypixel uint16
}

type PollFd struct {
	Fd      int32
	Events  int16
	Revents int16
}

const (
	POLLERR    = 0x8
	POLLHUP    = 0x10
	POLLIN     = 0x1
	POLLNVAL   = 0x20
	POLLOUT    = 0x4
	POLLPRI    = 0x2
	POLLRDBAND = 0x80
	POLLRDNORM = 0x40
	POLLWRBAND = 0x100
	POLLWRNORM = 0x4
)

	AT_REMOVEDIR        = 0x2
	AT_EACCESS          = 0x4
	AT_SYMLINK_FOLLOW   = 0x8
)

type PollFd struct {
	Fd      int32
	Events  int16
	Revents int16
}

const (
	POLLERR    = 0x8
	POLLHUP    = 0x10
	POLLIN     = 0x1
	POLLNVAL   = 0x20
	POLLOUT    = 0x4
	POLLPRI    = 0x2
	POLLRDBAND = 0x80
	POLLRDNORM = 0x40
	POLLWRBAND = 0x100
	POLLWRNORM = 0x4
)