assertFailsWith<EOFException> {
      source.buffer().readByteString(101)
    }
  }

  @Test fun blockedStreamDoesntStarveNewStream() {
    val framesThatFillWindow =
      roundUp(Settings.DEFAULT_INITIAL_WINDOW_SIZE, peer.maxOutboundDataLength())

    // Write the mocking script. This accepts more data frames than necessary!
    peer.sendFrame().settings(Settings())

      int x = 1 << exponent;
      intValues.add(x, x + 1, x - 1);
    }
    intValues.add(9999).add(10000).add(10001).add(1000000); // near powers of 10
    intValues.add(5792).add(5793); // sqrt(2^25) rounded up and down
    POSITIVE_INTEGER_CANDIDATES = intValues.build();
    NEGATIVE_INTEGER_CANDIDATES =
        ImmutableList.copyOf(
            Iterables.concat(

  static int lessThanBranchFree(long x, long y) {
    // Returns the sign bit of x - y.
    return (int) (~~(x - y) >>> (Long.SIZE - 1));
  }

  /**
   * Returns the base-2 logarithm of {@code x}, rounded according to the specified rounding mode.
   *
   * @throws IllegalArgumentException if {@code x <= 0}
   * @throws ArithmeticException if {@code mode} is {@link RoundingMode#UNNECESSARY} and {@code x}

      int result = BigIntegerMath.log2(x, HALF_UP);
      BigInteger x2 = x.pow(2);
      // x^2 < 2^(2 * result + 1), or else we would have rounded up
      assertThat(ZERO.setBit(2 * result + 1)).isGreaterThan(x2);
      // x^2 >= 2^(2 * result - 1), or else we would have rounded down
      assertTrue(result == 0 || ZERO.setBit(2 * result - 1).compareTo(x2) <= 0);
    }
  }

  public void testLog2HalfDown() {

        int size = request.size();

        // Expected size calculation: size8(SMB2_HEADER_LENGTH + 32 + info.size())
        // size8 rounds up to nearest multiple of 8
        int expectedRawSize = Smb2Constants.SMB2_HEADER_LENGTH + 32 + 100;
        int expectedSize = (expectedRawSize + 7) & ~7; // Round up to nearest 8
        assertEquals(expectedSize, size);
    }

    @Test
    @DisplayName("Test writeBytesWireFormat method")

        assertEquals("0A", Hexdump.toHexString(data3, 0, 2)); // 2 chars = 1 byte
        assertEquals("0A0", Hexdump.toHexString(data3, 0, 3)); // 3 chars = 1.5 bytes (rounds up to 2)
        assertEquals("0A0B", Hexdump.toHexString(data3, 0, 4)); // 4 chars = 2 bytes
        assertEquals("0A0B0", Hexdump.toHexString(data3, 0, 5)); // 5 chars = 2.5 bytes (rounds up to 3)

import org.junit.jupiter.api.Test;

/**
 * Unit tests for {@link NegTokenTarg}. The class has no external
 * collaborators so tests are mostly focused on round‑trip
 * serialisation and invalid input handling.
 */
class NegTokenTargTest {

    @Test
    @DisplayName("happy path – full token round‑trip")
    void testRoundTripFull() throws IOException {
        // Arrange – create a fully populated token

				cpuUserVal := math.Round(ts.User/tot*100*100) / 100
				updateResourceMetrics(cpuSubsystem, cpuUser, cpuUserVal, labels, false)
				cpuSystemVal := math.Round(ts.System/tot*100*100) / 100
				updateResourceMetrics(cpuSubsystem, cpuSystem, cpuSystemVal, labels, false)
				cpuIdleVal := math.Round(ts.Idle/tot*100*100) / 100

        if (unit == ScaleUnit.BYTE) {
            builder.append(size);
        } else if (scaledSize < 0.05d || scaledSize >= 10.0d) {
            builder.append(Math.round(scaledSize));
        } else {
            builder.append(Math.round(scaledSize * 10d) / 10d);
        }

        if (!omitSymbol) {
            builder.append(" ").append(unit.symbol());
        }
    }

        if (unit == ScaleUnit.BYTE) {
            builder.append(size);
        } else if (scaledSize < 0.05d || scaledSize >= 10.0d) {
            builder.append(Math.round(scaledSize));
        } else {
            builder.append(Math.round(scaledSize * 10d) / 10d);
        }

        if (!omitSymbol) {
            builder.append(" ").append(unit.symbol());
        }
    }