import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import jcifs.smb.SID;

/**
 * Unit tests for PacLogonInfo class.
 * Tests the parsing and data extraction from PAC Logon Info structures.
 */
class PacLogonInfoTest {

    private static final long TEST_FILETIME = 130640000000000000L;
    private static final String TEST_USERNAME = "testuser";

    assertThat(recordedEventTypes).startsWith(
      CallStart::class,
      ProxySelectStart::class,
      ProxySelectEnd::class,
      DnsStart::class,
      DnsEnd::class,
      ConnectStart::class,
      SecureConnectStart::class,
    )
    assertThat(recordedEventTypes).endsWith(CallFailed::class)
  }

  private fun buildClient(
    heldCertificate: HeldCertificate?,

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

/**
 * Unit tests for the {@link CompatibilityFixStrategy} class.
 * Tests Maven 4 compatibility fixes including duplicate dependency and plugin handling.
 */
@DisplayName("CompatibilityFixStrategy")
class CompatibilityFixStrategyTest {

    private CompatibilityFixStrategy strategy;

    @BeforeEach
    void setUp() {

* to handle

* the model
* the Pydantic model
* the data model
* the database model
* the form model
* the model object

* the class
* the base class
* the parent class
* the subclass
* the child class
* the sibling class
* the class method

* the header
* the headers
* the authorization header
* the `Authorization` header
* the forwarded header

import org.lastaflute.web.servlet.request.ResponseManager;

/**
 * Utility class for accessing system components and dependencies.
 * Provides centralized access to various helpers, managers, and services throughout the Fess application.
 */
public final class ComponentUtil {

    private static final Logger logger = LogManager.getLogger(ComponentUtil.class);

    /** Component map for storing component instances. */

<components>
	<include path="convention.xml" />
	<include path="lastaflute_core.xml"/>
	<include path="fess.xml" />

	<component name="fessSuggest" class="org.codelibs.fess.exec.SuggestCreator"
			   instance="prototype">
	</component>
	<component name="suggestHelper" class="org.codelibs.fess.helper.SuggestHelper">
	</component>

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None


class User(BaseModel):
    username: str
    full_name: str | None = None


@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item, user: User):

from fastapi import FastAPI
from pydantic.v1 import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None

    class Config:
        schema_extra = {
            "examples": [
                {
                    "name": "Foo",
                    "description": "A very nice Item",
                    "price": 35.4,

    static InternalMavenSession from(Session session) {
        return cast(InternalMavenSession.class, session, "session should be an " + InternalMavenSession.class);
    }

    static InternalMavenSession from(org.eclipse.aether.RepositorySystemSession session) {
        return cast(InternalMavenSession.class, session.getData().get(InternalSession.class), "session");
    }

/**
 * A class to represent the set of edges connecting an (implicit) origin node to a target node.
 *
 * <p>The {@link #outEdgeToNode} map allows this class to work on networks with parallel edges. See
 * {@link EdgesConnecting} for a class that is more efficient but forbids parallel edges.
 *
 * @author James Sexton
 * @param <E> Edge parameter type
 */
abstract class MultiEdgesConnecting<E> extends AbstractSet<E> {