*/

  private val journalFile: Path
  private val journalFileTmp: Path
  private val journalFileBackup: Path
  private var size: Long = 0L
  private var journalWriter: BufferedSink? = null
  internal val lruEntries = LinkedHashMap<String, Entry>(0, 0.75f, true)
  private var redundantOpCount: Int = 0
  private var hasJournalErrors: Boolean = false

   */
  @Throws(IOException::class)
  private fun writeOrCountBytes(
    sink: BufferedSink?,
    countBytes: Boolean,
  ): Long {
    var sink = sink
    var byteCount = 0L

    var byteCountBuffer: Buffer? = null
    if (countBytes) {
      byteCountBuffer = Buffer()
      sink = byteCountBuffer
    }

    for (p in 0 until parts.size) {
      val part = parts[p]

 * }
 *
 * @author Doug Lea
 * @author Martin Buchholz
 * @since 11.0
 */
@GwtIncompatible
@J2ktIncompatible
public class AtomicDoubleArray implements Serializable {
  private static final long serialVersionUID = 0L;

  // Making this non-final is the lesser evil according to Effective
  // Java 2nd Edition Item 76: Write readObject methods defensively.
  private transient AtomicLongArray longs;

  /**

        lenient().when(autoCloseableMockFileHandle.isValid()).thenReturn(true);
        lenient().when(autoCloseableMockFileHandle.getInitialSize()).thenReturn(0L);

        when(autoCloseableMockTreeHandle.getSendBufferSize()).thenReturn(65536);

        // When
        outputStream = new SmbFileOutputStream(mockFile);

        // Then

    // First, sanity check that naive multiplication would really overflow to a negative number:
    long nanosPerSecond = NANOSECONDS.convert(1, SECONDS);
    assertThat(nanosPerSecond * Long.MAX_VALUE).isLessThan(0L);

    // Check that we wait long enough anyway (presumably as long as MAX_VALUE nanos):
    TimedWaiterThread waiter = new TimedWaiterThread(future, Long.MAX_VALUE, SECONDS);
    waiter.start();
    waiter.awaitWaiting();

      accumulator.addAll(accumulator.snapshot());
    }
    // Should overflow without throwing.
    accumulator.addAll(accumulator.snapshot());
    assertThat(accumulator.count()).isLessThan(0L);
  }

  public void testXStats() {
    assertStatsApproxEqual(EMPTY_STATS_ITERABLE, emptyAccumulator.xStats());
    assertStatsApproxEqual(EMPTY_STATS_ITERABLE, emptyAccumulatorByAddAllEmptyPairedStats.xStats());

  }

  private static long charToTwoUtf8Bytes(char c) {
    // c has at most 11 bits
    return ((0x3L << 6) | (c >>> 6)) | ((0x80 | (0x3F & c)) << 8);
  }

  private static final long serialVersionUID = 0L;

        // as per rfc-1320; they are low-order byte first
        context[0] = 0x67452301;
        context[1] = 0xEFCDAB89;
        context[2] = 0x98BADCFE;
        context[3] = 0x10325476;
        count = 0L;
        for (int i = 0; i < BLOCK_LENGTH; i++) {
            buffer[i] = 0;
        }
    }

    /**
     * Continues an MD4 message digest using the input byte.
     */
    @Override

        SmbNegotiationResponse otherNego = mock(SmbNegotiationResponse.class);
        when(transport.getNegotiateResponse()).thenReturn(otherNego);

        assertEquals(0L, handle.getServerTimeZoneOffset());
        assertNull(handle.getOEMDomainName());
    }

    @Test
    @DisplayName("Tree properties delegate: getTreeType/getConnectedShare")
    void treePropertiesDelegate() {

            return "id-" + dataMap.get("url");
        }
    }

    private static class TestSearchLogHelper extends SearchLogHelper {
        int clickCount = 0;
        long favoriteCount = 0L;

        @Override
        public int getClickCount(String url) {
            return clickCount;
        }

        @Override
        public long getFavoriteCount(String url) {