assertEquals(0L, map.get(key));
    assertFalse(map.containsKey(key));

    assertEquals(1L, map.incrementAndGet(key));
    assertEquals(1L, map.get(key));

    assertEquals(0L, map.decrementAndGet(key));
    assertEquals(0L, map.get(key));
    assertTrue(map.containsKey(key));

    assertEquals(1L, map.incrementAndGet(key));
    assertEquals(1L, map.get(key));
  }

  public void testGetAndIncrement() {

    assertThat(Longs.constrainToRange(1L, 0L, 5L)).isEqualTo(1L);
    assertThat(Longs.constrainToRange(1L, 1L, 5L)).isEqualTo(1L);
    assertThat(Longs.constrainToRange(1L, 3L, 5L)).isEqualTo(3L);
    assertThat(Longs.constrainToRange(0L, -5L, -1L)).isEqualTo(-1L);
    assertThat(Longs.constrainToRange(5L, 2L, 2L)).isEqualTo(2L);
    assertThrows(IllegalArgumentException.class, () -> Longs.constrainToRange(1L, 3L, 2L));
  }

    new RoundToDoubleTester(BigDecimal.valueOf((1L << 54) + 3))
        .setExpectation(twoToThe54, DOWN, FLOOR)
        .setExpectation(nextUp(twoToThe54), CEILING, UP, HALF_DOWN, HALF_UP, HALF_EVEN)
        .roundUnnecessaryShouldThrow()
        .test();
  }

  public void testRoundToDouble_twoToThe54PlusFour() {
    new RoundToDoubleTester(BigDecimal.valueOf((1L << 54) + 4))

        // When
        Integer timeout = request.getOverrideTimeout();

        // Then
        assertNull(timeout, "Cancel requests should not override timeout");
    }

    @Test
    @DisplayName("Test allowChain returns false")
    void testAllowChain() {
        // Given
        Smb2CancelRequest request = new Smb2CancelRequest(mockConfig, 1L, 0L);

        return Stream.of(Arguments.of(0, 0L, 0L, 0L, 0L), // all zeros
                Arguments.of(1, 1L, 1L, 1L, 1L), // ones
                Arguments.of(123, 456L, 789L, 101112L, 131415L), // arbitrary positives
                Arguments.of(Integer.MAX_VALUE, Long.MAX_VALUE, Long.MIN_VALUE, 999_999_999_999L, -1L), // extremes
                Arguments.of(-1, -2L, -3L, -4L, -5L) // negative values
        );
    }

        Arrays.asList(
            new int[] {},
            new int[] {LEAST},
            new int[] {LEAST, LEAST},
            new int[] {LEAST, (int) 1L},
            new int[] {(int) 1L},
            new int[] {(int) 1L, LEAST},
            new int[] {GREATEST, (GREATEST - (int) 1L)},
            new int[] {GREATEST, GREATEST},
            new int[] {GREATEST, GREATEST, GREATEST});

                CollectSpliterators.flatMapToLong(
                    Arrays.spliterator(new Long[] {1L, 0L, 1L, 2L, 3L}),
                    (Long i) -> i == 0L ? null : LongStream.of(i).spliterator(),
                    Spliterator.SIZED | Spliterator.DISTINCT | Spliterator.NONNULL,
                    4))
        .expect(1L, 1L, 2L, 3L);
  }

  public void testFlatMapToDouble_nullStream() {
    SpliteratorTester.ofDouble(

) {
  // Guarded by the TaskRunner.
  internal var queue: TaskQueue? = null

  /** Undefined unless this is in [TaskQueue.futureTasks]. */
  internal var nextExecuteNanoTime = -1L

  /** Returns the delay in nanoseconds until the next execution, or -1L to not reschedule. */
  abstract fun runOnce(): Long

  internal fun initQueue(queue: TaskQueue) {
    if (this.queue === queue) return

        assertEquals("id-with-special-!@#$%^&*()", event1.getId());

        // Test unicode in event type
        TestSearchLogEvent event2 = new TestSearchLogEvent("id", 1L, "タイプ日本語");
        assertEquals("タイプ日本語", event2.getEventType());

        // Test empty strings
        TestSearchLogEvent event3 = new TestSearchLogEvent("", 1L, "");
        assertEquals("", event3.getId());

          invokeStartEvent = false
          call.eventListener.responseBodyStart(call)
        }

        if (read == -1L) {
          complete(null)
          return -1L
        }

        val newBytesReceived = bytesReceived + read
        if (contentLength != -1L && newBytesReceived > contentLength) {
          throw ProtocolException("expected $contentLength bytes but received $newBytesReceived")
        }