<mxGeometry x="-60" y="-540" width="330" height="260" as="geometry"/>
                </mxCell>
                <mxCell id="6" value="" style="rounded=0;whiteSpace=wrap;html=1;fontStyle=1;strokeWidth=4;fillColor=#dae8fc;strokeColor=#6c8ebf;" parent="1" vertex="1">

//go:build ppc64 || ppc64le

package cpu

// ppc64 doesn't have a 'cpuid' equivalent, so we rely on HWCAP/HWCAP2.
// These are initialized by archauxv and should not be changed after they are
// initialized.
var HWCap uint
var HWCap2 uint

// HWCAP bits. These are exposed by Linux.
const (
	// ISA Level
	hwcap2_ARCH_2_07 = 0x80000000
	hwcap2_ARCH_3_00 = 0x00800000

package cpu

const (
	// bit mask values from /usr/include/bits/hwcap.h
	hwcap_ZARCH  = 2
	hwcap_STFLE  = 4
	hwcap_MSA    = 8
	hwcap_LDISP  = 16
	hwcap_EIMM   = 32
	hwcap_DFP    = 64
	hwcap_ETF3EH = 256
	hwcap_VX     = 2048
	hwcap_VXE    = 8192
)

func initS390Xbase() {
	// test HWCAP bit vector
	has := func(featureMask uint) bool {
		return hwCap&featureMask == featureMask
	}

	// mandatory

	OAND:              "&",
	OAPPEND:           "append",
	OAS:               "=",
	OAS2:              "=",
	OBREAK:            "break",
	OCALL:             "function call", // not actual syntax
	OCAP:              "cap",
	OCASE:             "case",
	OCLEAR:            "clear",
	OCLOSE:            "close",
	OCOMPLEX:          "complex",
	OBITNOT:           "^",
	OCONTINUE:         "continue",
	OCOPY:             "copy",

	_HWCAP_VX = 1 << 11 // vector facility
)

func archauxv(tag, val uintptr) {
	switch tag {
	case _AT_HWCAP:
		cpu.HWCap = uint(val)
	}
}

func osArchInit() {}

func checkS390xCPU() {
	// Check if the present z-system has the hardware capability to carryout
	// floating point operations. Check if hwcap reflects CPU capability for the
	// necessary floating point hardware (HasVX) availability.

        def file = file('foo') << contents
        def delegate = Mock(LineEndingNormalizingFileSystemLocationSnapshotHasher)
        def hasher = LineEndingNormalizingFileSystemLocationSnapshotHasher.wrap(delegate, LineEndingSensitivity.NORMALIZE_LINE_ENDINGS)

        when:
        hasher.hash(snapshot(file))

        then:
        0 * delegate._

        where:
        description               | contents

		return errors.Wrap(err, "error updating or creating token")
	}
	// Create RBAC rules that makes the bootstrap tokens able to get nodes
	if err := nodebootstraptokenphase.AllowBoostrapTokensToGetNodes(client); err != nil {
		return errors.Wrap(err, "error allowing bootstrap tokens to get Nodes")
	}

package org.gradle.internal.io


import static org.gradle.internal.io.IoSupplier.wrap

class IoSupplierTest extends AbstractIoTest {

    def "executed when it doesn't throw"() {
        expect:
        wrap({ "lajos" }).get() == "lajos"
    }

    @Override
    protected void executeWithException(Throwable exception) {
        wrap({ throw exception }).get()
    }

import static org.gradle.internal.io.IoFunction.wrap

class IoFunctionTest extends AbstractIoTest {

    def "executed when it doesn't throw"() {
        expect:
        wrap({ String t -> "wrapped:$t" }).apply("lajos") == "wrapped:lajos"
    }

    @Override
    protected void executeWithException(Throwable exception) {
        wrap({ String t ->
            assert t == "lajos"
            throw exception

    %0 = tf_executor.island {
      tf_executor.yield
    }
    tf_executor.fetch
  }
  func.return
}

// CHECK: functions must be of a single Graph with single op Islands: tf_executor.island must perfectly wrap a single op

// -----

func.func @main() {
  tf_executor.graph {
    %0 = tf_executor.island {
      %1 = "tf.Const"() {value = dense<1> : tensor<i32>} : () -> tensor<i32>