assertThrows(OutOfScopeException.class, () -> bean.myBean.getSession());

        sessionScope.enter();
        sessionScope.seed(Session.class, this.session);
        assertNotNull(bean.myBean.getSession());
        assertNotNull(bean.myBean.getAnotherBean());
        assertSame(bean.myBean.getAnotherBean().getClass(), AnotherBean.class);

        assertThat(Logger.getLogger(getClass()), is(sameInstance(Logger.getLogger(getClass()))));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testDebug() throws Exception {
        logger.debug("debug");
    }

    /**
     * @throws Exception
     */
    @Test
    public void testInfo() throws Exception {
        logger.info("info");
    }

    /**
     * @throws Exception

from starlette.routing import Route

app = FastAPI()


class APIRouteA(APIRoute):
    x_type = "A"


class APIRouteB(APIRoute):
    x_type = "B"


class APIRouteC(APIRoute):
    x_type = "C"


router_a = APIRouter(route_class=APIRouteA)
router_b = APIRouter(route_class=APIRouteB)
router_c = APIRouter(route_class=APIRouteC)


@router_a.get("/")
def get_a():
    return {"msg": "A"}

from fastapi import FastAPI
from fastapi.responses import ORJSONResponse
from fastapi.testclient import TestClient
from sqlalchemy.sql.elements import quoted_name

app = FastAPI(default_response_class=ORJSONResponse)


@app.get("/orjson_non_str_keys")
def get_orjson_non_str_keys():
    key = quoted_name(value="msg", quote=False)
    return {key: "Hello World", 1: 1}


client = TestClient(app)


def test_orjson_non_str_keys():

fun <T : Any> Request.Builder.commonTag(
  type: KClass<T>,
  tag: T?,
) = apply {
  if (tag == null) {
    if (tags.isNotEmpty()) {
      (tags as MutableMap).remove(type)
    }
  } else {
    val mutableTags: MutableMap<KClass<*>, Any> =
      when {
        tags.isEmpty() -> mutableMapOf<KClass<*>, Any>().also { tags = it }
        else -> tags as MutableMap<KClass<*>, Any>
      }
    mutableTags[type] = tag

            } + nullableSuffix
        }
    }
    print(typeConversion(type))
}

val KType.simpleName: String
    get() = (classifier as KClass<*>).simpleName!!

val KType.qualifiedName: String

        }
        if (!(o instanceof Task)) {
            return false;
        }
        Task task = (Task) o;
        return Objects.equals(getClass(), task.getClass()) && Objects.equals(value, task.value);
    }

    @Override
    public int hashCode() {
        return Objects.hash(getClass(), value);
    }

    @Override
    public String toString() {
        return value;
    }

            }

            String errorName;
            final Throwable cause = e.getCause();
            if (cause != null) {
                errorName = cause.getClass().getCanonicalName();
            } else {
                errorName = e.getClass().getCanonicalName();
            }
            storeFailureUrl(crawlerContext, urlQueue, errorName, e);
        } catch (final ContainerNotAvailableException e) {

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        // make sure IncludesArtifactFilter is not equal ExcludesArtifactFilter!
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }

        IncludesArtifactFilter other = (IncludesArtifactFilter) obj;

        return patterns.equals(other.patterns);
    }

        @Override
        public boolean equals(Object obj) {
            return obj != null && getClass() == obj.getClass() && id().equals(((DefaultExtensibleEnum) obj).id());
        }

        @Override
        public String toString() {
            return getClass().getSimpleName() + "[" + id() + "]";
        }
    }

    private static class DefaultPathScope extends DefaultExtensibleEnum implements PathScope {