*/
    @Override
    public Object remove(final Object key) {
        return parent.remove(key);
    }

    /**
     * Copies all of the mappings from the specified map to this map.
     *
     * @param m the mappings to be stored in this map
     */
    @Override
    public void putAll(final Map<? extends String, ? extends Object> m) {
        parent.putAll(m);
    }

    /**

        // Test with boolean parameter
        Map<String, Object> booleanParams = new HashMap<>();
        booleanParams.put("boolean", true);
        assertNotNull(queryRescorer.evaluate(booleanParams));

        // Test with unknown parameter
        Map<String, Object> unknownParams = new HashMap<>();
        unknownParams.put("unknown", new Object());
        assertNull(queryRescorer.evaluate(unknownParams));
    }

        assertEquals(255, ndrSmall.value, "Value exceeding byte range should be masked correctly.");
    }

    @Test
    void testEncode() throws NdrException {
        // Create an NdrSmall object with a specific value
        NdrSmall ndrSmall = new NdrSmall(100);

        // Call the encode method
        ndrSmall.encode(mockNdrBuffer);

        // Verify that enc_ndr_small was called with the correct value

  /** Test proper handling where an object incorrectly tests for an incompatible class */
  public void testInvalidEqualsIncompatibleClass() {
    Object obj = new InvalidEqualsIncompatibleClassObject();
    equalsTester.addEqualityGroup(obj);
    try {
      equalsTester.testEquals();
    } catch (AssertionFailedError e) {
      assertErrorMessage(
          e, obj + " must not be Object#equals to an arbitrary object of another class");

        }
    }

    /**
     * Returns the string representation of the message object.
     *
     * @param message
     *            Message object
     * @return String representation of the message object
     */
    protected static String toString(final Object message) {
        if (message == null) {
            return "null";
        }
        if (message instanceof String) {

public final class CollectorTester<
    T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object> {
  /**
   * Creates a {@code CollectorTester} for the specified {@code Collector}. The result of the {@code
   * Collector} will be compared to the expected value using {@link Object#equals}.
   */
  public static <T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object>

   */
  public static <A extends @Nullable Object, B extends @Nullable Object, C extends @Nullable Object>
      Function<A, C> compose(Function<B, C> g, Function<A, ? extends B> f) {
    return new FunctionComposition<>(g, f);
  }

  private static final class FunctionComposition<
          A extends @Nullable Object, B extends @Nullable Object, C extends @Nullable Object>
      implements Function<A, C>, Serializable {

        });

    }

    /**
     * Begins statistics tracking for the specified crawler object.
     * Creates a new statistics object in the cache and starts timing.
     *
     * @param keyObj the crawler object to track (UrlQueue, StatsKeyObject, String, or Number)
     */
    public void begin(final Object keyObj) {
        getCacheKey(keyObj).ifPresent(key -> {
            try {

  }

  /**
   * A sensible definition of {@link #subSet(Object, Object)} in terms of the {@link #subSet(Object,
   * boolean, Object, boolean)} method. If you override {@link #subSet(Object, boolean, Object,
   * boolean)}, you may wish to override {@link #subSet(Object, Object)} to forward to this
   * implementation.
   */
  @Override
  protected SortedSet<E> standardSubSet(

    private final Object keys;
    private final Object values;

    SerializedForm(ImmutableMap<K, V> map) {
      if (USE_LEGACY_SERIALIZATION) {
        Object[] keys = new Object[map.size()];
        Object[] values = new Object[map.size()];
        int i = 0;
        // "extends Object" works around https://github.com/typetools/checker-framework/issues/3013