}
    }

    /**
     * Sets the list of duplicate host rules.
     *
     * @param duplicateHostList the list of duplicate host rules to use
     */
    public void setDuplicateHostList(final List<DuplicateHost> duplicateHostList) {
        this.duplicateHostList = duplicateHostList;
    }

    /**
     * Adds a new duplicate host rule to the list.
     * Initializes the list if it doesn't exist.
     *

# Without aliases


@app.post("/required-list-str", operation_id="required_list_str")
async def read_required_list_str(p: Annotated[list[str], Form()]):
    return {"p": p}


class FormModelRequiredListStr(BaseModel):
    p: list[str]


@app.post("/model-required-list-str", operation_id="model_required_list_str")

	// Next and previous pointers in the doubly-linked list of elements.
	// To simplify the implementation, internally a list l is implemented
	// as a ring, such that &l.root is both the next element of the last
	// list element (l.Back()) and the previous element of the first list
	// element (l.Front()).
	next, prev *Entry[K, V]

	// The list to which this element belongs.
	list *LruList[K, V]

	// The LRU Key of this element.

# Without aliases


@app.post("/required-list-str", operation_id="required_list_str")
async def read_required_list_str(p: Annotated[list[str], Body(embed=True)]):
    return {"p": p}


class BodyModelRequiredListStr(BaseModel):
    p: list[str]


@app.post("/model-required-list-str", operation_id="model_required_list_str")
def read_model_required_list_str(p: BodyModelRequiredListStr):

     *
     * @param tests           The REST tests from the same file. Uses linked list so we can easily add to the beginning of the list.
     * @param transformations The set of transformations to perform against the test
     * @return the transformed tests
     */
    public List<ObjectNode> transformRestTests(LinkedList<ObjectNode> tests, List<RestTestTransform<?>> transformations) {
        ObjectNode setupSection = null;

        });

        ComponentUtil.getPathMappingHelper().init();
    }

    /**
     * Gets the path mapping list by process types.
     *
     * @param processTypeList the process type list
     * @return the path mapping list
     */
    public List<PathMapping> getPathMappingList(final Collection<String> processTypeList) {

        return pathMappingBhv.selectList(cb -> {

     */
    public SuggestWriterResult() {
        // nothing
    }

    /**
     * A list of Throwables representing failures that occurred during the operation.
     */
    protected List<Throwable> failures = Collections.synchronizedList(new ArrayList<>());

    /**
     * Adds a Throwable to the list of failures.
     *
     * @param t the Throwable to add
     */
    public void addFailure(final Throwable t) {

@NullUnmarked
public abstract class AbstractHashFloodingTest<T> extends TestCase {
  private final List<Construction<T>> constructions;
  private final IntToDoubleFunction constructionAsymptotics;
  private final List<QueryOp<T>> queries;

  AbstractHashFloodingTest(
      List<Construction<T>> constructions,
      IntToDoubleFunction constructionAsymptotics,
      List<QueryOp<T>> queries) {
    this.constructions = constructions;

            if (processor.search("*", new TestSearchRequestParams(0, 10, 0), OptionalThing.empty()) instanceof QueryResponseList list) {
                assertEquals(1, list.size());
                assertEquals(1, list.getAllRecordCount());
                assertEquals("0", list.get(0).get(ID_FIELD));
            } else {
                fail();
            }
        }
    }

    /**

import java.util.ArrayList;
import java.util.List;

public class AnnotatedNotAbstractInSuperclassTest extends AbstractEventBusTest<SubClass> {
  static class SuperClass {
    final List<Object> notOverriddenInSubclassEvents = new ArrayList<>();
    final List<Object> overriddenNotAnnotatedInSubclassEvents = new ArrayList<>();
    final List<Object> overriddenAndAnnotatedInSubclassEvents = new ArrayList<>();