opts.BaseDir[:len(opts.BaseDir)-1]+globalDirSuffix,
			xlStorageFormatFile))
		diskHealthCheckOK(ctx, err)
		if err == nil {
			// if baseDir is already a directory object, consider it
			// as part of the list call, this is AWS S3 specific
			// behavior.
			if err := send(metaCacheEntry{
				name:     opts.BaseDir,
				metadata: metadata,
			}); err != nil {
				return err
			}
		} else {

   *         .put("one", 1)
   *         .putAll("several", 1, 2, 3)
   *         .putAll("many", 1, 2, 3, 4, 5)
   *         .build();
   * }
   *
   * <p>Builder instances can be reused; it is safe to call {@link #build} multiple times to build
   * multiple multimaps in series. Each multimap contains the key-value mappings in the previously
   * created multimaps.
   *
   * @since 2.0
   */

        assertThat(arr).hasLength(i);
        for (int j = 0; j < i; j++) {
          assertThat(arr[j]).isEqualTo(VALUES[j]);
        }
      }
    }
  }

  @SuppressWarnings("nullness") // test of a bogus call
  public void testToArray_withNull() {
    List<@Nullable Long> list = Arrays.asList(0L, 1L, null);
    assertThrows(NullPointerException.class, () -> Longs.toArray(list));
  }

		}
	}
}

// ImportIAM - imports all IAM info into MinIO
func (a adminAPIHandlers) ImportIAM(w http.ResponseWriter, r *http.Request) {
	a.importIAM(w, r, "")
}

// ImportIAMV2 - imports all IAM info into MinIO
func (a adminAPIHandlers) ImportIAMV2(w http.ResponseWriter, r *http.Request) {
	a.importIAM(w, r, "v2")
}

// ImportIAM - imports all IAM info into MinIO

                                const void** buf, size_t* len);

// TODO(josh11b,mrry): Change Session to be able to use a Graph*
// directly, instead of requiring us to serialize to a GraphDef and
// call Session::Extend().
bool ExtendSessionGraphHelper(TF_Session* session, TF_Status* status) {
  if (session->graph != nullptr) {
    // Take the graph lock before the session lock to avoid deadlock. This is

	}
	res := aoBucketInfo.New()
	for i := range buckets {
		bucket := buckets[i]
		res.Append(&bucket)
	}
	return res, nil
}

// HeadBucketHandler implements peer BucketInfo call, returns bucket create date.
func (s *peerRESTServer) HeadBucketHandler(mss *grid.MSS) (info *VolInfo, nerr *grid.RemoteErr) {
	bucket := mss.Get(peerS3Bucket)
	if isMinioMetaBucket(bucket) {

        }

        when(mockConfig.getLmHostsFileName()).thenReturn(lmhostsFile.getAbsolutePath());

        // First call should read the file
        NbtAddress result1 = lmhosts.getByName("TESTHOST", mockContext);
        assertNotNull(result1);

        // Second call should use cached data (file not modified)
        NbtAddress result2 = lmhosts.getByName("TESTHOST", mockContext);
        assertNotNull(result2);

        assertThat(arr).hasLength(i);
        for (int j = 0; j < i; j++) {
          assertThat(arr[j]).isEqualTo(VALUES[j]);
        }
      }
    }
  }

  @SuppressWarnings("nullness") // test of a bogus call
  public void testToArray_withNull() {
    List<@Nullable Byte> list = Arrays.asList((byte) 0, (byte) 1, null);
    assertThrows(NullPointerException.class, () -> Bytes.toArray(list));
  }

        when(nonPooledSpy.disconnect(false, false)).thenReturn(false); // Not in use

        // When: Close the pool
        boolean inUse = pool.close();

        // Then: Should report in-use and call disconnect on all
        assertTrue(inUse, "Should report connections in use");
        verify(pooledSpy).disconnect(false, false);
        verify(nonPooledSpy).disconnect(false, false);
    }

    @Test

        MockSMailPostingDiscloser discloser = new MockSMailPostingDiscloser();
        discloser.setSubject("Test Subject");
        discloser.setPlainText("Test Content");

        // Should call both sendToSlack and sendToGoogleChat
        try {
            notificationHelper.send(null, discloser);
        } catch (Exception e) {
            fail("send() should not throw an exception: " + e.getMessage());