})
		_, err := nodeC.Update(context.TODO(), &node, metav1.UpdateOptions{})
		if err != nil {
			return err
		}
	}

	return nil
}

// Untaint nodes if the test failed, so we restore the cluster to a usable state.
func untaintNodes(t resource.Context) {
	nodeC := t.Clusters().Default().
		Kube().CoreV1().Nodes()
	nodes, err := nodeC.List(context.TODO(), metav1.ListOptions{})
	if err != nil {

	MOVD	FARG, CTR		// address of function to be called
	MOVD	R0, 0(R1)		// clear back chain pointer
	BL	(CTR)
	MOVD	$0, R0			// C code can clobber R0 set it back to 0
	MOVD	R16, R1			// restore R1;
	MOVD	runtime·tls_g(SB), R10	// find correct g
	MOVD	0(R10), g
	RET

// tls_g, g value for each thread in TLS

        when:
        def snapshot = configurer.snapshot()
        configurer.setLevel(LogLevel.DEBUG)
        configurer.startCapture()
        Logger.getLogger('test').info('info message')
        configurer.restore(snapshot)
        Logger.getLogger('test').info('ignore me')

        then:
        outputEventListener.toString() == '[[INFO] [test] info message]'
    }

            when (psi) {
                is KtDeclaration -> psi.getSymbol()
                is KtFile -> psi.getFileSymbol()
                else -> {
                    error("Unexpected declaration to restore: ${psi::class}, text:\n ${psi.text}")
                }
            }
        }

        if (!expectedClass.isInstance(symbol)) return null

        @Suppress("UNCHECKED_CAST")
        return symbol as S
    }

	return c
}

func (mr *mockRand) bool() bool {
	b := mr.b
	mr.b = !mr.b
	return b
}

func (mr *mockRand) save(*uint64, *uint64) {
	panic("unimplemented")
}

func (mr *mockRand) restore(uint64, uint64) {
	panic("unimplemented")
}

func TestByteSliceMutators(t *testing.T) {
	for _, tc := range []struct {
		name     string
		mutator  func(*mutator, []byte) []byte
		randVals []int

	std	2, 40(1)	// Save TOC in caller's frame
	bl	saveregs
	stdu	1, -296(1)

	// Set up Go ABI constant registers
	// Must match _cgo_reginit in runtime package.
	xor 0, 0, 0

	// Restore g pointer (r30 in Go ABI, which may have been clobbered by C)
	mr	30, 4

	// Call fn
	mr	12, 3
	mtctr	12
	bctrl

	addi	1, 1, 296
	bl	restoreregs
	ld	2, 40(1)
	ld	0, 16(1)
	mtlr	0
	blr

	l := &locker{}
	defer func(l *locker) {
		// Clean up immediately on failure
		if !success {
			l.Close()
		}
	}(l)

	// Grab both 1.6.x and 1.4.x-style locks; we don't know what the
	// iptables-restore version is if it doesn't support --wait, so we
	// can't assume which lock method it'll use.

	// Roughly duplicate iptables 1.6.x xtables_lock() function.
	l.lock16, err = os.OpenFile(lockfilePath16x, os.O_CREATE, 0600)

iptables -t mangle -A OUTPUT ! -d 127.0.0.1/32 -p tcp -o lo -m owner --gid-owner 1337 -j MARK --set-mark 1338
iptables -t mangle -A OUTPUT -p tcp -m connmark --mark 1337 -j CONNMARK --restore-mark
iptables -t mangle -I ISTIO_INBOUND 1 -p tcp -m mark --mark 1337 -j RETURN
iptables -t mangle -I ISTIO_INBOUND 2 -p tcp -s 127.0.0.6/32 -i lo -j RETURN

        distribution: 'temurin'
    - name: Cache Maven packages
      uses: actions/cache@v2
      with:
        path: ~/.m2
        key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
        restore-keys: ${{ runner.os }}-m2
    - name: Build with Maven
      run: mvn -B package --file pom.xml

    - name: Perform CodeQL Analysis

    shortNames:
      - vs
    singular: volumesnapshot
  scope: Namespaced
  versions:
    - additionalPrinterColumns:
        - description: Indicates if the snapshot is ready to be used to restore a volume.
          jsonPath: .status.readyToUse
          name: ReadyToUse
          type: boolean
        - description: If a new snapshot needs to be created, this contains the name of