import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.Mock;

        params.put("long", 123456789L);
        params.put("boolean", true);
        params.put("double", 3.14);

        Map<String, Object> nestedMap = new HashMap<>();
        nestedMap.put("nested-key", "nested-value");
        params.put("map", nestedMap);

        IndexUpdateCallback callback = new TestIndexUpdateCallback();

        // Execute store
        dataStore.store(config, callback, params);

        booleanData.put("flag", true);
        callback.store(params, booleanData);

        // Test with nested map
        Map<String, Object> nestedData = new HashMap<>();
        Map<String, String> innerMap = new HashMap<>();
        innerMap.put("inner", "value");
        nestedData.put("nested", innerMap);
        callback.store(params, nestedData);

        assertEquals(4L, callback.getDocumentSize());
    }

            assertNotNull(tree, "Tree should not be null in try block");
        }

        verify(autoCloseTree).close();
    }

    /**
     * Test for unwrap with nested wrapping.
     * Verifies that unwrap works correctly with multiple levels of wrapping.
     */
    @Test
    void testUnwrap_nestedWrapping() {
        // Create a chain of wrapped trees

        assertEquals("Map contents should match", original, deserializedMap);
    }

    /**
     * Test serialization and deserialization of complex nested object
     */
    @Test
    public void test_serializeDeserialize_complexObject() {
        Map<String, Object> original = new HashMap<>();
        original.put("string", "test");

import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.Mock;

package callbacks

import (
	"fmt"
	"reflect"
	"sort"
	"strings"

	"gorm.io/gorm"
	"gorm.io/gorm/clause"
	"gorm.io/gorm/schema"
	"gorm.io/gorm/utils"
)

// parsePreloadMap extracts nested preloads. e.g.
//
//	// schema has a "k0" relation and a "k7.k8" embedded relation
//	parsePreloadMap(schema, map[string][]interface{}{
//		clause.Associations: {"arg1"},
//		"k1":                {"arg2"},

import static org.junit.jupiter.api.Assertions.assertTrue;

import java.lang.reflect.Field;
import java.nio.charset.StandardCharsets;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.junit.jupiter.MockitoExtension;

/**

        assertTrue(duration < 1000, "Creating and using 10000 EmptyIterators should be fast (took " + duration + "ms)");
    }

    @Test
    @DisplayName("EmptyIterator should work correctly in nested iteration")
    void testNestedIteration() {
        // When & Then
        assertDoesNotThrow(() -> {
            int outerCount = 0;
            while (emptyIterator.hasNext()) {

        // Then
        assertEquals(0x71, command & 0xFF);
        assertEquals(ServerMessageBlock.SMB_COM_TREE_DISCONNECT, (byte) command);
    }

    /**
     * Nested class for testing buffer operations
     */
    @Nested
    @DisplayName("Buffer Operations Tests")
    class BufferOperationsTests {

        @Test
        @DisplayName("Test write operations with empty buffer")