newParams.put("key3", "value3");
        assertTrue(newParams.containsKey("key3"));
        assertFalse(dataStoreParams.containsKey("key3"));

        // Verify that modifications to original don't affect new instance
        dataStoreParams.put("key4", "value4");
        assertTrue(dataStoreParams.containsKey("key4"));
        assertFalse(newParams.containsKey("key4"));
    }

    // Test asMap

    }

    public void test_integer() {
        Map<String, Object> doc = new HashMap<>();

        int expected3 = 999;
        doc.put("key3", expected3);
        assertEquals(expected3, DocumentUtil.getValue(doc, "key3", Integer.class));

        doc.put("key9", new ArrayList<Integer>(Arrays.asList(777, 888, 999)));
        assertEquals(777, DocumentUtil.getValue(doc, "key9", Integer.class));
    }

        dataMap.put("key1", "value1");
        dataMap.put("key2", "");
        dataMap.put("key3", null);

        // Test with existing value
        String result1 = (String) method.invoke(crawler, dataMap, "key1", "default");
        assertEquals("value1", result1);

        // Test with empty value
        String result2 = (String) method.invoke(crawler, dataMap, "key2", "default");

        // Test with whitespace around keys and values
        value = "  key1  =  value1  \n  key2=value2\n";
        paramMap = ParameterUtil.parse(value);
        assertEquals(2, paramMap.size());
        assertEquals("value1", paramMap.get("key1"));
        assertEquals("value2", paramMap.get("key2"));

        // Test with empty lines and mixed whitespace
        value = "key1=value1\n\n\t\nkey2=value2\n \n";

        String[] keys = entrySet.stream().map(Map.Entry::getKey).toArray(String[]::new);

        assertTrue("Should contain all keys", Arrays.asList(keys).contains("lang"));
        assertTrue("Should contain all keys", Arrays.asList(keys).contains("a_key"));
        assertTrue("Should contain all keys", Arrays.asList(keys).contains("b_key"));
        assertTrue("Should contain all keys", Arrays.asList(keys).contains("c_key"));

      while (same != 0xffffffff || diff != 0xffffffff) {
        int key1 = rand.nextInt();
        // flip input bit for key2
        int key2 = key1 ^ (1 << i);
        // get hashes
        int hash1 = function.hashInt(key1).asInt();
        int hash2 = function.hashInt(key2).asInt();
        // test whether the hash values have same output bits
        same |= ~(hash1 ^ hash2);

 * i.e. {@code if (key1.equals(key2))} then {@code striped.get(key1) == striped.get(key2)} (assuming
 * {@link Object#hashCode()} is correctly implemented for the keys). Note that if {@code key1} is
 * <strong>not</strong> equal to {@code key2}, it is <strong>not</strong> guaranteed that {@code

 * {@link #entries()}. Unlike {@link LinkedHashMultimap}, the iteration order is kept consistent
 * between keys, entries and values. For example, calling:
 *
 * {@snippet :
 * multimap.remove(key1, foo);
 * }
 *
 * <p>changes the entries iteration order to {@code [key2=bar, key1=baz]} and the key iteration
 * order to {@code [key2, key1]}. The {@link #entries()} iterator returns mutable map entries, and

        StringBuilder buf = new StringBuilder();

        monitorTarget.append(buf, "key1", () -> "value1");
        buf.append(",");
        monitorTarget.append(buf, "key2", () -> 123);
        buf.append(",");
        monitorTarget.append(buf, "key3", () -> null);

        assertEquals("\"key1\":\"value1\",\"key2\":123,\"key3\":null", buf.toString());
    }

    // Test append with empty string

  public void testKeySetEntrySetValues() {
    for (LoadingCache<Key, String> cache : caches()) {
      Key key1 = new Key(1);
      String value1 = key1.toString();
      Key key2 = new Key(2);
      String value2 = key2.toString();
      assertSame(value1, cache.getUnchecked(key1));
      assertSame(value2, cache.getUnchecked(key2));
      assertEquals(ImmutableSet.of(key1, key2), cache.asMap().keySet());