array_test.go

/*
 * Atree - Scalable Arrays and Ordered Maps
 *
 * Copyright Flow Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package atree_test

import (
	"errors"
	"math"
	"math/rand"
	"reflect"
	"runtime"
	"slices"
	"strings"
	"testing"

	"github.com/stretchr/testify/require"

	"github.com/onflow/atree"
	"github.com/onflow/atree/test_utils"
)

func testEmptyArrayV0(
	t *testing.T,
	storage *atree.PersistentSlabStorage,
	typeInfo atree.TypeInfo,
	address atree.Address,
	array *atree.Array,
) {
	testArrayV0(t, storage, typeInfo, address, array, nil, false)
}

func testEmptyArray(
	t *testing.T,
	storage *atree.PersistentSlabStorage,
	typeInfo atree.TypeInfo,
	address atree.Address,
	array *atree.Array,
) {
	testArray(t, storage, typeInfo, address, array, nil, false)
}

func testArrayV0(
	t *testing.T,
	storage *atree.PersistentSlabStorage,
	typeInfo atree.TypeInfo,
	address atree.Address,
	array *atree.Array,
	expectedValues test_utils.ExpectedArrayValue,
	hasNestedArrayMapElement bool,
) {
	_testArray(t, storage, typeInfo, address, array, expectedValues, hasNestedArrayMapElement, false)
}

func testArray(
	t *testing.T,
	storage *atree.PersistentSlabStorage,
	typeInfo atree.TypeInfo,
	address atree.Address,
	array *atree.Array,
	expectedValues test_utils.ExpectedArrayValue,
	hasNestedArrayMapElement bool,
) {
	_testArray(t, storage, typeInfo, address, array, expectedValues, hasNestedArrayMapElement, true)
}

// _testArray tests array elements, serialization, and in-memory slab tree.
func _testArray(
	t *testing.T,
	storage *atree.PersistentSlabStorage,
	typeInfo atree.TypeInfo,
	address atree.Address,
	array *atree.Array,
	expectedValues test_utils.ExpectedArrayValue,
	hasNestedArrayMapElement bool,
	inlineEnabled bool,
) {
	require.True(t, test_utils.CompareTypeInfo(typeInfo, array.Type()))
	require.Equal(t, address, array.Address())
	require.Equal(t, uint64(len(expectedValues)), array.Count())

	var err error

	// Verify array elements
	for i, expected := range expectedValues {
		actual, err := array.Get(uint64(i))
		require.NoError(t, err)

		testValueEqual(t, expected, actual)
	}

	// Verify array elements by iterator
	i := 0
	err = array.IterateReadOnly(func(v atree.Value) (bool, error) {
		testValueEqual(t, expectedValues[i], v)
		i++
		return true, nil
	})
	require.NoError(t, err)
	require.Equal(t, len(expectedValues), i)

	// Verify in-memory slabs
	err = atree.VerifyArray(array, address, typeInfo, test_utils.CompareTypeInfo, test_utils.GetHashInput, inlineEnabled)
	if err != nil {
		atree.PrintArray(array)
	}
	require.NoError(t, err)

	// Verify slab serializations
	err = atree.VerifyArraySerialization(
		array,
		atree.GetCBORDecMode(storage),
		atree.GetCBOREncMode(storage),
		storage.DecodeStorable,
		storage.DecodeTypeInfo,
		func(a, b atree.Storable) bool {
			return reflect.DeepEqual(a, b)
		},
	)
	if err != nil {
		atree.PrintArray(array)
	}
	require.NoError(t, err)

	// Check storage slab tree
	rootIDSet, err := atree.CheckStorageHealth(storage, 1)
	require.NoError(t, err)

	rootIDs := make([]atree.SlabID, 0, len(rootIDSet))
	for id := range rootIDSet {
		rootIDs = append(rootIDs, id)
	}
	require.Equal(t, 1, len(rootIDs))
	require.Equal(t, array.SlabID(), rootIDs[0])

	// Encode all non-nil slab
	deltas := atree.GetDeltas(storage)
	encodedSlabs := make(map[atree.SlabID][]byte)
	for id, slab := range deltas {
		if slab != nil {
			b, err := atree.EncodeSlab(slab, atree.GetCBOREncMode(storage))
			require.NoError(t, err)
			encodedSlabs[id] = b
		}
	}

	// Test decoded array from new storage to force slab decoding
	decodedArray, err := atree.NewArrayWithRootID(
		newTestPersistentStorageWithBaseStorageAndDeltas(t, atree.GetBaseStorage(storage), encodedSlabs),
		array.SlabID())
	require.NoError(t, err)

	// Verify decoded array elements
	for i, expected := range expectedValues {
		actual, err := decodedArray.Get(uint64(i))
		require.NoError(t, err)

		testValueEqual(t, expected, actual)
	}

	if !hasNestedArrayMapElement {
		// Need to call Commit before calling storage.Count() for atree.PersistentSlabStorage.
		err = storage.Commit()
		require.NoError(t, err)

		stats, err := atree.GetArrayStats(array)
		require.NoError(t, err)
		require.Equal(t, stats.SlabCount(), uint64(storage.Count()))

		if len(expectedValues) == 0 {
			// Verify slab count for empty array
			require.Equal(t, uint64(1), stats.DataSlabCount)
			require.Equal(t, uint64(0), stats.MetaDataSlabCount)
			require.Equal(t, uint64(0), stats.StorableSlabCount)
		}
	}
}

func TestArrayAppendAndGet(t *testing.T) {
	// With slab size 256 bytes, number of array elements equal 4096,
	// element values equal 0-4095, array tree will be 3 levels,
	// with 14 metadata slabs, and 109 data slabs.

	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	const arrayCount = uint64(4096)

	typeInfo := test_utils.NewSimpleTypeInfo(42)
	storage := newTestPersistentStorage(t)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	array, err := atree.NewArray(storage, address, typeInfo)
	require.NoError(t, err)

	expectedValues := make([]atree.Value, arrayCount)
	for i := range expectedValues {
		v := test_utils.NewUint64ValueFromInteger(i)
		expectedValues[i] = v
		err := array.Append(v)
		require.NoError(t, err)
	}

	e, err := array.Get(array.Count())
	require.Nil(t, e)
	require.Equal(t, 1, errorCategorizationCount(err))

	var userError *atree.UserError
	var indexOutOfBoundsError *atree.IndexOutOfBoundsError
	require.ErrorAs(t, err, &userError)
	require.ErrorAs(t, err, &indexOutOfBoundsError)
	require.ErrorAs(t, userError, &indexOutOfBoundsError)

	testArray(t, storage, typeInfo, address, array, expectedValues, false)
}

func TestArraySetAndGet(t *testing.T) {

	t.Run("new elements with similar bytesize", func(t *testing.T) {
		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = v
			err := array.Append(v)
			require.NoError(t, err)
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, false)

		for i := range expectedValues {
			oldValue := expectedValues[i]
			newValue := test_utils.NewUint64ValueFromInteger(i * 10)
			expectedValues[i] = newValue

			existingStorable, err := array.Set(uint64(i), newValue)
			require.NoError(t, err)

			existingValue, err := existingStorable.StoredValue(storage)
			require.NoError(t, err)
			testValueEqual(t, oldValue, existingValue)
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	// This tests slabs splitting and root slab reassignment caused by Set operation.
	t.Run("new elements with larger bytesize", func(t *testing.T) {
		// With slab size 256 bytes, number of array elements equal 50,
		// element values equal 0-49, array tree will be 1 level,
		// with 0 metadata slab, and 1 data slab (root).
		// When elements are overwritten with values from math.MaxUint64-49 to math.MaxUint64,
		// array tree is 2 levels, with 1 metadata slab, and 2 data slabs.

		const arrayCount = uint64(50)

		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = v
			err := array.Append(v)
			require.NoError(t, err)
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, false)

		for i := range expectedValues {
			oldValue := expectedValues[i]
			newValue := test_utils.Uint64Value(math.MaxUint64 - arrayCount + uint64(i) + 1)
			expectedValues[i] = newValue

			existingStorable, err := array.Set(uint64(i), newValue)
			require.NoError(t, err)

			existingValue, err := existingStorable.StoredValue(storage)
			require.NoError(t, err)
			testValueEqual(t, oldValue, existingValue)
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	// This tests slabs merging and root slab reassignment caused by Set operation.
	t.Run("new elements with smaller bytesize", func(t *testing.T) {

		// With slab size 256 bytes, number of array elements equal 50,
		// element values equal math.MaxUint64-49 to math.MaxUint64,
		// array tree is 2 levels, with 1 metadata slab, and 2 data slabs.
		// When elements are overwritten with values from 0-49,
		// array tree will be 1 level, with 0 metadata slab, and 1 data slab (root).

		const arrayCount = uint64(50)

		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.Uint64Value(math.MaxUint64 - arrayCount + uint64(i) + 1)
			expectedValues[i] = v
			err := array.Append(v)
			require.NoError(t, err)
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, false)

		for i := range expectedValues {
			oldValue := expectedValues[i]
			newValue := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = newValue

			existingStorable, err := array.Set(uint64(i), newValue)
			require.NoError(t, err)

			existingValue, err := existingStorable.StoredValue(storage)
			require.NoError(t, err)
			testValueEqual(t, oldValue, existingValue)
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("index out of bounds", func(t *testing.T) {

		const arrayCount = uint64(1024)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = v
			err := array.Append(v)
			require.NoError(t, err)
		}

		r := newRand(t)

		v := test_utils.NewStringValue(randStr(r, 1024))
		storable, err := array.Set(array.Count(), v)
		require.Nil(t, storable)
		require.Equal(t, 1, errorCategorizationCount(err))

		var userError *atree.UserError
		var indexOutOfBoundsError *atree.IndexOutOfBoundsError
		require.ErrorAs(t, err, &userError)
		require.ErrorAs(t, err, &indexOutOfBoundsError)
		require.ErrorAs(t, userError, &indexOutOfBoundsError)

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})
}

func TestArrayInsertAndGet(t *testing.T) {

	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	t.Run("insert-first", func(t *testing.T) {

		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := len(expectedValues) - 1; i >= 0; i-- {
			v := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = v
			err := array.Insert(0, v)
			require.NoError(t, err)
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("insert-last", func(t *testing.T) {

		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = v
			err := array.Insert(array.Count(), v)
			require.NoError(t, err)
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("insert", func(t *testing.T) {

		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, 0, arrayCount)
		for i := uint64(0); i < arrayCount; i += 2 {
			v := test_utils.Uint64Value(i)
			expectedValues = append(expectedValues, v)
			err := array.Append(v)
			require.NoError(t, err)
		}

		for i := uint64(1); i < arrayCount; i += 2 {
			v := test_utils.Uint64Value(i)

			expectedValues = slices.Insert(expectedValues, int(i), atree.Value(v))

			err := array.Insert(i, v)
			require.NoError(t, err)
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("index out of bounds", func(t *testing.T) {

		const arrayCount = uint64(1024)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = v
			err := array.Append(v)
			require.NoError(t, err)
		}

		r := newRand(t)

		v := test_utils.NewStringValue(randStr(r, 1024))
		err = array.Insert(array.Count()+1, v)
		require.Equal(t, 1, errorCategorizationCount(err))

		var userError *atree.UserError
		var indexOutOfBoundsError *atree.IndexOutOfBoundsError
		require.ErrorAs(t, err, &userError)
		require.ErrorAs(t, err, &indexOutOfBoundsError)
		require.ErrorAs(t, userError, &indexOutOfBoundsError)

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})
}

func TestArrayRemove(t *testing.T) {
	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	t.Run("remove-first", func(t *testing.T) {

		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = v
			err := array.Append(v)
			require.NoError(t, err)
		}

		require.True(t, test_utils.CompareTypeInfo(typeInfo, array.Type()))
		require.Equal(t, address, array.Address())
		require.Equal(t, arrayCount, array.Count())

		remainingArrayCount := uint64(len(expectedValues))

		for i := range expectedValues {
			existingStorable, err := array.Remove(0)
			require.NoError(t, err)

			existingValue, err := existingStorable.StoredValue(array.Storage)
			require.NoError(t, err)

			testValueEqual(t, expectedValues[i], existingValue)

			if id, ok := existingStorable.(atree.SlabIDStorable); ok {
				err = array.Storage.Remove(atree.SlabID(id))
				require.NoError(t, err)
			}

			remainingArrayCount--

			require.Equal(t, remainingArrayCount, array.Count())

			if i%256 == 0 {
				testArray(t, storage, typeInfo, address, array, expectedValues[i+1:], false)
			}
		}

		testEmptyArray(t, storage, typeInfo, address, array)
	})

	t.Run("remove-last", func(t *testing.T) {

		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = v
			err := array.Append(v)
			require.NoError(t, err)
		}

		require.True(t, test_utils.CompareTypeInfo(typeInfo, array.Type()))
		require.Equal(t, address, array.Address())
		require.Equal(t, arrayCount, array.Count())

		for i := len(expectedValues) - 1; i >= 0; i-- {
			existingStorable, err := array.Remove(uint64(i))
			require.NoError(t, err)

			existingValue, err := existingStorable.StoredValue(array.Storage)
			require.NoError(t, err)

			testValueEqual(t, expectedValues[i], existingValue)

			if id, ok := existingStorable.(atree.SlabIDStorable); ok {
				err = array.Storage.Remove(atree.SlabID(id))
				require.NoError(t, err)
			}

			require.Equal(t, uint64(i), array.Count())

			if i%256 == 0 {
				testArray(t, storage, typeInfo, address, array, expectedValues[:i], false)
			}
		}

		testEmptyArray(t, storage, typeInfo, address, array)
	})

	t.Run("remove", func(t *testing.T) {

		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = v
			err := array.Append(v)
			require.NoError(t, err)
		}

		require.True(t, test_utils.CompareTypeInfo(typeInfo, array.Type()))
		require.Equal(t, address, array.Address())
		require.Equal(t, arrayCount, array.Count())

		// Remove every other elements
		for i := range arrayCount / 2 {
			v := expectedValues[i]

			existingStorable, err := array.Remove(i)
			require.NoError(t, err)

			existingValue, err := existingStorable.StoredValue(array.Storage)
			require.NoError(t, err)

			testValueEqual(t, v, existingValue)

			if id, ok := existingStorable.(atree.SlabIDStorable); ok {
				err = array.Storage.Remove(atree.SlabID(id))
				require.NoError(t, err)
			}

			expectedValues = slices.Delete(expectedValues, int(i), int(i+1))

			require.Equal(t, uint64(len(expectedValues)), array.Count())

			if i%256 == 0 {
				testArray(t, storage, typeInfo, address, array, expectedValues, false)
			}
		}

		require.Equal(t, arrayCount/2, uint64(len(expectedValues)))

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("index out of bounds", func(t *testing.T) {

		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = v
			err := array.Append(v)
			require.NoError(t, err)
		}

		storable, err := array.Remove(array.Count())
		require.Nil(t, storable)
		require.Equal(t, 1, errorCategorizationCount(err))

		var userError *atree.UserError
		var indexOutOfBounds *atree.IndexOutOfBoundsError
		require.ErrorAs(t, err, &userError)
		require.ErrorAs(t, err, &indexOutOfBounds)
		require.ErrorAs(t, userError, &indexOutOfBounds)

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})
}

func TestReadOnlyArrayIterate(t *testing.T) {

	t.Run("empty", func(t *testing.T) {
		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		i := uint64(0)
		err = array.IterateReadOnly(func(atree.Value) (bool, error) {
			i++
			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, uint64(0), i)
	})

	t.Run("append", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		for i := range arrayCount {
			err := array.Append(test_utils.Uint64Value(i))
			require.NoError(t, err)
		}

		i := uint64(0)
		err = array.IterateReadOnly(func(v atree.Value) (bool, error) {
			require.Equal(t, test_utils.Uint64Value(i), v)
			i++
			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)
	})

	t.Run("set", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		for range arrayCount {
			err := array.Append(test_utils.Uint64Value(0))
			require.NoError(t, err)
		}

		for i := range arrayCount {
			existingStorable, err := array.Set(i, test_utils.Uint64Value(i))
			require.NoError(t, err)

			existingValue, err := existingStorable.StoredValue(storage)
			require.NoError(t, err)
			require.Equal(t, test_utils.Uint64Value(0), existingValue)
		}

		i := uint64(0)
		err = array.IterateReadOnly(func(v atree.Value) (bool, error) {
			require.Equal(t, test_utils.Uint64Value(i), v)
			i++
			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)
	})

	t.Run("insert", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		for i := uint64(0); i < arrayCount; i += 2 {
			err := array.Append(test_utils.Uint64Value(i))
			require.NoError(t, err)
		}

		for i := uint64(1); i < arrayCount; i += 2 {
			err := array.Insert(i, test_utils.Uint64Value(i))
			require.NoError(t, err)
		}

		i := uint64(0)
		err = array.IterateReadOnly(func(v atree.Value) (bool, error) {
			require.Equal(t, test_utils.Uint64Value(i), v)
			i++
			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)
	})

	t.Run("remove", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		for i := range arrayCount {
			err := array.Append(test_utils.Uint64Value(i))
			require.NoError(t, err)
		}

		// Remove every other elements
		for i := uint64(0); i < array.Count(); i++ {
			storable, err := array.Remove(i)
			require.NoError(t, err)
			require.Equal(t, test_utils.Uint64Value(i*2), storable)
		}

		i := uint64(0)
		j := uint64(1)
		err = array.IterateReadOnly(func(v atree.Value) (bool, error) {
			require.Equal(t, test_utils.Uint64Value(j), v)
			i++
			j += 2
			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount/2, i)
	})

	t.Run("stop", func(t *testing.T) {

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(10)
		for i := range arrayCount {
			err := array.Append(test_utils.Uint64Value(i))
			require.NoError(t, err)
		}

		i := uint64(0)
		err = array.IterateReadOnly(func(_ atree.Value) (bool, error) {
			if i == arrayCount/2 {
				return false, nil
			}
			i++
			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount/2, i)
	})

	t.Run("error", func(t *testing.T) {

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(10)
		for i := range arrayCount {
			err := array.Append(test_utils.Uint64Value(i))
			require.NoError(t, err)
		}

		testErr := errors.New("test")

		i := uint64(0)
		err = array.IterateReadOnly(func(_ atree.Value) (bool, error) {
			if i == arrayCount/2 {
				return false, testErr
			}
			i++
			return true, nil
		})
		// err is testErr wrapped in atree.ExternalError.
		require.Equal(t, 1, errorCategorizationCount(err))
		var externalError *atree.ExternalError
		require.ErrorAs(t, err, &externalError)
		require.Equal(t, testErr, externalError.Unwrap())

		require.Equal(t, arrayCount/2, i)
	})
}

func TestMutateElementFromReadOnlyArrayIterator(t *testing.T) {

	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	typeInfo := test_utils.NewSimpleTypeInfo(42)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}
	storage := newTestPersistentStorage(t)

	var mutationError *atree.ReadOnlyIteratorElementMutationError

	t.Run("mutate inlined element from IterateReadOnly", func(t *testing.T) {
		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		// child array []
		childArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)
		require.False(t, childArray.Inlined())

		// parent array [[]]
		err = parentArray.Append(childArray)
		require.NoError(t, err)
		require.True(t, childArray.Inlined())

		// Iterate and modify element
		var valueMutationCallbackCalled bool
		err = parentArray.IterateReadOnlyWithMutationCallback(
			func(v atree.Value) (resume bool, err error) {
				c, ok := v.(*atree.Array)
				require.True(t, ok)
				require.True(t, c.Inlined())

				err = c.Append(test_utils.Uint64Value(0))
				require.ErrorAs(t, err, &mutationError)

				return true, err
			},
			func(atree.Value) {
				valueMutationCallbackCalled = true
			})

		require.ErrorAs(t, err, &mutationError)
		require.True(t, valueMutationCallbackCalled)
	})

	t.Run("mutate inlined element from IterateReadOnlyRange", func(t *testing.T) {
		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		// child array []
		childArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)
		require.False(t, childArray.Inlined())

		// parent array [[]]
		err = parentArray.Append(childArray)
		require.NoError(t, err)
		require.True(t, childArray.Inlined())

		// Iterate and modify element
		var valueMutationCallbackCalled bool
		err = parentArray.IterateReadOnlyRangeWithMutationCallback(
			0,
			parentArray.Count(),
			func(v atree.Value) (resume bool, err error) {
				c, ok := v.(*atree.Array)
				require.True(t, ok)
				require.True(t, c.Inlined())

				err = c.Append(test_utils.Uint64Value(0))
				require.ErrorAs(t, err, &mutationError)

				return true, err
			},
			func(atree.Value) {
				valueMutationCallbackCalled = true
			})

		require.ErrorAs(t, err, &mutationError)
		require.True(t, valueMutationCallbackCalled)
	})

	t.Run("mutate not inlined array element from IterateReadOnly", func(t *testing.T) {
		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		// child array []
		childArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)
		require.False(t, childArray.Inlined())

		// parent array [[]]
		err = parentArray.Append(childArray)
		require.NoError(t, err)
		require.True(t, childArray.Inlined())

		// Inserting elements into childArray so it can't be inlined
		for i := uint64(0); childArray.Inlined(); i++ {
			v := test_utils.Uint64Value(i)
			err = childArray.Append(v)
			require.NoError(t, err)
		}

		// Iterate and modify element
		var valueMutationCallbackCalled bool
		err = parentArray.IterateReadOnlyWithMutationCallback(
			func(v atree.Value) (resume bool, err error) {
				c, ok := v.(*atree.Array)
				require.True(t, ok)
				require.False(t, c.Inlined())

				existingStorable, err := c.Remove(0)
				require.ErrorAs(t, err, &mutationError)
				require.Nil(t, existingStorable)

				return true, err
			},
			func(atree.Value) {
				valueMutationCallbackCalled = true
			})

		require.ErrorAs(t, err, &mutationError)
		require.True(t, valueMutationCallbackCalled)
	})

	t.Run("mutate not inlined array element from IterateReadOnlyRange", func(t *testing.T) {
		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		// child array []
		childArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)
		require.False(t, childArray.Inlined())

		// parent array [[]]
		err = parentArray.Append(childArray)
		require.NoError(t, err)
		require.True(t, childArray.Inlined())

		// Inserting elements into childArray so it can't be inlined
		for i := uint64(0); childArray.Inlined(); i++ {
			v := test_utils.Uint64Value(i)
			err = childArray.Append(v)
			require.NoError(t, err)
		}

		// Iterate and modify element
		var valueMutationCallbackCalled bool
		err = parentArray.IterateReadOnlyRangeWithMutationCallback(
			0,
			parentArray.Count(),
			func(v atree.Value) (resume bool, err error) {
				c, ok := v.(*atree.Array)
				require.True(t, ok)
				require.False(t, c.Inlined())

				existingStorable, err := c.Remove(0)
				require.ErrorAs(t, err, &mutationError)
				require.Nil(t, existingStorable)

				return true, err
			},
			func(atree.Value) {
				valueMutationCallbackCalled = true
			})

		require.ErrorAs(t, err, &mutationError)
		require.True(t, valueMutationCallbackCalled)
	})
}

func TestMutableArrayIterate(t *testing.T) {

	t.Run("empty", func(t *testing.T) {
		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		i := uint64(0)
		err = array.Iterate(func(atree.Value) (bool, error) {
			i++
			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, uint64(0), i)
	})

	t.Run("mutate primitive values, root is data slab, no slab operation", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(15)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)
			err = array.Append(v)
			require.NoError(t, err)

			expectedValues[i] = v
		}
		require.True(t, IsArrayRootDataSlab(array))

		i := uint64(0)
		err = array.Iterate(func(v atree.Value) (bool, error) {
			require.Equal(t, test_utils.Uint64Value(i), v)

			// Mutate primitive array elements by overwritting existing elements of similar byte size.
			newValue := test_utils.Uint64Value(i * 2)
			existingStorable, err := array.Set(i, newValue)
			require.NoError(t, err)

			existingValue, err := existingStorable.StoredValue(storage)
			require.NoError(t, err)
			require.Equal(t, test_utils.Uint64Value(i), existingValue)

			expectedValues[i] = newValue

			i++

			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)
		require.True(t, IsArrayRootDataSlab(array))

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("mutate primitive values, root is metadata slab, no slab operation", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(1024)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)
			err = array.Append(v)
			require.NoError(t, err)

			expectedValues[i] = v
		}
		require.False(t, IsArrayRootDataSlab(array))

		i := uint64(0)
		err = array.Iterate(func(v atree.Value) (bool, error) {
			require.Equal(t, test_utils.Uint64Value(i), v)

			// Mutate primitive array elements by overwritting existing elements with elements of similar size.
			newValue := test_utils.Uint64Value(i * 2)
			existingStorable, err := array.Set(i, newValue)
			require.NoError(t, err)

			existingValue, err := existingStorable.StoredValue(storage)
			require.NoError(t, err)
			require.Equal(t, test_utils.Uint64Value(i), existingValue)

			expectedValues[i] = newValue

			i++

			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)
		require.False(t, IsArrayRootDataSlab(array))

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("mutate primitive values, root is data slab, split slab", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(15)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		r := rune('a')
		for i := range expectedValues {
			v := test_utils.NewStringValue(string(r))
			err = array.Append(v)
			require.NoError(t, err)

			expectedValues[i] = v
			r++
		}
		require.True(t, IsArrayRootDataSlab(array))

		i := uint64(0)
		r = rune('a')
		err = array.Iterate(func(v atree.Value) (bool, error) {
			require.Equal(t, test_utils.NewStringValue(string(r)), v)

			// Mutate primitive array elements by overwritting existing elements with larger elements.
			// Larger elements causes slabs to split.
			newValue := test_utils.NewStringValue(strings.Repeat(string(r), 25))
			existingStorable, err := array.Set(i, newValue)
			require.NoError(t, err)

			existingValue, err := existingStorable.StoredValue(storage)
			require.NoError(t, err)
			require.Equal(t, test_utils.NewStringValue(string(r)), existingValue)

			expectedValues[i] = newValue

			i++
			r++

			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)
		require.False(t, IsArrayRootDataSlab(array))

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("mutate primitive values, root is metadata slab, split slab", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(200)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		r := rune('a')
		for i := range expectedValues {
			v := test_utils.NewStringValue(string(r))
			err = array.Append(v)
			require.NoError(t, err)

			expectedValues[i] = v
			r++
		}
		require.False(t, IsArrayRootDataSlab(array))

		i := uint64(0)
		r = rune('a')
		err = array.Iterate(func(v atree.Value) (bool, error) {
			require.Equal(t, test_utils.NewStringValue(string(r)), v)

			// Mutate primitive array elements by overwritting existing elements with larger elements.
			// Larger elements causes slabs to split.
			newValue := test_utils.NewStringValue(strings.Repeat(string(r), 25))
			existingStorable, err := array.Set(i, newValue)
			require.NoError(t, err)

			existingValue, err := existingStorable.StoredValue(storage)
			require.NoError(t, err)
			require.Equal(t, test_utils.NewStringValue(string(r)), existingValue)

			expectedValues[i] = newValue

			i++
			r++

			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)
		require.False(t, IsArrayRootDataSlab(array))

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("mutate primitive values, root is metadata slab, merge slabs", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(80)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		r := rune('a')
		for i := range expectedValues {
			v := test_utils.NewStringValue(strings.Repeat(string(r), 25))
			err = array.Append(v)
			require.NoError(t, err)

			expectedValues[i] = v
			r++
		}
		require.False(t, IsArrayRootDataSlab(array))

		i := uint64(0)
		r = rune('a')
		err = array.Iterate(func(v atree.Value) (bool, error) {
			require.Equal(t, test_utils.NewStringValue(strings.Repeat(string(r), 25)), v)

			// Mutate primitive array elements by overwritting existing elements with smaller elements.
			// Smaller elements causes slabs to merge.
			newValue := test_utils.NewStringValue(string(r))
			existingStorable, err := array.Set(i, newValue)
			require.NoError(t, err)

			existingValue, err := existingStorable.StoredValue(storage)
			require.NoError(t, err)
			require.Equal(t, test_utils.NewStringValue(strings.Repeat(string(r), 25)), existingValue)

			expectedValues[i] = newValue

			i++
			r++

			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)
		require.True(t, IsArrayRootDataSlab(array))

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("mutate inlined container, root is data slab, no slab operation", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(15)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			childArray, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			v := test_utils.NewUint64ValueFromInteger(i)
			err = childArray.Append(v)
			require.NoError(t, err)

			err = array.Append(childArray)
			require.NoError(t, err)

			expectedValues[i] = test_utils.ExpectedArrayValue{v}
		}
		require.True(t, IsArrayRootDataSlab(array))

		i := uint64(0)
		err = array.Iterate(func(v atree.Value) (bool, error) {
			childArray, ok := v.(*atree.Array)
			require.True(t, ok)
			require.Equal(t, uint64(1), childArray.Count())
			require.True(t, childArray.Inlined())

			// Mutate array elements by inserting more elements to child arrays.
			newElement := test_utils.Uint64Value(0)
			err := childArray.Append(newElement)
			require.NoError(t, err)
			require.Equal(t, uint64(2), childArray.Count())
			require.True(t, childArray.Inlined())

			expectedChildArrayValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedChildArrayValues = append(expectedChildArrayValues, newElement)
			expectedValues[i] = expectedChildArrayValues

			i++

			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)
		require.True(t, IsArrayRootDataSlab(array))

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("mutate inlined container, root is metadata slab, no slab operation", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(25)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			childArray, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			v := test_utils.NewUint64ValueFromInteger(i)
			err = childArray.Append(v)
			require.NoError(t, err)

			err = array.Append(childArray)
			require.NoError(t, err)

			expectedValues[i] = test_utils.ExpectedArrayValue{v}
		}
		require.False(t, IsArrayRootDataSlab(array))

		i := uint64(0)
		err = array.Iterate(func(v atree.Value) (bool, error) {
			childArray, ok := v.(*atree.Array)
			require.True(t, ok)
			require.Equal(t, uint64(1), childArray.Count())
			require.True(t, childArray.Inlined())

			// Mutate array elements by inserting more elements to child arrays.
			newElement := test_utils.Uint64Value(0)
			err := childArray.Append(newElement)
			require.NoError(t, err)
			require.Equal(t, uint64(2), childArray.Count())
			require.True(t, childArray.Inlined())

			expectedChildArrayValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedChildArrayValues = append(expectedChildArrayValues, newElement)
			expectedValues[i] = expectedChildArrayValues

			i++

			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)
		require.False(t, IsArrayRootDataSlab(array))

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("mutate inlined container, root is data slab, split slab", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const (
			arrayCount             = uint64(15)
			childArrayCount        = uint64(1)
			mutatedChildArrayCount = uint64(4)
		)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			childArray, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			expectedValue := make(test_utils.ExpectedArrayValue, childArrayCount)
			for j := range expectedValue {
				v := test_utils.NewUint64ValueFromInteger(j + i)
				err = childArray.Append(v)
				require.NoError(t, err)

				expectedValue[j] = v
			}

			err = array.Append(childArray)
			require.NoError(t, err)

			expectedValues[i] = expectedValue
		}
		require.True(t, IsArrayRootDataSlab(array))

		i := uint64(0)
		err = array.Iterate(func(v atree.Value) (bool, error) {
			childArray, ok := v.(*atree.Array)
			require.True(t, ok)
			require.Equal(t, childArrayCount, childArray.Count())
			require.True(t, childArray.Inlined())

			expectedChildArrayValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			// Mutate array elements by inserting more elements to child arrays.
			for j := i; j < i+mutatedChildArrayCount-childArrayCount; j++ {
				newElement := test_utils.Uint64Value(j)

				err := childArray.Append(newElement)
				require.NoError(t, err)

				expectedChildArrayValues = append(expectedChildArrayValues, newElement)
			}

			require.Equal(t, mutatedChildArrayCount, childArray.Count())
			require.True(t, childArray.Inlined())

			expectedValues[i] = expectedChildArrayValues

			i++

			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)
		require.False(t, IsArrayRootDataSlab(array))

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("mutate inlined container, root is metadata slab, split slab", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const (
			arrayCount             = uint64(25)
			childArrayCount        = uint64(1)
			mutatedChildArrayCount = uint64(4)
		)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			childArray, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			expectedValue := make(test_utils.ExpectedArrayValue, childArrayCount)
			for j := range expectedValue {
				v := test_utils.NewUint64ValueFromInteger(j + i)
				err = childArray.Append(v)
				require.NoError(t, err)

				expectedValue[j] = v
			}

			err = array.Append(childArray)
			require.NoError(t, err)

			expectedValues[i] = expectedValue
		}
		require.False(t, IsArrayRootDataSlab(array))

		i := uint64(0)
		err = array.Iterate(func(v atree.Value) (bool, error) {
			childArray, ok := v.(*atree.Array)
			require.True(t, ok)
			require.Equal(t, childArrayCount, childArray.Count())
			require.True(t, childArray.Inlined())

			expectedChildArrayValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			// Mutate array elements by inserting more elements to child arrays.
			for j := i; j < i+mutatedChildArrayCount-childArrayCount; j++ {
				newElement := test_utils.Uint64Value(j)

				err := childArray.Append(newElement)
				require.NoError(t, err)

				expectedChildArrayValues = append(expectedChildArrayValues, newElement)
			}

			require.Equal(t, mutatedChildArrayCount, childArray.Count())
			require.True(t, childArray.Inlined())

			expectedValues[i] = expectedChildArrayValues

			i++

			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)
		require.False(t, IsArrayRootDataSlab(array))

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("mutate inlined container, root is metadata slab, merge slab", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const (
			arrayCount             = uint64(10)
			childArrayCount        = uint64(10)
			mutatedChildArrayCount = uint64(1)
		)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range arrayCount {
			childArray, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			expectedValue := make(test_utils.ExpectedArrayValue, childArrayCount)
			for j := range expectedValue {
				v := test_utils.Uint64Value(uint64(j) + i)
				err = childArray.Append(v)
				require.NoError(t, err)

				expectedValue[j] = v
			}

			err = array.Append(childArray)
			require.NoError(t, err)

			expectedValues[i] = expectedValue
		}

		require.False(t, IsArrayRootDataSlab(array))

		i := uint64(0)
		err = array.Iterate(func(v atree.Value) (bool, error) {
			childArray, ok := v.(*atree.Array)
			require.True(t, ok)
			require.Equal(t, childArrayCount, childArray.Count())
			require.True(t, childArray.Inlined())

			expectedChildArrayValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			for j := childArrayCount - 1; j > mutatedChildArrayCount-1; j-- {
				existingStorble, err := childArray.Remove(j)
				require.NoError(t, err)

				existingValue, err := existingStorble.StoredValue(storage)
				require.NoError(t, err)
				require.Equal(t, test_utils.Uint64Value(i+j), existingValue)
			}

			require.Equal(t, mutatedChildArrayCount, childArray.Count())
			require.True(t, childArray.Inlined())

			expectedValues[i] = expectedChildArrayValues[:mutatedChildArrayCount]

			i++

			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)
		require.True(t, IsArrayRootDataSlab(array))

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("uninline inlined container, root is data slab, no slab operation", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const (
			arrayCount             = uint64(2)
			childArrayCount        = uint64(1)
			mutatedChildArrayCount = uint64(50)
		)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			childArray, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			expectedValue := make(test_utils.ExpectedArrayValue, childArrayCount)
			for j := range expectedValue {
				v := test_utils.NewUint64ValueFromInteger(j + i)
				err = childArray.Append(v)
				require.NoError(t, err)

				expectedValue[j] = v
			}

			err = array.Append(childArray)
			require.NoError(t, err)

			expectedValues[i] = expectedValue
		}

		require.True(t, IsArrayRootDataSlab(array))

		i := uint64(0)
		err = array.Iterate(func(v atree.Value) (bool, error) {
			childArray, ok := v.(*atree.Array)
			require.True(t, ok)
			require.Equal(t, childArrayCount, childArray.Count())
			require.True(t, childArray.Inlined())

			expectedChildArrayValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			for j := childArrayCount; j < mutatedChildArrayCount; j++ {
				v := test_utils.Uint64Value(i + j)

				err := childArray.Append(v)
				require.NoError(t, err)

				expectedChildArrayValues = append(expectedChildArrayValues, v)
			}

			require.Equal(t, mutatedChildArrayCount, childArray.Count())
			require.False(t, childArray.Inlined())

			expectedValues[i] = expectedChildArrayValues

			i++

			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)

		require.True(t, IsArrayRootDataSlab(array))

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("uninline inlined container, root is metadata slab, merge slab", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const (
			arrayCount             = uint64(10)
			childArrayCount        = uint64(10)
			mutatedChildArrayCount = uint64(50)
		)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			childArray, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			expectedValue := make(test_utils.ExpectedArrayValue, childArrayCount)

			for j := range expectedValue {
				v := test_utils.NewUint64ValueFromInteger(j + i)
				err = childArray.Append(v)
				require.NoError(t, err)

				expectedValue[j] = v
			}

			err = array.Append(childArray)
			require.NoError(t, err)

			expectedValues[i] = expectedValue
		}

		require.False(t, IsArrayRootDataSlab(array))

		i := uint64(0)
		err = array.Iterate(func(v atree.Value) (bool, error) {
			childArray, ok := v.(*atree.Array)
			require.True(t, ok)
			require.Equal(t, childArrayCount, childArray.Count())
			require.True(t, childArray.Inlined())

			expectedChildArrayValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			for j := childArrayCount; j < mutatedChildArrayCount; j++ {
				v := test_utils.Uint64Value(i + j)

				err := childArray.Append(v)
				require.NoError(t, err)

				expectedChildArrayValues = append(expectedChildArrayValues, v)
			}

			require.Equal(t, mutatedChildArrayCount, childArray.Count())
			require.False(t, childArray.Inlined())

			expectedValues[i] = expectedChildArrayValues

			i++

			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)
		require.True(t, IsArrayRootDataSlab(array))

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("inline uninlined container, root is data slab, no slab operation", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const (
			arrayCount             = uint64(2)
			childArrayCount        = uint64(50)
			mutatedChildArrayCount = uint64(1)
		)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			childArray, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			expectedValue := make(test_utils.ExpectedArrayValue, childArrayCount)

			for j := range expectedValue {
				v := test_utils.NewUint64ValueFromInteger(j + i)
				err = childArray.Append(v)
				require.NoError(t, err)

				expectedValue[j] = v
			}

			err = array.Append(childArray)
			require.NoError(t, err)

			expectedValues[i] = expectedValue
		}

		require.True(t, IsArrayRootDataSlab(array))

		i := uint64(0)
		err = array.Iterate(func(v atree.Value) (bool, error) {
			childArray, ok := v.(*atree.Array)
			require.True(t, ok)
			require.Equal(t, childArrayCount, childArray.Count())
			require.False(t, childArray.Inlined())

			expectedChildArrayValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			for j := childArrayCount - 1; j > mutatedChildArrayCount-1; j-- {
				existingStorable, err := childArray.Remove(j)
				require.NoError(t, err)

				value, err := existingStorable.StoredValue(storage)
				require.NoError(t, err)
				require.Equal(t, test_utils.Uint64Value(i+j), value)
			}

			require.Equal(t, mutatedChildArrayCount, childArray.Count())
			require.True(t, childArray.Inlined())

			expectedValues[i] = expectedChildArrayValues[:1]

			i++

			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)

		require.True(t, IsArrayRootDataSlab(array))

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("inline uninlined container, root is data slab, split slab", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const (
			arrayCount             = uint64(4)
			childArrayCount        = uint64(50)
			mutatedChildArrayCount = uint64(25)
		)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			childArray, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			expectedValue := make(test_utils.ExpectedArrayValue, childArrayCount)

			for j := range expectedValue {
				v := test_utils.NewUint64ValueFromInteger(j + i)
				err = childArray.Append(v)
				require.NoError(t, err)

				expectedValue[j] = v
			}

			err = array.Append(childArray)
			require.NoError(t, err)

			expectedValues[i] = expectedValue
		}

		require.True(t, IsArrayRootDataSlab(array))

		i := uint64(0)
		err = array.Iterate(func(v atree.Value) (bool, error) {
			childArray, ok := v.(*atree.Array)
			require.True(t, ok)
			require.Equal(t, childArrayCount, childArray.Count())
			require.False(t, childArray.Inlined())

			expectedChildArrayValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			for j := childArrayCount - 1; j >= mutatedChildArrayCount; j-- {
				existingStorable, err := childArray.Remove(j)
				require.NoError(t, err)

				value, err := existingStorable.StoredValue(storage)
				require.NoError(t, err)
				require.Equal(t, test_utils.Uint64Value(i+j), value)
			}

			require.Equal(t, mutatedChildArrayCount, childArray.Count())
			require.True(t, childArray.Inlined())

			expectedValues[i] = expectedChildArrayValues[:mutatedChildArrayCount]

			i++

			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)

		require.False(t, IsArrayRootDataSlab(array))

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("stop", func(t *testing.T) {

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(10)
		for i := range arrayCount {
			err := array.Append(test_utils.Uint64Value(i))
			require.NoError(t, err)
		}

		i := uint64(0)
		err = array.Iterate(func(_ atree.Value) (bool, error) {
			if i == arrayCount/2 {
				return false, nil
			}
			i++
			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount/2, i)
	})

	t.Run("error", func(t *testing.T) {

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(10)
		for i := range arrayCount {
			err := array.Append(test_utils.Uint64Value(i))
			require.NoError(t, err)
		}

		testErr := errors.New("test")

		i := uint64(0)
		err = array.Iterate(func(_ atree.Value) (bool, error) {
			if i == arrayCount/2 {
				return false, testErr
			}
			i++
			return true, nil
		})
		// err is testErr wrapped in atree.ExternalError.
		require.Equal(t, 1, errorCategorizationCount(err))
		var externalError *atree.ExternalError
		require.ErrorAs(t, err, &externalError)
		require.Equal(t, testErr, externalError.Unwrap())

		require.Equal(t, arrayCount/2, i)
	})
}

func testArrayIterateRange(t *testing.T, array *atree.Array, expectedValues test_utils.ExpectedArrayValue) {
	var i uint64
	var err error
	var sliceOutOfBoundsError *atree.SliceOutOfBoundsError
	var invalidSliceIndexError *atree.InvalidSliceIndexError

	count := array.Count()

	// If startIndex > count, IterateRange returns atree.SliceOutOfBoundsError
	err = array.IterateReadOnlyRange(count+1, count+1, func(atree.Value) (bool, error) {
		i++
		return true, nil
	})
	require.Equal(t, 1, errorCategorizationCount(err))

	var userError *atree.UserError
	require.ErrorAs(t, err, &userError)
	require.ErrorAs(t, err, &sliceOutOfBoundsError)
	require.ErrorAs(t, userError, &sliceOutOfBoundsError)
	require.Equal(t, uint64(0), i)

	// If endIndex > count, IterateRange returns atree.SliceOutOfBoundsError
	err = array.IterateReadOnlyRange(0, count+1, func(atree.Value) (bool, error) {
		i++
		return true, nil
	})
	require.Equal(t, 1, errorCategorizationCount(err))
	require.ErrorAs(t, err, &userError)
	require.ErrorAs(t, err, &sliceOutOfBoundsError)
	require.ErrorAs(t, userError, &sliceOutOfBoundsError)
	require.Equal(t, uint64(0), i)

	// If startIndex > endIndex, IterateRange returns atree.InvalidSliceIndexError
	if count > 0 {
		err = array.IterateReadOnlyRange(1, 0, func(atree.Value) (bool, error) {
			i++
			return true, nil
		})
		require.Equal(t, 1, errorCategorizationCount(err))
		require.ErrorAs(t, err, &userError)
		require.ErrorAs(t, err, &invalidSliceIndexError)
		require.ErrorAs(t, userError, &invalidSliceIndexError)
		require.Equal(t, uint64(0), i)
	}

	// IterateRange returns no error and iteration function is called on sliced array
	for startIndex := uint64(0); startIndex <= count; startIndex++ {
		for endIndex := startIndex; endIndex <= count; endIndex++ {
			i = uint64(0)
			err = array.IterateReadOnlyRange(startIndex, endIndex, func(v atree.Value) (bool, error) {
				testValueEqual(t, v, expectedValues[startIndex+i])
				i++
				return true, nil
			})
			require.NoError(t, err)
			require.Equal(t, endIndex-startIndex, i)
		}
	}
}

func TestReadOnlyArrayIterateRange(t *testing.T) {
	typeInfo := test_utils.NewSimpleTypeInfo(42)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	t.Run("empty", func(t *testing.T) {
		storage := newTestPersistentStorage(t)

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		testArrayIterateRange(t, array, []atree.Value{})
	})

	t.Run("dataslab as root", func(t *testing.T) {
		const arrayCount = uint64(10)

		storage := newTestPersistentStorage(t)

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			value := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = value
			err := array.Append(value)
			require.NoError(t, err)
		}

		testArrayIterateRange(t, array, expectedValues)
	})

	t.Run("metadataslab as root", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(1024)

		storage := newTestPersistentStorage(t)

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			value := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = value
			err := array.Append(value)
			require.NoError(t, err)
		}

		testArrayIterateRange(t, array, expectedValues)
	})

	t.Run("stop", func(t *testing.T) {
		const arrayCount = uint64(10)

		storage := newTestPersistentStorage(t)

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		for i := range arrayCount {
			err := array.Append(test_utils.Uint64Value(i))
			require.NoError(t, err)
		}

		i := uint64(0)
		startIndex := uint64(1)
		endIndex := uint64(5)
		count := endIndex - startIndex
		err = array.IterateReadOnlyRange(startIndex, endIndex, func(_ atree.Value) (bool, error) {
			if i == count/2 {
				return false, nil
			}
			i++
			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, count/2, i)
	})

	t.Run("error", func(t *testing.T) {
		storage := newTestPersistentStorage(t)

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(10)
		for i := range arrayCount {
			err := array.Append(test_utils.Uint64Value(i))
			require.NoError(t, err)
		}

		testErr := errors.New("test")

		i := uint64(0)
		startIndex := uint64(1)
		endIndex := uint64(5)
		count := endIndex - startIndex
		err = array.IterateReadOnlyRange(startIndex, endIndex, func(_ atree.Value) (bool, error) {
			if i == count/2 {
				return false, testErr
			}
			i++
			return true, nil
		})
		// err is testErr wrapped in atree.ExternalError.
		require.Equal(t, 1, errorCategorizationCount(err))
		var externalError *atree.ExternalError
		require.ErrorAs(t, err, &externalError)
		require.Equal(t, testErr, externalError.Unwrap())
		require.Equal(t, count/2, i)
	})
}

func TestMutableArrayIterateRange(t *testing.T) {

	typeInfo := test_utils.NewSimpleTypeInfo(42)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	t.Run("empty", func(t *testing.T) {
		storage := newTestPersistentStorage(t)

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		i := 0
		err = array.IterateRange(0, 0, func(atree.Value) (bool, error) {
			i++
			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, 0, i)
	})

	t.Run("mutate inlined container, root is data slab, no slab operation", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(15)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			childArray, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			v := test_utils.NewUint64ValueFromInteger(i)
			err = childArray.Append(v)
			require.NoError(t, err)

			err = array.Append(childArray)
			require.NoError(t, err)

			expectedValues[i] = test_utils.ExpectedArrayValue{v}
		}
		require.True(t, IsArrayRootDataSlab(array))

		sizeBeforeMutation := GetArrayRootSlabByteSize(array)

		i := uint64(0)
		startIndex := uint64(1)
		endIndex := array.Count() - 2
		newElement := test_utils.Uint64Value(0)
		err = array.IterateRange(startIndex, endIndex, func(v atree.Value) (bool, error) {
			childArray, ok := v.(*atree.Array)
			require.True(t, ok)
			require.Equal(t, uint64(1), childArray.Count())
			require.True(t, childArray.Inlined())

			err := childArray.Append(newElement)
			require.NoError(t, err)

			index := startIndex + i
			expectedChildArrayValues, ok := expectedValues[index].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedChildArrayValues = append(expectedChildArrayValues, newElement)
			expectedValues[index] = expectedChildArrayValues

			i++

			require.Equal(t, GetArrayRootSlabByteSize(array), sizeBeforeMutation+uint32(i)*newElement.ByteSize())

			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, endIndex-startIndex, i)
		require.True(t, IsArrayRootDataSlab(array))

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("stop", func(t *testing.T) {
		const arrayCount = uint64(10)

		storage := newTestPersistentStorage(t)

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		for i := range arrayCount {
			err := array.Append(test_utils.Uint64Value(i))
			require.NoError(t, err)
		}

		i := uint64(0)
		startIndex := uint64(1)
		endIndex := uint64(5)
		count := endIndex - startIndex
		err = array.IterateRange(startIndex, endIndex, func(_ atree.Value) (bool, error) {
			if i == count/2 {
				return false, nil
			}
			i++
			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, count/2, i)
	})

	t.Run("error", func(t *testing.T) {
		storage := newTestPersistentStorage(t)

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(10)
		for i := range arrayCount {
			err := array.Append(test_utils.Uint64Value(i))
			require.NoError(t, err)
		}

		testErr := errors.New("test")

		i := uint64(0)
		startIndex := uint64(1)
		endIndex := uint64(5)
		count := endIndex - startIndex
		err = array.IterateRange(startIndex, endIndex, func(_ atree.Value) (bool, error) {
			if i == count/2 {
				return false, testErr
			}
			i++
			return true, nil
		})
		// err is testErr wrapped in atree.ExternalError.
		require.Equal(t, 1, errorCategorizationCount(err))
		var externalError *atree.ExternalError
		require.ErrorAs(t, err, &externalError)
		require.Equal(t, testErr, externalError.Unwrap())
		require.Equal(t, count/2, i)
	})
}

func TestArrayRootSlabID(t *testing.T) {
	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	const arrayCount = uint64(4096)

	typeInfo := test_utils.NewSimpleTypeInfo(42)
	storage := newTestPersistentStorage(t)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	array, err := atree.NewArray(storage, address, typeInfo)
	require.NoError(t, err)

	savedRootID := array.SlabID()
	require.NotEqual(t, atree.SlabIDUndefined, savedRootID)

	// Append elements
	for i := range arrayCount {
		err := array.Append(test_utils.Uint64Value(i))
		require.NoError(t, err)
		require.Equal(t, savedRootID, array.SlabID())
	}

	require.True(t, test_utils.CompareTypeInfo(typeInfo, array.Type()))
	require.Equal(t, address, array.Address())
	require.Equal(t, arrayCount, array.Count())

	// Remove elements
	for i := range arrayCount {
		storable, err := array.Remove(0)
		require.NoError(t, err)
		require.Equal(t, test_utils.Uint64Value(i), storable)
		require.Equal(t, savedRootID, array.SlabID())
	}

	require.True(t, test_utils.CompareTypeInfo(typeInfo, array.Type()))
	require.Equal(t, address, array.Address())
	require.Equal(t, uint64(0), array.Count())
	require.Equal(t, savedRootID, array.SlabID())
}

func TestArraySetRandomValues(t *testing.T) {

	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	const arrayCount = uint64(4096)

	r := newRand(t)

	typeInfo := test_utils.NewSimpleTypeInfo(42)
	storage := newTestPersistentStorage(t)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	array, err := atree.NewArray(storage, address, typeInfo)
	require.NoError(t, err)

	expectedValues := make([]atree.Value, arrayCount)
	for i := range expectedValues {
		v := test_utils.NewUint64ValueFromInteger(i)
		expectedValues[i] = v
		err := array.Append(v)
		require.NoError(t, err)
	}

	for i := range expectedValues {
		oldValue := expectedValues[i]
		newValue := randomValue(r, atree.MaxInlineArrayElementSize())
		expectedValues[i] = newValue

		existingStorable, err := array.Set(uint64(i), newValue)
		require.NoError(t, err)

		existingValue, err := existingStorable.StoredValue(storage)
		require.NoError(t, err)
		testValueEqual(t, oldValue, existingValue)
	}

	testArray(t, storage, typeInfo, address, array, expectedValues, false)
}

func TestArrayInsertRandomValues(t *testing.T) {

	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	t.Run("insert-first", func(t *testing.T) {

		const arrayCount = uint64(4096)

		r := newRand(t)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := len(expectedValues) - 1; i >= 0; i-- {
			v := randomValue(r, atree.MaxInlineArrayElementSize())
			expectedValues[i] = v

			err := array.Insert(0, v)
			require.NoError(t, err)
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("insert-last", func(t *testing.T) {

		const arrayCount = uint64(4096)

		r := newRand(t)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := randomValue(r, atree.MaxInlineArrayElementSize())
			expectedValues[i] = v

			err := array.Insert(uint64(i), v)
			require.NoError(t, err)
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("insert-random", func(t *testing.T) {

		const arrayCount = uint64(4096)

		r := newRand(t)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, 0, arrayCount)
		for i := range arrayCount {
			k := r.Intn(int(i + 1))
			v := randomValue(r, atree.MaxInlineArrayElementSize())

			expectedValues = slices.Insert(expectedValues, k, v)

			err := array.Insert(uint64(k), v)
			require.NoError(t, err)
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})
}

func TestArrayRemoveRandomValues(t *testing.T) {

	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	const arrayCount = uint64(4096)

	r := newRand(t)

	typeInfo := test_utils.NewSimpleTypeInfo(42)
	storage := newTestPersistentStorage(t)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	array, err := atree.NewArray(storage, address, typeInfo)
	require.NoError(t, err)

	expectedValues := make([]atree.Value, arrayCount)
	// Insert n random values into array
	for i := range expectedValues {
		v := randomValue(r, atree.MaxInlineArrayElementSize())
		expectedValues[i] = v

		err := array.Insert(uint64(i), v)
		require.NoError(t, err)
	}

	testArray(t, storage, typeInfo, address, array, expectedValues, false)

	// Remove n elements at random index
	for range arrayCount {
		k := getRandomArrayIndex(r, array)

		existingStorable, err := array.Remove(k)
		require.NoError(t, err)

		existingValue, err := existingStorable.StoredValue(storage)
		require.NoError(t, err)
		testValueEqual(t, expectedValues[k], existingValue)

		expectedValues = slices.Delete(expectedValues, int(k), int(k+1))

		if id, ok := existingStorable.(atree.SlabIDStorable); ok {
			err = storage.Remove(atree.SlabID(id))
			require.NoError(t, err)
		}
	}

	testEmptyArray(t, storage, typeInfo, address, array)
}

func testArrayAppendSetInsertRemoveRandomValues(
	t *testing.T,
	r *rand.Rand,
	storage *atree.PersistentSlabStorage,
	typeInfo atree.TypeInfo,
	address atree.Address,
	opCount int,
) (*atree.Array, []atree.Value) {
	const (
		ArrayAppendOp = iota
		ArrayInsertOp
		ArraySetOp
		ArrayRemoveOp
		MaxArrayOp
	)

	array, err := atree.NewArray(storage, address, typeInfo)
	require.NoError(t, err)

	expectedValues := make([]atree.Value, 0, opCount)
	for range opCount {

		var nextOp int

		for {
			nextOp = r.Intn(MaxArrayOp)

			if array.Count() > 0 || (nextOp != ArrayRemoveOp && nextOp != ArraySetOp) {
				break
			}
		}

		switch nextOp {

		case ArrayAppendOp:
			v := randomValue(r, atree.MaxInlineArrayElementSize())
			expectedValues = append(expectedValues, v)

			err := array.Append(v)
			require.NoError(t, err)

		case ArraySetOp:
			k := getRandomArrayIndex(r, array)
			v := randomValue(r, atree.MaxInlineArrayElementSize())

			oldV := expectedValues[k]

			expectedValues[k] = v

			existingStorable, err := array.Set(k, v)
			require.NoError(t, err)

			existingValue, err := existingStorable.StoredValue(storage)
			require.NoError(t, err)
			testValueEqual(t, oldV, existingValue)

			if id, ok := existingStorable.(atree.SlabIDStorable); ok {
				err = storage.Remove(atree.SlabID(id))
				require.NoError(t, err)
			}

		case ArrayInsertOp:
			k := getRandomUint64InRange(r, 0, array.Count()+1)
			v := randomValue(r, atree.MaxInlineArrayElementSize())

			expectedValues = slices.Insert(expectedValues, int(k), v)

			err := array.Insert(k, v)
			require.NoError(t, err)

		case ArrayRemoveOp:
			k := getRandomArrayIndex(r, array)

			existingStorable, err := array.Remove(k)
			require.NoError(t, err)

			existingValue, err := existingStorable.StoredValue(storage)
			require.NoError(t, err)
			testValueEqual(t, expectedValues[k], existingValue)

			expectedValues = slices.Delete(expectedValues, int(k), int(k+1))

			if id, ok := existingStorable.(atree.SlabIDStorable); ok {
				err = storage.Remove(atree.SlabID(id))
				require.NoError(t, err)
			}
		}

		require.Equal(t, uint64(len(expectedValues)), array.Count())
		require.True(t, test_utils.CompareTypeInfo(typeInfo, array.Type()))
		require.Equal(t, address, array.Address())
	}

	return array, expectedValues
}

func TestArrayAppendSetInsertRemoveRandomValues(t *testing.T) {

	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	const opCount = 4096

	r := newRand(t)

	typeInfo := test_utils.NewSimpleTypeInfo(42)
	storage := newTestPersistentStorage(t)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	array, expectedValues := testArrayAppendSetInsertRemoveRandomValues(t, r, storage, typeInfo, address, opCount)
	testArray(t, storage, typeInfo, address, array, expectedValues, false)
}

func TestArrayWithChildArrayMap(t *testing.T) {

	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	t.Run("small array", func(t *testing.T) {

		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		childTypeInfo := test_utils.NewSimpleTypeInfo(43)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		// Create child arrays with 1 element.
		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			childArray, err := atree.NewArray(storage, address, childTypeInfo)
			require.NoError(t, err)

			v := test_utils.NewUint64ValueFromInteger(i)

			err = childArray.Append(v)
			require.NoError(t, err)

			require.True(t, IsArrayRootDataSlab(childArray))
			require.False(t, childArray.Inlined())

			err = array.Append(childArray)
			require.NoError(t, err)
			require.True(t, childArray.Inlined())

			expectedValues[i] = test_utils.ExpectedArrayValue{v}
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("big array", func(t *testing.T) {

		const arrayCount = uint64(4096)
		const childArrayCount = 40

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		childTypeInfo := test_utils.NewSimpleTypeInfo(43)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		// Create child arrays with 40 element.
		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			childArray, err := atree.NewArray(storage, address, childTypeInfo)
			require.NoError(t, err)

			expectedChildArrayValues := make([]atree.Value, childArrayCount)
			for j := range expectedChildArrayValues {
				v := test_utils.Uint64Value(math.MaxUint64)

				err := childArray.Append(v)
				require.NoError(t, err)

				expectedChildArrayValues[j] = v
			}

			require.False(t, IsArrayRootDataSlab(childArray))

			err = array.Append(childArray)
			require.NoError(t, err)
			require.False(t, childArray.Inlined())

			expectedValues[i] = test_utils.ExpectedArrayValue(expectedChildArrayValues)
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, true)
	})

	t.Run("small map", func(t *testing.T) {

		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		childArayTypeInfo := test_utils.NewSimpleTypeInfo(43)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			childMap, err := atree.NewMap(storage, address, atree.NewDefaultDigesterBuilder(), childArayTypeInfo)
			require.NoError(t, err)

			k := test_utils.NewUint64ValueFromInteger(i)
			v := test_utils.NewUint64ValueFromInteger(i * 2)
			storable, err := childMap.Set(test_utils.CompareValue, test_utils.GetHashInput, k, v)
			require.NoError(t, err)
			require.Nil(t, storable)

			require.True(t, IsMapRootDataSlab(childMap))

			err = array.Append(childMap)
			require.NoError(t, err)

			expectedValues[i] = test_utils.ExpectedMapValue{k: v}
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("big map", func(t *testing.T) {

		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		nestedTypeInfo := test_utils.NewSimpleTypeInfo(43)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {

			childMap, err := atree.NewMap(storage, address, atree.NewDefaultDigesterBuilder(), nestedTypeInfo)
			require.NoError(t, err)

			const childMapCount = uint64(25)
			expectedChildMapValues := test_utils.ExpectedMapValue{}
			for j := range childMapCount {
				k := test_utils.Uint64Value(j)
				v := test_utils.Uint64Value(j * 2)

				storable, err := childMap.Set(test_utils.CompareValue, test_utils.GetHashInput, k, v)
				require.NoError(t, err)
				require.Nil(t, storable)

				expectedChildMapValues[k] = v
			}

			require.False(t, IsMapRootDataSlab(childMap))

			err = array.Append(childMap)
			require.NoError(t, err)

			expectedValues[i] = expectedChildMapValues
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, true)
	})
}

func TestArrayDecodeV0(t *testing.T) {

	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	t.Run("empty", func(t *testing.T) {
		typeInfo := test_utils.NewSimpleTypeInfo(42)

		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}
		arraySlabID := atree.NewSlabID(
			address,
			atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 1},
		)

		slabData := map[atree.SlabID][]byte{
			arraySlabID: {
				// extra data
				// version
				0x00,
				// extra data flag
				0x80,
				// array of extra data
				0x81,
				// type info
				0x18, 0x2a,

				// version
				0x00,
				// array data slab flag
				0x80,
				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x00,
			},
		}

		// Decode data to new storage
		storage := newTestPersistentStorageWithData(t, slabData)

		// Test new array from storage
		array, err := atree.NewArrayWithRootID(storage, arraySlabID)
		require.NoError(t, err)

		testEmptyArrayV0(t, storage, typeInfo, address, array)
	})

	t.Run("dataslab as root", func(t *testing.T) {
		typeInfo := test_utils.NewSimpleTypeInfo(42)

		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}
		arraySlabID := atree.NewSlabID(
			address,
			atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 1},
		)

		expectedValues := []atree.Value{
			test_utils.Uint64Value(0),
		}

		slabData := map[atree.SlabID][]byte{
			arraySlabID: {
				// extra data
				// version
				0x00,
				// extra data flag
				0x80,
				// array of extra data
				0x81,
				// type info
				0x18, 0x2a,

				// version
				0x00,
				// array data slab flag
				0x80,
				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x01,
				// CBOR encoded array elements
				0xd8, 0xa4, 0x00,
			},
		}

		// Decode data to new storage
		storage := newTestPersistentStorageWithData(t, slabData)

		// Test new array from storage
		array, err := atree.NewArrayWithRootID(storage, arraySlabID)
		require.NoError(t, err)

		testArrayV0(t, storage, typeInfo, address, array, expectedValues, false)
	})

	t.Run("metadataslab as root", func(t *testing.T) {
		typeInfo := test_utils.NewSimpleTypeInfo(42)

		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		arraySlabID := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 1})
		arrayDataSlabID1 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 2})
		arrayDataSlabID2 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 3})
		childArraySlabID := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 4})

		const arrayCount = uint64(20)
		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			var v atree.Value
			if i == len(expectedValues)-1 {
				v = test_utils.ExpectedArrayValue{test_utils.Uint64Value(0)}
			} else {
				v = test_utils.NewStringValue(strings.Repeat("a", 22))
			}
			expectedValues[i] = v
		}

		slabData := map[atree.SlabID][]byte{
			// (metadata slab) headers: [{id:2 size:228 count:9} {id:3 size:270 count:11} ]
			arraySlabID: {
				// extra data
				// version
				0x00,
				// extra data flag
				0x81,
				// array of extra data
				0x81,
				// type info
				0x18, 0x2a,

				// version
				0x00,
				// array meta data slab flag
				0x81,
				// child header count
				0x00, 0x02,
				// child header 1 (slab id, count, size)
				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
				0x00, 0x00, 0x00, 0x09,
				0x00, 0x00, 0x00, 0xe4,
				// child header 2
				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
				0x00, 0x00, 0x00, 0x0b,
				0x00, 0x00, 0x01, 0x0e,
			},

			// (data slab) next: 3, data: [aaaaaaaaaaaaaaaaaaaaaa ... aaaaaaaaaaaaaaaaaaaaaa]
			arrayDataSlabID1: {
				// version
				0x00,
				// array data slab flag
				0x00,
				// next slab id
				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x09,
				// CBOR encoded array elements
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
			},

			// (data slab) next: 0, data: [aaaaaaaaaaaaaaaaaaaaaa ... atree.SlabID(...)]
			arrayDataSlabID2: {
				// version
				0x00,
				// array data slab flag
				0x40,
				// next slab id
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x0b,
				// CBOR encoded array elements
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0xd8, 0xff, 0x50, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
			},

			// (data slab) next: 0, data: [0]
			childArraySlabID: {
				// extra data
				// version
				0x00,
				// extra data flag
				0x80,
				// array of extra data
				0x81,
				// type info
				0x18, 0x2b,

				// version
				0x00,
				// array data slab flag
				0x80,
				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x01,
				// CBOR encoded array elements
				0xd8, 0xa4, 0x00,
			},
		}

		// Decode data to new storage
		storage2 := newTestPersistentStorageWithData(t, slabData)

		// Test new array from storage2
		array, err := atree.NewArrayWithRootID(storage2, arraySlabID)
		require.NoError(t, err)

		testArrayV0(t, storage2, typeInfo, address, array, expectedValues, false)
	})
}

func TestArrayEncodeDecode(t *testing.T) {

	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	t.Run("empty", func(t *testing.T) {
		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestBasicStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedData := []byte{
			// version
			0x10,
			// flag
			0x80,

			// extra data
			// array of extra data
			0x81,
			// type info
			0x18, 0x2a,

			// CBOR encoded array head (fixed size 3 byte)
			0x99, 0x00, 0x00,
		}

		slabData, err := storage.Encode()
		require.NoError(t, err)
		require.Equal(t, 1, len(slabData))
		require.Equal(t, expectedData, slabData[array.SlabID()])

		// Decode data to new storage
		storage2 := newTestPersistentStorageWithData(t, slabData)

		// Test new array from storage2
		array2, err := atree.NewArrayWithRootID(storage2, array.SlabID())
		require.NoError(t, err)

		testEmptyArray(t, storage2, typeInfo, address, array2)
	})

	t.Run("root dataslab", func(t *testing.T) {
		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestBasicStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		v := test_utils.Uint64Value(0)
		expectedValues := []atree.Value{v}
		err = array.Append(v)
		require.NoError(t, err)

		expectedData := []byte{
			// version
			0x10,
			// flag
			0x80,

			// extra data
			// array of extra data
			0x81,
			// type info
			0x18, 0x2a,

			// CBOR encoded array head (fixed size 3 byte)
			0x99, 0x00, 0x01,
			// CBOR encoded array elements
			0xd8, 0xa4, 0x00,
		}

		slabData, err := storage.Encode()
		require.NoError(t, err)
		require.Equal(t, 1, len(slabData))
		require.Equal(t, expectedData, slabData[array.SlabID()])

		// Decode data to new storage
		storage2 := newTestPersistentStorageWithData(t, slabData)

		// Test new array from storage2
		array2, err := atree.NewArrayWithRootID(storage2, array.SlabID())
		require.NoError(t, err)

		testArray(t, storage2, typeInfo, address, array2, expectedValues, false)
	})

	t.Run("root metadata slab", func(t *testing.T) {
		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestBasicStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(18)
		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewStringValue(strings.Repeat("a", 22))
			expectedValues[i] = v

			err := array.Append(v)
			require.NoError(t, err)
		}

		id1 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 1})
		id2 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 2})
		id3 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 3})

		// Expected serialized slab data with slab id
		expected := map[atree.SlabID][]byte{

			// (metadata slab) headers: [{id:2 size:228 count:9} {id:3 size:270 count:11} ]
			id1: {
				// version
				0x10,
				// flag
				0x81,

				// extra data
				// array of extra data
				0x81,
				// type info
				0x18, 0x2a,

				// child shared address
				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
				// child header count
				0x00, 0x02,
				// child header 1 (slab index, count, size)
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
				0x00, 0x00, 0x00, 0x09,
				0x00, 0xe4,
				// child header 2
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
				0x00, 0x00, 0x00, 0x09,
				0x00, 0xe4,
			},

			// (data slab) next: 3, data: [aaaaaaaaaaaaaaaaaaaaaa ... aaaaaaaaaaaaaaaaaaaaaa]
			id2: {
				// version
				0x12,
				// array data slab flag
				0x00,
				// next slab id
				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x09,
				// CBOR encoded array elements
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
			},

			// (data slab) data: [aaaaaaaaaaaaaaaaaaaaaa ... aaaaaaaaaaaaaaaaaaaaaa]
			id3: {
				// version
				0x10,
				// array data slab flag
				0x00,
				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x09,
				// CBOR encoded array elements
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
			},
		}

		m, err := storage.Encode()
		require.NoError(t, err)
		require.Equal(t, len(expected), len(m))
		require.Equal(t, expected[id1], m[id1])
		require.Equal(t, expected[id2], m[id2])
		require.Equal(t, expected[id3], m[id3])

		// Decode data to new storage
		storage2 := newTestPersistentStorageWithData(t, m)

		// Test new array from storage2
		array2, err := atree.NewArrayWithRootID(storage2, array.SlabID())
		require.NoError(t, err)

		testArray(t, storage2, typeInfo, address, array2, expectedValues, false)
	})

	// Same type info is reused.
	t.Run("root data slab, inlined child array of same type", func(t *testing.T) {
		typeInfo := test_utils.NewSimpleTypeInfo(42)
		childTypeInfo := test_utils.NewSimpleTypeInfo(43)
		storage := newTestBasicStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(2)
		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)

			childArray, err := atree.NewArray(storage, address, childTypeInfo)
			require.NoError(t, err)

			err = childArray.Append(v)
			require.NoError(t, err)

			err = parentArray.Append(childArray)
			require.NoError(t, err)

			expectedValues[i] = test_utils.ExpectedArrayValue{v}
		}

		id1 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 1})

		// Expected serialized slab data with slab id
		expected := map[atree.SlabID][]byte{
			// (data slab) data: [[0] [1]]
			id1: {
				// version
				0x11,
				// array data slab flag
				0x80,

				// extra data
				// array of extra data
				0x81,
				// type info
				0x18, 0x2a,

				// inlined extra data
				0x82,
				// element 0: array of type info
				0x80,
				// element 1: array of extra data
				0x81,
				// array extra data
				0xd8, 0xf7,
				0x81,
				// array type info ref
				0x18, 0x2b,

				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x02,
				// CBOR encoded array elements
				0xd8, 0xfa, 0x83, 0x18, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x99, 0x00, 0x01, 0xd8, 0xa4, 0x00,
				0xd8, 0xfa, 0x83, 0x18, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x99, 0x00, 0x01, 0xd8, 0xa4, 0x01,
			},
		}

		m, err := storage.Encode()
		require.NoError(t, err)
		require.Equal(t, len(expected), len(m))
		require.Equal(t, expected[id1], m[id1])

		// Decode data to new storage
		storage2 := newTestPersistentStorageWithData(t, m)

		// Test new array from storage2
		array2, err := atree.NewArrayWithRootID(storage2, parentArray.SlabID())
		require.NoError(t, err)

		testArray(t, storage2, typeInfo, address, array2, expectedValues, false)
	})

	// Different type info are encoded.
	t.Run("root data slab, inlined array of different type", func(t *testing.T) {
		typeInfo := test_utils.NewSimpleTypeInfo(42)
		typeInfo2 := test_utils.NewSimpleTypeInfo(43)
		typeInfo3 := test_utils.NewSimpleTypeInfo(44)
		storage := newTestBasicStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(2)
		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)

			var ti atree.TypeInfo
			if i == 0 {
				ti = typeInfo3
			} else {
				ti = typeInfo2
			}
			childArray, err := atree.NewArray(storage, address, ti)
			require.NoError(t, err)

			err = childArray.Append(v)
			require.NoError(t, err)

			err = parentArray.Append(childArray)
			require.NoError(t, err)

			expectedValues[i] = test_utils.ExpectedArrayValue{v}
		}

		id1 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 1})

		// Expected serialized slab data with slab id
		expected := map[atree.SlabID][]byte{
			// (data slab) data: [[0] [1]]
			id1: {
				// version
				0x11,
				// array data slab flag
				0x80,

				// extra data
				// array of extra data
				0x81,
				// type info
				0x18, 0x2a,

				// inlined extra data
				0x82,
				// element 0: array of inlined type info
				0x80,
				// element 1: array of inlined extra data
				0x82,
				// inlined array extra data
				0xd8, 0xf7,
				0x81,
				0x18, 0x2c,
				// inlined array extra data
				0xd8, 0xf7,
				0x81,
				0x18, 0x2b,

				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x02,
				// CBOR encoded array elements
				0xd8, 0xfa, 0x83, 0x18, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x99, 0x00, 0x01, 0xd8, 0xa4, 0x00,
				0xd8, 0xfa, 0x83, 0x18, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x99, 0x00, 0x01, 0xd8, 0xa4, 0x01,
			},
		}

		m, err := storage.Encode()
		require.NoError(t, err)
		require.Equal(t, len(expected), len(m))
		require.Equal(t, expected[id1], m[id1])

		// Decode data to new storage
		storage2 := newTestPersistentStorageWithData(t, m)

		// Test new array from storage2
		array2, err := atree.NewArrayWithRootID(storage2, parentArray.SlabID())
		require.NoError(t, err)

		testArray(t, storage2, typeInfo, address, array2, expectedValues, false)
	})

	// Same type info is reused.
	t.Run("root data slab, multiple levels of inlined array of same type", func(t *testing.T) {
		typeInfo := test_utils.NewSimpleTypeInfo(42)
		typeInfo2 := test_utils.NewSimpleTypeInfo(43)
		typeInfo3 := test_utils.NewSimpleTypeInfo(44)
		storage := newTestBasicStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(2)
		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)

			gchildArray, err := atree.NewArray(storage, address, typeInfo2)
			require.NoError(t, err)

			err = gchildArray.Append(v)
			require.NoError(t, err)

			childArray, err := atree.NewArray(storage, address, typeInfo3)
			require.NoError(t, err)

			err = childArray.Append(gchildArray)
			require.NoError(t, err)

			err = parentArray.Append(childArray)
			require.NoError(t, err)

			expectedValues[i] = test_utils.ExpectedArrayValue{
				test_utils.ExpectedArrayValue{
					v,
				},
			}
		}

		id1 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 1})

		// Expected serialized slab data with slab id
		expected := map[atree.SlabID][]byte{
			// (data slab) data: [[0] [1]]
			id1: {
				// version
				0x11,
				// array data slab flag
				0x80,

				// extra data
				// array of extra data
				0x81,
				// type info
				0x18, 0x2a,

				// inlined extra data
				0x82,
				// element 0: array of inlined type info
				0x80,
				// element 1: array of inlined extra data
				0x82,
				// inlined array extra data
				0xd8, 0xf7,
				0x81,
				0x18, 0x2c,
				0xd8, 0xf7,
				0x81,
				0x18, 0x2b,

				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x02,
				// CBOR encoded array elements
				0xd8, 0xfa, 0x83, 0x18, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x99, 0x00, 0x01, 0xd8, 0xfa, 0x83, 0x18, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x99, 0x00, 0x01, 0xd8, 0xa4, 0x00,
				0xd8, 0xfa, 0x83, 0x18, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x99, 0x00, 0x01, 0xd8, 0xfa, 0x83, 0x18, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x99, 0x00, 0x01, 0xd8, 0xa4, 0x01,
			},
		}

		m, err := storage.Encode()
		require.NoError(t, err)
		require.Equal(t, len(expected), len(m))
		require.Equal(t, expected[id1], m[id1])

		// Decode data to new storage
		storage2 := newTestPersistentStorageWithData(t, m)

		// Test new array from storage2
		array2, err := atree.NewArrayWithRootID(storage2, parentArray.SlabID())
		require.NoError(t, err)

		testArray(t, storage2, typeInfo, address, array2, expectedValues, false)
	})

	t.Run("root data slab, multiple levels of inlined array of different type", func(t *testing.T) {
		typeInfo := test_utils.NewSimpleTypeInfo(42)
		typeInfo2 := test_utils.NewSimpleTypeInfo(43)
		typeInfo3 := test_utils.NewSimpleTypeInfo(44)
		typeInfo4 := test_utils.NewSimpleTypeInfo(45)
		typeInfo5 := test_utils.NewSimpleTypeInfo(46)
		storage := newTestBasicStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(2)
		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)

			var ti atree.TypeInfo
			if i == 0 {
				ti = typeInfo2
			} else {
				ti = typeInfo4
			}
			gchildArray, err := atree.NewArray(storage, address, ti)
			require.NoError(t, err)

			err = gchildArray.Append(v)
			require.NoError(t, err)

			if i == 0 {
				ti = typeInfo3
			} else {
				ti = typeInfo5
			}
			childArray, err := atree.NewArray(storage, address, ti)
			require.NoError(t, err)

			err = childArray.Append(gchildArray)
			require.NoError(t, err)

			err = parentArray.Append(childArray)
			require.NoError(t, err)

			expectedValues[i] = test_utils.ExpectedArrayValue{
				test_utils.ExpectedArrayValue{
					v,
				},
			}
		}

		id1 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 1})

		// Expected serialized slab data with slab id
		expected := map[atree.SlabID][]byte{
			// (data slab) data: [[0] [1]]
			id1: {
				// version
				0x11,
				// array data slab flag
				0x80,

				// extra data
				// array of extra data
				0x81,
				// type info
				0x18, 0x2a,

				// inlined extra data
				0x82,
				// element 0: array of inlined type info
				0x80,
				// element 1: array of inlined extra data
				0x84,
				// typeInfo3
				0xd8, 0xf7,
				0x81,
				0x18, 0x2c,
				// typeInfo2
				0xd8, 0xf7,
				0x81,
				0x18, 0x2b,
				// typeInfo5
				0xd8, 0xf7,
				0x81,
				0x18, 0x2e,
				// typeInfo4
				0xd8, 0xf7,
				0x81,
				0x18, 0x2d,

				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x02,
				// CBOR encoded array elements
				0xd8, 0xfa, 0x83, 0x18, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x99, 0x00, 0x01, 0xd8, 0xfa, 0x83, 0x18, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x99, 0x00, 0x01, 0xd8, 0xa4, 0x00,
				0xd8, 0xfa, 0x83, 0x18, 0x02, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x99, 0x00, 0x01, 0xd8, 0xfa, 0x83, 0x18, 0x03, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x99, 0x00, 0x01, 0xd8, 0xa4, 0x01,
			},
		}

		m, err := storage.Encode()
		require.NoError(t, err)
		require.Equal(t, len(expected), len(m))
		require.Equal(t, expected[id1], m[id1])

		// Decode data to new storage
		storage2 := newTestPersistentStorageWithData(t, m)

		// Test new array from storage2
		array2, err := atree.NewArrayWithRootID(storage2, parentArray.SlabID())
		require.NoError(t, err)

		testArray(t, storage2, typeInfo, address, array2, expectedValues, false)
	})

	t.Run("root metadata slab, inlined array of same type", func(t *testing.T) {

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		typeInfo2 := test_utils.NewSimpleTypeInfo(43)
		storage := newTestBasicStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(20)
		expectedValues := make([]atree.Value, 0, arrayCount)
		for range arrayCount - 2 {
			v := test_utils.NewStringValue(strings.Repeat("a", 22))

			err := array.Append(v)
			require.NoError(t, err)

			expectedValues = append(expectedValues, v)
		}

		for i := range uint64(2) {
			childArray, err := atree.NewArray(storage, address, typeInfo2)
			require.NoError(t, err)

			v := test_utils.Uint64Value(i)
			err = childArray.Append(v)
			require.NoError(t, err)

			err = array.Append(childArray)
			require.NoError(t, err)

			expectedValues = append(expectedValues, test_utils.ExpectedArrayValue{v})
		}

		require.Equal(t, arrayCount, array.Count())

		id1 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 1})
		id2 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 2})
		id3 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 3})

		// Expected serialized slab data with slab id
		expected := map[atree.SlabID][]byte{

			// (metadata slab) headers: [{id:2 size:228 count:9} {id:3 size:268 count:11} ]
			id1: {
				// version
				0x10,
				// flag
				0x81,

				// extra data
				// array of extra data
				0x81,
				// type info
				0x18, 0x2a,

				// child shared address
				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
				// child header count
				0x00, 0x02,
				// child header 1 (slab index, count, size)
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
				0x00, 0x00, 0x00, 0x09,
				0x00, 0xe4,
				// child header 2
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
				0x00, 0x00, 0x00, 0x0b,
				0x01, 0x0c,
			},

			// (data slab) next: 3, data: [aaaaaaaaaaaaaaaaaaaaaa ... aaaaaaaaaaaaaaaaaaaaaa]
			id2: {
				// version
				0x12,
				// array data slab flag
				0x00,
				// next slab id
				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x09,
				// CBOR encoded array elements
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
			},

			// (data slab) next: 0, data: [aaaaaaaaaaaaaaaaaaaaaa ... [0] [1]]
			id3: {
				// version
				0x11,
				// array data slab flag
				0x00,
				// inlined extra data
				0x82,
				// element 0: array of inlined type info
				0x80,
				// element 1: array of inlined extra data
				0x81,
				// inlined array extra data
				0xd8, 0xf7,
				0x81,
				0x18, 0x2b,
				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x0b,
				// CBOR encoded array elements
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0xd8, 0xfa, 0x83, 0x18, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x99, 0x00, 0x01, 0xd8, 0xa4, 0x0,
				0xd8, 0xfa, 0x83, 0x18, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x99, 0x00, 0x01, 0xd8, 0xa4, 0x1,
			},
		}

		m, err := storage.Encode()
		require.NoError(t, err)
		require.Equal(t, len(expected), len(m))
		require.Equal(t, expected[id1], m[id1])
		require.Equal(t, expected[id2], m[id2])
		require.Equal(t, expected[id3], m[id3])

		// Decode data to new storage
		storage2 := newTestPersistentStorageWithData(t, m)

		// Test new array from storage2
		array2, err := atree.NewArrayWithRootID(storage2, array.SlabID())
		require.NoError(t, err)

		testArray(t, storage2, typeInfo, address, array2, expectedValues, false)
	})

	t.Run("root metadata slab, inlined array of different type", func(t *testing.T) {

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		typeInfo2 := test_utils.NewSimpleTypeInfo(43)
		typeInfo3 := test_utils.NewSimpleTypeInfo(44)
		storage := newTestBasicStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(20)
		expectedValues := make([]atree.Value, 0, arrayCount)
		for range arrayCount - 2 {
			v := test_utils.NewStringValue(strings.Repeat("a", 22))

			err := array.Append(v)
			require.NoError(t, err)

			expectedValues = append(expectedValues, v)
		}

		for i := range uint64(2) {
			var ti atree.TypeInfo
			if i == 0 {
				ti = typeInfo3
			} else {
				ti = typeInfo2
			}

			childArray, err := atree.NewArray(storage, address, ti)
			require.NoError(t, err)

			v := test_utils.Uint64Value(i)

			err = childArray.Append(v)
			require.NoError(t, err)

			err = array.Append(childArray)
			require.NoError(t, err)

			expectedValues = append(expectedValues, test_utils.ExpectedArrayValue{v})
		}

		require.Equal(t, arrayCount, array.Count())

		id1 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 1})
		id2 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 2})
		id3 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 3})

		// Expected serialized slab data with slab id
		expected := map[atree.SlabID][]byte{

			// (metadata slab) headers: [{id:2 size:228 count:9} {id:3 size:268 count:11} ]
			id1: {
				// version
				0x10,
				// flag
				0x81,

				// extra data
				// array of extra data
				0x81,
				// type info
				0x18, 0x2a,

				// child shared address
				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
				// child header count
				0x00, 0x02,
				// child header 1 (slab index, count, size)
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
				0x00, 0x00, 0x00, 0x09,
				0x00, 0xe4,
				// child header 2
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
				0x00, 0x00, 0x00, 0x0b,
				0x01, 0x0c,
			},

			// (data slab) next: 3, data: [aaaaaaaaaaaaaaaaaaaaaa ... aaaaaaaaaaaaaaaaaaaaaa]
			id2: {
				// version
				0x12,
				// array data slab flag
				0x00,
				// next slab id
				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x09,
				// CBOR encoded array elements
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
			},

			// (data slab) next: 0, data: [aaaaaaaaaaaaaaaaaaaaaa ... [0] [1]]
			id3: {
				// version
				0x11,
				// array data slab flag
				0x00,
				// inlined extra data
				0x82,
				// element 0: array of inlined extra data
				0x80,
				// element 1: array of inlined extra data
				0x82,
				// inlined array extra data
				0xd8, 0xf7,
				0x81,
				0x18, 0x2c,
				0xd8, 0xf7,
				0x81,
				0x18, 0x2b,
				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x0b,
				// CBOR encoded array elements
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0xd8, 0xfa, 0x83, 0x18, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x99, 0x00, 0x01, 0xd8, 0xa4, 0x0,
				0xd8, 0xfa, 0x83, 0x18, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x99, 0x00, 0x01, 0xd8, 0xa4, 0x1,
			},
		}

		m, err := storage.Encode()
		require.NoError(t, err)
		require.Equal(t, len(expected), len(m))
		require.Equal(t, expected[id1], m[id1])
		require.Equal(t, expected[id2], m[id2])
		require.Equal(t, expected[id3], m[id3])

		// Decode data to new storage
		storage2 := newTestPersistentStorageWithData(t, m)

		// Test new array from storage2
		array2, err := atree.NewArrayWithRootID(storage2, array.SlabID())
		require.NoError(t, err)

		testArray(t, storage2, typeInfo, address, array2, expectedValues, false)
	})

	t.Run("has pointers", func(t *testing.T) {
		typeInfo := test_utils.NewSimpleTypeInfo(42)
		typeInfo2 := test_utils.NewSimpleTypeInfo(43)
		storage := newTestBasicStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(20)
		expectedValues := make([]atree.Value, 0, arrayCount)
		for range arrayCount - 1 {
			v := test_utils.NewStringValue(strings.Repeat("a", 22))

			err := array.Append(v)
			require.NoError(t, err)

			expectedValues = append(expectedValues, v)
		}

		const childArrayCount = uint64(5)

		childArray, err := atree.NewArray(storage, address, typeInfo2)
		require.NoError(t, err)

		expectedChildArrayValues := make([]atree.Value, childArrayCount)
		for i := range expectedChildArrayValues {
			v := test_utils.NewStringValue(strings.Repeat("b", 22))
			err = childArray.Append(v)
			require.NoError(t, err)
			expectedChildArrayValues[i] = v
		}

		err = array.Append(childArray)
		require.NoError(t, err)

		expectedValues = append(expectedValues, test_utils.ExpectedArrayValue(expectedChildArrayValues))

		require.Equal(t, arrayCount, array.Count())
		require.Equal(t, childArrayCount, childArray.Count())

		id1 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 1})
		id2 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 2})
		id3 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 3})
		id4 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 4})

		// Expected serialized slab data with slab id
		expected := map[atree.SlabID][]byte{

			// (metadata slab) headers: [{id:2 size:228 count:9} {id:3 size:270 count:11} ]
			id1: {
				// version
				0x10,
				// flag
				0x81,

				// extra data
				// array of extra data
				0x81,
				// type info
				0x18, 0x2a,

				// child shared address
				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
				// child header count
				0x00, 0x02,
				// child header 1 (slab index, count, size)
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
				0x00, 0x00, 0x00, 0x09,
				0x00, 0xe4,
				// child header 2
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
				0x00, 0x00, 0x00, 0x0b,
				0x01, 0x0e,
			},

			// (data slab) next: 3, data: [aaaaaaaaaaaaaaaaaaaaaa ... aaaaaaaaaaaaaaaaaaaaaa]
			id2: {
				// version
				0x12,
				// array data slab flag
				0x00,
				// next slab id
				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x09,
				// CBOR encoded array elements
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
			},

			// (data slab) next: 0, data: [aaaaaaaaaaaaaaaaaaaaaa ... atree.SlabID(...)]
			id3: {
				// version (no next slab ID, no inlined slabs)
				0x10,
				// array data slab flag
				0x40,
				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x0b,
				// CBOR encoded array elements
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0xd8, 0xff, 0x50, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
			},

			// (data slab) next: 0, data: [bbbbbbbbbbbbbbbbbbbbbb ...]
			id4: {
				// version
				0x10,
				// extra data flag
				0x80,

				// extra data
				// array of extra data
				0x81,
				// type info
				0x18, 0x2b,

				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x05,
				// CBOR encoded array elements
				0x76, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62,
				0x76, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62,
				0x76, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62,
				0x76, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62,
				0x76, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62,
			},
		}

		m, err := storage.Encode()
		require.NoError(t, err)
		require.Equal(t, len(expected), len(m))
		require.Equal(t, expected[id1], m[id1])
		require.Equal(t, expected[id2], m[id2])
		require.Equal(t, expected[id3], m[id3])
		require.Equal(t, expected[id4], m[id4])

		// Decode data to new storage
		storage2 := newTestPersistentStorageWithData(t, m)

		// Test new array from storage2
		array2, err := atree.NewArrayWithRootID(storage2, array.SlabID())
		require.NoError(t, err)

		testArray(t, storage2, typeInfo, address, array2, expectedValues, false)
	})

	t.Run("has pointers in inlined slab", func(t *testing.T) {
		typeInfo := test_utils.NewSimpleTypeInfo(42)
		typeInfo2 := test_utils.NewSimpleTypeInfo(43)
		typeInfo3 := test_utils.NewSimpleTypeInfo(44)
		storage := newTestBasicStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(20)
		expectedValues := make([]atree.Value, 0, arrayCount)
		for range arrayCount - 1 {
			v := test_utils.NewStringValue(strings.Repeat("a", 22))

			err := array.Append(v)
			require.NoError(t, err)

			expectedValues = append(expectedValues, v)
		}

		childArray, err := atree.NewArray(storage, address, typeInfo3)
		require.NoError(t, err)

		gchildArray, err := atree.NewArray(storage, address, typeInfo2)
		require.NoError(t, err)

		const gchildArrayCount = 5

		expectedGChildArrayValues := make([]atree.Value, gchildArrayCount)
		for i := range expectedGChildArrayValues {
			v := test_utils.NewStringValue(strings.Repeat("b", 22))

			err = gchildArray.Append(v)
			require.NoError(t, err)

			expectedGChildArrayValues[i] = v
		}

		err = childArray.Append(gchildArray)
		require.NoError(t, err)

		err = array.Append(childArray)
		require.NoError(t, err)

		expectedValues = append(expectedValues, test_utils.ExpectedArrayValue{
			test_utils.ExpectedArrayValue(expectedGChildArrayValues),
		})

		require.Equal(t, arrayCount, array.Count())
		require.Equal(t, uint64(1), childArray.Count())
		require.Equal(t, uint64(5), gchildArray.Count())

		id1 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 1})
		id2 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 2})
		id3 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 3})
		id4 := atree.NewSlabID(address, atree.SlabIndex{0, 0, 0, 0, 0, 0, 0, 5})

		// Expected serialized slab data with slab id
		expected := map[atree.SlabID][]byte{

			// (metadata slab) headers: [{id:2 size:228 count:9} {id:3 size:287 count:11} ]
			id1: {
				// version
				0x10,
				// flag
				0x81,

				// extra data
				// array of extra data
				0x81,
				// type info
				0x18, 0x2a,

				// child shared address
				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
				// child header count
				0x00, 0x02,
				// child header 1 (slab index, count, size)
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
				0x00, 0x00, 0x00, 0x09,
				0x00, 0xe4,
				// child header 2
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
				0x00, 0x00, 0x00, 0x0b,
				0x01, 0x1f,
			},

			// (data slab) next: 3, data: [aaaaaaaaaaaaaaaaaaaaaa ... aaaaaaaaaaaaaaaaaaaaaa]
			id2: {
				// version
				0x12,
				// array data slab flag
				0x00,
				// next slab id
				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x09,
				// CBOR encoded array elements
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
			},

			// (data slab) next: 0, data: [aaaaaaaaaaaaaaaaaaaaaa ... [atree.SlabID(...)]]
			id3: {
				// version (no next slab ID, has inlined slabs)
				0x11,
				// array data slab flag (has pointer)
				0x40,

				// inlined extra data
				0x82,
				// element 0: array of type info
				0x80,
				// element 1: array of extra data
				0x81,
				// type info
				0xd8, 0xf7,
				0x81,
				0x18, 0x2c,

				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x0b,
				// CBOR encoded array elements
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0x76, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
				0xd8, 0xfa, 0x83, 0x18, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x99, 0x00, 0x01,
				0xd8, 0xff, 0x50, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
			},

			// (data slab) data: [bbbbbbbbbbbbbbbbbbbbbb ...]
			id4: {
				// version
				0x10,
				// extra data flag
				0x80,

				// extra data
				// array of extra data
				0x81,
				// type info
				0x18, 0x2b,

				// CBOR encoded array head (fixed size 3 byte)
				0x99, 0x00, 0x05,
				// CBOR encoded array elements
				0x76, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62,
				0x76, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62,
				0x76, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62,
				0x76, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62,
				0x76, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62,
			},
		}

		m, err := storage.Encode()
		require.NoError(t, err)
		require.Equal(t, len(expected), len(m))
		require.Equal(t, expected[id1], m[id1])
		require.Equal(t, expected[id2], m[id2])
		require.Equal(t, expected[id3], m[id3])
		require.Equal(t, expected[id4], m[id4])

		// Decode data to new storage
		storage2 := newTestPersistentStorageWithData(t, m)

		// Test new array from storage2
		array2, err := atree.NewArrayWithRootID(storage2, array.SlabID())
		require.NoError(t, err)

		testArray(t, storage2, typeInfo, address, array2, expectedValues, false)
	})
}

func TestArrayEncodeDecodeRandomValues(t *testing.T) {

	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	const opCount = 8192

	r := newRand(t)

	typeInfo := test_utils.NewSimpleTypeInfo(42)
	storage := newTestPersistentStorage(t)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	array, expectedValues := testArrayAppendSetInsertRemoveRandomValues(t, r, storage, typeInfo, address, opCount)

	testArray(t, storage, typeInfo, address, array, expectedValues, false)

	// Decode data to new storage
	storage2 := newTestPersistentStorageWithBaseStorage(t, atree.GetBaseStorage(storage))

	// Test new array from storage2
	array2, err := atree.NewArrayWithRootID(storage2, array.SlabID())
	require.NoError(t, err)

	testArray(t, storage2, typeInfo, address, array2, expectedValues, false)
}

func TestEmptyArray(t *testing.T) {

	t.Parallel()

	typeInfo := test_utils.NewSimpleTypeInfo(42)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}
	storage := newTestBasicStorage(t)

	array, err := atree.NewArray(storage, address, typeInfo)
	require.NoError(t, err)

	t.Run("get", func(t *testing.T) {
		s, err := array.Get(0)
		require.Equal(t, 1, errorCategorizationCount(err))
		var userError *atree.UserError
		var indexOutOfBoundsError *atree.IndexOutOfBoundsError
		require.ErrorAs(t, err, &userError)
		require.ErrorAs(t, err, &indexOutOfBoundsError)
		require.ErrorAs(t, userError, &indexOutOfBoundsError)
		require.Nil(t, s)
	})

	t.Run("set", func(t *testing.T) {
		s, err := array.Set(0, test_utils.Uint64Value(0))
		require.Equal(t, 1, errorCategorizationCount(err))
		var userError *atree.UserError
		var indexOutOfBoundsError *atree.IndexOutOfBoundsError
		require.ErrorAs(t, err, &userError)
		require.ErrorAs(t, err, &indexOutOfBoundsError)
		require.ErrorAs(t, userError, &indexOutOfBoundsError)
		require.Nil(t, s)
	})

	t.Run("insert", func(t *testing.T) {
		err := array.Insert(1, test_utils.Uint64Value(0))
		require.Equal(t, 1, errorCategorizationCount(err))
		var userError *atree.UserError
		var indexOutOfBoundsError *atree.IndexOutOfBoundsError
		require.ErrorAs(t, err, &userError)
		require.ErrorAs(t, err, &indexOutOfBoundsError)
		require.ErrorAs(t, userError, &indexOutOfBoundsError)
	})

	t.Run("remove", func(t *testing.T) {
		s, err := array.Remove(0)
		require.Equal(t, 1, errorCategorizationCount(err))
		var userError *atree.UserError
		var indexOutOfBoundsError *atree.IndexOutOfBoundsError
		require.ErrorAs(t, err, &userError)
		require.ErrorAs(t, err, &indexOutOfBoundsError)
		require.ErrorAs(t, userError, &indexOutOfBoundsError)
		require.Nil(t, s)
	})

	t.Run("readonly iterate", func(t *testing.T) {
		i := uint64(0)
		err := array.IterateReadOnly(func(atree.Value) (bool, error) {
			i++
			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, uint64(0), i)
	})

	t.Run("iterate", func(t *testing.T) {
		i := uint64(0)
		err := array.Iterate(func(atree.Value) (bool, error) {
			i++
			return true, nil
		})
		require.NoError(t, err)
		require.Equal(t, uint64(0), i)
	})

	t.Run("count", func(t *testing.T) {
		count := array.Count()
		require.Equal(t, uint64(0), count)
	})

	t.Run("type", func(t *testing.T) {
		require.True(t, test_utils.CompareTypeInfo(typeInfo, array.Type()))
	})

	// TestArrayEncodeDecode/empty tests empty array encoding and decoding
}

func TestArrayStringElement(t *testing.T) {

	t.Parallel()

	t.Run("inline", func(t *testing.T) {

		const arrayCount = uint64(4096)

		r := newRand(t)

		stringSize := int(atree.MaxInlineArrayElementSize() - 3)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			s := randStr(r, stringSize)
			expectedValues[i] = test_utils.NewStringValue(s)
		}

		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}
		typeInfo := test_utils.NewSimpleTypeInfo(42)

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		for i := range expectedValues {
			err := array.Append(expectedValues[i])
			require.NoError(t, err)
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, false)

		stats, err := atree.GetArrayStats(array)
		require.NoError(t, err)
		require.Equal(t, uint64(0), stats.StorableSlabCount)
	})

	t.Run("external slab", func(t *testing.T) {

		const arrayCount = uint64(4096)

		r := newRand(t)

		stringSize := int(atree.MaxInlineArrayElementSize() + 512)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			s := randStr(r, stringSize)
			expectedValues[i] = test_utils.NewStringValue(s)
		}

		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}
		typeInfo := test_utils.NewSimpleTypeInfo(42)

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		for i := range expectedValues {
			err := array.Append(expectedValues[i])
			require.NoError(t, err)
		}

		testArray(t, storage, typeInfo, address, array, expectedValues, false)

		stats, err := atree.GetArrayStats(array)
		require.NoError(t, err)
		require.Equal(t, arrayCount, stats.StorableSlabCount)
	})
}

func TestArrayStoredValue(t *testing.T) {

	const arrayCount = uint64(4096)

	typeInfo := test_utils.NewSimpleTypeInfo(42)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}
	storage := newTestPersistentStorage(t)

	array, err := atree.NewArray(storage, address, typeInfo)
	require.NoError(t, err)

	expectedValues := make([]atree.Value, arrayCount)
	for i := range expectedValues {
		v := test_utils.NewUint64ValueFromInteger(i)
		expectedValues[i] = v
		err := array.Append(v)
		require.NoError(t, err)
	}

	rootID := array.SlabID()

	slabIterator, err := storage.SlabIterator()
	require.NoError(t, err)

	for {
		id, slab := slabIterator()

		if id == atree.SlabIDUndefined {
			break
		}

		value, err := slab.StoredValue(storage)

		if id == rootID {
			require.NoError(t, err)

			array2, ok := value.(*atree.Array)
			require.True(t, ok)

			testArray(t, storage, typeInfo, address, array2, expectedValues, false)
		} else {
			require.Equal(t, 1, errorCategorizationCount(err))
			var fatalError *atree.FatalError
			var notValueError *atree.NotValueError
			require.ErrorAs(t, err, &fatalError)
			require.ErrorAs(t, err, &notValueError)
			require.ErrorAs(t, fatalError, &notValueError)
			require.Nil(t, value)
		}
	}
}

func TestArrayPopIterate(t *testing.T) {

	t.Run("empty", func(t *testing.T) {
		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		i := uint64(0)
		err = array.PopIterate(func(atree.Storable) {
			i++
		})
		require.NoError(t, err)
		require.Equal(t, uint64(0), i)

		testEmptyArray(t, storage, typeInfo, address, array)
	})

	t.Run("root-dataslab", func(t *testing.T) {

		const arrayCount = uint64(10)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = v
			err := array.Append(v)
			require.NoError(t, err)
		}

		i := uint64(0)
		err = array.PopIterate(func(v atree.Storable) {
			vv, err := v.StoredValue(storage)
			require.NoError(t, err)
			testValueEqual(t, expectedValues[arrayCount-i-1], vv)
			i++
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)

		testEmptyArray(t, storage, typeInfo, address, array)
	})

	t.Run("root-metaslab", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = v
			err := array.Append(v)
			require.NoError(t, err)
		}

		i := uint64(0)
		err = array.PopIterate(func(v atree.Storable) {
			vv, err := v.StoredValue(storage)
			require.NoError(t, err)
			testValueEqual(t, expectedValues[arrayCount-i-1], vv)
			i++
		})
		require.NoError(t, err)
		require.Equal(t, arrayCount, i)

		testEmptyArray(t, storage, typeInfo, address, array)
	})
}

func TestArrayFromBatchData(t *testing.T) {

	t.Run("empty", func(t *testing.T) {
		typeInfo := test_utils.NewSimpleTypeInfo(42)

		array, err := atree.NewArray(
			newTestPersistentStorage(t),
			atree.Address{1, 2, 3, 4, 5, 6, 7, 8},
			typeInfo)
		require.NoError(t, err)
		require.Equal(t, uint64(0), array.Count())

		iter, err := array.ReadOnlyIterator()
		require.NoError(t, err)

		// Create a new array with new storage, new address, and original array's elements.
		address := atree.Address{2, 3, 4, 5, 6, 7, 8, 9}
		storage := newTestPersistentStorage(t)
		copied, err := atree.NewArrayFromBatchData(
			storage,
			address,
			array.Type(),
			func() (atree.Value, error) {
				return iter.Next()
			})
		require.NoError(t, err)
		require.NotEqual(t, copied.SlabID(), array.SlabID())

		testEmptyArray(t, storage, typeInfo, address, copied)
	})

	t.Run("root-dataslab", func(t *testing.T) {

		const arrayCount = uint64(10)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		array, err := atree.NewArray(
			newTestPersistentStorage(t),
			atree.Address{1, 2, 3, 4, 5, 6, 7, 8},
			typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = v
			err := array.Append(v)
			require.NoError(t, err)
		}

		require.Equal(t, arrayCount, array.Count())

		iter, err := array.ReadOnlyIterator()
		require.NoError(t, err)

		// Create a new array with new storage, new address, and original array's elements.
		address := atree.Address{2, 3, 4, 5, 6, 7, 8, 9}
		storage := newTestPersistentStorage(t)
		copied, err := atree.NewArrayFromBatchData(
			storage,
			address,
			array.Type(),
			func() (atree.Value, error) {
				return iter.Next()
			})

		require.NoError(t, err)
		require.NotEqual(t, copied.SlabID(), array.SlabID())

		testArray(t, storage, typeInfo, address, copied, expectedValues, false)
	})

	t.Run("root-metaslab", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(4096)

		typeInfo := test_utils.NewSimpleTypeInfo(42)

		array, err := atree.NewArray(
			newTestPersistentStorage(t),
			atree.Address{1, 2, 3, 4, 5, 6, 7, 8},
			typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := test_utils.NewUint64ValueFromInteger(i)
			expectedValues[i] = v
			err := array.Append(v)
			require.NoError(t, err)
		}

		require.Equal(t, arrayCount, array.Count())

		iter, err := array.ReadOnlyIterator()
		require.NoError(t, err)

		address := atree.Address{2, 3, 4, 5, 6, 7, 8, 9}
		storage := newTestPersistentStorage(t)
		copied, err := atree.NewArrayFromBatchData(
			storage,
			address,
			array.Type(),
			func() (atree.Value, error) {
				return iter.Next()
			})

		require.NoError(t, err)
		require.NotEqual(t, array.SlabID(), copied.SlabID())

		testArray(t, storage, typeInfo, address, copied, expectedValues, false)
	})

	t.Run("rebalance two data slabs", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(36)

		typeInfo := test_utils.NewSimpleTypeInfo(42)

		array, err := atree.NewArray(
			newTestPersistentStorage(t),
			atree.Address{1, 2, 3, 4, 5, 6, 7, 8},
			typeInfo)
		require.NoError(t, err)

		var expectedValues []atree.Value
		var v atree.Value

		v = test_utils.NewStringValue(strings.Repeat("a", int(atree.MaxInlineArrayElementSize()-2)))
		expectedValues = append(expectedValues, v)

		err = array.Insert(0, v)
		require.NoError(t, err)

		for i := range arrayCount - 1 {
			v = test_utils.Uint64Value(i)
			expectedValues = append(expectedValues, v)

			err = array.Append(v)
			require.NoError(t, err)
		}

		require.Equal(t, arrayCount, array.Count())

		iter, err := array.ReadOnlyIterator()
		require.NoError(t, err)

		storage := newTestPersistentStorage(t)
		address := atree.Address{2, 3, 4, 5, 6, 7, 8, 9}
		copied, err := atree.NewArrayFromBatchData(
			storage,
			address,
			array.Type(),
			func() (atree.Value, error) {
				return iter.Next()
			})

		require.NoError(t, err)
		require.NotEqual(t, array.SlabID(), copied.SlabID())

		testArray(t, storage, typeInfo, address, copied, expectedValues, false)
	})

	t.Run("merge two data slabs", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(36)

		typeInfo := test_utils.NewSimpleTypeInfo(42)

		array, err := atree.NewArray(
			newTestPersistentStorage(t),
			atree.Address{1, 2, 3, 4, 5, 6, 7, 8},
			typeInfo)
		require.NoError(t, err)

		var expectedValues []atree.Value
		var v atree.Value
		for i := range arrayCount - 1 {
			v = test_utils.Uint64Value(i)
			expectedValues = append(expectedValues, v)
			err = array.Append(v)
			require.NoError(t, err)
		}

		v = test_utils.NewStringValue(strings.Repeat("a", int(atree.MaxInlineArrayElementSize()-2)))

		expectedValues = slices.Insert(expectedValues, 25, v)

		err = array.Insert(25, v)
		require.NoError(t, err)

		require.Equal(t, arrayCount, array.Count())

		iter, err := array.ReadOnlyIterator()
		require.NoError(t, err)

		storage := newTestPersistentStorage(t)
		address := atree.Address{2, 3, 4, 5, 6, 7, 8, 9}
		copied, err := atree.NewArrayFromBatchData(
			storage,
			address,
			array.Type(),
			func() (atree.Value, error) {
				return iter.Next()
			})

		require.NoError(t, err)
		require.NotEqual(t, array.SlabID(), copied.SlabID())

		testArray(t, storage, typeInfo, address, copied, expectedValues, false)
	})

	t.Run("random", func(t *testing.T) {
		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		const arrayCount = uint64(4096)

		r := newRand(t)

		typeInfo := test_utils.NewSimpleTypeInfo(42)

		array, err := atree.NewArray(
			newTestPersistentStorage(t),
			atree.Address{1, 2, 3, 4, 5, 6, 7, 8},
			typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			v := randomValue(r, atree.MaxInlineArrayElementSize())
			expectedValues[i] = v

			err := array.Append(v)
			require.NoError(t, err)
		}

		require.Equal(t, arrayCount, array.Count())

		iter, err := array.ReadOnlyIterator()
		require.NoError(t, err)

		storage := newTestPersistentStorage(t)

		address := atree.Address{2, 3, 4, 5, 6, 7, 8, 9}
		copied, err := atree.NewArrayFromBatchData(
			storage,
			address,
			array.Type(),
			func() (atree.Value, error) {
				return iter.Next()
			})

		require.NoError(t, err)
		require.NotEqual(t, array.SlabID(), copied.SlabID())

		testArray(t, storage, typeInfo, address, copied, expectedValues, false)
	})

	t.Run("data slab too large", func(t *testing.T) {
		// Slab size must not exceed maxThreshold.
		// We cannot make this problem happen after Atree Issue #193
		// was fixed by PR #194 & PR #197. This test is to catch regressions.

		atree.SetThreshold(256)
		defer atree.SetThreshold(1024)

		r := newRand(t)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		array, err := atree.NewArray(
			newTestPersistentStorage(t),
			atree.Address{1, 2, 3, 4, 5, 6, 7, 8},
			typeInfo)
		require.NoError(t, err)

		var expectedValues []atree.Value
		var v atree.Value

		v = test_utils.NewStringValue(randStr(r, int(atree.MaxInlineArrayElementSize()-2)))
		expectedValues = append(expectedValues, v)
		err = array.Append(v)
		require.NoError(t, err)

		v = test_utils.NewStringValue(randStr(r, int(atree.MaxInlineArrayElementSize()-2)))
		expectedValues = append(expectedValues, v)
		err = array.Append(v)
		require.NoError(t, err)

		v = test_utils.NewStringValue(randStr(r, int(atree.MaxInlineArrayElementSize()-2)))
		expectedValues = append(expectedValues, v)
		err = array.Append(v)
		require.NoError(t, err)

		iter, err := array.ReadOnlyIterator()
		require.NoError(t, err)

		storage := newTestPersistentStorage(t)
		address := atree.Address{2, 3, 4, 5, 6, 7, 8, 9}
		copied, err := atree.NewArrayFromBatchData(
			storage,
			address,
			array.Type(),
			func() (atree.Value, error) {
				return iter.Next()
			})

		require.NoError(t, err)
		require.NotEqual(t, array.SlabID(), copied.SlabID())

		testArray(t, storage, typeInfo, address, copied, expectedValues, false)
	})
}

func TestArrayNestedStorables(t *testing.T) {

	t.Parallel()

	typeInfo := test_utils.NewSimpleTypeInfo(42)

	const arrayCount = uint64(1024 * 4)

	storage := newTestPersistentStorage(t)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	array, err := atree.NewArray(storage, address, typeInfo)
	require.NoError(t, err)

	expectedValues := make([]atree.Value, arrayCount)
	for i := range expectedValues {
		s := strings.Repeat("a", i)
		v := test_utils.NewSomeValue(test_utils.NewStringValue(s))
		expectedValues[i] = test_utils.NewExpectedWrapperValue(test_utils.NewStringValue(s))

		err := array.Append(v)
		require.NoError(t, err)
	}

	testArray(t, storage, typeInfo, address, array, expectedValues, true)
}

func TestArrayMaxInlineElement(t *testing.T) {
	t.Parallel()

	r := newRand(t)

	typeInfo := test_utils.NewSimpleTypeInfo(42)
	storage := newTestPersistentStorage(t)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	array, err := atree.NewArray(storage, address, typeInfo)
	require.NoError(t, err)

	const arrayCount = uint64(2)

	expectedValues := make([]atree.Value, arrayCount)
	for i := range expectedValues {
		// String length is atree.MaxInlineArrayElementSize - 3 to account for string encoding overhead.
		v := test_utils.NewStringValue(randStr(r, int(atree.MaxInlineArrayElementSize()-3)))
		expectedValues[i] = v

		err = array.Append(v)
		require.NoError(t, err)
	}

	require.True(t, IsArrayRootDataSlab(array))

	// Size of root data slab with two elements of max inlined size is target slab size minus
	// slab id size (next slab id is omitted in root slab), and minus 1 byte
	// (for rounding when computing max inline array element size).
	require.Equal(t, atree.TargetSlabSize()-atree.SlabIDLength-1, uint64(GetArrayRootSlabByteSize(array)))

	testArray(t, storage, typeInfo, address, array, expectedValues, false)
}

func TestArrayString(t *testing.T) {

	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	t.Run("small", func(t *testing.T) {
		const arrayCount = uint64(6)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		for i := range arrayCount {
			err := array.Append(test_utils.Uint64Value(i))
			require.NoError(t, err)
		}

		want := `[0 1 2 3 4 5]`
		require.Equal(t, want, array.String())
	})

	t.Run("large", func(t *testing.T) {
		const arrayCount = uint64(120)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		for i := range arrayCount {
			err := array.Append(test_utils.Uint64Value(i))
			require.NoError(t, err)
		}

		want := `[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119]`
		require.Equal(t, want, array.String())
	})
}

func TestArraySlabDump(t *testing.T) {
	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	t.Run("small", func(t *testing.T) {
		const arrayCount = uint64(6)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		for i := range arrayCount {
			err := array.Append(test_utils.Uint64Value(i))
			require.NoError(t, err)
		}

		want := []string{
			"level 1, ArrayDataSlab id:0x102030405060708.1 size:23 count:6 elements: [0 1 2 3 4 5]",
		}
		dumps, err := atree.DumpArraySlabs(array)
		require.NoError(t, err)
		require.Equal(t, want, dumps)
	})

	t.Run("large", func(t *testing.T) {
		const arrayCount = uint64(120)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		for i := range arrayCount {
			err := array.Append(test_utils.Uint64Value(i))
			require.NoError(t, err)
		}

		want := []string{
			"level 1, ArrayMetaDataSlab id:0x102030405060708.1 size:40 count:120 children: [{id:0x102030405060708.2 size:213 count:54} {id:0x102030405060708.3 size:285 count:66}]",
			"level 2, ArrayDataSlab id:0x102030405060708.2 size:213 count:54 elements: [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53]",
			"level 2, ArrayDataSlab id:0x102030405060708.3 size:285 count:66 elements: [54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119]",
		}

		dumps, err := atree.DumpArraySlabs(array)
		require.NoError(t, err)
		require.Equal(t, want, dumps)
	})

	t.Run("overflow", func(t *testing.T) {

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		err = array.Append(test_utils.NewStringValue(strings.Repeat("a", int(atree.MaxInlineArrayElementSize()))))
		require.NoError(t, err)

		want := []string{
			"level 1, ArrayDataSlab id:0x102030405060708.1 size:24 count:1 elements: [SlabIDStorable({[1 2 3 4 5 6 7 8] [0 0 0 0 0 0 0 2]})]",
			"StorableSlab id:0x102030405060708.2 storable:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
		}

		dumps, err := atree.DumpArraySlabs(array)
		require.NoError(t, err)
		require.Equal(t, want, dumps)
	})
}

func errorCategorizationCount(err error) int {
	var fatalError *atree.FatalError
	var userError *atree.UserError
	var externalError *atree.ExternalError

	count := 0
	if errors.As(err, &fatalError) {
		count++
	}
	if errors.As(err, &userError) {
		count++
	}
	if errors.As(err, &externalError) {
		count++
	}
	return count
}

func TestArrayLoadedValueIterator(t *testing.T) {

	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	typeInfo := test_utils.NewSimpleTypeInfo(42)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	runTest := func(name string, f func(useWrapperValue bool) func(*testing.T)) {
		for _, useWrapperValue := range []bool{false, true} {
			if useWrapperValue {
				name += ", use wrapper value"
			}

			t.Run(name, f(useWrapperValue))
		}
	}

	t.Run("empty", func(t *testing.T) {
		storage := newTestPersistentStorage(t)

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		// parent array: 1 root data slab
		require.Equal(t, 1, GetDeltasCount(storage))
		require.Equal(t, 0, getArrayMetaDataSlabCount(storage))

		testArrayLoadedElements(t, array, nil)
	})

	runTest("root data slab with simple values", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(3)
			array, expectedValues := createArrayWithSimpleValues(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array: 1 root data slab
			require.Equal(t, 1, GetDeltasCount(storage))
			require.Equal(t, 0, getArrayMetaDataSlabCount(storage))

			testArrayLoadedElements(t, array, expectedValues)
		}
	})

	runTest("root data slab with composite values", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(3)
			array, expectedValues, _ := createArrayWithChildArrays(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array: 1 root data slab
			// nested composite elements: 1 root data slab for each
			require.Equal(t, 1+arrayCount, uint64(GetDeltasCount(storage)))
			require.Equal(t, 0, getArrayMetaDataSlabCount(storage))

			testArrayLoadedElements(t, array, expectedValues)
		}
	})

	runTest("root data slab with composite values, unload composite element from front to back", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(3)
			array, expectedValues, childSlabIDs := createArrayWithChildArrays(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array: 1 root data slab
			// nested composite elements: 1 root data slab for each
			require.Equal(t, 1+arrayCount, uint64(GetDeltasCount(storage)))
			require.Equal(t, 0, getArrayMetaDataSlabCount(storage))
			require.True(t, len(expectedValues) == len(childSlabIDs))

			testArrayLoadedElements(t, array, expectedValues)

			// Unload composite element from front to back
			for i, slabID := range childSlabIDs {
				err := storage.Remove(slabID)
				require.NoError(t, err)

				testArrayLoadedElements(t, array, expectedValues[i+1:])
			}
		}
	})

	runTest("root data slab with composite values, unload composite element from back to front", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(3)
			array, expectedValues, childSlabIDs := createArrayWithChildArrays(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array: 1 root data slab
			// nested composite elements: 1 root data slab for each
			require.Equal(t, 1+arrayCount, uint64(GetDeltasCount(storage)))
			require.Equal(t, 0, getArrayMetaDataSlabCount(storage))

			testArrayLoadedElements(t, array, expectedValues)

			// Unload composite element from back to front
			for i := len(expectedValues) - 1; i >= 0; i-- {
				slabID := childSlabIDs[i]

				err := storage.Remove(slabID)
				require.NoError(t, err)

				testArrayLoadedElements(t, array, expectedValues[:i])
			}
		}
	})

	runTest("root data slab with composite values, unload composite element in the middle", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(3)
			array, expectedValues, childSlabIDs := createArrayWithChildArrays(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array: 1 root data slab
			// nested composite elements: 1 root data slab for each
			require.Equal(t, 1+arrayCount, uint64(GetDeltasCount(storage)))
			require.Equal(t, 0, getArrayMetaDataSlabCount(storage))

			testArrayLoadedElements(t, array, expectedValues)

			// Unload composite element in the middle
			unloadValueIndex := 1

			slabID := childSlabIDs[unloadValueIndex]

			err := storage.Remove(slabID)
			require.NoError(t, err)

			expectedValues = slices.Delete(expectedValues, unloadValueIndex, unloadValueIndex+1)

			testArrayLoadedElements(t, array, expectedValues)
		}
	})

	runTest("root data slab with composite values, unload composite elements during iteration", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(3)
			array, expectedValues, childSlabIDs := createArrayWithChildArrays(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array: 1 root data slab
			// nested composite elements: 1 root data slab for each
			require.Equal(t, 1+arrayCount, uint64(GetDeltasCount(storage)))
			require.Equal(t, 0, getArrayMetaDataSlabCount(storage))

			testArrayLoadedElements(t, array, expectedValues)

			i := 0
			err := array.IterateReadOnlyLoadedValues(func(v atree.Value) (bool, error) {
				// At this point, iterator returned first element (v).

				// Remove all other nested composite elements (except first element) from storage.
				for _, slabID := range childSlabIDs[1:] {
					err := storage.Remove(slabID)
					require.NoError(t, err)
				}

				require.Equal(t, 0, i)
				testValueEqual(t, expectedValues[0], v)
				i++
				return true, nil
			})

			require.NoError(t, err)
			require.Equal(t, 1, i) // Only first element is iterated because other elements are remove during iteration.
		}
	})

	runTest("root data slab with simple and composite values, unload composite element", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			const arrayCount = uint64(3)

			// Create an array with nested composite value at specified index
			for childArrayIndex := range arrayCount {
				storage := newTestPersistentStorage(t)

				array, expectedValues, childSlabID := createArrayWithSimpleAndChildArrayValues(t, storage, address, typeInfo, arrayCount, childArrayIndex, useWrapperValue)

				// parent array: 1 root data slab
				// nested composite element: 1 root data slab
				require.Equal(t, 2, GetDeltasCount(storage))
				require.Equal(t, 0, getArrayMetaDataSlabCount(storage))

				testArrayLoadedElements(t, array, expectedValues)

				// Unload composite element
				err := storage.Remove(childSlabID)
				require.NoError(t, err)

				expectedValues = slices.Delete(expectedValues, int(childArrayIndex), int(childArrayIndex+1))

				testArrayLoadedElements(t, array, expectedValues)
			}
		}
	})

	runTest("root metadata slab with simple values", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(20)
			array, expectedValues := createArrayWithSimpleValues(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array: 1 root metadata slab, 2 data slabs
			require.Equal(t, 3, GetDeltasCount(storage))
			require.Equal(t, 1, getArrayMetaDataSlabCount(storage))

			testArrayLoadedElements(t, array, expectedValues)
		}
	})

	runTest("root metadata slab with composite values", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(20)
			array, expectedValues, _ := createArrayWithChildArrays(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array: 1 root metadata slab, 2 data slabs
			// nested composite value element: 1 root data slab for each
			require.Equal(t, 3+arrayCount, uint64(GetDeltasCount(storage)))
			require.Equal(t, 1, getArrayMetaDataSlabCount(storage))

			testArrayLoadedElements(t, array, expectedValues)
		}
	})

	runTest("root metadata slab with composite values, unload composite element from front to back", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(20)
			array, expectedValues, childSlabIDs := createArrayWithChildArrays(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array: 1 root metadata slab, 2 data slabs
			// nested composite value element: 1 root data slab for each
			require.Equal(t, 3+arrayCount, uint64(GetDeltasCount(storage)))
			require.Equal(t, 1, getArrayMetaDataSlabCount(storage))
			require.True(t, len(expectedValues) == len(childSlabIDs))

			testArrayLoadedElements(t, array, expectedValues)

			// Unload composite element from front to back
			for i, slabID := range childSlabIDs {
				err := storage.Remove(slabID)
				require.NoError(t, err)

				testArrayLoadedElements(t, array, expectedValues[i+1:])
			}
		}
	})

	runTest("root metadata slab with composite values, unload composite element from back to front", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(20)
			array, expectedValues, childSlabIDs := createArrayWithChildArrays(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array: 1 root metadata slab, 2 data slabs
			// nested composite value element: 1 root data slab for each
			require.Equal(t, 3+arrayCount, uint64(GetDeltasCount(storage)))
			require.Equal(t, 1, getArrayMetaDataSlabCount(storage))

			testArrayLoadedElements(t, array, expectedValues)

			// Unload composite element from back to front
			for i := len(childSlabIDs) - 1; i >= 0; i-- {
				slabID := childSlabIDs[i]

				err := storage.Remove(slabID)
				require.NoError(t, err)

				testArrayLoadedElements(t, array, expectedValues[:i])
			}
		}
	})

	runTest("root metadata slab with composite values, unload composite element in the middle", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(20)
			array, expectedValues, childSlabIDs := createArrayWithChildArrays(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array: 1 root metadata slab, 2 data slabs
			// nested composite value element: 1 root data slab for each
			require.Equal(t, 3+arrayCount, uint64(GetDeltasCount(storage)))
			require.Equal(t, 1, getArrayMetaDataSlabCount(storage))

			testArrayLoadedElements(t, array, expectedValues)

			// Unload composite element in the middle
			for _, index := range []int{4, 14} {

				slabID := childSlabIDs[index]

				err := storage.Remove(slabID)
				require.NoError(t, err)

				expectedValues = slices.Delete(expectedValues, index, index+1)

				testArrayLoadedElements(t, array, expectedValues)
			}
		}
	})

	runTest("root metadata slab with simple and composite values, unload composite element", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			const arrayCount = uint64(20)

			// Create an array with composite value at specified index.
			for childArrayIndex := range arrayCount {
				storage := newTestPersistentStorage(t)

				array, expectedValues, childSlabID := createArrayWithSimpleAndChildArrayValues(t, storage, address, typeInfo, arrayCount, childArrayIndex, useWrapperValue)

				// parent array: 1 root metadata slab, 2 data slabs
				// nested composite value element: 1 root data slab for each
				require.Equal(t, 3+1, GetDeltasCount(storage))
				require.Equal(t, 1, getArrayMetaDataSlabCount(storage))

				testArrayLoadedElements(t, array, expectedValues)

				// Unload composite value
				err := storage.Remove(childSlabID)
				require.NoError(t, err)

				expectedValues = slices.Delete(expectedValues, int(childArrayIndex), int(childArrayIndex+1))

				testArrayLoadedElements(t, array, expectedValues)
			}
		}
	})

	runTest("root metadata slab, unload data slab from front to back", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(30)
			array, expectedValues := createArrayWithSimpleValues(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array (2 levels): 1 root metadata slab, 3 data slabs
			require.Equal(t, 4, GetDeltasCount(storage))
			require.Equal(t, 1, getArrayMetaDataSlabCount(storage))

			testArrayLoadedElements(t, array, expectedValues)

			metaDataSlab, ok := atree.GetArrayRootSlab(array).(*atree.ArrayMetaDataSlab)
			require.True(t, ok)

			childSlabIDs, childCounts := atree.GetArrayMetaDataSlabChildInfo(metaDataSlab)

			// Unload data slabs from front to back
			for i := range childSlabIDs {

				slabID := childSlabIDs[i]
				count := childCounts[i]

				err := storage.Remove(slabID)
				require.NoError(t, err)

				expectedValues = expectedValues[count:]

				testArrayLoadedElements(t, array, expectedValues)
			}
		}
	})

	runTest("root metadata slab, unload data slab from back to front", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(30)
			array, expectedValues := createArrayWithSimpleValues(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array (2 levels): 1 root metadata slab, 3 data slabs
			require.Equal(t, 4, GetDeltasCount(storage))
			require.Equal(t, 1, getArrayMetaDataSlabCount(storage))

			testArrayLoadedElements(t, array, expectedValues)

			metaDataSlab, ok := atree.GetArrayRootSlab(array).(*atree.ArrayMetaDataSlab)
			require.True(t, ok)

			childSlabIDs, childCounts := atree.GetArrayMetaDataSlabChildInfo(metaDataSlab)

			// Unload data slabs from back to front
			for i := len(childSlabIDs) - 1; i >= 0; i-- {

				slabID := childSlabIDs[i]
				count := childCounts[i]

				err := storage.Remove(slabID)
				require.NoError(t, err)

				expectedValues = expectedValues[:len(expectedValues)-int(count)]

				testArrayLoadedElements(t, array, expectedValues)
			}
		}
	})

	runTest("root metadata slab, unload data slab in the middle", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(30)
			array, expectedValues := createArrayWithSimpleValues(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array (2 levels): 1 root metadata slab, 3 data slabs
			require.Equal(t, 4, GetDeltasCount(storage))
			require.Equal(t, 1, getArrayMetaDataSlabCount(storage))

			testArrayLoadedElements(t, array, expectedValues)

			metaDataSlab, ok := atree.GetArrayRootSlab(array).(*atree.ArrayMetaDataSlab)
			require.True(t, ok)

			childSlabIDs, childCounts := atree.GetArrayMetaDataSlabChildInfo(metaDataSlab)

			require.True(t, len(childSlabIDs) > 2)

			const index = 1

			slabID := childSlabIDs[index]
			count := childCounts[index]

			err := storage.Remove(slabID)
			require.NoError(t, err)

			var accumulativeCount uint32
			for _, childCount := range childCounts[:index] {
				accumulativeCount += childCount
			}

			expectedValues = slices.Delete(expectedValues, int(accumulativeCount), int(accumulativeCount+count))

			testArrayLoadedElements(t, array, expectedValues)
		}
	})

	runTest("root metadata slab, unload non-root metadata slab from front to back", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(250)
			array, expectedValues := createArrayWithSimpleValues(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array (3 levels): 1 root metadata slab, 2 non-root metadata slabs, n data slabs
			require.Equal(t, 3, getArrayMetaDataSlabCount(storage))

			rootMetaDataSlab, ok := atree.GetArrayRootSlab(array).(*atree.ArrayMetaDataSlab)
			require.True(t, ok)

			childSlabIDs, childCounts := atree.GetArrayMetaDataSlabChildInfo(rootMetaDataSlab)

			// Unload non-root metadata slabs from front to back
			for i := range childSlabIDs {

				slabID := childSlabIDs[i]
				count := childCounts[i]

				err := storage.Remove(slabID)
				require.NoError(t, err)

				expectedValues = expectedValues[count:]

				testArrayLoadedElements(t, array, expectedValues)
			}
		}
	})

	runTest("root metadata slab, unload non-root metadata slab from back to front", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {
			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(250)
			array, expectedValues := createArrayWithSimpleValues(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array (3 levels): 1 root metadata slab, 2 child metadata slabs, n data slabs
			require.Equal(t, 3, getArrayMetaDataSlabCount(storage))

			rootMetaDataSlab, ok := atree.GetArrayRootSlab(array).(*atree.ArrayMetaDataSlab)
			require.True(t, ok)

			childSlabIDs, childCounts := atree.GetArrayMetaDataSlabChildInfo(rootMetaDataSlab)

			// Unload non-root metadata slabs from back to front
			for i := len(childSlabIDs) - 1; i >= 0; i-- {

				slabID := childSlabIDs[i]
				count := childCounts[i]

				err := storage.Remove(slabID)
				require.NoError(t, err)

				expectedValues = expectedValues[count:]

				testArrayLoadedElements(t, array, expectedValues)
			}
		}
	})

	runTest("root metadata slab with composite values, unload random composite value", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {

			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(500)
			array, expectedValues, childSlabIDs := createArrayWithChildArrays(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array (3 levels): 1 root metadata slab, n non-root metadata slabs, n data slabs
			// nested composite elements: 1 root data slab for each
			require.True(t, uint64(GetDeltasCount(storage)) > 1+arrayCount)
			require.True(t, getArrayMetaDataSlabCount(storage) > 1)

			testArrayLoadedElements(t, array, expectedValues)

			r := newRand(t)

			// Unload random composite element
			for len(expectedValues) > 0 {

				i := r.Intn(len(expectedValues))

				slabID := childSlabIDs[i]

				err := storage.Remove(slabID)
				require.NoError(t, err)

				expectedValues = slices.Delete(expectedValues, i, i+1)

				childSlabIDs = slices.Delete(childSlabIDs, i, i+1)

				testArrayLoadedElements(t, array, expectedValues)
			}
		}
	})

	runTest("root metadata slab with composite values, unload random data slab", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {

			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(500)
			array, expectedValues, _ := createArrayWithChildArrays(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array (3 levels): 1 root metadata slab, n non-root metadata slabs, n data slabs
			// nested composite elements: 1 root data slab for each
			require.True(t, uint64(GetDeltasCount(storage)) > 1+arrayCount)
			require.True(t, getArrayMetaDataSlabCount(storage) > 1)

			testArrayLoadedElements(t, array, expectedValues)

			rootMetaDataSlab, ok := atree.GetArrayRootSlab(array).(*atree.ArrayMetaDataSlab)
			require.True(t, ok)

			childSlabIDs, _ := atree.GetArrayMetaDataSlabChildInfo(rootMetaDataSlab)

			type slabInfo struct {
				id         atree.SlabID
				startIndex int
				count      int
			}

			count := 0
			var dataSlabInfos []*slabInfo
			for _, slabID := range childSlabIDs {
				nonrootMetaDataSlab, ok := atree.GetDeltas(storage)[slabID].(*atree.ArrayMetaDataSlab)
				require.True(t, ok)

				nonrootChildSlabIDs, nonrootChildCounts := atree.GetArrayMetaDataSlabChildInfo(nonrootMetaDataSlab)

				for i := range nonrootChildSlabIDs {
					nonrootSlabID := nonrootChildSlabIDs[i]
					nonrootCount := nonrootChildCounts[i]

					dataSlabInfo := &slabInfo{id: nonrootSlabID, startIndex: count, count: int(
						nonrootCount)}
					dataSlabInfos = append(dataSlabInfos, dataSlabInfo)
					count += int(nonrootCount)
				}
			}

			r := newRand(t)

			// Unload random data slab.
			for len(dataSlabInfos) > 0 {
				indexToUnload := r.Intn(len(dataSlabInfos))

				slabInfoToUnload := dataSlabInfos[indexToUnload]

				// Update startIndex for all data slabs after indexToUnload.
				for i := indexToUnload + 1; i < len(dataSlabInfos); i++ {
					dataSlabInfos[i].startIndex -= slabInfoToUnload.count
				}

				// Remove slabInfo to be unloaded from dataSlabInfos.

				dataSlabInfos = slices.Delete(dataSlabInfos, indexToUnload, indexToUnload+1)

				err := storage.Remove(slabInfoToUnload.id)
				require.NoError(t, err)

				expectedValues = slices.Delete(
					expectedValues,
					slabInfoToUnload.startIndex,
					slabInfoToUnload.startIndex+slabInfoToUnload.count)

				testArrayLoadedElements(t, array, expectedValues)
			}

			require.Equal(t, 0, len(expectedValues))
		}
	})

	runTest("root metadata slab with composite values, unload random slab", func(useWrapperValue bool) func(t *testing.T) {
		return func(t *testing.T) {

			storage := newTestPersistentStorage(t)

			const arrayCount = uint64(500)
			array, expectedValues, _ := createArrayWithChildArrays(t, storage, address, typeInfo, arrayCount, useWrapperValue)

			// parent array (3 levels): 1 root metadata slab, n non-root metadata slabs, n data slabs
			// nested composite elements: 1 root data slab for each
			require.True(t, uint64(GetDeltasCount(storage)) > 1+arrayCount)
			require.True(t, getArrayMetaDataSlabCount(storage) > 1)

			testArrayLoadedElements(t, array, expectedValues)

			type slabInfo struct {
				id         atree.SlabID
				startIndex int
				count      int
				children   []*slabInfo
			}

			rootMetaDataSlab, ok := atree.GetArrayRootSlab(array).(*atree.ArrayMetaDataSlab)
			require.True(t, ok)

			childSlabIDs, childCounts := atree.GetArrayMetaDataSlabChildInfo(rootMetaDataSlab)

			var dataSlabCount, metadataSlabCount int
			nonrootMetadataSlabInfos := make([]*slabInfo, len(childSlabIDs))
			for i := range childSlabIDs {

				slabID := childSlabIDs[i]
				count := childCounts[i]

				nonrootMetadataSlabInfo := &slabInfo{
					id:         slabID,
					startIndex: metadataSlabCount,
					count:      int(count),
				}
				metadataSlabCount += int(count)

				nonrootMetadataSlab, ok := atree.GetDeltas(storage)[slabID].(*atree.ArrayMetaDataSlab)
				require.True(t, ok)

				nonrootChildSlabIDs, nonrootChildCounts := atree.GetArrayMetaDataSlabChildInfo(nonrootMetadataSlab)

				children := make([]*slabInfo, len(nonrootChildSlabIDs))
				for j := range nonrootChildSlabIDs {

					nonrootSlabID := nonrootChildSlabIDs[j]
					nonrootCount := nonrootChildCounts[j]

					children[j] = &slabInfo{
						id:         nonrootSlabID,
						startIndex: dataSlabCount,
						count:      int(nonrootCount),
					}
					dataSlabCount += int(nonrootCount)
				}

				nonrootMetadataSlabInfo.children = children
				nonrootMetadataSlabInfos[i] = nonrootMetadataSlabInfo
			}

			r := newRand(t)

			const (
				metadataSlabType int = iota
				dataSlabType
				maxSlabType
			)

			for len(nonrootMetadataSlabInfos) > 0 {

				var slabInfoToBeRemoved *slabInfo
				var isLastSlab bool

				// Unload random metadata or data slab.
				switch r.Intn(maxSlabType) {

				case metadataSlabType:
					// Unload metadata slab at random index.
					metadataSlabIndex := r.Intn(len(nonrootMetadataSlabInfos))

					isLastSlab = metadataSlabIndex == len(nonrootMetadataSlabInfos)-1

					slabInfoToBeRemoved = nonrootMetadataSlabInfos[metadataSlabIndex]

					count := slabInfoToBeRemoved.count

					// Update startIndex for subsequent metadata and data slabs.
					for _, slabInfo := range nonrootMetadataSlabInfos[metadataSlabIndex+1:] {
						slabInfo.startIndex -= count

						for _, childSlabInfo := range slabInfo.children {
							childSlabInfo.startIndex -= count
						}
					}

					nonrootMetadataSlabInfos = slices.Delete(
						nonrootMetadataSlabInfos,
						metadataSlabIndex,
						metadataSlabIndex+1)

				case dataSlabType:
					// Unload data slab at random index.
					metadataSlabIndex := r.Intn(len(nonrootMetadataSlabInfos))

					metaSlabInfo := nonrootMetadataSlabInfos[metadataSlabIndex]

					dataSlabIndex := r.Intn(len(metaSlabInfo.children))

					slabInfoToBeRemoved = metaSlabInfo.children[dataSlabIndex]

					isLastSlab = (metadataSlabIndex == len(nonrootMetadataSlabInfos)-1) &&
						(dataSlabIndex == len(metaSlabInfo.children)-1)

					count := slabInfoToBeRemoved.count

					// Update startIndex for subsequent data slabs.
					for _, slabInfo := range metaSlabInfo.children[dataSlabIndex+1:] {
						slabInfo.startIndex -= count
					}

					metaSlabInfo.children = slices.Delete(
						metaSlabInfo.children,
						dataSlabIndex,
						dataSlabIndex+1)

					metaSlabInfo.count -= count

					// Update startIndex for all subsequent metadata slabs.
					for _, slabInfo := range nonrootMetadataSlabInfos[metadataSlabIndex+1:] {
						slabInfo.startIndex -= count

						for _, childSlabInfo := range slabInfo.children {
							childSlabInfo.startIndex -= count
						}
					}

					if len(metaSlabInfo.children) == 0 {
						nonrootMetadataSlabInfos = slices.Delete(
							nonrootMetadataSlabInfos,
							metadataSlabIndex,
							metadataSlabIndex+1)
					}
				}

				err := storage.Remove(slabInfoToBeRemoved.id)
				require.NoError(t, err)

				if isLastSlab {
					expectedValues = expectedValues[:slabInfoToBeRemoved.startIndex]
				} else {
					expectedValues = slices.Delete(
						expectedValues,
						slabInfoToBeRemoved.startIndex,
						slabInfoToBeRemoved.startIndex+slabInfoToBeRemoved.count,
					)
				}

				testArrayLoadedElements(t, array, expectedValues)
			}

			require.Equal(t, 0, len(expectedValues))
		}
	})
}

func createArrayWithSimpleValues(
	t *testing.T,
	storage atree.SlabStorage,
	address atree.Address,
	typeInfo atree.TypeInfo,
	arrayCount uint64,
	useWrapperValue bool,
) (*atree.Array, []atree.Value) {

	// Create parent array
	array, err := atree.NewArray(storage, address, typeInfo)
	require.NoError(t, err)

	expectedValues := make([]atree.Value, arrayCount)
	r := rune('a')
	for i := range expectedValues {
		s := test_utils.NewStringValue(strings.Repeat(string(r), 20))

		if useWrapperValue {
			err := array.Append(test_utils.NewSomeValue(s))
			require.NoError(t, err)

			expectedValues[i] = test_utils.NewExpectedWrapperValue(s)
		} else {
			err := array.Append(s)
			require.NoError(t, err)

			expectedValues[i] = s
		}
	}

	return array, expectedValues
}

func createArrayWithChildArrays(
	t *testing.T,
	storage atree.SlabStorage,
	address atree.Address,
	typeInfo atree.TypeInfo,
	arrayCount uint64,
	useWrapperValue bool,
) (*atree.Array, test_utils.ExpectedArrayValue, []atree.SlabID) {
	const childArrayCount = 50

	// Create parent array
	array, err := atree.NewArray(storage, address, typeInfo)
	require.NoError(t, err)

	expectedValues := make([]atree.Value, arrayCount)
	childSlabIDs := make([]atree.SlabID, arrayCount)

	for i := range expectedValues {
		// Create child array
		childArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedChildArrayValues := make([]atree.Value, childArrayCount)
		for j := range expectedChildArrayValues {
			v := test_utils.NewUint64ValueFromInteger(j)
			err = childArray.Append(v)
			require.NoError(t, err)

			expectedChildArrayValues[j] = v
		}

		childSlabIDs[i] = childArray.SlabID()

		// Append nested array to parent
		if useWrapperValue {
			err = array.Append(test_utils.NewSomeValue(childArray))
			require.NoError(t, err)

			expectedValues[i] = test_utils.NewExpectedWrapperValue(test_utils.ExpectedArrayValue(expectedChildArrayValues))
		} else {
			err = array.Append(childArray)
			require.NoError(t, err)

			expectedValues[i] = test_utils.ExpectedArrayValue(expectedChildArrayValues)
		}
	}

	return array, expectedValues, childSlabIDs
}

func createArrayWithSimpleAndChildArrayValues(
	t *testing.T,
	storage atree.SlabStorage,
	address atree.Address,
	typeInfo atree.TypeInfo,
	arrayCount uint64,
	compositeValueIndex uint64,
	useWrapperValue bool,
) (*atree.Array, []atree.Value, atree.SlabID) {
	const childArrayCount = 50

	require.True(t, compositeValueIndex < arrayCount)

	array, err := atree.NewArray(storage, address, typeInfo)
	require.NoError(t, err)

	expectedValues := make([]atree.Value, arrayCount)
	var childSlabID atree.SlabID
	r := 'a'
	for i := range expectedValues {

		if compositeValueIndex == uint64(i) {
			// Create child array with one element
			childArray, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			expectedChildArrayValues := make([]atree.Value, childArrayCount)
			for j := range expectedChildArrayValues {
				v := test_utils.NewUint64ValueFromInteger(j)
				err = childArray.Append(v)
				require.NoError(t, err)

				expectedChildArrayValues[j] = v
			}

			if useWrapperValue {
				err = array.Append(test_utils.NewSomeValue(childArray))
				require.NoError(t, err)

				expectedValues[i] = test_utils.NewExpectedWrapperValue(test_utils.ExpectedArrayValue(expectedChildArrayValues))
			} else {
				err = array.Append(childArray)
				require.NoError(t, err)

				expectedValues[i] = test_utils.ExpectedArrayValue(expectedChildArrayValues)
			}

			childSlabID = childArray.SlabID()
		} else {
			v := test_utils.NewStringValue(strings.Repeat(string(r), 20))
			r++

			if useWrapperValue {
				err = array.Append(test_utils.NewSomeValue(v))
				require.NoError(t, err)

				expectedValues[i] = test_utils.NewExpectedWrapperValue(v)
			} else {
				err = array.Append(v)
				require.NoError(t, err)

				expectedValues[i] = v
			}
		}
	}

	return array, expectedValues, childSlabID
}

func testArrayLoadedElements(t *testing.T, array *atree.Array, expectedValues test_utils.ExpectedArrayValue) {
	i := 0
	err := array.IterateReadOnlyLoadedValues(func(v atree.Value) (bool, error) {
		require.True(t, i < len(expectedValues))
		testValueEqual(t, expectedValues[i], v)
		i++
		return true, nil
	})
	require.NoError(t, err)
	require.Equal(t, len(expectedValues), i)
}

func getArrayMetaDataSlabCount(storage *atree.PersistentSlabStorage) int {
	var counter int
	deltas := atree.GetDeltas(storage)
	for _, slab := range deltas {
		if _, ok := slab.(*atree.ArrayMetaDataSlab); ok {
			counter++
		}
	}
	return counter
}

func TestArrayID(t *testing.T) {
	typeInfo := test_utils.NewSimpleTypeInfo(42)
	storage := newTestPersistentStorage(t)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	array, err := atree.NewArray(storage, address, typeInfo)
	require.NoError(t, err)

	slabID := array.SlabID()
	valueID := array.ValueID()

	testEqualValueIDAndSlabID(t, slabID, valueID)
}

func TestSlabSizeWhenResettingMutableStorable(t *testing.T) {
	const (
		arrayCount          = 3
		initialStorableSize = 1
		mutatedStorableSize = 5
	)

	typeInfo := test_utils.NewSimpleTypeInfo(42)
	storage := newTestPersistentStorage(t)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	array, err := atree.NewArray(storage, address, typeInfo)
	require.NoError(t, err)

	expectedValues := make([]*test_utils.MutableValue, arrayCount)
	for i := range expectedValues {
		v := test_utils.NewMutableValue(initialStorableSize)
		expectedValues[i] = v

		err := array.Append(v)
		require.NoError(t, err)
	}

	require.True(t, IsArrayRootDataSlab(array))

	expectedArrayRootDataSlabSize := atree.ComputeArrayRootDataSlabByteSizeWithFixSizedElement(initialStorableSize, arrayCount)
	require.Equal(t, expectedArrayRootDataSlabSize, GetArrayRootSlabByteSize(array))

	err = atree.VerifyArray(array, address, typeInfo, test_utils.CompareTypeInfo, test_utils.GetHashInput, true)
	require.NoError(t, err)

	for i := range expectedValues {
		mv := expectedValues[i]
		mv.UpdateStorableSize(mutatedStorableSize)

		existingStorable, err := array.Set(uint64(i), mv)
		require.NoError(t, err)
		require.NotNil(t, existingStorable)
	}

	require.True(t, IsArrayRootDataSlab(array))

	expectedArrayRootDataSlabSize = atree.ComputeArrayRootDataSlabByteSizeWithFixSizedElement(mutatedStorableSize, arrayCount)
	require.Equal(t, expectedArrayRootDataSlabSize, GetArrayRootSlabByteSize(array))

	err = atree.VerifyArray(array, address, typeInfo, test_utils.CompareTypeInfo, test_utils.GetHashInput, true)
	require.NoError(t, err)
}

func TestChildArrayInlinabilityInParentArray(t *testing.T) {

	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	t.Run("parent is root data slab, with one child array", func(t *testing.T) {
		const arrayCount = uint64(1)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		// Create an array with empty child array as element.
		parentArray, expectedValues := createArrayWithEmptyChildArray(t, storage, address, typeInfo, arrayCount)

		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())
		require.Equal(t, arrayCount, parentArray.Count())
		require.True(t, IsArrayRootDataSlab(parentArray))
		require.Equal(t, 1, getStoredDeltas(storage)) // There is only 1 stored slab because child array is inlined.

		// Test parent slab size with 1 empty inlined child arrays
		childArraySize := emptyInlinedArrayByteSize
		expectedParentSize := atree.ComputeArrayRootDataSlabByteSizeWithFixSizedElement(childArraySize, arrayCount)
		require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		// Get inlined child array
		e, err := parentArray.Get(0)
		require.NoError(t, err)
		require.Equal(t, 1, getStoredDeltas(storage))

		expectedChildValues, ok := expectedValues[0].(test_utils.ExpectedArrayValue)
		require.True(t, ok)

		childArray, ok := e.(*atree.Array)
		require.True(t, ok)
		require.True(t, childArray.Inlined())
		require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())

		valueID := childArray.ValueID()
		require.Equal(t, address[:], valueID[:atree.SlabAddressLength])
		require.NotEqual(t, atree.SlabIndexUndefined[:], valueID[atree.SlabAddressLength:])

		v := test_utils.NewStringValue(strings.Repeat("a", 9))
		vSize := v.ByteSize()

		// Appending 10 elements to child array so that inlined child array reaches max inlined size as array element.
		for i := range uint64(10) {
			err = childArray.Append(v)
			require.NoError(t, err)
			require.Equal(t, i+1, childArray.Count())

			expectedChildValues = append(expectedChildValues, v)
			expectedValues[0] = expectedChildValues

			require.True(t, childArray.Inlined())
			require.Equal(t, 1, getStoredDeltas(storage))
			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Slab ID is undefined for inlined slab
			require.Equal(t, valueID, childArray.ValueID())              // atree.Value ID is unchanged

			// Test inlined child slab size
			expectedInlinedSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, childArray.Count())
			require.Equal(t, expectedInlinedSize, GetArrayRootSlabByteSize(childArray))

			// Test parent slab size
			expectedParentSize := atree.ComputeArrayRootDataSlabByteSize([]uint32{expectedInlinedSize})
			require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

			// Test parent array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		// Add one more element to child array which triggers inlined child array slab becomes standalone slab
		err = childArray.Append(v)
		require.NoError(t, err)

		expectedChildValues = append(expectedChildValues, v)
		expectedValues[0] = expectedChildValues

		require.False(t, childArray.Inlined())
		require.Equal(t, 2, getStoredDeltas(storage)) // There are 2 stored slab because child array is no longer inlined.

		expectedSlabID := valueIDToSlabID(valueID)
		require.Equal(t, expectedSlabID, childArray.SlabID()) // Storage ID is the same bytewise as value ID.
		require.Equal(t, valueID, childArray.ValueID())       // atree.Value ID is unchanged

		expectedStandaloneSlabSize := atree.ComputeArrayRootDataSlabByteSizeWithFixSizedElement(vSize, childArray.Count())
		require.Equal(t, expectedStandaloneSlabSize, GetArrayRootSlabByteSize(childArray))

		expectedParentSize = atree.ComputeArrayRootDataSlabByteSize([]uint32{slabIDStorableByteSize})
		require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

		// Test parent array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		// Remove elements from child array which triggers standalone array slab becomes inlined slab again.
		for childArray.Count() > 0 {
			existingStorable, err := childArray.Remove(0)
			require.NoError(t, err)
			require.Equal(t, test_utils.NewStringValue(strings.Repeat("a", 9)), existingStorable)

			expectedChildValues = expectedChildValues[1:]
			expectedValues[0] = expectedChildValues

			require.True(t, childArray.Inlined())
			require.Equal(t, 1, getStoredDeltas(storage))
			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())
			require.Equal(t, valueID, childArray.ValueID()) // value ID is unchanged

			expectedInlinedSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, childArray.Count())
			require.Equal(t, expectedInlinedSize, GetArrayRootSlabByteSize(childArray))

			expectedParentSize := atree.ComputeArrayRootDataSlabByteSize([]uint32{expectedInlinedSize})
			require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

			// Test parent array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		require.Equal(t, uint64(0), childArray.Count())
		require.Equal(t, arrayCount, parentArray.Count())
	})

	t.Run("parent is root data slab, with two child arrays", func(t *testing.T) {
		const arrayCount = uint64(2)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		// Create an array with empty child array as element.
		parentArray, expectedValues := createArrayWithEmptyChildArray(t, storage, address, typeInfo, arrayCount)

		require.Equal(t, arrayCount, parentArray.Count())
		require.Equal(t, 1, getStoredDeltas(storage)) // There is only 1 stored slab because child array is inlined.

		// Test parent slab size with 2 empty inlined child arrays
		childArrayByteSize := emptyInlinedArrayByteSize
		storableByteSizes := make([]uint32, arrayCount)
		for i := range storableByteSizes {
			storableByteSizes[i] = childArrayByteSize
		}
		expectedParentSize := atree.ComputeArrayRootDataSlabByteSize(storableByteSizes)
		require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

		// Test parent array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		children := make([]struct {
			array   *atree.Array
			valueID atree.ValueID
		}, arrayCount)

		for i := range children {
			e, err := parentArray.Get(uint64(i))
			require.NoError(t, err)
			require.Equal(t, 1, getStoredDeltas(storage))

			childArray, ok := e.(*atree.Array)
			require.True(t, ok)
			require.True(t, childArray.Inlined())
			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())

			valueID := childArray.ValueID()
			require.Equal(t, address[:], valueID[:atree.SlabAddressLength])
			require.NotEqual(t, atree.SlabIndexUndefined[:], valueID[atree.SlabAddressLength:])

			children[i].array = childArray
			children[i].valueID = valueID
		}

		v := test_utils.NewStringValue(strings.Repeat("a", 9))
		vSize := v.ByteSize()

		// Appending 10 elements to child array so that inlined child array reaches max inlined size as array element.
		for i := range uint64(10) {
			for j, child := range children {
				childArray := child.array
				childValueID := child.valueID

				err := childArray.Append(v)
				require.NoError(t, err)
				require.Equal(t, i+1, childArray.Count())

				expectedChildValues, ok := expectedValues[j].(test_utils.ExpectedArrayValue)
				require.True(t, ok)

				expectedChildValues = append(expectedChildValues, v)
				expectedValues[j] = expectedChildValues

				require.True(t, childArray.Inlined())
				require.Equal(t, 1, getStoredDeltas(storage))
				require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Slab ID is undefined for inlined slab
				require.Equal(t, childValueID, childArray.ValueID())         // atree.Value ID is unchanged

				// Test inlined child slab size
				expectedInlinedSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, childArray.Count())
				require.Equal(t, expectedInlinedSize, GetArrayRootSlabByteSize(childArray))

				// Test parent slab size
				storableByteSizes[j] = expectedInlinedSize
				require.Equal(t, atree.ComputeArrayRootDataSlabByteSize(storableByteSizes), GetArrayRootSlabByteSize(parentArray))

				// Test parent array's mutableElementIndex
				require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

				testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
			}
		}

		expectedStoredDeltas := 1

		// Add one more element to child array which triggers inlined child array slab becomes standalone slab
		for i, child := range children {
			childArray := child.array
			childValueID := child.valueID

			err := childArray.Append(v)
			require.NoError(t, err)
			require.False(t, childArray.Inlined())

			expectedChildValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedChildValues = append(expectedChildValues, v)
			expectedValues[i] = expectedChildValues

			expectedStoredDeltas++
			require.Equal(t, expectedStoredDeltas, getStoredDeltas(storage)) // There are more stored slab because child array is no longer inlined.

			expectedSlabID := valueIDToSlabID(childValueID)
			require.Equal(t, expectedSlabID, childArray.SlabID()) // Storage ID is the same bytewise as value ID.
			require.Equal(t, childValueID, childArray.ValueID())  // atree.Value ID is unchanged

			expectedStandaloneSlabSize := atree.ComputeArrayRootDataSlabByteSizeWithFixSizedElement(vSize, childArray.Count())
			require.Equal(t, expectedStandaloneSlabSize, GetArrayRootSlabByteSize(childArray))

			storableByteSizes[i] = slabIDStorableByteSize
			require.Equal(t, atree.ComputeArrayRootDataSlabByteSize(storableByteSizes), GetArrayRootSlabByteSize(parentArray))

			// Test parent array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		// Remove one element from child array which triggers standalone array slab becomes inlined slab again.
		for i, child := range children {
			childArray := child.array
			childValueID := child.valueID

			existingStorable, err := childArray.Remove(0)
			require.NoError(t, err)
			require.Equal(t, test_utils.NewStringValue(strings.Repeat("a", 9)), existingStorable)

			expectedChildValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedChildValues = expectedChildValues[1:]
			expectedValues[i] = expectedChildValues

			require.True(t, childArray.Inlined())

			expectedStoredDeltas--
			require.Equal(t, expectedStoredDeltas, getStoredDeltas(storage))

			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())
			require.Equal(t, childValueID, childArray.ValueID()) // value ID is unchanged

			expectedInlinedSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, childArray.Count())
			require.Equal(t, expectedInlinedSize, GetArrayRootSlabByteSize(childArray))

			storableByteSizes[i] = expectedInlinedSize
			require.Equal(t, atree.ComputeArrayRootDataSlabByteSize(storableByteSizes), GetArrayRootSlabByteSize(parentArray))

			// Test parent array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		// Remove remaining elements from inlined child array
		childArrayCount := children[0].array.Count()
		for range childArrayCount {
			for j, child := range children {
				childArray := child.array
				childValueID := child.valueID

				existingStorable, err := childArray.Remove(0)
				require.NoError(t, err)
				require.Equal(t, test_utils.NewStringValue(strings.Repeat("a", 9)), existingStorable)

				expectedChildValues, ok := expectedValues[j].(test_utils.ExpectedArrayValue)
				require.True(t, ok)

				expectedChildValues = expectedChildValues[1:]
				expectedValues[j] = expectedChildValues

				require.True(t, childArray.Inlined())
				require.Equal(t, 1, getStoredDeltas(storage))
				require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())
				require.Equal(t, childValueID, childArray.ValueID()) // value ID is unchanged

				expectedInlinedSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, childArray.Count())
				require.Equal(t, expectedInlinedSize, GetArrayRootSlabByteSize(childArray))

				storableByteSizes[j] = expectedInlinedSize
				require.Equal(t, atree.ComputeArrayRootDataSlabByteSize(storableByteSizes), GetArrayRootSlabByteSize(parentArray))

				// Test parent array's mutableElementIndex
				require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

				testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
			}
		}

		for _, child := range children {
			require.Equal(t, uint64(0), child.array.Count())
		}
		require.Equal(t, arrayCount, parentArray.Count())
	})

	t.Run("parent is root metadata slab, with four child arrays", func(t *testing.T) {
		const arrayCount = uint64(4)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		// Create an array with empty child array as element.
		parentArray, expectedValues := createArrayWithEmptyChildArray(t, storage, address, typeInfo, arrayCount)

		require.Equal(t, arrayCount, parentArray.Count())
		require.True(t, IsArrayRootDataSlab(parentArray))
		require.Equal(t, 1, getStoredDeltas(storage)) // There is only 1 stored slab because child array is inlined.

		// Test parent slab size with 4 empty inlined child arrays
		childArrayByteSize := emptyInlinedArrayByteSize
		expectedParentSize := atree.ComputeArrayRootDataSlabByteSizeWithFixSizedElement(childArrayByteSize, arrayCount)
		require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

		// Test parent array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		children := make([]struct {
			array   *atree.Array
			valueID atree.ValueID
		}, arrayCount)

		for i := range children {
			e, err := parentArray.Get(uint64(i))
			require.NoError(t, err)
			require.Equal(t, 1, getStoredDeltas(storage))

			childArray, ok := e.(*atree.Array)
			require.True(t, ok)
			require.True(t, childArray.Inlined())
			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())

			valueID := childArray.ValueID()
			require.Equal(t, address[:], valueID[:atree.SlabAddressLength])
			require.NotEqual(t, atree.SlabIndexUndefined[:], valueID[atree.SlabAddressLength:])

			children[i].array = childArray
			children[i].valueID = valueID
		}

		v := test_utils.NewStringValue(strings.Repeat("a", 9))
		vSize := v.ByteSize()

		// Appending 10 elements to child array so that inlined child array reaches max inlined size as array element.
		for i := range uint64(10) {
			for j, child := range children {
				childArray := child.array
				childValueID := child.valueID

				err := childArray.Append(v)
				require.NoError(t, err)
				require.Equal(t, i+1, childArray.Count())

				expectedChildValues, ok := expectedValues[j].(test_utils.ExpectedArrayValue)
				require.True(t, ok)

				expectedChildValues = append(expectedChildValues, v)
				expectedValues[j] = expectedChildValues

				require.True(t, childArray.Inlined())
				require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Slab ID is undefined for inlined slab
				require.Equal(t, childValueID, childArray.ValueID())         // atree.Value ID is unchanged

				// Test inlined child slab size
				expectedInlinedSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, childArray.Count())
				require.Equal(t, expectedInlinedSize, GetArrayRootSlabByteSize(childArray))

				// Test parent array's mutableElementIndex
				require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

				testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
			}
		}

		// Parent array has 1 meta data slab and 2 data slabs.
		// All child arrays are inlined.
		require.Equal(t, 3, getStoredDeltas(storage))
		require.False(t, IsArrayRootDataSlab(parentArray))

		// Add one more element to child array which triggers inlined child array slab becomes standalone slab
		for i, child := range children {
			childArray := child.array
			childValueID := child.valueID

			err := childArray.Append(v)
			require.NoError(t, err)
			require.False(t, childArray.Inlined())

			expectedChildValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedChildValues = append(expectedChildValues, v)
			expectedValues[i] = expectedChildValues

			expectedSlabID := valueIDToSlabID(childValueID)
			require.Equal(t, expectedSlabID, childArray.SlabID()) // Storage ID is the same bytewise as value ID.
			require.Equal(t, childValueID, childArray.ValueID())  // atree.Value ID is unchanged

			expectedStandaloneSlabSize := atree.ComputeArrayRootDataSlabByteSizeWithFixSizedElement(vSize, childArray.Count())
			require.Equal(t, expectedStandaloneSlabSize, GetArrayRootSlabByteSize(childArray))

			// Test parent array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		// Parent array has one data slab and all child arrays are not inlined.
		require.Equal(t, 1+arrayCount, uint64(getStoredDeltas(storage)))
		require.True(t, IsArrayRootDataSlab(parentArray))

		// Remove one element from child array which triggers standalone array slab becomes inlined slab again.
		for i, child := range children {
			childArray := child.array
			childValueID := child.valueID

			existingStorable, err := childArray.Remove(0)
			require.NoError(t, err)
			require.Equal(t, test_utils.NewStringValue(strings.Repeat("a", 9)), existingStorable)

			expectedChildValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedChildValues = expectedChildValues[1:]
			expectedValues[i] = expectedChildValues

			require.True(t, childArray.Inlined())
			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())
			require.Equal(t, childValueID, childArray.ValueID()) // value ID is unchanged

			expectedInlinedSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, childArray.Count())
			require.Equal(t, expectedInlinedSize, GetArrayRootSlabByteSize(childArray))

			// Test parent array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		// Parent array has 1 meta data slab and 2 data slabs.
		// All child arrays are inlined.
		require.Equal(t, 3, getStoredDeltas(storage))
		require.False(t, IsArrayRootDataSlab(parentArray))

		// Remove remaining elements from inlined child array
		childArrayCount := children[0].array.Count()
		for range childArrayCount {
			for j, child := range children {
				childArray := child.array
				childValueID := child.valueID

				existingStorable, err := childArray.Remove(0)
				require.NoError(t, err)
				require.Equal(t, test_utils.NewStringValue(strings.Repeat("a", 9)), existingStorable)

				expectedChildValues, ok := expectedValues[j].(test_utils.ExpectedArrayValue)
				require.True(t, ok)

				expectedChildValues = expectedChildValues[1:]
				expectedValues[j] = expectedChildValues

				require.True(t, childArray.Inlined())
				require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())
				require.Equal(t, childValueID, childArray.ValueID()) // value ID is unchanged

				expectedInlinedSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, childArray.Count())
				require.Equal(t, expectedInlinedSize, GetArrayRootSlabByteSize(childArray))

				// Test parent array's mutableElementIndex
				require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

				testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
			}
		}

		// Parent array has 1 data slab.
		// All child arrays are inlined.
		require.Equal(t, 1, getStoredDeltas(storage))
		require.True(t, IsArrayRootDataSlab(parentArray))

		for _, child := range children {
			require.Equal(t, uint64(0), child.array.Count())
		}
		require.Equal(t, arrayCount, parentArray.Count())
	})
}

func TestNestedThreeLevelChildArrayInlinabilityInParentArray(t *testing.T) {

	atree.SetThreshold(256)
	defer atree.SetThreshold(1024)

	t.Run("parent is root data slab, one child array, one grand child array, changes to grand child array triggers child array slab to become standalone slab", func(t *testing.T) {
		const arrayCount = uint64(1)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		// Create an array with empty child array as element, which has empty child array.
		parentArray, expectedValues := createArrayWithEmpty2LevelChildArray(t, storage, address, typeInfo, arrayCount)

		require.Equal(t, arrayCount, parentArray.Count())
		require.True(t, IsArrayRootDataSlab(parentArray))
		require.Equal(t, 1, getStoredDeltas(storage)) // There is only 1 stored slab because child array is inlined.

		// Test parent slab size with 1 inlined child array
		gchildArrayByteSize := emptyInlinedArrayByteSize
		childArrayByteSize := atree.ComputeInlinedArraySlabByteSize([]uint32{gchildArrayByteSize})
		expectedParentSize := atree.ComputeArrayRootDataSlabByteSizeWithFixSizedElement(childArrayByteSize, arrayCount)
		require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

		// Test parent array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		// Get inlined child array
		e, err := parentArray.Get(0)
		require.NoError(t, err)
		require.Equal(t, 1, getStoredDeltas(storage))

		childArray, ok := e.(*atree.Array)
		require.True(t, ok)
		require.True(t, childArray.Inlined())
		require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())

		valueID := childArray.ValueID()
		require.Equal(t, address[:], valueID[:atree.SlabAddressLength])
		require.NotEqual(t, atree.SlabIndexUndefined[:], valueID[atree.SlabAddressLength:])

		// Get inlined grand child array
		e, err = childArray.Get(0)
		require.NoError(t, err)
		require.Equal(t, 1, getStoredDeltas(storage))

		gchildArray, ok := e.(*atree.Array)
		require.True(t, ok)
		require.True(t, gchildArray.Inlined())
		require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID())

		gValueID := gchildArray.ValueID()
		require.Equal(t, address[:], gValueID[:atree.SlabAddressLength])
		require.NotEqual(t, atree.SlabIndexUndefined[:], gValueID[atree.SlabAddressLength:])
		require.NotEqual(t, valueID[atree.SlabAddressLength:], gValueID[atree.SlabAddressLength:])

		v := test_utils.NewStringValue(strings.Repeat("a", 9))
		vSize := v.ByteSize()

		// Appending 8 elements to grand child array so that inlined grand child array reaches max inlined size as array element.
		for i := range uint64(8) {
			err = gchildArray.Append(v)
			require.NoError(t, err)
			require.Equal(t, i+1, gchildArray.Count())
			require.Equal(t, uint64(1), childArray.Count())

			expectedChildValues, ok := expectedValues[0].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedGChildValues, ok := expectedChildValues[0].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedGChildValues = append(expectedGChildValues, v)
			expectedChildValues[0] = expectedGChildValues
			expectedValues[0] = expectedChildValues

			require.True(t, childArray.Inlined())
			require.True(t, gchildArray.Inlined())
			require.Equal(t, 1, getStoredDeltas(storage))

			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Slab ID is undefined for inlined slab
			require.Equal(t, valueID, childArray.ValueID())              // atree.Value ID is unchanged

			require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID()) // Slab ID is undefined for inlined slab
			require.Equal(t, gValueID, gchildArray.ValueID())             // atree.Value ID is unchanged

			// Test inlined grand child slab size

			expectedInlinedGrandChildSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, gchildArray.Count())
			require.Equal(t, expectedInlinedGrandChildSize, GetArrayRootSlabByteSize(gchildArray))

			// Test inlined child slab size
			expectedInlinedChildSize := atree.ComputeInlinedArraySlabByteSize([]uint32{expectedInlinedGrandChildSize})
			require.Equal(t, expectedInlinedChildSize, GetArrayRootSlabByteSize(childArray))

			// Test parent slab size
			expectedParentSize := atree.ComputeArrayRootDataSlabByteSize([]uint32{expectedInlinedChildSize})
			require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

			// Test array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(gchildArray) <= gchildArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		// Add one more element to grand child array which triggers inlined child array slab (NOT grand child array slab) becomes standalone slab
		err = gchildArray.Append(v)
		require.NoError(t, err)

		expectedChildValues, ok := expectedValues[0].(test_utils.ExpectedArrayValue)
		require.True(t, ok)

		expectedGChildValues, ok := expectedChildValues[0].(test_utils.ExpectedArrayValue)
		require.True(t, ok)

		expectedGChildValues = append(expectedGChildValues, v)
		expectedChildValues[0] = expectedGChildValues
		expectedValues[0] = expectedChildValues

		require.True(t, gchildArray.Inlined())
		require.False(t, childArray.Inlined())
		require.Equal(t, 2, getStoredDeltas(storage)) // There are 2 stored slab because child array is no longer inlined.

		expectedSlabID := valueIDToSlabID(valueID)
		require.Equal(t, expectedSlabID, childArray.SlabID()) // Storage ID is the same bytewise as value ID.
		require.Equal(t, valueID, childArray.ValueID())       // atree.Value ID is unchanged

		require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID()) // Slab ID is undefined for inlined slab
		require.Equal(t, gValueID, gchildArray.ValueID())             // atree.Value ID is unchanged

		// Test inlined grand child slab size
		expectedInlinedGrandChildSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, gchildArray.Count())
		require.Equal(t, expectedInlinedGrandChildSize, GetArrayRootSlabByteSize(gchildArray))

		expectedStandaloneSlabSize := atree.ComputeArrayRootDataSlabByteSize([]uint32{expectedInlinedGrandChildSize})
		require.Equal(t, expectedStandaloneSlabSize, GetArrayRootSlabByteSize(childArray))

		expectedParentSize = atree.ComputeArrayRootDataSlabByteSize([]uint32{slabIDStorableByteSize})
		require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

		// Test array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
		require.True(t, atree.GetArrayMutableElementIndexCount(gchildArray) <= gchildArray.Count())
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		// Remove elements from grand child array which triggers standalone child array slab becomes inlined slab again.
		for gchildArray.Count() > 0 {
			existingStorable, err := gchildArray.Remove(0)
			require.NoError(t, err)
			require.Equal(t, test_utils.NewStringValue(strings.Repeat("a", 9)), existingStorable)

			expectedChildValues, ok := expectedValues[0].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedGChildValues, ok := expectedChildValues[0].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedGChildValues = expectedGChildValues[1:]
			expectedChildValues[0] = expectedGChildValues
			expectedValues[0] = expectedChildValues

			require.True(t, gchildArray.Inlined())
			require.True(t, gchildArray.Inlined())
			require.Equal(t, 1, getStoredDeltas(storage))

			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())
			require.Equal(t, valueID, childArray.ValueID()) // value ID is unchanged

			require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID())
			require.Equal(t, gValueID, gchildArray.ValueID()) // value ID is unchanged

			// Test inlined grand child slab size
			expectedInlinedGrandChildSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, gchildArray.Count())
			require.Equal(t, expectedInlinedGrandChildSize, GetArrayRootSlabByteSize(gchildArray))

			// Test inlined child slab size
			expectedInlinedChildSize := atree.ComputeInlinedArraySlabByteSize([]uint32{expectedInlinedGrandChildSize})
			require.Equal(t, expectedInlinedChildSize, GetArrayRootSlabByteSize(childArray))

			// Test parent slab size
			expectedParentSize := atree.ComputeArrayRootDataSlabByteSize([]uint32{expectedInlinedChildSize})
			require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

			// Test array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(gchildArray) <= gchildArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		require.Equal(t, uint64(0), gchildArray.Count())
		require.Equal(t, uint64(1), childArray.Count())
		require.Equal(t, arrayCount, parentArray.Count())
	})

	t.Run("parent is root data slab, one child array, one grand child array, changes to grand child array triggers grand child array slab to become standalone slab", func(t *testing.T) {
		const arrayCount = uint64(1)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		// Create an array with empty child array as element, which has empty child array.
		parentArray, expectedValues := createArrayWithEmpty2LevelChildArray(t, storage, address, typeInfo, arrayCount)

		require.Equal(t, arrayCount, parentArray.Count())
		require.True(t, IsArrayRootDataSlab(parentArray))
		require.Equal(t, 1, getStoredDeltas(storage)) // There is only 1 stored slab because child array is inlined.

		// Test parent slab size with 1 inlined child array
		gchildArrayByteSize := emptyInlinedArrayByteSize
		childArrayByteSize := atree.ComputeInlinedArraySlabByteSize([]uint32{gchildArrayByteSize})
		expectedParentSize := atree.ComputeArrayRootDataSlabByteSizeWithFixSizedElement(childArrayByteSize, arrayCount)
		require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

		// Test parent array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		// Get inlined child array
		e, err := parentArray.Get(0)
		require.NoError(t, err)
		require.Equal(t, 1, getStoredDeltas(storage))

		childArray, ok := e.(*atree.Array)
		require.True(t, ok)
		require.True(t, childArray.Inlined())
		require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())

		valueID := childArray.ValueID()
		require.Equal(t, address[:], valueID[:atree.SlabAddressLength])
		require.NotEqual(t, atree.SlabIndexUndefined[:], valueID[atree.SlabAddressLength:])

		// Get inlined grand child array
		e, err = childArray.Get(0)
		require.NoError(t, err)
		require.Equal(t, 1, getStoredDeltas(storage))

		gchildArray, ok := e.(*atree.Array)
		require.True(t, ok)
		require.True(t, gchildArray.Inlined())
		require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID())

		gValueID := gchildArray.ValueID()
		require.Equal(t, address[:], gValueID[:atree.SlabAddressLength])
		require.NotEqual(t, atree.SlabIndexUndefined[:], gValueID[atree.SlabAddressLength:])
		require.NotEqual(t, valueID[atree.SlabAddressLength:], gValueID[atree.SlabAddressLength:])

		v := test_utils.NewStringValue(strings.Repeat("a", 9))
		vSize := v.ByteSize()

		// Appending 8 elements to grand child array so that inlined grand child array reaches max inlined size as array element.
		for i := range uint64(8) {
			err = gchildArray.Append(v)
			require.NoError(t, err)
			require.Equal(t, i+1, gchildArray.Count())
			require.Equal(t, uint64(1), childArray.Count())

			expectedChildValues, ok := expectedValues[0].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedGChildValues, ok := expectedChildValues[0].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedGChildValues = append(expectedGChildValues, v)
			expectedChildValues[0] = expectedGChildValues
			expectedValues[0] = expectedChildValues

			require.True(t, childArray.Inlined())
			require.True(t, gchildArray.Inlined())
			require.Equal(t, 1, getStoredDeltas(storage))

			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Slab ID is undefined for inlined slab
			require.Equal(t, valueID, childArray.ValueID())              // atree.Value ID is unchanged

			require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID()) // Slab ID is undefined for inlined slab
			require.Equal(t, gValueID, gchildArray.ValueID())             // atree.Value ID is unchanged

			// Test inlined grand child slab size
			expectedInlinedGrandChildSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, gchildArray.Count())
			require.Equal(t, expectedInlinedGrandChildSize, GetArrayRootSlabByteSize(gchildArray))

			// Test inlined child slab size
			expectedInlinedChildSize := atree.ComputeInlinedArraySlabByteSize([]uint32{expectedInlinedGrandChildSize})
			require.Equal(t, expectedInlinedChildSize, GetArrayRootSlabByteSize(childArray))

			// Test parent slab size
			expectedParentSize := atree.ComputeArrayRootDataSlabByteSize([]uint32{expectedInlinedChildSize})
			require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

			// Test array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(gchildArray) <= gchildArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		// Add one more element to grand child array which triggers inlined grand child array slab (NOT child array slab) becomes standalone slab
		largeValue := test_utils.NewStringValue(strings.Repeat("b", 20))
		largeValueSize := largeValue.ByteSize()
		err = gchildArray.Append(largeValue)
		require.NoError(t, err)

		expectedChildValues, ok := expectedValues[0].(test_utils.ExpectedArrayValue)
		require.True(t, ok)

		expectedGChildValues, ok := expectedChildValues[0].(test_utils.ExpectedArrayValue)
		require.True(t, ok)

		expectedGChildValues = append(expectedGChildValues, largeValue)
		expectedChildValues[0] = expectedGChildValues
		expectedValues[0] = expectedChildValues

		require.False(t, gchildArray.Inlined())
		require.True(t, childArray.Inlined())
		require.Equal(t, 2, getStoredDeltas(storage)) // There are 2 stored slab because child array is no longer inlined.

		require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Storage ID is the same bytewise as value ID.
		require.Equal(t, valueID, childArray.ValueID())              // atree.Value ID is unchanged

		expectedSlabID := valueIDToSlabID(gValueID)
		require.Equal(t, expectedSlabID, gchildArray.SlabID()) // Slab ID is undefined for inlined slab
		require.Equal(t, gValueID, gchildArray.ValueID())      // atree.Value ID is unchanged

		// Test inlined grand child slab size
		storableByteSizes := make([]uint32, int(gchildArray.Count()))
		storableByteSizes[0] = largeValueSize
		for i := 1; i < len(storableByteSizes); i++ {
			storableByteSizes[i] = vSize
		}
		expectedInlinedGrandChildSize := atree.ComputeArrayRootDataSlabByteSize(storableByteSizes)
		require.Equal(t, expectedInlinedGrandChildSize, GetArrayRootSlabByteSize(gchildArray))

		expectedStandaloneSlabSize := atree.ComputeInlinedArraySlabByteSize([]uint32{slabIDStorableByteSize})
		require.Equal(t, expectedStandaloneSlabSize, GetArrayRootSlabByteSize(childArray))

		expectedParentSize = atree.ComputeArrayRootDataSlabByteSize([]uint32{expectedStandaloneSlabSize})
		require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

		// Test array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
		require.True(t, atree.GetArrayMutableElementIndexCount(gchildArray) <= gchildArray.Count())
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		// Remove elements from grand child array which triggers standalone child array slab becomes inlined slab again.
		for gchildArray.Count() > 0 {
			_, err := gchildArray.Remove(gchildArray.Count() - 1)
			require.NoError(t, err)

			expectedChildValues, ok := expectedValues[0].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedGChildValues, ok := expectedChildValues[0].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedGChildValues = expectedGChildValues[:len(expectedGChildValues)-1]
			expectedChildValues[0] = expectedGChildValues
			expectedValues[0] = expectedChildValues

			require.True(t, gchildArray.Inlined())
			require.True(t, gchildArray.Inlined())
			require.Equal(t, 1, getStoredDeltas(storage))

			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())
			require.Equal(t, valueID, childArray.ValueID()) // value ID is unchanged

			require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID())
			require.Equal(t, gValueID, gchildArray.ValueID()) // value ID is unchanged

			// Test inlined grand child slab size
			expectedInlinedGrandChildSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, gchildArray.Count())
			require.Equal(t, expectedInlinedGrandChildSize, GetArrayRootSlabByteSize(gchildArray))

			// Test inlined child slab size
			expectedInlinedChildSize := atree.ComputeInlinedArraySlabByteSize([]uint32{expectedInlinedGrandChildSize})
			require.Equal(t, expectedInlinedChildSize, GetArrayRootSlabByteSize(childArray))

			// Test parent slab size
			expectedParentSize := atree.ComputeArrayRootDataSlabByteSize([]uint32{expectedInlinedChildSize})
			require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

			// Test array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(gchildArray) <= gchildArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		require.Equal(t, uint64(0), gchildArray.Count())
		require.Equal(t, uint64(1), childArray.Count())
		require.Equal(t, arrayCount, parentArray.Count())
	})

	t.Run("parent is root data slab, two child array, one grand child array each, changes to child array triggers child array slab to become standalone slab", func(t *testing.T) {
		const arrayCount = uint64(2)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		v := test_utils.NewStringValue(strings.Repeat("a", 9))
		vSize := v.ByteSize()

		// Create parent array
		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			// Create child array
			child, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			// Create grand child array
			gchild, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			// Append element to grand child array
			err = gchild.Append(v)
			require.NoError(t, err)

			// Append grand child array to child array
			err = child.Append(gchild)
			require.NoError(t, err)

			// Append child array to parent
			err = parentArray.Append(child)
			require.NoError(t, err)

			expectedValues[i] = test_utils.ExpectedArrayValue{test_utils.ExpectedArrayValue{v}}
		}

		require.Equal(t, arrayCount, parentArray.Count())
		require.True(t, IsArrayRootDataSlab(parentArray))
		require.Equal(t, 1, getStoredDeltas(storage)) // There is only 1 stored slab because child array is inlined.

		// Test parent slab size with 1 inlined child array
		gchildArraySize := atree.ComputeInlinedArraySlabByteSize([]uint32{vSize})
		childArraySize := atree.ComputeInlinedArraySlabByteSize([]uint32{gchildArraySize})
		expectedParentSize := atree.ComputeArrayRootDataSlabByteSizeWithFixSizedElement(childArraySize, arrayCount)
		require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

		// Test parent array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		type arrayInfo struct {
			array   *atree.Array
			valueID atree.ValueID
			child   *arrayInfo
		}

		children := make([]arrayInfo, arrayCount)

		for i := range children {
			e, err := parentArray.Get(uint64(i))
			require.NoError(t, err)
			require.Equal(t, 1, getStoredDeltas(storage))

			childArray, ok := e.(*atree.Array)
			require.True(t, ok)
			require.True(t, childArray.Inlined())
			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())

			valueID := childArray.ValueID()
			require.Equal(t, address[:], valueID[:atree.SlabAddressLength])
			require.NotEqual(t, atree.SlabIndexUndefined[:], valueID[atree.SlabAddressLength:])

			e, err = childArray.Get(0)
			require.NoError(t, err)
			require.Equal(t, 1, getStoredDeltas(storage))

			gchildArray, ok := e.(*atree.Array)
			require.True(t, ok)
			require.True(t, gchildArray.Inlined())
			require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID())

			gValueID := gchildArray.ValueID()
			require.Equal(t, address[:], gValueID[:atree.SlabAddressLength])
			require.NotEqual(t, atree.SlabIndexUndefined[:], gValueID[atree.SlabAddressLength:])
			require.NotEqual(t, valueID[atree.SlabAddressLength:], gValueID[atree.SlabAddressLength:])

			children[i] = arrayInfo{
				array:   childArray,
				valueID: valueID,
				child:   &arrayInfo{array: gchildArray, valueID: gValueID},
			}
		}

		// Appending 7 elements to child array so that inlined child array reaches max inlined size as array element.
		for i := range uint64(7) {
			for j, child := range children {
				childArray := child.array
				valueID := child.valueID
				gchildArray := child.child.array
				gValueID := child.child.valueID

				err := childArray.Append(v)
				require.NoError(t, err)
				require.Equal(t, i+2, childArray.Count())

				expectedChildValues, ok := expectedValues[j].(test_utils.ExpectedArrayValue)
				require.True(t, ok)

				expectedChildValues = append(expectedChildValues, v)

				expectedValues[j] = expectedChildValues

				require.True(t, childArray.Inlined())
				require.True(t, gchildArray.Inlined())
				require.Equal(t, 1, getStoredDeltas(storage))

				require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Slab ID is undefined for inlined slab
				require.Equal(t, valueID, childArray.ValueID())              // atree.Value ID is unchanged

				require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID()) // Slab ID is undefined for inlined slab
				require.Equal(t, gValueID, gchildArray.ValueID())             // atree.Value ID is unchanged

				// Test inlined grand child slab size (1 element, unchanged)
				expectedInlinedGrandChildSize := atree.ComputeInlinedArraySlabByteSize([]uint32{vSize})
				require.Equal(t, expectedInlinedGrandChildSize, GetArrayRootSlabByteSize(gchildArray))

				// Test inlined child slab size
				gchildArraySize := atree.ComputeInlinedArraySlabByteSize([]uint32{vSize})
				childStorableByteSizes := make([]uint32, int(childArray.Count()))
				for k := range childStorableByteSizes {
					var size uint32
					if k == 0 {
						size = gchildArraySize
					} else {
						size = vSize
					}
					childStorableByteSizes[k] = size
				}
				expectedInlinedChildSize := atree.ComputeInlinedArraySlabByteSize(childStorableByteSizes)
				require.Equal(t, expectedInlinedChildSize, GetArrayRootSlabByteSize(childArray))

				// Test parent slab size
				expectedParentSize += vSize
				require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

				// Test array's mutableElementIndex
				require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
				require.True(t, atree.GetArrayMutableElementIndexCount(gchildArray) <= gchildArray.Count())
				require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

				testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
			}
		}

		// Add one more element to child array which triggers inlined child array slab (NOT grand child array slab) becomes standalone slab
		for i, child := range children {
			childArray := child.array
			valueID := child.valueID
			gchildArray := child.child.array
			gValueID := child.child.valueID

			err = childArray.Append(v)
			require.NoError(t, err)

			expectedChildValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedChildValues = append(expectedChildValues, v)

			expectedValues[i] = expectedChildValues

			require.True(t, gchildArray.Inlined())
			require.False(t, childArray.Inlined())
			require.Equal(t, 2+i, getStoredDeltas(storage)) // There are >1 stored slab because child array is no longer inlined.

			expectedSlabID := valueIDToSlabID(valueID)
			require.Equal(t, expectedSlabID, childArray.SlabID()) // Storage ID is the same bytewise as value ID.
			require.Equal(t, valueID, childArray.ValueID())       // atree.Value ID is unchanged

			require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID()) // Slab ID is undefined for inlined slab
			require.Equal(t, gValueID, gchildArray.ValueID())             // atree.Value ID is unchanged

			// Test inlined grand child slab size
			expectedInlinedGrandChildSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, gchildArray.Count())
			require.Equal(t, expectedInlinedGrandChildSize, GetArrayRootSlabByteSize(gchildArray))

			childStorableByteSizes := make([]uint32, int(childArray.Count()))
			childStorableByteSizes[0] = expectedInlinedGrandChildSize
			for i := 1; i < len(childStorableByteSizes); i++ {
				childStorableByteSizes[i] = vSize
			}
			expectedStandaloneSlabSize := atree.ComputeArrayRootDataSlabByteSize(childStorableByteSizes)
			require.Equal(t, expectedStandaloneSlabSize, GetArrayRootSlabByteSize(childArray))

			// Test array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(gchildArray) <= gchildArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		require.Equal(t, 3, getStoredDeltas(storage)) // There are 3 stored slab because child array is no longer inlined.

		expectedParentSize = atree.ComputeArrayRootDataSlabByteSizeWithFixSizedElement(slabIDStorableByteSize, 2)
		require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

		// Remove one elements from each child array to trigger child arrays being inlined again.

		storableByteSizes := make([]uint32, arrayCount)

		for i, child := range children {
			childArray := child.array
			valueID := child.valueID
			gchildArray := child.child.array
			gValueID := child.child.valueID

			_, err = childArray.Remove(childArray.Count() - 1)
			require.NoError(t, err)

			expectedChildValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedChildValues = expectedChildValues[:len(expectedChildValues)-1]

			expectedValues[i] = expectedChildValues

			require.True(t, gchildArray.Inlined())
			require.True(t, childArray.Inlined())
			require.Equal(t, 2-i, getStoredDeltas(storage))

			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Storage ID is the same bytewise as value ID.
			require.Equal(t, valueID, childArray.ValueID())              // atree.Value ID is unchanged

			require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID()) // Slab ID is undefined for inlined slab
			require.Equal(t, gValueID, gchildArray.ValueID())             // atree.Value ID is unchanged

			// Test inlined grand child slab size
			expectedInlinedGrandChildSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, gchildArray.Count())
			require.Equal(t, expectedInlinedGrandChildSize, GetArrayRootSlabByteSize(gchildArray))

			// Test inlined child slab size
			childStorableByteSizes := make([]uint32, int(childArray.Count()))
			childStorableByteSizes[0] = expectedInlinedGrandChildSize
			for i := 1; i < len(childStorableByteSizes); i++ {
				childStorableByteSizes[i] = vSize
			}
			expectedInlinedChildSize := atree.ComputeInlinedArraySlabByteSize(childStorableByteSizes)
			require.Equal(t, expectedInlinedChildSize, GetArrayRootSlabByteSize(childArray))

			storableByteSizes[i] = expectedInlinedChildSize

			// Test array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(gchildArray) <= gchildArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		expectedParentSize = atree.ComputeArrayRootDataSlabByteSize(storableByteSizes)
		require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

		// Remove elements from child array.
		elementCount := children[0].array.Count()

		for range elementCount - 1 {
			for j, child := range children {
				childArray := child.array
				valueID := child.valueID
				gchildArray := child.child.array
				gValueID := child.child.valueID

				existingStorable, err := childArray.Remove(childArray.Count() - 1)
				require.NoError(t, err)
				require.Equal(t, test_utils.NewStringValue(strings.Repeat("a", 9)), existingStorable)

				expectedChildValues, ok := expectedValues[j].(test_utils.ExpectedArrayValue)
				require.True(t, ok)

				expectedChildValues = expectedChildValues[:len(expectedChildValues)-1]

				expectedValues[j] = expectedChildValues

				require.True(t, gchildArray.Inlined())
				require.True(t, gchildArray.Inlined())
				require.Equal(t, 1, getStoredDeltas(storage))

				require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())
				require.Equal(t, valueID, childArray.ValueID()) // value ID is unchanged

				require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID())
				require.Equal(t, gValueID, gchildArray.ValueID()) // value ID is unchanged

				// Test inlined grand child slab size
				expectedInlinedGrandChildSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, gchildArray.Count())
				require.Equal(t, expectedInlinedGrandChildSize, GetArrayRootSlabByteSize(gchildArray))

				// Test inlined child slab size
				childStorableByteSizes := make([]uint32, int(childArray.Count()))
				childStorableByteSizes[0] = expectedInlinedGrandChildSize
				for i := 1; i < len(childStorableByteSizes); i++ {
					childStorableByteSizes[i] = vSize
				}
				expectedInlinedChildSize := atree.ComputeInlinedArraySlabByteSize(childStorableByteSizes)
				require.Equal(t, expectedInlinedChildSize, GetArrayRootSlabByteSize(childArray))

				// Test parent slab size
				expectedParentSize -= vSize
				require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

				// Test array's mutableElementIndex
				require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
				require.True(t, atree.GetArrayMutableElementIndexCount(gchildArray) <= gchildArray.Count())
				require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

				testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
			}
		}

		for _, child := range children {
			require.Equal(t, uint64(1), child.child.array.Count())
			require.Equal(t, uint64(1), child.array.Count())
		}
		require.Equal(t, arrayCount, parentArray.Count())
	})

	t.Run("parent is root metadata slab, with four child arrays, each child array has grand child arrays", func(t *testing.T) {
		const arrayCount = uint64(4)

		typeInfo := test_utils.NewSimpleTypeInfo(42)
		storage := newTestPersistentStorage(t)
		address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

		v := test_utils.NewStringValue(strings.Repeat("a", 9))
		vSize := v.ByteSize()

		// Create parent array
		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make([]atree.Value, arrayCount)
		for i := range expectedValues {
			// Create child array
			child, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			// Create grand child array
			gchild, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			// Append grand child array to child array
			err = child.Append(gchild)
			require.NoError(t, err)

			// Append child array to parent
			err = parentArray.Append(child)
			require.NoError(t, err)

			expectedValues[i] = test_utils.ExpectedArrayValue{test_utils.ExpectedArrayValue{}}
		}

		require.Equal(t, arrayCount, parentArray.Count())
		require.True(t, IsArrayRootDataSlab(parentArray))
		require.Equal(t, 1, getStoredDeltas(storage)) // There is only 1 stored slab because child array is inlined.

		gchildArraySize := emptyInlinedArrayByteSize
		childArraySize := atree.ComputeInlinedArraySlabByteSize([]uint32{gchildArraySize})
		expectedParentSize := atree.ComputeArrayRootDataSlabByteSizeWithFixSizedElement(childArraySize, arrayCount)
		require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

		// Test parent array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		type arrayInfo struct {
			array   *atree.Array
			valueID atree.ValueID
			child   *arrayInfo
		}

		children := make([]arrayInfo, arrayCount)

		for i := range children {
			e, err := parentArray.Get(uint64(i))
			require.NoError(t, err)
			require.Equal(t, 1, getStoredDeltas(storage))

			childArray, ok := e.(*atree.Array)
			require.True(t, ok)
			require.True(t, childArray.Inlined())
			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())

			valueID := childArray.ValueID()
			require.Equal(t, address[:], valueID[:atree.SlabAddressLength])
			require.NotEqual(t, atree.SlabIndexUndefined[:], valueID[atree.SlabAddressLength:])

			e, err = childArray.Get(0)
			require.NoError(t, err)
			require.Equal(t, 1, getStoredDeltas(storage))

			gchildArray, ok := e.(*atree.Array)
			require.True(t, ok)
			require.True(t, gchildArray.Inlined())
			require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID())

			gValueID := gchildArray.ValueID()
			require.Equal(t, address[:], gValueID[:atree.SlabAddressLength])
			require.NotEqual(t, atree.SlabIndexUndefined[:], gValueID[atree.SlabAddressLength:])
			require.NotEqual(t, valueID[atree.SlabAddressLength:], gValueID[atree.SlabAddressLength:])

			children[i] = arrayInfo{
				array:   childArray,
				valueID: valueID,
				child:   &arrayInfo{array: gchildArray, valueID: gValueID},
			}
		}

		// Appending 6 elements to grand child array so that parent array root slab is metadata slab.
		for i := range uint64(6) {
			for j, child := range children {
				childArray := child.array
				valueID := child.valueID
				gchildArray := child.child.array
				gValueID := child.child.valueID

				err := gchildArray.Append(v)
				require.NoError(t, err)
				require.Equal(t, i+1, gchildArray.Count())

				expectedChildValues, ok := expectedValues[j].(test_utils.ExpectedArrayValue)
				require.True(t, ok)

				expectedGChildValues, ok := expectedChildValues[0].(test_utils.ExpectedArrayValue)
				require.True(t, ok)

				expectedGChildValues = append(expectedGChildValues, v)

				expectedChildValues[0] = expectedGChildValues
				expectedValues[j] = expectedChildValues

				require.True(t, childArray.Inlined())
				require.True(t, gchildArray.Inlined())
				require.Equal(t, 1, getStoredDeltas(storage))

				require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Slab ID is undefined for inlined slab
				require.Equal(t, valueID, childArray.ValueID())              // atree.Value ID is unchanged

				require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID()) // Slab ID is undefined for inlined slab
				require.Equal(t, gValueID, gchildArray.ValueID())             // atree.Value ID is unchanged

				// Test inlined grand child slab size
				expectedInlinedGrandChildSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, gchildArray.Count())
				require.Equal(t, expectedInlinedGrandChildSize, GetArrayRootSlabByteSize(gchildArray))

				// Test inlined child slab size
				expectedInlinedChildSize := atree.ComputeInlinedArraySlabByteSize([]uint32{expectedInlinedGrandChildSize})
				require.Equal(t, expectedInlinedChildSize, GetArrayRootSlabByteSize(childArray))

				// Test array's mutableElementIndex
				require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
				require.True(t, atree.GetArrayMutableElementIndexCount(gchildArray) <= gchildArray.Count())
				require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

				testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
			}
		}

		// Add one more element to grand child array which triggers parent array slab becomes metadata slab (all elements are still inlined).
		for i, child := range children {
			childArray := child.array
			valueID := child.valueID
			gchildArray := child.child.array
			gValueID := child.child.valueID

			err = gchildArray.Append(v)
			require.NoError(t, err)

			expectedChildValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedGChildValues, ok := expectedChildValues[0].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedGChildValues = append(expectedGChildValues, v)

			expectedChildValues[0] = expectedGChildValues
			expectedValues[i] = expectedChildValues

			require.True(t, gchildArray.Inlined())
			require.True(t, childArray.Inlined())
			require.Equal(t, 3, getStoredDeltas(storage)) // There are 3 stored slab because parent root slab is metadata.

			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Storage ID is the same bytewise as value ID.
			require.Equal(t, valueID, childArray.ValueID())              // atree.Value ID is unchanged

			require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID()) // Slab ID is undefined for inlined slab
			require.Equal(t, gValueID, gchildArray.ValueID())             // atree.Value ID is unchanged

			// Test inlined grand child slab size
			expectedInlinedGrandChildSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, gchildArray.Count())
			require.Equal(t, expectedInlinedGrandChildSize, GetArrayRootSlabByteSize(gchildArray))

			expectedInlinedChildSlabSize := atree.ComputeInlinedArraySlabByteSize([]uint32{expectedInlinedGrandChildSize})
			require.Equal(t, expectedInlinedChildSlabSize, GetArrayRootSlabByteSize(childArray))

			// Test array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(gchildArray) <= gchildArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		require.Equal(t, 3, getStoredDeltas(storage)) // There are 3 stored slab because child array is no longer inlined.
		require.False(t, IsArrayRootDataSlab(parentArray))

		// Add one more element to grand child array which triggers
		// - child arrays become standalone slab (grand child arrays are still inlined)
		// - parent array slab becomes data slab
		for i, child := range children {
			childArray := child.array
			valueID := child.valueID
			gchildArray := child.child.array
			gValueID := child.child.valueID

			expectedChildValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedGChildValues, ok := expectedChildValues[0].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			for range 2 {
				err = gchildArray.Append(v)
				require.NoError(t, err)

				expectedGChildValues = append(expectedGChildValues, v)
			}

			expectedChildValues[0] = expectedGChildValues
			expectedValues[i] = expectedChildValues

			require.True(t, gchildArray.Inlined())
			require.False(t, childArray.Inlined())

			expectedSlabID := valueIDToSlabID(valueID)
			require.Equal(t, expectedSlabID, childArray.SlabID()) // Storage ID is the same bytewise as value ID.
			require.Equal(t, valueID, childArray.ValueID())       // atree.Value ID is unchanged

			require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID()) // Slab ID is undefined for inlined slab
			require.Equal(t, gValueID, gchildArray.ValueID())             // atree.Value ID is unchanged

			// Test standalone grand child slab size
			expectedInlinedGrandChildSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, gchildArray.Count())
			require.Equal(t, expectedInlinedGrandChildSize, GetArrayRootSlabByteSize(gchildArray))

			expectedStandaloneChildSlabSize := atree.ComputeArrayRootDataSlabByteSize([]uint32{expectedInlinedGrandChildSize})
			require.Equal(t, expectedStandaloneChildSlabSize, GetArrayRootSlabByteSize(childArray))

			// Test array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(gchildArray) <= gchildArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		// Parent array has one root data slab, 4 grand child array with standalone root data slab.
		require.Equal(t, 1+arrayCount, uint64(getStoredDeltas(storage)))
		require.True(t, IsArrayRootDataSlab(parentArray))

		// Remove elements from grand child array to trigger child array inlined again.
		for i, child := range children {
			childArray := child.array
			valueID := child.valueID
			gchildArray := child.child.array
			gValueID := child.child.valueID

			expectedChildValues, ok := expectedValues[i].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedGChildValues, ok := expectedChildValues[0].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			for range 2 {
				_, err = gchildArray.Remove(0)
				require.NoError(t, err)

				expectedGChildValues = expectedGChildValues[:len(expectedGChildValues)-1]
			}

			expectedChildValues[0] = expectedGChildValues
			expectedValues[i] = expectedChildValues

			require.True(t, gchildArray.Inlined())
			require.True(t, childArray.Inlined())

			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Storage ID is the same bytewise as value ID.
			require.Equal(t, valueID, childArray.ValueID())              // atree.Value ID is unchanged

			require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID()) // Slab ID is undefined for inlined slab
			require.Equal(t, gValueID, gchildArray.ValueID())             // atree.Value ID is unchanged

			// Test inlined grand child slab size
			expectedInlinedGrandChildSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, gchildArray.Count())
			require.Equal(t, expectedInlinedGrandChildSize, GetArrayRootSlabByteSize(gchildArray))

			// Test inlined child slab size
			expectedInlinedChildSize := atree.ComputeInlinedArraySlabByteSize([]uint32{expectedInlinedGrandChildSize})
			require.Equal(t, expectedInlinedChildSize, GetArrayRootSlabByteSize(childArray))

			// Test array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(gchildArray) <= gchildArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		// Parent array has 1 metadata slab, and two data slab, all child and grand child arrays are inlined.
		require.Equal(t, 3, getStoredDeltas(storage))
		require.False(t, IsArrayRootDataSlab(parentArray))

		// Remove elements from grand child array.
		elementCount := children[0].child.array.Count()

		for range elementCount {
			for j, child := range children {
				childArray := child.array
				valueID := child.valueID
				gchildArray := child.child.array
				gValueID := child.child.valueID

				existingStorable, err := gchildArray.Remove(0)
				require.NoError(t, err)
				require.Equal(t, v, existingStorable)

				expectedChildValues, ok := expectedValues[j].(test_utils.ExpectedArrayValue)
				require.True(t, ok)

				expectedGChildValues, ok := expectedChildValues[0].(test_utils.ExpectedArrayValue)
				require.True(t, ok)

				expectedGChildValues = expectedGChildValues[1:]

				expectedChildValues[0] = expectedGChildValues
				expectedValues[j] = expectedChildValues

				require.True(t, gchildArray.Inlined())
				require.True(t, gchildArray.Inlined())

				require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())
				require.Equal(t, valueID, childArray.ValueID()) // value ID is unchanged

				require.Equal(t, atree.SlabIDUndefined, gchildArray.SlabID())
				require.Equal(t, gValueID, gchildArray.ValueID()) // value ID is unchanged

				// Test inlined grand child slab size
				expectedInlinedGrandChildSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, gchildArray.Count())
				require.Equal(t, expectedInlinedGrandChildSize, GetArrayRootSlabByteSize(gchildArray))

				// Test inlined child slab size
				expectedInlinedChildSize := atree.ComputeInlinedArraySlabByteSize([]uint32{expectedInlinedGrandChildSize})
				require.Equal(t, expectedInlinedChildSize, GetArrayRootSlabByteSize(childArray))

				// Test array's mutableElementIndex
				require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
				require.True(t, atree.GetArrayMutableElementIndexCount(gchildArray) <= gchildArray.Count())
				require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

				testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
			}
		}

		for _, child := range children {
			require.Equal(t, uint64(0), child.child.array.Count())
			require.Equal(t, uint64(1), child.array.Count())
		}
		require.Equal(t, arrayCount, parentArray.Count())
		require.Equal(t, 1, getStoredDeltas(storage))

		gchildArraySize = emptyInlinedArrayByteSize
		childArraySize = atree.ComputeInlinedArraySlabByteSize([]uint32{gchildArraySize})
		expectedParentSize = atree.ComputeArrayRootDataSlabByteSizeWithFixSizedElement(childArraySize, arrayCount)
		require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))
	})
}

func TestChildArrayWhenParentArrayIsModified(t *testing.T) {

	const arrayCount = uint64(2)

	typeInfo := test_utils.NewSimpleTypeInfo(42)
	storage := newTestPersistentStorage(t)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	// Create an array with empty child array as element.
	parentArray, expectedValues := createArrayWithEmptyChildArray(t, storage, address, typeInfo, arrayCount)

	require.Equal(t, arrayCount, parentArray.Count())
	require.True(t, IsArrayRootDataSlab(parentArray))
	require.Equal(t, 1, getStoredDeltas(storage)) // There is only 1 stored slab because child array is inlined.

	// Test parent slab size with empty inlined child arrays
	childArraySize := emptyInlinedArrayByteSize
	expectedParentSize := atree.ComputeArrayRootDataSlabByteSizeWithFixSizedElement(childArraySize, arrayCount)
	require.Equal(t, expectedParentSize, GetArrayRootSlabByteSize(parentArray))

	// Test array's mutableElementIndex
	require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

	testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

	children := make([]*struct {
		array       *atree.Array
		valueID     atree.ValueID
		parentIndex int
	}, arrayCount)

	for i := range children {
		e, err := parentArray.Get(uint64(i))
		require.NoError(t, err)
		require.Equal(t, 1, getStoredDeltas(storage))

		childArray, ok := e.(*atree.Array)
		require.True(t, ok)
		require.True(t, childArray.Inlined())
		require.Equal(t, atree.SlabIDUndefined, childArray.SlabID())

		valueID := childArray.ValueID()
		require.Equal(t, address[:], valueID[:atree.SlabAddressLength])
		require.NotEqual(t, atree.SlabIndexUndefined[:], valueID[atree.SlabAddressLength:])

		children[i] = &struct {
			array       *atree.Array
			valueID     atree.ValueID
			parentIndex int
		}{
			childArray, valueID, i,
		}
	}

	t.Run("insert elements in parent array", func(t *testing.T) {
		// insert value at index 0, so all child array indexes are moved by +1
		v := test_utils.Uint64Value(0)
		err := parentArray.Insert(0, v)
		require.NoError(t, err)

		expectedValues = slices.Insert(expectedValues, 0, atree.Value(v))

		for i, child := range children {
			childArray := child.array
			childValueID := child.valueID

			v := test_utils.NewUint64ValueFromInteger(i)
			vSize := v.ByteSize()

			err := childArray.Append(v)
			require.NoError(t, err)
			require.Equal(t, uint64(1), childArray.Count())

			child.parentIndex = i + 1

			expectedChildValues, ok := expectedValues[child.parentIndex].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedChildValues = append(expectedChildValues, v)
			expectedValues[child.parentIndex] = expectedChildValues

			require.True(t, childArray.Inlined())
			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Slab ID is undefined for inlined slab
			require.Equal(t, childValueID, childArray.ValueID())         // atree.Value ID is unchanged

			// Test inlined child slab size
			expectedInlinedSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, childArray.Count())
			require.Equal(t, expectedInlinedSize, GetArrayRootSlabByteSize(childArray))

			// Test array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		// insert value at index 2, so only second child array index is moved by +1
		v = test_utils.Uint64Value(2)
		err = parentArray.Insert(2, v)
		require.NoError(t, err)

		expectedValues = slices.Insert(expectedValues, 2, atree.Value(v))

		for i, child := range children {
			childArray := child.array
			childValueID := child.valueID

			v := test_utils.NewUint64ValueFromInteger(i)
			vSize := v.ByteSize()

			err := childArray.Append(v)
			require.NoError(t, err)
			require.Equal(t, uint64(2), childArray.Count())

			if i > 0 {
				child.parentIndex++
			}

			expectedChildValues, ok := expectedValues[child.parentIndex].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedChildValues = append(expectedChildValues, v)
			expectedValues[child.parentIndex] = expectedChildValues

			require.True(t, childArray.Inlined())
			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Slab ID is undefined for inlined slab
			require.Equal(t, childValueID, childArray.ValueID())         // atree.Value ID is unchanged

			// Test inlined child slab size
			expectedInlinedSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, childArray.Count())
			require.Equal(t, expectedInlinedSize, GetArrayRootSlabByteSize(childArray))

			// Test array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		// insert value at index 4, so none of child array indexes are affected.
		v = test_utils.Uint64Value(4)
		err = parentArray.Insert(4, v)
		require.NoError(t, err)

		expectedValues = append(expectedValues, nil)
		expectedValues[4] = v

		for i, child := range children {
			childArray := child.array
			childValueID := child.valueID

			v := test_utils.NewUint64ValueFromInteger(i)
			vSize := v.ByteSize()

			err := childArray.Append(v)
			require.NoError(t, err)
			require.Equal(t, uint64(3), childArray.Count())

			expectedChildValues, ok := expectedValues[child.parentIndex].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedChildValues = append(expectedChildValues, v)
			expectedValues[child.parentIndex] = expectedChildValues

			require.True(t, childArray.Inlined())
			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Slab ID is undefined for inlined slab
			require.Equal(t, childValueID, childArray.ValueID())         // atree.Value ID is unchanged

			// Test inlined child slab size
			expectedInlinedSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, childArray.Count())
			require.Equal(t, expectedInlinedSize, GetArrayRootSlabByteSize(childArray))

			// Test array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}
	})

	t.Run("remove elements from parent array", func(t *testing.T) {
		// remove value at index 0, so all child array indexes are moved by -1.
		existingStorable, err := parentArray.Remove(0)
		require.NoError(t, err)
		require.Equal(t, test_utils.Uint64Value(0), existingStorable)

		expectedValues = slices.Delete(expectedValues, 0, 1)

		for i, child := range children {
			childArray := child.array
			childValueID := child.valueID

			v := test_utils.NewUint64ValueFromInteger(i)
			vSize := v.ByteSize()

			err := childArray.Append(v)
			require.NoError(t, err)
			require.Equal(t, uint64(4), childArray.Count())

			child.parentIndex--

			expectedChildValues, ok := expectedValues[child.parentIndex].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedChildValues = append(expectedChildValues, v)
			expectedValues[child.parentIndex] = expectedChildValues

			require.True(t, childArray.Inlined())
			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Slab ID is undefined for inlined slab
			require.Equal(t, childValueID, childArray.ValueID())         // atree.Value ID is unchanged

			// Test inlined child slab size
			expectedInlinedSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, childArray.Count())
			require.Equal(t, expectedInlinedSize, GetArrayRootSlabByteSize(childArray))

			// Test array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		// Remove value at index 1, so only second child array index is moved by -1
		existingStorable, err = parentArray.Remove(1)
		require.NoError(t, err)
		require.Equal(t, test_utils.Uint64Value(2), existingStorable)

		expectedValues = slices.Delete(expectedValues, 1, 2)

		for i, child := range children {
			childArray := child.array
			childValueID := child.valueID

			v := test_utils.NewUint64ValueFromInteger(i)
			vSize := v.ByteSize()

			err := childArray.Append(v)
			require.NoError(t, err)
			require.Equal(t, uint64(5), childArray.Count())

			if i > 0 {
				child.parentIndex--
			}

			expectedChildValues, ok := expectedValues[child.parentIndex].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedChildValues = append(expectedChildValues, v)
			expectedValues[child.parentIndex] = expectedChildValues

			require.True(t, childArray.Inlined())
			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Slab ID is undefined for inlined slab
			require.Equal(t, childValueID, childArray.ValueID())         // atree.Value ID is unchanged

			// Test inlined child slab size
			expectedInlinedSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, childArray.Count())
			require.Equal(t, expectedInlinedSize, GetArrayRootSlabByteSize(childArray))

			// Test array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}

		// Remove value at index 2 (last element), so none of child array indexes are affected.
		existingStorable, err = parentArray.Remove(2)
		require.NoError(t, err)
		require.Equal(t, test_utils.Uint64Value(4), existingStorable)

		expectedValues[len(expectedValues)-1] = nil
		expectedValues = expectedValues[:len(expectedValues)-1]

		for i, child := range children {
			childArray := child.array
			childValueID := child.valueID

			v := test_utils.NewUint64ValueFromInteger(i)
			vSize := v.ByteSize()

			err := childArray.Append(v)
			require.NoError(t, err)
			require.Equal(t, uint64(6), childArray.Count())

			expectedChildValues, ok := expectedValues[child.parentIndex].(test_utils.ExpectedArrayValue)
			require.True(t, ok)

			expectedChildValues = append(expectedChildValues, v)
			expectedValues[child.parentIndex] = expectedChildValues

			require.True(t, childArray.Inlined())
			require.Equal(t, atree.SlabIDUndefined, childArray.SlabID()) // Slab ID is undefined for inlined slab
			require.Equal(t, childValueID, childArray.ValueID())         // atree.Value ID is unchanged

			// Test inlined child slab size
			expectedInlinedSize := atree.ComputeInlinedArraySlabByteSizeWithFixSizedElement(vSize, childArray.Count())
			require.Equal(t, expectedInlinedSize, GetArrayRootSlabByteSize(childArray))

			// Test array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(childArray) <= childArray.Count())
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

			testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
		}
	})
}

func createArrayWithEmptyChildArray(
	t *testing.T,
	storage atree.SlabStorage,
	address atree.Address,
	typeInfo atree.TypeInfo,
	arrayCount uint64,
) (*atree.Array, []atree.Value) {

	// Create parent array
	array, err := atree.NewArray(storage, address, typeInfo)
	require.NoError(t, err)

	expectedValues := make([]atree.Value, arrayCount)
	for i := range expectedValues {
		// Create child array
		child, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		// Append child array to parent
		err = array.Append(child)
		require.NoError(t, err)

		expectedValues[i] = test_utils.ExpectedArrayValue{}
	}

	return array, expectedValues
}

func createArrayWithEmpty2LevelChildArray(
	t *testing.T,
	storage atree.SlabStorage,
	address atree.Address,
	typeInfo atree.TypeInfo,
	arrayCount uint64,
) (*atree.Array, []atree.Value) {

	// Create parent array
	array, err := atree.NewArray(storage, address, typeInfo)
	require.NoError(t, err)

	expectedValues := make([]atree.Value, arrayCount)
	for i := range expectedValues {
		// Create child array
		child, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		// Create grand child array
		gchild, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		// Append grand child array to child array
		err = child.Append(gchild)
		require.NoError(t, err)

		// Append child array to parent
		err = array.Append(child)
		require.NoError(t, err)

		expectedValues[i] = test_utils.ExpectedArrayValue{test_utils.ExpectedArrayValue{}}
	}

	return array, expectedValues
}

func getStoredDeltas(storage *atree.PersistentSlabStorage) int {
	count := 0
	deltas := atree.GetDeltas(storage)
	for _, slab := range deltas {
		if slab != nil {
			count++
		}
	}
	return count
}

func TestArraySetReturnedValue(t *testing.T) {
	typeInfo := test_utils.NewSimpleTypeInfo(42)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	t.Run("child array is not inlined", func(t *testing.T) {
		const arrayCount = uint64(2)

		storage := newTestPersistentStorage(t)

		// Create parent array
		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make(test_utils.ExpectedArrayValue, arrayCount)

		for i := range expectedValues {
			// Create child array
			childArray, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			err = parentArray.Append(childArray)
			require.NoError(t, err)

			var expectedChildValues test_utils.ExpectedArrayValue
			for {
				v := test_utils.NewStringValue(strings.Repeat("a", 10))

				err = childArray.Append(v)
				require.NoError(t, err)

				expectedChildValues = append(expectedChildValues, v)

				if !childArray.Inlined() {
					break
				}
			}

			expectedValues[i] = expectedChildValues
		}

		// Test array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		// Overwrite existing child array value
		for i := range expectedValues {
			existingStorable, err := parentArray.Set(uint64(i), test_utils.Uint64Value(0))
			require.NoError(t, err)
			require.NotNil(t, existingStorable)

			id, ok := existingStorable.(atree.SlabIDStorable)
			require.True(t, ok)

			child, err := id.StoredValue(storage)
			require.NoError(t, err)

			testValueEqual(t, expectedValues[i], child)

			err = storage.Remove(atree.SlabID(id))
			require.NoError(t, err)

			expectedValues[i] = test_utils.Uint64Value(0)

			// Test array's mutableElementIndex
			require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())
		}

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
	})

	t.Run("child array is inlined", func(t *testing.T) {
		const arrayCount = uint64(2)

		storage := newTestPersistentStorage(t)

		// Create parent array
		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make(test_utils.ExpectedArrayValue, arrayCount)

		for i := range expectedValues {
			// Create child array
			childArray, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			err = parentArray.Append(childArray)
			require.NoError(t, err)

			// Insert one element to child array
			v := test_utils.NewStringValue(strings.Repeat("a", 10))

			err = childArray.Append(v)
			require.NoError(t, err)
			require.True(t, childArray.Inlined())

			expectedValues[i] = test_utils.ExpectedArrayValue{v}
		}

		// Test array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		// Overwrite existing child array value
		for i := range expectedValues {
			existingStorable, err := parentArray.Set(uint64(i), test_utils.Uint64Value(0))
			require.NoError(t, err)
			require.NotNil(t, existingStorable)

			id, ok := existingStorable.(atree.SlabIDStorable)
			require.True(t, ok)

			child, err := id.StoredValue(storage)
			require.NoError(t, err)

			testValueEqual(t, expectedValues[i], child)

			expectedValues[i] = test_utils.Uint64Value(0)

			err = storage.Remove(atree.SlabID(id))
			require.NoError(t, err)
		}

		// Test array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
	})

	t.Run("child map is not inlined", func(t *testing.T) {
		const arrayCount = uint64(2)

		storage := newTestPersistentStorage(t)

		// Create parent array
		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make(test_utils.ExpectedArrayValue, arrayCount)

		for i := range expectedValues {
			// Create child map
			childMap, err := atree.NewMap(storage, address, atree.NewDefaultDigesterBuilder(), typeInfo)
			require.NoError(t, err)

			err = parentArray.Append(childMap)
			require.NoError(t, err)

			expectedChildValues := make(test_utils.ExpectedMapValue)
			expectedValues[i] = expectedChildValues

			// Insert into child map until child map is not inlined
			for j := uint64(0); ; j++ {
				k := test_utils.Uint64Value(j)
				v := test_utils.NewStringValue(strings.Repeat("a", 10))

				existingStorable, err := childMap.Set(test_utils.CompareValue, test_utils.GetHashInput, k, v)
				require.NoError(t, err)
				require.Nil(t, existingStorable)

				expectedChildValues[k] = v

				if !childMap.Inlined() {
					break
				}
			}
		}

		// Test array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		// Overwrite existing child map value
		for i := range expectedValues {
			existingStorable, err := parentArray.Set(uint64(i), test_utils.Uint64Value(0))
			require.NoError(t, err)
			require.NotNil(t, existingStorable)

			id, ok := existingStorable.(atree.SlabIDStorable)
			require.True(t, ok)

			child, err := id.StoredValue(storage)
			require.NoError(t, err)

			testValueEqual(t, expectedValues[i], child)

			expectedValues[i] = test_utils.Uint64Value(0)

			err = storage.Remove(atree.SlabID(id))
			require.NoError(t, err)
		}

		// Test array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
	})

	t.Run("child map is inlined", func(t *testing.T) {
		const arrayCount = uint64(2)

		storage := newTestPersistentStorage(t)

		// Create parent array
		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make(test_utils.ExpectedArrayValue, arrayCount)

		for i := range expectedValues {
			// Create child map
			childMap, err := atree.NewMap(storage, address, atree.NewDefaultDigesterBuilder(), typeInfo)
			require.NoError(t, err)

			k := test_utils.NewUint64ValueFromInteger(i)

			err = parentArray.Append(childMap)
			require.NoError(t, err)

			expectedChildValues := make(test_utils.ExpectedMapValue)
			expectedValues[i] = expectedChildValues

			// Insert into child map until child map is not inlined
			v := test_utils.NewStringValue(strings.Repeat("a", 10))

			existingStorable, err := childMap.Set(test_utils.CompareValue, test_utils.GetHashInput, k, v)
			require.NoError(t, err)
			require.Nil(t, existingStorable)

			expectedChildValues[k] = v
		}

		// Test array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		// Overwrite existing child map value
		for i := range expectedValues {
			existingStorable, err := parentArray.Set(uint64(i), test_utils.Uint64Value(0))
			require.NoError(t, err)
			require.NotNil(t, existingStorable)

			id, ok := existingStorable.(atree.SlabIDStorable)
			require.True(t, ok)

			child, err := id.StoredValue(storage)
			require.NoError(t, err)

			testValueEqual(t, expectedValues[i], child)

			expectedValues[i] = test_utils.Uint64Value(0)

			err = storage.Remove(atree.SlabID(id))
			require.NoError(t, err)
		}

		// Test array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)
	})
}

func TestArrayRemoveReturnedValue(t *testing.T) {
	typeInfo := test_utils.NewSimpleTypeInfo(42)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	t.Run("child array is not inlined", func(t *testing.T) {
		const arrayCount = uint64(2)

		storage := newTestPersistentStorage(t)

		// Create parent array
		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make(test_utils.ExpectedArrayValue, arrayCount)

		for i := range expectedValues {
			// Create child array
			childArray, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			err = parentArray.Append(childArray)
			require.NoError(t, err)

			var expectedChildValues test_utils.ExpectedArrayValue
			for {
				v := test_utils.NewStringValue(strings.Repeat("a", 10))

				err = childArray.Append(v)
				require.NoError(t, err)

				expectedChildValues = append(expectedChildValues, v)

				if !childArray.Inlined() {
					break
				}
			}

			expectedValues[i] = expectedChildValues
		}

		// Test array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		// Remove child array value
		for i := range expectedValues {
			valueStorable, err := parentArray.Remove(uint64(0))
			require.NoError(t, err)

			id, ok := valueStorable.(atree.SlabIDStorable)
			require.True(t, ok)

			child, err := id.StoredValue(storage)
			require.NoError(t, err)

			testValueEqual(t, expectedValues[i], child)

			err = storage.Remove(atree.SlabID(id))
			require.NoError(t, err)
		}

		// Test array's mutableElementIndex
		require.Equal(t, uint64(0), atree.GetArrayMutableElementIndexCount(parentArray))

		testEmptyArray(t, storage, typeInfo, address, parentArray)
	})

	t.Run("child array is inlined", func(t *testing.T) {
		const arrayCount = uint64(2)

		storage := newTestPersistentStorage(t)

		// Create parent array
		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make(test_utils.ExpectedArrayValue, arrayCount)

		for i := range expectedValues {
			// Create child array
			childArray, err := atree.NewArray(storage, address, typeInfo)
			require.NoError(t, err)

			err = parentArray.Append(childArray)
			require.NoError(t, err)

			// Insert one element to child array
			v := test_utils.NewStringValue(strings.Repeat("a", 10))

			err = childArray.Append(v)
			require.NoError(t, err)
			require.True(t, childArray.Inlined())

			expectedValues[i] = test_utils.ExpectedArrayValue{v}
		}

		// Test array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		// Remove child array value
		for i := range expectedValues {
			valueStorable, err := parentArray.Remove(uint64(0))
			require.NoError(t, err)

			id, ok := valueStorable.(atree.SlabIDStorable)
			require.True(t, ok)

			child, err := id.StoredValue(storage)
			require.NoError(t, err)

			testValueEqual(t, expectedValues[i], child)

			err = storage.Remove(atree.SlabID(id))
			require.NoError(t, err)
		}

		// Test array's mutableElementIndex
		require.Equal(t, uint64(0), atree.GetArrayMutableElementIndexCount(parentArray))

		testEmptyArray(t, storage, typeInfo, address, parentArray)
	})

	t.Run("child map is not inlined", func(t *testing.T) {
		const arrayCount = uint64(2)

		storage := newTestPersistentStorage(t)

		// Create parent array
		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make(test_utils.ExpectedArrayValue, arrayCount)

		for i := range expectedValues {
			// Create child map
			childMap, err := atree.NewMap(storage, address, atree.NewDefaultDigesterBuilder(), typeInfo)
			require.NoError(t, err)

			err = parentArray.Append(childMap)
			require.NoError(t, err)

			expectedChildValues := make(test_utils.ExpectedMapValue)
			expectedValues[i] = expectedChildValues

			// Insert into child map until child map is not inlined

			for j := uint64(0); ; j++ {
				k := test_utils.Uint64Value(j)
				v := test_utils.NewStringValue(strings.Repeat("a", 10))

				existingStorable, err := childMap.Set(test_utils.CompareValue, test_utils.GetHashInput, k, v)
				require.NoError(t, err)
				require.Nil(t, existingStorable)

				expectedChildValues[k] = v

				if !childMap.Inlined() {
					break
				}
			}
		}

		// Test array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		// Remove child map value
		for i := range expectedValues {
			valueStorable, err := parentArray.Remove(uint64(0))
			require.NoError(t, err)

			id, ok := valueStorable.(atree.SlabIDStorable)
			require.True(t, ok)

			child, err := id.StoredValue(storage)
			require.NoError(t, err)

			testValueEqual(t, expectedValues[i], child)

			err = storage.Remove(atree.SlabID(id))
			require.NoError(t, err)
		}

		// Test array's mutableElementIndex
		require.Equal(t, uint64(0), atree.GetArrayMutableElementIndexCount(parentArray))

		testEmptyArray(t, storage, typeInfo, address, parentArray)
	})

	t.Run("child map is inlined", func(t *testing.T) {
		const arrayCount = uint64(2)

		storage := newTestPersistentStorage(t)

		// Create parent array
		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		expectedValues := make(test_utils.ExpectedArrayValue, arrayCount)

		for i := range expectedValues {
			// Create child map
			childMap, err := atree.NewMap(storage, address, atree.NewDefaultDigesterBuilder(), typeInfo)
			require.NoError(t, err)

			k := test_utils.NewUint64ValueFromInteger(i)

			err = parentArray.Append(childMap)
			require.NoError(t, err)

			expectedChildValues := make(test_utils.ExpectedMapValue)
			expectedValues[i] = expectedChildValues

			// Insert into child map until child map is not inlined
			v := test_utils.NewStringValue(strings.Repeat("a", 10))

			existingStorable, err := childMap.Set(test_utils.CompareValue, test_utils.GetHashInput, k, v)
			require.NoError(t, err)
			require.Nil(t, existingStorable)

			expectedChildValues[k] = v
		}

		// Test array's mutableElementIndex
		require.True(t, atree.GetArrayMutableElementIndexCount(parentArray) <= parentArray.Count())

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		// Remove child map value
		for i := range expectedValues {
			valueStorable, err := parentArray.Remove(uint64(0))
			require.NoError(t, err)

			id, ok := valueStorable.(atree.SlabIDStorable)
			require.True(t, ok)

			child, err := id.StoredValue(storage)
			require.NoError(t, err)

			testValueEqual(t, expectedValues[i], child)

			err = storage.Remove(atree.SlabID(id))
			require.NoError(t, err)
		}

		// Test array's mutableElementIndex
		require.Equal(t, uint64(0), atree.GetArrayMutableElementIndexCount(parentArray))

		testEmptyArray(t, storage, typeInfo, address, parentArray)
	})
}

func TestArrayWithOutdatedCallback(t *testing.T) {
	typeInfo := test_utils.NewSimpleTypeInfo(42)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	t.Run("overwritten child array", func(t *testing.T) {

		storage := newTestPersistentStorage(t)

		// Create parent array
		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		var expectedValues test_utils.ExpectedArrayValue

		// Create child array
		childArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		// Insert child array to parent array
		err = parentArray.Append(childArray)
		require.NoError(t, err)

		v := test_utils.NewStringValue(strings.Repeat("a", 10))

		err = childArray.Append(v)
		require.NoError(t, err)

		expectedValues = append(expectedValues, test_utils.ExpectedArrayValue{v})

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		// Overwrite child array value from parent
		valueStorable, err := parentArray.Set(0, test_utils.Uint64Value(0))
		require.NoError(t, err)

		id, ok := valueStorable.(atree.SlabIDStorable)
		require.True(t, ok)

		child, err := id.StoredValue(storage)
		require.NoError(t, err)

		testValueEqual(t, expectedValues[0], child)

		expectedValues[0] = test_utils.Uint64Value(0)

		// childArray.parentUpdater isn't nil before callback is invoked.
		require.True(t, atree.ArrayHasParentUpdater(childArray))

		// modify overwritten child array
		err = childArray.Append(test_utils.Uint64Value(0))
		require.NoError(t, err)

		// childArray.parentUpdater is nil after callback is invoked.
		require.False(t, atree.ArrayHasParentUpdater(childArray))

		// No-op on parent
		testValueEqual(t, expectedValues, parentArray)
	})

	t.Run("removed child array", func(t *testing.T) {

		storage := newTestPersistentStorage(t)

		// Create parent array
		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		var expectedValues test_utils.ExpectedArrayValue

		// Create child array
		childArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		// Insert child array to parent array
		err = parentArray.Append(childArray)
		require.NoError(t, err)

		v := test_utils.NewStringValue(strings.Repeat("a", 10))

		err = childArray.Append(v)
		require.NoError(t, err)

		expectedValues = append(expectedValues, test_utils.ExpectedArrayValue{v})

		testArray(t, storage, typeInfo, address, parentArray, expectedValues, true)

		// Remove child array value from parent
		valueStorable, err := parentArray.Remove(0)
		require.NoError(t, err)

		id, ok := valueStorable.(atree.SlabIDStorable)
		require.True(t, ok)

		child, err := id.StoredValue(storage)
		require.NoError(t, err)

		testValueEqual(t, expectedValues[0], child)

		expectedValues = test_utils.ExpectedArrayValue{}

		// childArray.parentUpdater isn't nil before callback is invoked.
		require.True(t, atree.ArrayHasParentUpdater(childArray))

		// modify removed child array
		err = childArray.Append(test_utils.Uint64Value(0))
		require.NoError(t, err)

		// childArray.parentUpdater is nil after callback is invoked.
		require.False(t, atree.ArrayHasParentUpdater(childArray))

		// No-op on parent
		testValueEqual(t, expectedValues, parentArray)
	})
}

func TestArraySetType(t *testing.T) {
	typeInfo := test_utils.NewSimpleTypeInfo(42)
	newTypeInfo := test_utils.NewSimpleTypeInfo(43)
	address := atree.Address{1, 2, 3, 4, 5, 6, 7, 8}

	t.Run("empty", func(t *testing.T) {
		storage := newTestPersistentStorage(t)

		// Create a new array in memory
		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)
		require.Equal(t, uint64(0), array.Count())
		require.Equal(t, typeInfo, array.Type())
		require.True(t, IsArrayRootDataSlab(array))

		// Modify type info of new array
		err = array.SetType(newTypeInfo)
		require.NoError(t, err)
		require.Equal(t, newTypeInfo, array.Type())

		// Commit new array to storage
		err = storage.FastCommit(runtime.NumCPU())
		require.NoError(t, err)

		testExistingArraySetType(t, array.SlabID(), atree.GetBaseStorage(storage), newTypeInfo, array.Count())
	})

	t.Run("data slab root", func(t *testing.T) {
		storage := newTestPersistentStorage(t)

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(10)
		for i := range arrayCount {
			v := test_utils.Uint64Value(i)
			err := array.Append(v)
			require.NoError(t, err)
		}

		require.Equal(t, arrayCount, array.Count())
		require.Equal(t, typeInfo, array.Type())
		require.True(t, IsArrayRootDataSlab(array))

		err = array.SetType(newTypeInfo)
		require.NoError(t, err)
		require.Equal(t, newTypeInfo, array.Type())

		// Commit modified slabs in storage
		err = storage.FastCommit(runtime.NumCPU())
		require.NoError(t, err)

		testExistingArraySetType(t, array.SlabID(), atree.GetBaseStorage(storage), newTypeInfo, array.Count())
	})

	t.Run("metadata slab root", func(t *testing.T) {
		storage := newTestPersistentStorage(t)

		array, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(10_000)
		for i := range arrayCount {
			v := test_utils.Uint64Value(i)
			err := array.Append(v)
			require.NoError(t, err)
		}

		require.Equal(t, arrayCount, array.Count())
		require.Equal(t, typeInfo, array.Type())
		require.False(t, IsArrayRootDataSlab(array))

		err = array.SetType(newTypeInfo)
		require.NoError(t, err)
		require.Equal(t, newTypeInfo, array.Type())

		// Commit modified slabs in storage
		err = storage.FastCommit(runtime.NumCPU())
		require.NoError(t, err)

		testExistingArraySetType(t, array.SlabID(), atree.GetBaseStorage(storage), newTypeInfo, array.Count())
	})

	t.Run("inlined in parent container root data slab", func(t *testing.T) {
		storage := newTestPersistentStorage(t)

		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		childArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		err = parentArray.Append(childArray)
		require.NoError(t, err)

		require.Equal(t, uint64(1), parentArray.Count())
		require.Equal(t, typeInfo, parentArray.Type())
		require.True(t, IsArrayRootDataSlab(parentArray))
		require.False(t, parentArray.Inlined())

		require.Equal(t, uint64(0), childArray.Count())
		require.Equal(t, typeInfo, childArray.Type())
		require.True(t, IsArrayRootDataSlab(childArray))
		require.True(t, childArray.Inlined())

		err = childArray.SetType(newTypeInfo)
		require.NoError(t, err)
		require.Equal(t, newTypeInfo, childArray.Type())

		// Commit modified slabs in storage
		err = storage.FastCommit(runtime.NumCPU())
		require.NoError(t, err)

		testExistingInlinedArraySetType(t, parentArray.SlabID(), 0, atree.GetBaseStorage(storage), newTypeInfo, childArray.Count())
	})

	t.Run("inlined in parent container non-root data slab", func(t *testing.T) {
		storage := newTestPersistentStorage(t)

		parentArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		const arrayCount = uint64(10_000)
		for i := range arrayCount - 1 {
			v := test_utils.Uint64Value(i)
			err := parentArray.Append(v)
			require.NoError(t, err)
		}

		childArray, err := atree.NewArray(storage, address, typeInfo)
		require.NoError(t, err)

		err = parentArray.Append(childArray)
		require.NoError(t, err)

		require.Equal(t, arrayCount, parentArray.Count())
		require.Equal(t, typeInfo, parentArray.Type())
		require.False(t, IsArrayRootDataSlab(parentArray))
		require.False(t, parentArray.Inlined())

		require.Equal(t, uint64(0), childArray.Count())
		require.Equal(t, typeInfo, childArray.Type())
		require.True(t, IsArrayRootDataSlab(childArray))
		require.True(t, childArray.Inlined())

		err = childArray.SetType(newTypeInfo)
		require.NoError(t, err)
		require.Equal(t, newTypeInfo, childArray.Type())

		// Commit modified slabs in storage
		err = storage.FastCommit(runtime.NumCPU())
		require.NoError(t, err)

		testExistingInlinedArraySetType(t, parentArray.SlabID(), arrayCount-1, atree.GetBaseStorage(storage), newTypeInfo, childArray.Count())
	})
}

func testExistingArraySetType(
	t *testing.T,
	id atree.SlabID,
	baseStorage atree.BaseStorage,
	expectedTypeInfo test_utils.SimpleTypeInfo,
	expectedCount uint64,
) {
	newTypeInfo := test_utils.NewSimpleTypeInfo(expectedTypeInfo.Value() + 1)

	// Create storage from existing data
	storage := newTestPersistentStorageWithBaseStorage(t, baseStorage)

	// Load existing array by ID
	array, err := atree.NewArrayWithRootID(storage, id)
	require.NoError(t, err)
	require.Equal(t, expectedCount, array.Count())
	require.Equal(t, expectedTypeInfo, array.Type())

	// Modify type info of existing array
	err = array.SetType(newTypeInfo)
	require.NoError(t, err)
	require.Equal(t, expectedCount, array.Count())
	require.Equal(t, newTypeInfo, array.Type())

	// Commit data in storage
	err = storage.FastCommit(runtime.NumCPU())
	require.NoError(t, err)

	// Create storage from existing data
	storage2 := newTestPersistentStorageWithBaseStorage(t, atree.GetBaseStorage(storage))

	// Load existing array again from storage
	array2, err := atree.NewArrayWithRootID(storage2, id)
	require.NoError(t, err)
	require.Equal(t, expectedCount, array2.Count())
	require.Equal(t, newTypeInfo, array2.Type())
}

func testExistingInlinedArraySetType(
	t *testing.T,
	parentID atree.SlabID,
	inlinedChildIndex uint64,
	baseStorage atree.BaseStorage,
	expectedTypeInfo test_utils.SimpleTypeInfo,
	expectedCount uint64,
) {
	newTypeInfo := test_utils.NewSimpleTypeInfo(expectedTypeInfo.Value() + 1)

	// Create storage from existing data
	storage := newTestPersistentStorageWithBaseStorage(t, baseStorage)

	// Load existing array by ID
	parentArray, err := atree.NewArrayWithRootID(storage, parentID)
	require.NoError(t, err)

	element, err := parentArray.Get(inlinedChildIndex)
	require.NoError(t, err)

	childArray, ok := element.(*atree.Array)
	require.True(t, ok)

	require.Equal(t, expectedCount, childArray.Count())
	require.Equal(t, expectedTypeInfo, childArray.Type())

	// Modify type info of existing array
	err = childArray.SetType(newTypeInfo)
	require.NoError(t, err)
	require.Equal(t, expectedCount, childArray.Count())
	require.Equal(t, newTypeInfo, childArray.Type())

	// Commit data in storage
	err = storage.FastCommit(runtime.NumCPU())
	require.NoError(t, err)

	// Create storage from existing data
	storage2 := newTestPersistentStorageWithBaseStorage(t, atree.GetBaseStorage(storage))

	// Load existing array again from storage
	parentArray2, err := atree.NewArrayWithRootID(storage2, parentID)
	require.NoError(t, err)

	element2, err := parentArray2.Get(inlinedChildIndex)
	require.NoError(t, err)

	childArray2, ok := element2.(*atree.Array)
	require.True(t, ok)

	require.Equal(t, expectedCount, childArray2.Count())
	require.Equal(t, newTypeInfo, childArray2.Type())
}