g := errgroup.WithNErrs(len(storageDisks))

	// Write `format.json` to all disks.
	for index := range storageDisks {
		index := index
		g.Go(func() error {
			if formats[index] == nil {
				return errDiskNotFound
			}
			return saveFormatErasure(storageDisks[index], formats[index], "")
		}, index)
	}

	// Wait for the routines to finish.

    runRemoveTest(getNumElements() - 1);
  }

  private void runRemoveTest(int index) {
    assertEquals(
        Platform.format("remove(%d) should return the element at index %d", index, index),
        getList().get(index),
        getList().remove(index));
    List<E> expected = copyToList(createSamplesArray());
    expected.remove(index);
    expectContents(expected);
  }

import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opensearch.action.bulk.BulkRequestBuilder;
import org.opensearch.action.index.IndexAction;
import org.opensearch.action.index.IndexRequestBuilder;
import org.opensearch.client.Client;
import org.opensearch.index.IndexNotFoundException;
import org.opensearch.search.sort.SortBuilders;
import org.opensearch.search.sort.SortOrder;

public class ESSourceReaderTest {

	g := errgroup.WithNErrs(len(disks))
	for index := range disks {
		index := index
		g.Go(func() error {
			di := madmin.Disk{
				Endpoint:  endpoints[index].String(),
				PoolIndex: endpoints[index].PoolIdx,
				SetIndex:  endpoints[index].SetIdx,
				DiskIndex: endpoints[index].DiskIdx,
				Local:     endpoints[index].IsLocal,
			}
			if disks[index] == OfflineDisk {

	for _, testCase := range testCases {
		if index := objectPartIndex(fi.Parts, testCase.partNum); index != testCase.expectedIndex {
			t.Fatalf("%+v: expected = %d, got: %d", testCase, testCase.expectedIndex, index)
		}
	}
}

// Test FileInfo.ObjectToPartOffset().
func TestObjectToPartOffset(t *testing.T) {
	// Setup.
	fi := newFileInfo("test-object", 8, 8)
	fi.Erasure.Index = 1
	if !fi.IsValid() {

    SuggestWriterResult delete(Client client, SuggestSettings settings, String index, String id);

    SuggestWriterResult deleteByQuery(Client client, SuggestSettings settings, String index, QueryBuilder queryBuilder);

    default SuggestItem[] mergeItems(final SuggestItem[] items) {
        final Set<String> mergedIdSet = new HashSet<>();

    // Search for misses.
    assertEquals(-1, binarySearch(0, 6) { index -> 0.compareTo(table[index]) })
    assertEquals(-2, binarySearch(0, 6) { index -> 2.compareTo(table[index]) })
    assertEquals(-3, binarySearch(0, 6) { index -> 4.compareTo(table[index]) })
    assertEquals(-4, binarySearch(0, 6) { index -> 6.compareTo(table[index]) })
    assertEquals(-5, binarySearch(0, 6) { index -> 8.compareTo(table[index]) })

			if err == errDoneForNow {
				err = nil
			}
			return err
		}
	}
	return nil
}

// isIndexedMetaV2 returns non-nil result if metadata is indexed.
// Returns 3x nil if not XLV2 or not indexed.
// If indexed and unable to parse an error will be returned.
func isIndexedMetaV2(buf []byte) (meta xlMetaBuf, data xlMetaInlineData, err error) {
	buf, major, minor, err := checkXL2V1(buf)

org.checkerframework.checker.i18nformatter.unittests
org.checkerframework.checker.index
org.checkerframework.checker.index.lowerbound
org.checkerframework.checker.index.qual
org.checkerframework.checker.index.samelen
org.checkerframework.checker.index.searchindex
org.checkerframework.checker.index.substringindex
org.checkerframework.checker.index.upperbound
org.checkerframework.checker.initialization

	exp := argP.Expand()

	if node == "" {
		for index, e := range exp {
			result = append(result, localDisk{index: index, path: strings.Join(e, "")})
		}
	} else {
		for index, e := range exp {
			u, err := url.Parse(strings.Join(e, ""))
			if err != nil {
				return nil, err
			}
			if strings.Contains(u.Host, node) {
				result = append(result, localDisk{index: index, path: u.Path})
			}
		}
	}