*
   * <p>Because the map may be ascending or descending, this test must derive the relative order of
   * these extreme values rather than relying on their regular sort ordering.
   */
  final TestSuite createSubmapSuite(
      FeatureSpecificTestSuiteBuilder<
              ?, ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>>
          parentBuilder,
      Bound from,

                                    </c:if>
                                    <c:if test="${!running && enabled}">
                                        <button type="submit" class="btn btn-success" name="start"
                                                value="<la:message key="labels.scheduledjob_button_start" />">
                                            <i class="fa fa-play-circle" aria-hidden="true"></i>

    /**
     * Processes a document map for datastore operations.
     * Default implementation delegates to the basic process method.
     *
     * @param target the document data to process
     * @param params the data store parameters
     * @return the processed document data
     */
    public Map<String, Object> process(final Map<String, Object> target, final DataStoreParams params) {
        return process(target);
    }

- Uses external Eclipse formatter from CodeLibs
- Apache License 2.0 headers on all source files
- Comprehensive Javadoc on public APIs

## Test Conventions

- Test class names end with `Test`
- Test methods start with `test_` prefix
- Tests use `## Arrange ##`, `## Act ##`, `## Assert ##` comments
- Some integration tests require network access

## Important Notes for AI Assistants

 *
 * <p><b>Important note:</b> the primary goal of this benchmark is to ensure that varying {@code
 * whereToDiffer} produces no observable change in performance. We want to make sure that the array
 * equals implementation is *not* short-circuiting to prevent timing-based attacks. Being fast is
 * only a secondary goal.
 *
 * @author Kurt Alfred Kluever
 */
@NullUnmarked
public class HashCodeBenchmark {

  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putBytes(ByteBuffer bytes) {
    update(bytes);
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putShort(short s) {
    ByteBuffer scratch = scratch();
    scratch.putShort(s);
    return update(scratch, Shorts.BYTES);
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putInt(int i) {

If you have ktlint errors, you can automatically fix them by running `mvn com.github.gantsign.maven:ktlint-maven-plugin:1.1.1:format`.

## How the configuration works

We use Kotlin portable DSL to store TeamCity configuration, which means you can easily create a new pipeline
based on a specific branch. Currently, we have two pipelines: `master` and `release`, but you can easily create
and test another isolated pipeline from any branch. 

                            logger.debug("SSE phase start event sent. phase={}, message={}, keywords={}", phase, phaseMessage, keywords);
                        }
                    } catch (final Exception e) {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Failed to send phase start event. phase={}, error={}", phase, e.getMessage());
                        }

     * Adds a score booster.
     * @param scoreBooster The score booster.
     */
    protected void addScoreBooster(final ScoreBooster scoreBooster) {
        scoreBoosterList.add(scoreBooster);
        scoreBoosterList.sort((b1, b2) -> b2.getPriority() - b1.getPriority());
    }

    // https://github.com/square/okhttp/issues/4729
    platform.expectFailureOnConscryptPlatform()
    platform.expectFailureOnCorrettoPlatform()
    platform.expectFailureOnLoomPlatform()

    // Start with a trusted root CA certificate.
    val rootCa =
      HeldCertificate
        .Builder()
        .serialNumber(1L)
        .certificateAuthority(1)
        .commonName("root")
        .build()