Configuration result1 = mockSession.getConfig();
            Configuration result2 = mockSession.getConfig();

            assertSame(result1, result2, "getConfig() should return consistent values");
            verify(mockSession, times(2)).getConfig();
        }
    }

    @Nested
    @DisplayName("Resource Unwrapping Tests")
    class ResourceUnwrappingTest {

        @Test

        // All overwrite keys should be removed
        assertFalse(dataMap.containsKey("m.overwrite"));
        assertFalse(dataMap.containsKey("n.overwrite"));

        // m and n are updated with overwrite values, p is merged normally
        assertEquals("M1", dataMap.get("m"));
        assertEquals("N1", dataMap.get("n"));
        assertEquals("P1", dataMap.get("p"));
        assertEquals(3, dataMap.size());
    }

    }

    @Override
    public boolean containsKey(Object key) {
      return standardContainsKey(key);
    }

    @Override
    public boolean containsValue(Object value) {
      return standardContainsValue(value);
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> map) {
      standardPutAll(map);
    }

    @Override
    public @Nullable V remove(Object object) {

                if (selected.hour() >= 12) {
                    html += '<option value="AM"' + am_html + '>AM</option><option value="PM" selected="selected"' + pm_html + '>PM</option>';
                } else {
                    html += '<option value="AM" selected="selected"' + am_html + '>AM</option><option value="PM"' + pm_html + '>PM</option>';
                }

                html += '</select>';

 * underlying (implementation specific) data structures to be shared.
 *
 * <p>The size of the data structure used by ArrayBasedCharEscaper and ArrayBasedUnicodeEscaper is
 * proportional to the highest valued character that has a replacement. For example a replacement
 * map containing the single character '{@literal \}u1000' will require approximately 16K of memory.

   * algorithm, x86 variant</a> (little-endian variant), using the given seed value, <b>with a known
   * bug</b> as described in the deprecation text.
   *
   * <p>The C++ equivalent is the MurmurHash3_x86_32 function (Murmur3A), which however does not
   * have the bug.
   *
   * @deprecated This implementation produces incorrect hash values from the {@link

        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        final String value = fessConfig.getPurgeByBots();
        String[] botNames;
        if (StringUtil.isBlank(value)) {
            botNames = StringUtil.EMPTY_STRINGS;
        } else {
            botNames = value.split(",");
        }

        final int batchSize = fessConfig.getSearchlogProcessBatchSizeAsInteger();

    return predicate.apply(immutableEntry(key, value));
  }

  final class ValuePredicate implements Predicate<V> {
    @ParametricNullness private final K key;

    ValuePredicate(@ParametricNullness K key) {
      this.key = key;
    }

    @Override
    public boolean apply(@ParametricNullness V value) {
      return satisfies(key, value);
    }
  }

        return new CopyOptions().exclude(propertyNames);
    }

    /**
     * Returns a {@link CopyOptions} that excludes properties with {@literal null} values from the operation.
     *
     * @return A {@link CopyOptions} that excludes properties with {@literal null} values from the operation.
     * @see CopyOptions#excludeNull()
     */
    public static CopyOptions excludeNull() {
        return new CopyOptions().excludeNull();

		}
	}
}

func TestParseNumeric(t *testing.T) {
	vectors := []struct {
		in   string
		want int64
		ok   bool
	}{
		// Test base-256 (binary) encoded values.
		{"", 0, true},
		{"\x80", 0, true},
		{"\x80\x00", 0, true},
		{"\x80\x00\x00", 0, true},
		{"\xbf", (1 << 6) - 1, true},
		{"\xbf\xff", (1 << 14) - 1, true},
		{"\xbf\xff\xff", (1 << 22) - 1, true},