assertTrue(result instanceof QueryRescorerBuilder);

        QueryRescorerBuilder queryRescorerBuilder = (QueryRescorerBuilder) result;
        assertEquals(testWindowSize, queryRescorerBuilder.windowSize().intValue());
    }

    @Test
    public void test_evaluate_withEmptyParams() {
        // Test with empty parameters map
        final String testModelName = "test_model";
        final int testWindowSize = 50;

    EquivalenceTester.of(Equivalence.equals().onResultOf(Functions.toStringFunction()))
        .addEquivalenceGroup(new IntValue(1), new IntValue(1))
        .addEquivalenceGroup(new IntValue(2))
        .test();
  }

  public void testOnResultOf_equals() {
    new EqualsTester()
        .addEqualityGroup(
            Equivalence.identity().onResultOf(Functions.toStringFunction()),

    map.put("Null", null);
    Function<String, @Nullable Integer> function = Functions.forMap(map, 42);

    assertEquals(1, function.apply("One").intValue());
    assertEquals(42, function.apply("Two").intValue());
    assertEquals(3, function.apply("Three").intValue());
    assertThat(function.apply("Null")).isNull();

    new EqualsTester()
        .addEqualityGroup(function, Functions.forMap(map, 42))

    assertFalse(task.isDone());
    task.run();
    assertTrue(task.isDone());
    assertFalse(task.isCancelled());
    assertEquals(2, getDone(task).intValue());
  }

  public void testCancelled() throws Exception {
    TrustedListenableFutureTask<Integer> task = TrustedListenableFutureTask.create(returning(2));
    assertFalse(task.isDone());
    task.cancel(false);

              assertEquals(1, threadLocalCount.get().intValue());
              return null;
            });
    new Thread(otherTask).start();

    ListenableFuture<?> future = executor.submit(incrementTask);
    assertTrue(future.isDone());
    assertListenerRunImmediately(future);
    assertEquals(1, threadLocalCount.get().intValue());
    otherTask.get();
  }

    // Finish the task by unblocking the task latch.  Then wait for the
    // listener to be called by blocking on the listener latch.
    taskLatch.countDown();
    assertEquals(25, task.get().intValue());
    assertTrue(listenerLatch.await(5, SECONDS));
    assertTrue(task.isDone());
    assertFalse(task.isCancelled());
  }

  public void testListenerCalledOnException() throws Exception {

    // Finish the task by unblocking the task latch.  Then wait for the
    // listener to be called by blocking on the listener latch.
    taskLatch.countDown();
    assertEquals(25, task.get().intValue());
    assertTrue(listenerLatch.await(5, SECONDS));
    assertTrue(task.isDone());
    assertFalse(task.isCancelled());
  }

  public void testListenerCalledOnException() throws Exception {

      assertThat(at.toString()).isEqualTo(Double.toString(x));
    }
  }

  /** intValue returns current value. */
  public void testIntValue() {
    AtomicDouble at = new AtomicDouble();
    assertEquals(0, at.intValue());
    for (double x : VALUES) {
      at.set(x);
      assertEquals((int) x, at.intValue());
    }
  }

  /** longValue returns current value. */
  public void testLongValue() {

    assertEquals(UnsignedLong.ZERO, ArbitraryInstances.get(UnsignedLong.class));
    assertEquals(0, ArbitraryInstances.get(BigDecimal.class).intValue());
    assertEquals(0, ArbitraryInstances.get(BigInteger.class).intValue());
    assertThat(ArbitraryInstances.get(String.class)).isEqualTo("");
    assertEquals("", ArbitraryInstances.get(CharSequence.class));

        if (userCode == null) {
            return false;
        }

        final int length = userCode.length();
        if (getUserCodeMinLengthAsInteger().intValue() > length || getUserCodeMaxLengthAsInteger().intValue() < length) {
            return false;
        }

        Pattern pattern = (Pattern) propMap.get(USER_CODE_PATTERN);
        if (pattern == null) {