super(indexSettings, name, settings);

        maxTokenLength = settings.getAsInt("max_token_length", AlphaNumWordFilter.DEFAULT_MAX_TOKEN_LENGTH);
    }

    @Override
    public TokenStream create(final TokenStream tokenStream) {
        final AlphaNumWordFilter alphaNumWordFilter = new AlphaNumWordFilter(tokenStream);
        alphaNumWordFilter.setMaxTokenLength(maxTokenLength);
        return alphaNumWordFilter;
    }

public class MinimalSetTest extends TestCase {
  public static Test suite() {
    return SetTestSuiteBuilder.using(
            new TestStringSetGenerator() {
              @Override
              protected Set<String> create(String[] elements) {
                return MinimalSet.of(elements);
              }
            })
        .named("MinimalSet")
        .withFeatures(

  }

  @Override
  protected Map<String, Integer> makeEmptyMap() {
    throw new UnsupportedOperationException();
  }

  @Override
  Table<String, Character, Integer> makeTable() {
    return ArrayTable.create(asList("one", "two", "three", "four"), asList('a', 'b', 'c'));
  }

  @Override
  protected Map<String, Integer> makeEmptyMap() {
    throw new UnsupportedOperationException();
  }

  @Override
  protected Table<Character, String, Integer> makeTable() {
    return ArrayTable.create(asList('a', 'b', 'c'), asList("one", "two", "three", "four"));
  }

        // Strictly, this doesn't necessarily indicate a hidden 'this' in the case of
        // static initializer. But there seems no way to tell in that case. :(
        // This may cause issues when an anonymous class is created inside a static initializer,
        // and the class's constructor's first parameter happens to be the enclosing class.
        // In such case, we may mistakenly think that the class is within a non-static context

        client = runner.client();

        // Initialize suggest settings
        Suggester suggester = Suggester.builder().build(client, "test");
        settings = suggester.settings();

        // Create test index
        client.admin().indices().prepareCreate(TEST_INDEX).execute().actionGet();
    }

    @AfterClass
    public static void afterClass() throws Exception {
        runner.close();

        // Then
        // These fields are protected in parent class, so we can't access them directly
        // We verify the object was created successfully instead
        assertNotNull(trans2GetDfsReferral);

        // Verify that request buffer was created with correct parameters
        Field requestField = Trans2GetDfsReferral.class.getDeclaredField("request");
        requestField.setAccessible(true);

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 */
class DefaultProjectDependencyGraphTest {

    private final MavenProject aProject = createA();

    private final MavenProject bProject = createProject(Arrays.asList(toDependency(aProject)), "bProject");

    private final MavenProject cProject = createProject(Arrays.asList(toDependency(bProject)), "cProject");

 * RDMA peers to prevent buffer overflow.
 */
public class RdmaCredits {

    private int initialCredits;
    private int creditsGranted;

    /**
     * Create new RDMA credits manager
     */
    public RdmaCredits() {
        this.initialCredits = RdmaCapabilities.DEFAULT_SEND_CREDIT_TARGET;
        this.creditsGranted = 0;
    }

    /**

Development for branch 8x remains in the shared repository:

- https://gitbox.apache.org/repos/asf/lucene-solr.git

## GitHub forks?

If you are using GitHub, make a clone of the corresponding repository
mirror and create your pull requests against the main branch:

- Lucene: <https://github.com/apache/lucene>