// Test various boundary values
        long[] testValues = { 0L, // Zero
                1L, // One
                -1L, // Negative one
                0x00000000FFFFFFFFL, // 32-bit max as long
                0xFFFFFFFF00000000L, // High 32 bits set
                0x7FFFFFFFFFFFFFFFL, // Long.MAX_VALUE
                0x8000000000000000L, // Long.MIN_VALUE
                0x0101010101010101L, // Repeating pattern

    // slightly nearer.
    long floatConversionTest = 0xfffffe8000000002L;
    long doubleConversionTest = 0xfffffffffffff402L;

    for (long i = -3; i <= 3; i++) {
      testLongsBuilder
          .add(i)
          .add(Long.MAX_VALUE + i)
          .add(Long.MIN_VALUE + i)
          .add(Integer.MIN_VALUE + i)
          .add(Integer.MAX_VALUE + i)

        // When - Calculate delays for increasing attempts
        long delay1 = policy.getDelayMs(1);
        long delay2 = policy.getDelayMs(2);
        long delay3 = policy.getDelayMs(3);
        long delay4 = policy.getDelayMs(4);
        long delay10 = policy.getDelayMs(10);

        // Then
        assertEquals(1000, delay1);
        assertEquals(2000, delay2);

/**
 * @author FreeGen
 */
public class Role extends BsRole {

    private static final long serialVersionUID = 1L;

    private Map<String, String> attributes;

    public Long getVersionNo() {
        return asDocMeta().version();
    }

    public void setVersionNo(final Long version) {
        asDocMeta().version(version);
    }

    public String getId() {
        return asDocMeta().id();

    private final byte[] fileId;
    private final String fileName;
    private int closeFlags;
    private long creationTime;
    private long lastAccessTime;
    private long lastWriteTime;
    private long changeTime;
    private long allocationSize;
    private long endOfFile;
    private int fileAttributes;

    /**
     * Constructs a close response
     *
     * @param config

    return new ImmutableLongArray(new long[] {e0, e1, e2, e3});
  }

  /** Returns an immutable array containing the given values, in order. */
  public static ImmutableLongArray of(long e0, long e1, long e2, long e3, long e4) {
    return new ImmutableLongArray(new long[] {e0, e1, e2, e3, e4});
  }

  /** Returns an immutable array containing the given values, in order. */

      Long[] suffix = {86L, 99L};
      Long[] all = concat(concat(prefix, elements), suffix);
      return makeArray(all).subArray(2, elements.length + 2).asList();
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // used only from suite
  @AndroidIncompatible
  private static Long[] concat(Long[] a, Long[] b) {
    return ObjectArrays.concat(a, b, Long.class);
  }

  @J2ktIncompatible

        // First access - should not delay
        final long start1 = System.nanoTime();
        controller.delayBeforeProcessing();
        final long elapsed1 = (System.nanoTime() - start1) / 1000000;
        assertTrue("First access should not delay", elapsed1 < 50);

        // Second access to same host - should delay
        q.setUrl("http://example.com/page2");
        final long start2 = System.nanoTime();

            assertNotNull(lock);
        }

        @Test
        @DisplayName("Should create lock with maximum values")
        void testConstructorWithMaxValues() {
            long maxOffset = Long.MAX_VALUE;
            long maxLength = Long.MAX_VALUE;
            int flags = 0xFFFFFFFF;

            lock = new Smb2Lock(maxOffset, maxLength, flags);

            assertNotNull(lock);
        }

        @Test

            if (!timings.isEmpty()) {
                double avgTime = timings.stream().mapToLong(Long::longValue).average().orElse(0.0);
                long maxTime = timings.stream().mapToLong(Long::longValue).max().orElse(0L);
                long minTime = timings.stream().mapToLong(Long::longValue).min().orElse(0L);

                double variance = (maxTime - minTime) / avgTime;