errors.docid_not_found = ID do documento não encontrada. Causa: {0}
errors.document_not_found = URL do ID do documento não encontrada. Causa: {0}
errors.not_load_from_server = Não foi possível carregar deste servidor. Causa: {0}
errors.failed_to_start_job = Não foi possível iniciar o trabalho {0}.
errors.failed_to_stop_job = Não foi possível parar o trabalho {0}.

    }

    // Test evaluate method with nested expressions
    public void test_evaluate_withNestedExpressions() {
        String template = "${level1.level2.value}";
        Map<String, Object> paramMap = new HashMap<>();
        Map<String, Object> level2 = new HashMap<>();
        level2.put("value", "nested");
        Map<String, Object> level1 = new HashMap<>();

    }

    public void test_complexDocumentStructure() {
        // Test with complex nested document structure
        Map<String, Object> doc = new HashMap<>();
        doc.put("id", "complex");

        Map<String, Object> nested = new HashMap<>();
        nested.put("level2", "value");
        doc.put("nested", nested);

        List<String> list = new ArrayList<>();
        list.add("item1");

    }

    public void test_sizeOf_complexNestedStructures() {
        // Complex nested structure
        Map<String, Object> complexMap = new HashMap<>();
        complexMap.put("strings", Arrays.asList("test1", "test2"));
        complexMap.put("numbers", Arrays.asList(1, 2, 3));
        complexMap.put("nested", Maps.map("inner", "value").$());
        complexMap.put("array", new String[] { "array1", "array2" });

        }
    }

    public void test_execute_withNestedBoostQuery() {
        // Test executing BoostQuery with another BoostQuery inside (nested boost)
        Term term = new Term("field", "nested");
        TermQuery termQuery = new TermQuery(term);
        BoostQuery innerBoostQuery = new BoostQuery(termQuery, 2.0f);
        BoostQuery outerBoostQuery = new BoostQuery(innerBoostQuery, 3.0f);

        assertEquals(3.14, result.get("double"));
        assertEquals(false, result.get("boolean"));
        assertNull(result.get("null_value"));
        assertNotNull(result.get("nested"));
        assertEquals("nested_value", ((Map<String, Object>) result.get("nested")).get("nested_key"));
    }

    // Test interface contract consistency
    public void test_interfaceContract() {

        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);

     */
    static final VarHandle HANDLE = byteArrayViewVarHandle(long[].class, LITTLE_ENDIAN);
  }

  /**
   * The only reference to Unsafe is in this nested class. We set things up so that if
   * Unsafe.theUnsafe is inaccessible, the attempt to load the nested class fails, and the outer
   * class's static initializer can fall back on a non-Unsafe version.
   */
  @SuppressWarnings("SunApi") // b/345822163
  @VisibleForTesting

        complexObject.put("nested", "value");

        dataStoreParams.put("complexKey", complexObject);
        assertEquals(complexObject, dataStoreParams.get("complexKey"));

        String asString = dataStoreParams.getAsString("complexKey");
        assertNotNull(asString);
        assertTrue(asString.contains("nested"));
    }

    // Test overwriting existing values

        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());
    }