testBlock = new TestServerMessageBlock(mockConfig, (byte) 0x25);

            assertEquals(0x25, testBlock.getCommand());
            assertNull(testBlock.getPath());
        }

        @Test
        @DisplayName("Test constructor with config, command, and path")
        void testConstructorWithPath() {
            testBlock = new TestServerMessageBlock(mockConfig, (byte) 0x25, "\\test\\path");

   * Builder} constructor.
   */
  public static <K, V> Builder<K, V> builder() {
    return new Builder<>();
  }

  /**
   * Returns a new builder, expecting the specified number of entries to be added.
   *
   * <p>If {@code expectedSize} is exactly the number of entries added to the builder before {@link

      ImmutableList.Builder<Object> builder = new ImmutableList.Builder<>(size);
      for (int i = 0; i < size; i++) {
        builder.add(OBJECT);
      }
      dummy += builder.build().size();
    }
    return dummy;
  }

  @Benchmark
  int copyArrayList(int reps) {
    int size = this.size;
    int dummy = 0;
    for (int rep = 0; rep < reps; rep++) {
      List<Object> builder = new ArrayList<>();

 *
 * @author Louis Wasserman
 */
@NullUnmarked
public class DoubleMathRoundingBenchmark {
  private static final double[] doubleInIntRange = new double[ARRAY_SIZE];
  private static final double[] doubleInLongRange = new double[ARRAY_SIZE];
  private static final double[] positiveDoubles = new double[ARRAY_SIZE];

  @Param({"DOWN", "UP", "FLOOR", "CEILING", "HALF_EVEN", "HALF_UP", "HALF_DOWN"})
  RoundingMode mode;

  @BeforeExperiment

    @Override
    public String toString() {
        final int len = this.length / 2 - (this.zterm ? 1 : 0);
        final char[] ca = new char[len];
        for (int i = 0; i < len; i++) {
            ca[i] = (char) this.buffer[i];
        }
        return new String(ca, 0, len);
    }

            if (throwOnEncode) {
                throw new NdrException("Failed to encode");
            }
            // Simulate some encoding activity on the buffer
            dst.enc_ndr_long(123);
        }

        @Override
        public void decode(NdrBuffer src) throws NdrException {
            if (throwOnDecode) {
                throw new NdrException("Failed to decode");
            }

        List<Artifact> list = new ArrayList<>();
        list.add(newArtifact("b"));
        list.add(newArtifact("a"));
        list.add(newArtifact("c"));
        list.add(newArtifact("e"));
        list.add(newArtifact("d"));

        Map<String, Artifact> map = ArtifactUtils.artifactMapByVersionlessId(list);
        assertNotNull(map);
        assertEquals(list, new ArrayList<>(map.values()));
    }

        final SearchHit[] hits = searchResponse.getHits().getHits();
        final List<String> words = new ArrayList<>();
        final List<String> firstWords = new ArrayList<>();
        final List<String> secondWords = new ArrayList<>();
        final List<SuggestItem> firstItems = new ArrayList<>();
        final List<SuggestItem> secondItems = new ArrayList<>();

        final String index;
        if (hits.length > 0) {

    // seed the map, so its segment's count > 0
    cache.getUnchecked("a");
    shouldWait.set(true);

    CountDownLatch computationStarted = new CountDownLatch(1);
    CountDownLatch computationComplete = new CountDownLatch(1);
    new Thread(
            new Runnable() {
              @Override
              public void run() {
                computationStarted.countDown();
                cache.getUnchecked("b");

  public static <E> ArrayBlockingQueue<E> newArrayBlockingQueue(int capacity) {
    return new ArrayBlockingQueue<>(capacity);
  }

  // ArrayDeque

  /**
   * Creates an empty {@code ArrayDeque}.
   *
   * @since 12.0
   */
  public static <E> ArrayDeque<E> newArrayDeque() {
    return new ArrayDeque<>();
  }

  /**