List<AnalyzeToken> tokensContent = analyzer.analyze(text, "content", lang);
        assertNotNull(tokensContent);
        assertEquals(2, tokensContent.size());

        List<AnalyzeToken> tokensTitle = analyzer.analyze(text, "title", lang);
        assertNotNull(tokensTitle);
        assertEquals(2, tokensTitle.size());

        // Test with null field
        List<AnalyzeToken> tokensNull = analyzer.analyze(text, null, lang);

        try {
            final List<String> list = new ArrayList<>();
            list.add("BadWord");
            csvWriter.writeValues(list);

            badWordBhv.selectCursor(cb -> cb.query().matchAll(), new EntityRowHandler<BadWord>() {
                @Override
                public void handle(final BadWord entity) {
                    final List<String> list = new ArrayList<>();

            .where(
                new TypeCapture<List<T>>() {}.capture(),
                new TypeCapture<List<String>>() {}.capture())
            .resolveType(t));
    assertEquals(
        Types.subtypeOf(String.class),
        new TypeResolver()
            .where(
                new TypeCapture<List<T>>() {}.capture(),
                new TypeCapture<List<? extends String>>() {}.capture())
            .resolveType(t));

    private boolean ignoreTransitiveRepositories;

    private List<Proxy> proxies;

    private List<Server> servers;

    private List<Mirror> mirrors;

    private List<Profile> profiles;

    private final ProjectActivation projectActivation = new ProjectActivation();
    private final ProfileActivation profileActivation = new ProfileActivation();

    private List<String> pluginGroups;

    private DependencyNode root;

    private List<Dependency> dependencies = new ArrayList<>();

    private List<Dependency> resolvedDependencies = new ArrayList<>();

    private List<Dependency> unresolvedDependencies = new ArrayList<>();

    private List<Exception> collectionErrors = new ArrayList<>();

    private Map<Dependency, List<Exception>> resolutionErrors = new IdentityHashMap<>();

    @Override

 *
 * @since 3.0
 */
public class DefaultPluginPrefixRequest implements PluginPrefixRequest {

    private String prefix;

    private List<String> pluginGroups = Collections.emptyList();

    private Model pom;

    private List<RemoteRepository> repositories = Collections.emptyList();

    private RepositorySystemSession session;

    /**
     * Creates an empty request.
     */

    /**
     * The list of popular words.
     */
    protected final List<String> words;

    /**
     * The number of popular words.
     */
    protected final int num;

    /**
     * The total number of words.
     */
    protected final long total;

    /**
     * The list of suggested items.
     */
    protected final List<SuggestItem> items;

    /**

                    offset += term.length();
                }
            }

            final List<String> list = new ArrayList<>(1);
            if (readingBuf.length() > 0) {
                list.add(readingBuf.toString());
            }
            return list;
        }
    }

		t.Fatalf("List() Expected: 10, got %d", len(keys))
	}

	// Delete all
	for _, key := range keys {
		err := store.Del(key)
		if err != nil {
			t.Fatal(err)
		}
	}
	// Re-list
	keys = store.List()
	if len(keys) > 0 || err != nil {
		t.Fatalf("Expected List() to return empty list and no error, got %v err: %v", keys, err)
	}
}

func TestMultiplePutGetRaw(t *testing.T) {
	defer func() {

  public void testAsListSet() {
    List<Boolean> list = Booleans.asList(ARRAY_FALSE);
    assertThat(list.set(0, true)).isFalse();
    assertThat(list.set(0, false)).isTrue();
    assertThrows(NullPointerException.class, () -> list.set(0, null));
    assertThrows(IndexOutOfBoundsException.class, () -> list.set(1, true));
  }

  public void testAsListCanonicalValues() {
    List<Boolean> list = Booleans.asList(true, false);