*       String}.
 * </ul>
 *
 * This is the same behavior as type-variable usages have to Kotlin and to the Checker Framework.
 * Contrast the method above to:
 *
 * <ul>
 *   <li>methods whose return type is a type variable but which can never return {@code null},
 *       typically because the type forbids nullable type arguments: For example, {@code

 *       String}.
 * </ul>
 *
 * This is the same behavior as type-variable usages have to Kotlin and to the Checker Framework.
 * Contrast the method above to:
 *
 * <ul>
 *   <li>methods whose return type is a type variable but which can never return {@code null},
 *       typically because the type forbids nullable type arguments: For example, {@code

     * @param defaultClazz The default implementation type
     * @return Custom implementation type if one was given; otherwise default implementation type
     */
    private static Class<?> loadImplementation(final String name, final Class<?> defaultClazz) {
        if (null == name) {
            return defaultClazz; // just use the default type
        }

    assert app.openapi()["components"]["schemas"][body_model_name] == {
        "properties": {
            "p": {
                "anyOf": [{"type": "string"}, {"type": "null"}],
                "title": "P",
            },
        },
        "title": body_model_name,
        "type": "object",
    }


@pytest.mark.parametrize(
    "path",
    ["/optional-str", "/model-optional-str"],
)

)
def test_required_str_schema(path: str):
    assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
        [
            {
                "required": True,
                "schema": {"title": "P", "type": "string"},
                "name": "p",
                "in": "query",
            }
        ]
    )


@pytest.mark.parametrize(
    "path",
    ["/required-str", "/model-required-str"],
)

pkg debug/macho, type Reloc struct, Value uint32
pkg debug/macho, type RelocTypeARM int
pkg debug/macho, type RelocTypeARM64 int
pkg debug/macho, type RelocTypeGeneric int
pkg debug/macho, type RelocTypeX86_64 int
pkg debug/macho, type Rpath struct
pkg debug/macho, type Rpath struct, Path string
pkg debug/macho, type Rpath struct, embedded LoadBytes
pkg debug/macho, type RpathCmd struct
pkg debug/macho, type RpathCmd struct, Cmd LoadCmd

		return &sps
	}
	return s
}

type Roles []string

type Job struct {
	Title    string
	Number   int
	Location string
	IsIntern bool
}

type EncryptedString string

func (es *EncryptedString) Scan(ctx context.Context, field *schema.Field, dst reflect.Value, dbValue interface{}) (err error) {
	switch value := dbValue.(type) {
	case []byte:

		return
	}
	switch {
	case target.Type == obj.TYPE_BRANCH:
		// JMP 4(PC)
		*targetAddr = obj.Addr{
			Type:   obj.TYPE_BRANCH,
			Offset: p.pc + 1 + target.Offset, // +1 because p.pc is incremented in append, below.
		}
	case target.Type == obj.TYPE_REG:
		// JMP R1
		*targetAddr = *target
	case target.Type == obj.TYPE_MEM && (target.Name == obj.NAME_EXTERN || target.Name == obj.NAME_STATIC):

    /** Log type constant for zero-click search aggregation. */
    public static final String LOG_TYPE_SEARCH_ZEROCLICK = "search_zeroclick_agg";

    /** Log type constant for click logs. */
    public static final String LOG_TYPE_CLICK = "click";

    /** Log type constant for click count aggregation. */
    public static final String LOG_TYPE_CLICK_COUNT = "click_count_agg";

    /** Log type constant for favorite logs. */

class BaseItem(BaseModel):
    description: str
    type: str


class CarItem(BaseItem):
    type: str = "car"


class PlaneItem(BaseItem):
    type: str = "plane"
    size: int


items = {
    "item1": {"description": "All my friends drive a low rider", "type": "car"},
    "item2": {
        "description": "Music is my aeroplane, it's my aeroplane",
        "type": "plane",
        "size": 5,
    },
}