}

		if len(input) != 0 && unsafe.StringData(clone) == unsafe.StringData(input) {
			t.Errorf("Clone(%q) return value should not reference inputs backing memory.", input)
		}

		if len(input) == 0 && unsafe.StringData(clone) != unsafe.StringData(emptyString) {
			t.Errorf("Clone(%#v) return value should be equal to empty string.", unsafe.StringData(input))
		}
	}
}

func BenchmarkClone(b *testing.B) {

		if z := min(x[i], x[j], x[k]); unsafe.StringData(z) != unsafe.StringData(x[i]) {
			t.Errorf("min(x[%v], x[%v], x[%v]) = %p, want %p", i, j, k, unsafe.StringData(z), unsafe.StringData(x[i]))
		}
		if z := max(x[i], x[j], x[k]); unsafe.StringData(z) != unsafe.StringData(x[i]) {
			t.Errorf("max(x[%v], x[%v], x[%v]) = %p, want %p", i, j, k, unsafe.StringData(z), unsafe.StringData(x[i]))
		}
	}

	test(0, 1, 2)

import (
	"fmt"
	"reflect"
	"unsafe"
)

func main() {
	var s = "abc"
	sh1 := (*reflect.StringHeader)(unsafe.Pointer(&s))
	ptr2 := unsafe.Pointer(unsafe.StringData(s))
	if ptr2 != unsafe.Pointer(sh1.Data) {
		panic(fmt.Errorf("unsafe.StringData ret %p != %p", ptr2, unsafe.Pointer(sh1.Data)))
	}

		last := (*byte)(unsafe.Pointer(^uintptr(0)))
		_ = unsafe.String(last, 1)
		mustPanic(func() { _ = unsafe.String(last, 2) })
	}

	// unsafe.StringData
	{
		var s = "string"
		assert(string(unsafe.Slice(unsafe.StringData(s), len(s))) == s)
	}

	//unsafe.SliceData
	{
		var s = []byte("slice")
		assert(unsafe.String(unsafe.SliceData(s), len(s)) == string(s))
	}
}

	data, err := saferio.ReadData(r, sLen+dLen)
	if err != nil {
		errorf("cannot read %d bytes of stringData and declData: %s", sLen+dLen, err)
	}
	stringData := data[:sLen]
	declData := data[sLen:]

	p := iimporter{
		exportVersion: version,
		ipath:         path,
		version:       int(version),

		stringData:  stringData,
		stringCache: make(map[uint64]string),
		pkgCache:    make(map[uint64]*types.Package),

	asCopy := UserArenaClone(as)
	if unsafe.StringData(as) == unsafe.StringData(asCopy) {
		t.Error("Clone did not make a copy")
	}

	// Clone should make a copy of subAs, since subAs is just part of as and so is in the arena.
	subAs := as[1:3]
	subAsCopy := UserArenaClone(subAs)
	if unsafe.StringData(subAs) == unsafe.StringData(subAsCopy) {
		t.Error("Clone did not make a copy")
	}

        "fieldsType": "fieldsTypeValue",
        "fieldsV1": {},
        "subresource": "subresourceValue"
      }
    ]
  },
  "immutable": true,
  "data": {
    "dataKey": "Ag=="
  },
  "stringData": {
    "stringDataKey": "stringDataValue"
  },
  "type": "typeValue"

    blockOwnerDeletion: true
    controller: true
    kind: kindValue
    name: nameValue
    uid: uidValue
  resourceVersion: resourceVersionValue
  selfLink: selfLinkValue
  uid: uidValue
stringData:
  stringDataKey: stringDataValue

    blockOwnerDeletion: true
    controller: true
    kind: kindValue
    name: nameValue
    uid: uidValue
  resourceVersion: resourceVersionValue
  selfLink: selfLinkValue
  uid: uidValue
stringData:
  stringDataKey: stringDataValue

	b.Run("lenruneslice", func(b *testing.B) {
		for _, sd := range stringdata {
			b.Run(sd.name, func(b *testing.B) {
				for i := 0; i < b.N; i++ {
					sinkInt += len([]rune(sd.data))
				}
			})
		}
	})
	b.Run("rangeloop", func(b *testing.B) {
		for _, sd := range stringdata {
			b.Run(sd.name, func(b *testing.B) {
				for i := 0; i < b.N; i++ {
					n := 0