}
  }

  static void checkInRangeForRoundingInputs(boolean condition, double input, RoundingMode mode) {
    if (!condition) {
      throw new ArithmeticException(
          "rounded value is out of range for input " + input + " and rounding mode " + mode);
    }
  }

  static void checkNoOverflow(boolean condition, String methodName, int a, int b) {
    if (!condition) {

										href="/search?q=${f:u(q)}&ex_q=label%3a${f:u(countEntry.key)}&sdh=${f:u(fe:sdh(sh))}${fe:pagingQuery(null)}${fe:facetQuery()}${fe:geoQuery()}">
											${f:h(fe:label(countEntry.key))} 
											<span class="badge rounded-pill text-bg-secondary float-end">${f:h(countEntry.value)}</span>
									</la:link></li>
							</c:if>
						</c:forEach>
					</ul>
				</c:if>
			</c:forEach>

   * primitive conversion from {@code int} to {@code float}, and correctly rounded.
   */
  @Override
  public float floatValue() {
    return longValue();
  }

  /**
   * Returns the value of this {@code UnsignedInteger} as a {@code double}, analogous to a widening
   * primitive conversion from {@code int} to {@code double}, and correctly rounded.
   */
  @Override
  public double doubleValue() {

 *
 * @author Louis Wasserman
 * @since 30.0
 */
@J2ktIncompatible
@GwtIncompatible
public class BigDecimalMath {
  private BigDecimalMath() {}

  /**
   * Returns {@code x}, rounded to a {@code double} with the specified rounding mode. If {@code x}
   * is precisely representable as a {@code double}, its {@code double} value will be returned;

        int size = request.size();

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

    @Test
    @DisplayName("Test size method with input buffer")

          // Four byte characters
          FOUR_BYTE_ROUNDTRIPPABLE_CHARACTERS;

  /** Tests that round tripping of all two byte permutations work. */
  @GwtIncompatible // java.nio.charset.Charset
  public void testIsWellFormed_1Byte() {
    testBytes(1, EXPECTED_ONE_BYTE_ROUNDTRIPPABLE_COUNT);
  }

  /** Tests that round tripping of all two byte permutations work. */
  @GwtIncompatible // java.nio.charset.Charset

            verify(mockBuffer).dec_ndr_short();
            assertEquals(largeValue, ndrShort.value);
        }
    }

    @Nested
    @DisplayName("Round-trip Tests")
    class RoundTripTests {

        @Test
        @DisplayName("Should handle encode-decode round-trip correctly")
        void testEncodeDecodeRoundTrip() throws NdrException {
            // Given: Original value that fits in byte range

    return value;
  }

  /**
   * Returns the value of this {@code UnsignedLong} as a {@code float}, analogous to a widening
   * primitive conversion from {@code long} to {@code float}, and correctly rounded.
   */
  @Override
  public float floatValue() {
    if (value >= 0) {
      return (float) value;
    }
    // The top bit is set, which means that the float value is going to come from the top 24 bits.

 */
package jcifs.internal.smb2.multichannel;

/**
 * Load balancing strategies for multi-channel connections
 */
public enum LoadBalancingStrategy {
    /**
     * Round-robin selection through available channels
     */
    ROUND_ROBIN,

    /**
     * Select the least busy channel based on pending operations
     */
    LEAST_LOADED,

    /**

 *
 * @author Louis Wasserman
 * @since 30.0
 */
@J2ktIncompatible
@GwtIncompatible
public class BigDecimalMath {
  private BigDecimalMath() {}

  /**
   * Returns {@code x}, rounded to a {@code double} with the specified rounding mode. If {@code x}
   * is precisely representable as a {@code double}, its {@code double} value will be returned;