for i, v := range src {
		dest[i] = v
	}
	return len(src)
}

func copyU16(val uint16, dest []uint16) int {
	if len(dest) < 1 {
		return 0
	}
	dest[0] = val
	return 1
}

func copyU32(val uint32, dest []uint32) int {
	if len(dest) < 1 {
		return 0
	}
	dest[0] = val
	return 1
}

func copyU32Arr(src, dest []uint32) int {
	if len(dest) < len(src) {
		return 0
	}

  // CHECK-DAG: %[[COPY2:.*]] = "tf.TPUCopyWithLayout"(%[[ITER1]]#0, %[[LAYOUT0]]) {device = "/device:TPU:1"}
  // CHECK-DAG: %[[COPY3:.*]] = "tf.TPUCopyWithLayout"(%[[ITER1]]#1, %[[LAYOUT1]]) {device = "/device:TPU:1"}
  // CHECK: tf_device.replicate([%[[COPY0]], %[[COPY2]]] as %[[R0:.*]]: tensor<3x3x1x32xf32>, [%[[COPY1]], %[[COPY3]]] as %[[R1:.*]]: tensor<3x3x1x32xf32>)

        def original2 = ["123"] as String[]
        def isolated2 = isolatableFactory.isolate(original2)
        isolated2 instanceof IsolatedArray
        def copy2 = isolated2.isolate()
        copy2 == ["123"] as String[]
        copy2.class == String[].class
        !copy2.is(original2)
    }

    def "creates isolated list"() {
        expect:
        def original1 = []

        def copy1 = storeAndLoad(block1)
        def copy2 = storeAndLoad(block2)

        read(copy2) == "test 2"
        read(copy1) == "test 1"
    }

    def "can persist block address and read block later"() {
        expect:
        def block1 = write("test 1")
        def block2 = write("test 2")

        def copy1 = storeAndLoad(block1)
        def copy2 = storeAndLoad(block2)

        def dest = store()

                from file('source1')
                into file('target')
            }

            task copy2(type: Copy) {
                from file('source2')
                into file('target')
            }

            task copyAll {
                dependsOn copy1, copy2
            }
        """

        when:
        result = runWithMostRecentFinalRelease(taskPath)

        then:

        "TaskProvider"                   | "copy1"                | "[copy1]"
        "Array[Task, TaskProvider]"      | "copy1.get(), copy2"   | "[copy1, copy2]"
        "Collection(Task, TaskProvider)" | "[copy1.get(), copy2]" | "[copy1, copy2]"
    }

    def "using a tasks from another project as 'files(#type)' input is prohibited"() {
        settingsFile << """
            include ':foo'
        """

        state2.length == 2
        state2[0] == "name"
        state2[1] == [12] as Set

        def copy2 = managedFactoryRegistry.lookup(bean.getFactoryId()).fromState(InterfaceBean, state2)
        !copy2.is(bean)
        copy2.name == "name"
        copy2.numbers == [12] as Set
    }

    def canConstructInstanceOfInterfaceWithPrimitivePropertyGetterAndSetter() {

	CMP	$8, R2
	BLT	copy7
	MOVD	(R1), R6
	MOVD	-8(R4), R7
	MOVD	R6, (R0)
	MOVD	R7, -8(R5)
	RET

copy7:
	TBZ	$2, R2, copy3
	MOVWU	(R1), R6
	MOVWU	-4(R4), R7
	MOVW	R6, (R0)
	MOVW	R7, -4(R5)
	RET

copy3:
	TBZ	$1, R2, copy1
	MOVHU	(R1), R6
	MOVHU	-2(R4), R7
	MOVH	R6, (R0)
	MOVH	R7, -2(R5)
	RET

copy1:
	MOVBU	(R1), R6
	MOVB	R6, (R0)

copy0:

        # Construct the destination assets file path.
        curr_dst_dir = curr_dir.replace(src_assets_path, dst_assets_path)
        dst_asset_file = file_io.join(curr_dst_dir, asset_file_name)

        file_io.copy_v2(src_asset_file, dst_asset_file)
        logging.info(
            'Copied asset file: %s -> %s', src_asset_file, dst_asset_file
        )


def _validate_representative_dataset(

        copy.getOrNull() == null

        def state2 = property.unpackState()
        def copy2 = managedFactory().fromState(property.publicType(), state2)
        !copy2.is(property)
        copy2.get() == someValue()

        property.set(someOtherValue())
        copy.getOrNull() == null
        copy2.get() == someValue()
    }