return 1
	fi

	# Induce bitrot in single part -- status still green
	induce_bitrot "2" "/data"$((DATA_DRIVE + 1)) $FILE
	WANT='{ "before": { "color": "green", "missing": 0, "corrupted": 1 }, "after": { "color": "green", "missing": 0, "corrupted": 0 }, "args": {"file": "'${FILE}'", "dir": "'${DIR}'", "deep": true} }'
	verify_resiliency_healing "${FUNCNAME[0]}" "${WANT}"

            "EQL",
            "Engine",
            "FIPS",
            "Features/CAT APIs",
            "Features/Data streams",
            "Features/Features",
            "Features/ILM+SLM",
            "Features/Indices APIs",
            "Features/Ingest",
            "Features/Java High Level REST Client",
            "Features/Java Low Level REST Client",
            "Features/Monitoring",
            "Features/Stats",

      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();
}

                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();

import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.support.NestedScope;
import org.elasticsearch.indices.breaker.CircuitBreakerService;
import org.elasticsearch.indices.breaker.HierarchyCircuitBreakerService;
import org.elasticsearch.indices.breaker.NoneCircuitBreakerService;
import org.elasticsearch.indices.fielddata.cache.IndicesFieldDataCache;
import org.elasticsearch.script.Script;
import org.elasticsearch.script.ScriptContext;

    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

				{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) {

	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 {

     */
    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);

     * @return The index timeout.
     */
    public String getIndexTimeout() {
        return timeoutSettings.indexTimeout;
    }

    /**
     * Returns the indices timeout.
     * @return The indices timeout.
     */
    public String getIndicesTimeout() {
        return timeoutSettings.indicesTimeout;
    }

    /**
     * Returns the bulk timeout.
     * @return The bulk timeout.