}

    @Test
    @DisplayName("Should handle different previous session IDs")
    void testDifferentPreviousSessionIds() throws Exception {
        // Given
        long[] sessionIds = { 0L, 1L, Long.MAX_VALUE, Long.MIN_VALUE, 0xFFFFFFFFFFFFFFFFL };

        for (long sessionId : sessionIds) {
            Smb2SessionSetupRequest req = new Smb2SessionSetupRequest(mockContext, TEST_SECURITY_MODE, TEST_CAPABILITIES, sessionId, null);

   *
   * @since 3.0 (source-compatible since 2.0)
   */
  @SafeVarargs // For Eclipse. For internal javac we have disabled this pointless type of warning.
  public static <E> ImmutableSet<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E... others) {
    checkArgument(
        others.length <= Integer.MAX_VALUE - 6, "the total number of elements must fit in an int");

   * overflowing or underflowing, by bounding the value between 0 and (Long.MAX_VALUE / 4) * 3.
   * Actually waiting for more than 219 years is not supported!
   */
  private static long toSafeNanos(long time, TimeUnit unit) {
    long timeoutNanos = unit.toNanos(time);
    return Longs.constrainToRange(timeoutNanos, 0L, (Long.MAX_VALUE / 4) * 3);
  }

  /**

   * infinite {@code double} values are considered infinitely far away. For example, 2^2000 is not
   * representable as a double, but {@code roundToDouble(BigInteger.valueOf(2).pow(2000), HALF_UP)}
   * will return {@code Double.MAX_VALUE}, not {@code Double.POSITIVE_INFINITY}.
   *
   * <p>For the case of {@link RoundingMode#HALF_EVEN}, this implementation uses the IEEE 754

            WebApiUtil.setObject("listValue", list);

            java.util.Map<String, String> map = new java.util.HashMap<>();
            map.put("key", "value");
            WebApiUtil.setObject("mapValue", map);

        } catch (Exception e) {
            fail("setObject should handle different object types: " + e.getMessage());
        }
    }

    public void test_error_handling_edge_cases() {

        }
    }

    @DisplayName("Test exception handling for invalid information levels")
    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 2, 4, 5, 6, 8, 100, -2, -100, Integer.MIN_VALUE, Integer.MAX_VALUE })
    void testInvalidInformationLevels(int invalidLevel) {
        // Skip valid levels
        if (invalidLevel == FileSystemInformation.SMB_INFO_ALLOCATION || invalidLevel == FileSystemInformation.FS_SIZE_INFO) {

        monitor.leave();
      }
    } else {
      return null;
    }
  }

  // this doc comment is overridden to remove the reference to collections
  // greater in size than Integer.MAX_VALUE
  /**
   * Returns the number of elements in this queue.
   *
   * @return the number of elements in this queue
   */
  @CanIgnoreReturnValue
  @Override
  public int size() {

    private static final String DISABLE_URL_ENCODE = "#DISABLE_URL_ENCODE";

    /**
     * Maximum number of URLs to access during crawling.
     */
    protected long maxAccessCount = Long.MAX_VALUE;

    /**
     * Interval time in milliseconds between crawling executions.
     */
    protected long crawlingExecutionInterval = Constants.DEFAULT_CRAWLING_EXECUTION_INTERVAL;

    /**

  /**
   * Returns the number of nanoseconds of the given duration without throwing or overflowing.
   *
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  @GwtIncompatible // Duration

  }

  @Test fun builderClampsMaxDate() {
    val cookie =
      Cookie
        .Builder()
        .name("a")
        .value("b")
        .hostOnlyDomain("example.com")
        .expiresAt(Long.MAX_VALUE)
        .build()
    assertThat(cookie.toString()).isEqualTo("a=b; expires=Fri, 31 Dec 9999 23:59:59 GMT; path=/")
  }

  @Test fun builderExpiresAt() {
    val cookie =
      Cookie
        .Builder()