assertEquals(0x8000, Smb2CreateRequest.FILE_NO_COMPRESSION);
        assertEquals(0x10000, Smb2CreateRequest.FILE_OPEN_REQUIRING_OPLOCK);
        assertEquals(0x20000, Smb2CreateRequest.FILE_DISALLOW_EXCLUSIVE);
        assertEquals(0x100000, Smb2CreateRequest.FILE_RESERVE_OPFILTER);
        assertEquals(0x200000, Smb2CreateRequest.FILE_OPEN_REPARSE_POINT);

            b[off + 6] = 0x00;
            b[off + 7] = 0x00;
            return 8;
        }).when(raf).read(any(byte[].class), anyInt(), eq(8));
        assertEquals(1.0d, raf.readDouble(), 0.0000001);
    }

    @Test
    @DisplayName("readLine(): reads until newline and handles CRLF")
    void readLine_reads() throws Exception {
        SmbRandomAccessFile raf = spy(newInstance("r", false, false, false));

    private final Map<String, AtomicInteger> consecutiveFailures = new ConcurrentHashMap<>();
    private static final int MAX_CONSECUTIVE_FAILURES = 3;
    private static final long FAILURE_RECOVERY_TIME = 600000; // 10 minutes

    @Override
    public SmbTransportImpl getSmbTransport(final CIFSContext tc, final Address address, final int port, final boolean nonPooled) {

  }

  /** Sanity checking with many combinations of false positive rates and expected insertions */
  public void testBasic() {
    for (double fpr = 0.0000001; fpr < 0.1; fpr *= 10) {
      for (int expectedInsertions = 1; expectedInsertions <= 10000; expectedInsertions *= 10) {
        checkSanity(BloomFilter.create(HashTestUtils.BAD_FUNNEL, expectedInsertions, fpr));
      }

  }

  /** Sanity checking with many combinations of false positive rates and expected insertions */
  public void testBasic() {
    for (double fpr = 0.0000001; fpr < 0.1; fpr *= 10) {
      for (int expectedInsertions = 1; expectedInsertions <= 10000; expectedInsertions *= 10) {
        checkSanity(BloomFilter.create(HashTestUtils.BAD_FUNNEL, expectedInsertions, fpr));
      }

    assertThat(ImmutableDoubleArray.of(0, 1, 3).asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
  }

  public void testOf4() {
    assertThat(ImmutableDoubleArray.of(0, 1, 3, 6).asList())
        .containsExactly(0.0, 1.0, 3.0, 6.0)
        .inOrder();
  }

  public void testOf5() {
    assertThat(ImmutableDoubleArray.of(0, 1, 3, 6, 10).asList())
        .containsExactly(0.0, 1.0, 3.0, 6.0, 10.0)
        .inOrder();
  }

     */
    public static final int FILE_OPEN_REQUIRING_OPLOCK = 0x10000;
    /**
     * Any open of this file cannot be exclusive
     */
    public static final int FILE_DISALLOW_EXCLUSIVE = 0x20000;
    /**
     * Reserve an opportunistic lock filter on the open
     */
    public static final int FILE_RESERVE_OPFILTER = 0x100000;
    /**
     * Open a reparse point and bypass normal reparse point processing

    assertThat(ImmutableDoubleArray.of(0, 1, 3).asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
  }

  public void testOf4() {
    assertThat(ImmutableDoubleArray.of(0, 1, 3, 6).asList())
        .containsExactly(0.0, 1.0, 3.0, 6.0)
        .inOrder();
  }

  public void testOf5() {
    assertThat(ImmutableDoubleArray.of(0, 1, 3, 6, 10).asList())
        .containsExactly(0.0, 1.0, 3.0, 6.0, 10.0)
        .inOrder();
  }

    assertThat((double) list.get(1)).isEqualTo(1.0);
  }

  // This test stems from a real bug found by andrewk
  public void testAsList_subList_toArray_roundTrip() {
    double[] array = {0.0, 1.0, 2.0, 3.0};
    List<Double> list = Doubles.asList(array);
    assertThat(Doubles.toArray(list.subList(1, 3))).isEqualTo(new double[] {1.0, 2.0});
    assertThat(Doubles.toArray(list.subList(2, 2))).isEmpty();
  }

    private final AtomicInteger consecutiveSuccesses = new AtomicInteger(0);

    // Hystrix-style windowed statistics
    private final RollingWindow rollingWindow = new RollingWindow(10, 1000); // 10 buckets, 1 second each

    /**
     * Create a circuit breaker with default settings
     *
     * @param name circuit breaker name for logging
     */
    public SmbCircuitBreaker(String name) {