* @throws IllegalArgumentException if {@code indexes} is empty
     */
    public ScaleAndIndexes indexes(int... indexes) {
      return new ScaleAndIndexes(scale, indexes.clone());
    }

    /**
     * Specifies multiple quantile indexes to be calculated, each index being the k in the kth
     * q-quantile.
     *
     * @param indexes the quantile indexes, each of which must be in the inclusive range [0, q] for

				})
			}
		}
	}
	for _, index := range indexes {
		if index.Class == "UNIQUE" && len(index.Fields) == 1 {
			index.Fields[0].Field.UniqueIndex = index.Name
		}
	}
	return indexes
}

func (schema *Schema) LookIndex(name string) *Index {
	if schema != nil {
		indexes := schema.ParseIndexes()
		for _, index := range indexes {
			if index.Name == name {
				return index
			}

			}
			if !reflect.DeepEqual(testCase.indexes, gotIndexes) {
				t.Errorf("Expected %v, got %v", testCase.indexes, gotIndexes)
			}
		})
	}
}

// Test tests calculating set indexes.
func TestGetSetIndexes(t *testing.T) {
	testCases := []struct {
		args       []string
		totalSizes []uint64
		indexes    [][]uint64
		success    bool
	}{
		// Invalid inputs.
		{

/**
 * Form class for creating protected words dictionary entries.
 * Protected words are terms that should not be modified or analyzed during
 * text processing, preserving their original form in search indexes.
 *
 */
public class CreateForm {

    /**
     * Creates a new CreateForm instance.
     */
    public CreateForm() {
        // Default constructor
    }

    /** Dictionary identifier */

    @DisplayName("readBytesWireFormat")
    class ReadBytesWireFormat {

        @ParameterizedTest
        @ValueSource(ints = { 0, 1, 5, 10 })
        @DisplayName("Reads structure size 4 and returns 4 for various start indexes")
        void returnsFour_whenStructureSizeIsFour(int start) throws Exception {
            // Arrange: build a buffer that has the little-endian value 4 at 'start'

            suggester.indexer().addBadWord(word, apply);
        }
        refresh();
    }

    /**
     * Adds a bad word to the suggest index.
     *
     * @param badWord The bad word to add.
     * @param apply   true to apply the changes immediately.
     */
    public void addBadWord(final String badWord, final boolean apply) {
        suggester.indexer().addBadWord(badWord, apply);

    KeySet() {
      super(HashBiMap.this);
    }

    @Override
    @ParametricNullness
    K forEntry(int entry) {
      // The cast is safe because we call forEntry only for indexes that contain entries.
      return uncheckedCastNullableTToT(keys[entry]);
    }

    @Override
    public boolean contains(@Nullable Object o) {
      return HashBiMap.this.containsKey(o);
    }

)

// a bucketMetacache keeps track of all caches generated
// for a bucket.
type bucketMetacache struct {
	// Name of bucket
	bucket string

	// caches indexed by id.
	caches map[string]metacache
	// cache ids indexed by root paths
	cachesRoot map[string][]string `msg:"-"`

	// Internal state
	mu      sync.RWMutex `msg:"-"`
	updated bool         `msg:"-"`
}

type deleteAllStorager interface {

		}
	}

	checkIndex := func(t *testing.T, expected []gorm.Index) {
		indexes, err := DB.Migrator().GetIndexes(table)
		if err != nil {
			t.Fatalf("%v: failed to get indexes, got error: %v", utils.FileWithLineNum(), err)
		}
		assert.ElementsMatch(t, expected, indexes)
	}

  }

  /**
   * Returns a stream consisting of the results of applying the given function to the elements of
   * {@code stream} and their indexes in the stream. For example,
   *
   * {@snippet :
   * mapWithIndex(
   *     IntStream.of(10, 11, 12),
   *     (e, index) -> index + ":" + e)
   * }
   *