cache.initialize()
  }

  /**
   * Closes the cache and deletes all of its stored values. This will delete all files in the cache
   * directory including files that weren't created by the cache.
   */
  @Throws(IOException::class)
  fun delete() {
    cache.delete()
  }

  /**
   * Deletes all values stored in the cache. In-flight writes to the cache will complete normally,

   *
   * <p>It should be noted that using a {@code Striped<L>} with relatively few stripes, and {@code
   * bulkGet(keys)} with a relative large number of keys can cause an excessive number of shared
   * stripes (much like the birthday paradox, where much fewer than anticipated birthdays are needed
   * for a pair of them to match). Please consider carefully the implications of the number of

    CIFSContext context = getTestContext();
    context.getConfig().setProperty("jcifs.smb.client.directoryNotificationsEnabled", "true");
    
    SmbFile dir = new SmbFile("smb://server/share/testdir/", context);
    SmbFile testFile = new SmbFile("smb://server/share/testdir/newfile.txt", context);
    
    // Get initial listing (establishes cache)
    SmbFile[] initialFiles = dir.listFiles();
    
    // Create new file

   * '\\u5432'} would yield the byte array {@code {0x54, 0x32}}.
   *
   * <p>If you need to convert and concatenate several values (possibly even of different types),
   * use a shared {@link java.nio.ByteBuffer} instance, or use {@link
   * com.google.common.io.ByteStreams#newDataOutput()} to get a growable buffer.
   */
  @GwtIncompatible // doesn't work
  public static byte[] toByteArray(char value) {

// BucketAlreadyExists the requested bucket name is not available.
type BucketAlreadyExists GenericError

func (e BucketAlreadyExists) Error() string {
	return "The requested bucket name is not available. The bucket namespace is shared by all users of the system. Please select a different name and try again."
}

// BucketAlreadyOwnedByYou already owned by you.
type BucketAlreadyOwnedByYou GenericError

   * (short) 0x1234} would yield the byte array {@code {0x12, 0x34}}.
   *
   * <p>If you need to convert and concatenate several values (possibly even of different types),
   * use a shared {@link java.nio.ByteBuffer} instance, or use {@link
   * com.google.common.io.ByteStreams#newDataOutput()} to get a growable buffer.
   */
  @GwtIncompatible // doesn't work
  public static byte[] toByteArray(short value) {

    assertThat((long) arraysDim1 * arraysDim2).isNotEqualTo((long) (arraysDim1 * arraysDim2));

    double[][] arrays = new double[arraysDim1][];
    // it's shared to avoid using too much memory in tests
    double[] sharedArray = new double[arraysDim2];
    Arrays.fill(arrays, sharedArray);

    try {
      Doubles.concat(arrays);
      fail();

  private static void testConcatOverflow(int arraysDim1, int arraysDim2) {
    assertThat((long) arraysDim1 * arraysDim2).isNotEqualTo((long) (arraysDim1 * arraysDim2));

    int[][] arrays = new int[arraysDim1][];
    // it's shared to avoid using too much memory in tests
    int[] sharedArray = new int[arraysDim2];
    Arrays.fill(arrays, sharedArray);

    try {
      Ints.concat(arrays);
      fail();

	lastBlockSize := totalLength % e.BlockSize
	lastShardSize := ceilFrac(lastBlockSize, int64(e.DataBlocks))
	return numShards*e.ShardSize() + lastShardSize
}

// ShardSize - returns actual shared size from erasure blockSize.
func (e ErasureInfo) ShardSize() int64 {
	return ceilFrac(e.BlockSize, int64(e.DataBlocks))
}

// IsValid - tells if erasure info fields are valid.
func (fi FileInfo) IsValid() bool {

    assertThat((long) arraysDim1 * arraysDim2).isNotEqualTo((long) (arraysDim1 * arraysDim2));

    char[][] arrays = new char[arraysDim1][];
    // it's shared to avoid using too much memory in tests
    char[] sharedArray = new char[arraysDim2];
    Arrays.fill(arrays, sharedArray);

    try {
      Chars.concat(arrays);
      fail();