input_nodes->insert({node, {idx}});
    } else {
      auto& indices = iter->second;
      if (std::find(indices.begin(), indices.end(), idx) != indices.end()) {
        return InvalidArgument("TF_Output ", node->name(), ":", idx,
                               " appears more than once in the input list");
      }
      indices.push_back(idx);
    }
  }
  return absl::OkStatus();
}

	if len(indices) == 0 {
		return errInvalidArgument
	}

	if z.SinglePool() {
		return errInvalidArgument
	}

	// Make pool unwritable before decommissioning.
	if err := z.StartDecommission(ctx, indices...); err != nil {
		return err
	}

	go func() {
		for _, idx := range indices {

                client.admin().indices().prepareCreate(TEST_INDEX).setSettings(indexSettings).execute().actionGet();

        assertTrue(createIndexResponse.isAcknowledged());

        // Create suggest settings index
        Settings suggestIndexSettings = Settings.builder().put("number_of_shards", 1).put("number_of_replicas", 0).build();

    runner = new OpenSearchRunner();
    runner.build(newConfigs().clusterName("TestCluster").numOfNode(1));
    client = runner.client();
}

@Before
public void before() {
    runner.admin().indices().prepareDelete("_all").execute().actionGet();
}

@AfterClass
public static void afterClass() {
    runner.close();
    runner.clean();
}
```

### Testing Best Practices

import org.opensearch.action.DocWriteResponse.Result;
import org.opensearch.action.admin.indices.create.CreateIndexResponse;
import org.opensearch.action.admin.indices.exists.indices.IndicesExistsResponse;
import org.opensearch.action.admin.indices.mapping.get.GetMappingsResponse;
import org.opensearch.action.admin.indices.refresh.RefreshResponse;
import org.opensearch.action.bulk.BulkItemResponse;

				{Field: &schema.Field{Name: "FieldH2"}},
			},
		},
	}
	CheckIndices(t, expectedIndices, indices)
}

func CheckIndices(t *testing.T, expected, actual []*schema.Index) {
	if len(expected) != len(actual) {
		t.Errorf("expected %d indices, but got %d", len(expected), len(actual))
		return
	}

	for i, ei := range expected {
		t.Run(ei.Name, func(t *testing.T) {

     */
    public SuggestSettingsBuilder bulkTimeout(final String timeout) {
        timeoutSettings.setBulkTimeout(timeout);
        return this;
    }

    /**
     * Sets the indices timeout.
     * @param timeout The indices timeout.
     * @return This builder instance.
     */
    public SuggestSettingsBuilder indicesTimeout(final String timeout) {
        timeoutSettings.setIndicesTimeout(timeout);

Europe/Vienna Europe/Vilnius Europe/Volgograd Europe/Warsaw Europe/Zagreb Europe/Zaporozhye Europe/Zurich Factory GB GB-Eire GMT GMT+0 GMT-0 GMT0 Greenwich HST Hongkong Iceland Indian/Antananarivo Indian/Chagos Indian/Christmas Indian/Cocos Indian/Comoro Indian/Kerguelen Indian/Mahe Indian/Maldives Indian/Mauritius Indian/Mayotte Indian/Reunion Iran Israel Jamaica Japan Kwajalein Libya MET MST MST7MDT Mexico/BajaNorte Mexico/BajaSur Mexico/General NZ NZ-CHAT Navajo PRC PST8PDT Pacific/Apia Pacific/Auckland...

    }

    @Test
    @DisplayName("Methods should handle negative indices")
    void testMethodsWithNegativeIndices() {
        // Arrange
        byte[] buffer = new byte[100];
        int negativeIndex = -1;

        // Act & Assert
        // These methods don't validate indices, so they return 0
        assertEquals(0, response.writeSetupWireFormat(buffer, negativeIndex));

	res, err := c.Indices.ResolveIndex([]string{args.Index})
	if err != nil {
		return err
	}
	defer res.Body.Close()

	var v map[string]any
	found := false
	if err := json.NewDecoder(res.Body).Decode(&v); err != nil {
		return fmt.Errorf("Error parsing response body: %v", err)
	}

	indices, ok := v["indices"].([]any)
	if ok {
		for _, index := range indices {