}

    public <T> StandardCrawlerContainer prototype(final String name, final Class<T> cls, final Consumer<T> component) {
        prototypeMap.put(name, new ComponentDef<>(cls, component, this));
        return this;
    }

    public <T> StandardCrawlerContainer prototype(final String name, final Class<T> cls) {
        return prototype(name, cls, null);
    }

        when:
        def framework = newFramework(true, ["app-cls"], ["app-mod"], ["impl-cls"], ["impl-mod"])
        def classpath = underTest.create([new File("cls.jar")], [new File("mod.jar")], framework, false)

        then:
        classpath.applicationClasspath == [new File("cls.jar"), new File("app-cls-external.jar"), new File("app-mod-external.jar")]

    def "can consume gmm with dependency null or empty artifactSelector extension"() {
        given:
        mavenRepo.module("org", "transitive", "1.0")
            .artifact(classifier: "cls")
            .artifact(classifier: "cls", type: "")
            .withNoPom()
            .withModuleMetadata()
            .publish()

        def module = mavenRepo.module("org", "foo")
        module.withNoPom().publish()

   *       {@code cls}, instance methods are skipped for nulls test.
   *   <li>Nulls test is not performed on method return values unless the method is a non-private
   *       static factory method whose return type is {@code cls} or {@code cls}'s subtype.
   * </ul>
   */
  public void testNulls(Class<?> cls) {
    try {
      doTestNulls(cls, Visibility.PACKAGE);
    } catch (Exception e) {

        private void traverseObjectWithParents(Class<?> cls, Object target) throws ModelInterpolationException {
            if (cls == null) {
                return;
            }

            if (cls.isArray()) {
                evaluateArray(target);
            } else if (isQualifiedForInterpolation(cls)) {
                Field[] fields = FIELDS_BY_CLASS.computeIfAbsent(cls, k -> cls.getDeclaredFields());

        if (testClass == null) {
            return;
        }
        for (String cls : inclusions) {
            loadClass(testClass.getClassLoader(), cls);
        }
        for (String cls : exclusions) {
            loadClass(testClass.getClassLoader(), cls);
        }
    }

    private boolean shouldRun(final Description description, final Description parent) {

        if (innerClassInstance == null) {
            return null;
        }
        Class<?> cls = innerClassInstance.getClass();
        Class<?> enclosingClass = cls.getEnclosingClass();
        if (enclosingClass == null) {
            return null;
        }
        for (Field field : cls.getDeclaredFields()) {

    @classmethod
    def __get_validators__(cls: Type["UploadFile"]) -> Iterable[Callable[..., Any]]:
        yield cls.validate

    @classmethod
    def validate(cls: Type["UploadFile"], v: Any) -> Any:
        if not isinstance(v, StarletteUploadFile):
            raise ValueError(f"Expected UploadFile, received: {type(v)}")
        return v

    @classmethod
    def _validate(cls, __input_value: Any, _: Any) -> "UploadFile":

@app.get("/a")
async def a(dep: Dep[A]):
    return {"cls": dep.__class__.__name__}


@app.get("/b")
async def b(dep: Dep[B]):
    return {"cls": dep.__class__.__name__}


client = TestClient(app)


def test_generic_parameterless_depends():
    response = client.get("/a")
    assert response.status_code == 200, response.text
    assert response.json() == {"cls": "A"}

    response = client.get("/b")

   *       {@code cls}, instance methods are skipped for nulls test.
   *   <li>Nulls test is not performed on method return values unless the method is a non-private
   *       static factory method whose return type is {@code cls} or {@code cls}'s subtype.
   * </ul>
   */
  public void testNulls(Class<?> cls) {
    try {
      doTestNulls(cls, Visibility.PACKAGE);
    } catch (Exception e) {