assertThat(formEncode(12)).isEqualTo("%0C")
    // Browsers convert '\r' to '\r\n'
    assertThat(formEncode(13)).isEqualTo("%0D")
    assertThat(formEncode(14)).isEqualTo("%0E")
    assertThat(formEncode(15)).isEqualTo("%0F")
    assertThat(formEncode(16)).isEqualTo("%10")
    assertThat(formEncode(17)).isEqualTo("%11")
    assertThat(formEncode(18)).isEqualTo("%12")
    assertThat(formEncode(19)).isEqualTo("%13")

        assertTrue(output.contains("00010:")); // Second line offset

        // Verify first line contains bytes 0-15
        assertTrue(output.contains(" 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F"));
        // Verify second line contains bytes 16-31
        assertTrue(output.contains(" 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F"));
    }

    @Test

        QueryBuilder builder = queryProcessor.execute(context, prefixQuery, 10.0f);

        assertNotNull(builder);
        assertTrue(builder instanceof MatchPhrasePrefixQueryBuilder);

        // Query was processed with high boost
        MatchPhrasePrefixQueryBuilder mpqb = (MatchPhrasePrefixQueryBuilder) builder;
        assertEquals(10.0f, mpqb.boost());
    }

    @Test

        QueryContext context = new QueryContext("test", false);
        QueryBuilder result = queryProcessor.execute(context, boostQuery, 1.0f);

        assertNotNull(result);
        assertTrue(result instanceof MatchAllQueryBuilder);
        MatchAllQueryBuilder matchAllQueryBuilder = (MatchAllQueryBuilder) result;
        assertEquals(3.0f, matchAllQueryBuilder.boost());
    }

        assertNotNull(queryBuilder);
    }

    @Test
    public void test_execute_withNonWildcardQuery() {
        QueryContext queryContext = new QueryContext("test", false);
        TermQuery termQuery = new TermQuery(new Term("title", "test"));

        try {
            queryCommand.execute(queryContext, termQuery, 1.0f);

            .add(LONG_NAME, 8)
            .addValue(9)
            .add(SHORT_NAME, 10L)
            .add(LONG_NAME, 11L)
            .addValue(12L)
            .add(SHORT_NAME, 13.0f)
            .add(LONG_NAME, 14.0f)
            .addValue(15.0f);
      }
    };

    void addEntries(MoreObjects.ToStringHelper helper) {}
  }

  @Param Dataset dataset;

  private static final String SHORT_NAME = "userId";

        Term term = new Term("title", "fuzzy");
        FuzzyQuery fuzzyQuery = new FuzzyQuery(term);

        // Test with different boost values
        float[] boostValues = { 0.5f, 1.0f, 2.5f, 10.0f };
        for (float boost : boostValues) {
            QueryBuilder result = queryProcessor.execute(context, fuzzyQuery, boost);
            assertNotNull(result);

  ASSERT_EQ(3, TF_OutputListNumOutputs(func_outputs));

  float expected_outputs[3][4] = {{1.0f, 1.0f, 1.0f, 1.0f},
                                  {2.0f, 0.0f, 0.0f, 2.0f},
                                  {2.0f, 2.0f, 2.0f, 2.0f}};

  float result_data[4];
  for (int idx = 0; idx < 3; ++idx) {
    TF_AbstractTensor* result = TF_OutputListGet(func_outputs, idx);

  float A_vals[] = {1.0f, 2.0f, 3.0f, 4.0f};
  int64_t A_dims[] = {2, 2};
  AbstractTensorHandlePtr A;
  {
    AbstractTensorHandle* A_raw;
    absl::Status s = TestTensorHandleWithDims<float, TF_FLOAT>(
        ctx_.get(), A_vals, A_dims, 2, &A_raw);
    ASSERT_EQ(errors::OK, s.code()) << s.message();
    A.reset(A_raw);
  }
  float B_vals[] = {.5f, -1.0f, 1.0f, 1.0f};
  int64_t B_dims[] = {2, 2};

        map.put("boost1", 0);
        map.put("boost2", 0);
        assertTrue(0.0f == docBoostMatcher.getValue(map));

        map.put("boost1", 1);
        map.put("boost2", 0);
        assertTrue(10.0f == docBoostMatcher.getValue(map));

        map.put("boost1", 1);
        map.put("boost2", 2);
        assertTrue(12.0f == docBoostMatcher.getValue(map));
    }

    @Test