"name": {
        "type": "keyword"
      },
      "value": {
        "type": "keyword"
      },
      "includedPaths": {
        "type": "keyword"
      },
      "excludedPaths": {
        "type": "keyword"
      },
      "permissions": {
        "type": "keyword"
      },
      "virtualHost": {
        "type": "keyword"
      },
      "sortOrder": {
        "type": "integer"
      },

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


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

                                "type": "array",
                                "items": {
                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
                                },
                            },
                            "msg": {"title": "Message", "type": "string"},
                            "type": {"title": "Error Type", "type": "string"},

                        "required": ["loc", "msg", "type"],
                        "type": "object",
                        "properties": {
                            "loc": {
                                "title": "Location",
                                "type": "array",
                                "items": {
                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
                                },

  public <T extends @NonNull B> @Nullable T getInstance(Class<T> type) {
    return trustedGet(TypeToken.of(type));
  }

  @Override
  public <T extends @NonNull B> @Nullable T getInstance(TypeToken<T> type) {
    return trustedGet(type.rejectTypeVariables());
  }

  @Override
  @CanIgnoreReturnValue
  public <T extends B> @Nullable T putInstance(
      Class<@NonNull T> type, @ParametricNullness T value) {

     * @param guid the create GUID
     * @param fileId the 16-byte file ID
     * @param type the handle type
     * @param timeout the timeout in milliseconds
     * @param leaseKey the associated lease key (can be null)
     */
    public HandleInfo(String path, HandleGuid guid, byte[] fileId, HandleType type, long timeout, Smb2LeaseKey leaseKey) {
        this.path = path;
        this.createGuid = guid;

  }

  public void testNewArrayType() {
    Type jvmType1 = new TypeCapture<List<String>[]>() {}.capture();
    GenericArrayType ourType1 =
        (GenericArrayType) Types.newArrayType(Types.newParameterizedType(List.class, String.class));
    @SuppressWarnings("rawtypes") // test of raw types
    Type jvmType2 = new TypeCapture<List[]>() {}.capture();
    Type ourType2 = Types.newArrayType(List.class);
    new EqualsTester()

    /**
     * The value of the label type (alphanumeric and underscore only).
     */
    @Required
    @Size(max = 100)
    @Pattern(regexp = "^[a-zA-Z0-9_]+$")
    public String value;

    /**
     * The paths to include for this label type.
     */
    @CustomSize(maxKey = "form.admin.max.input.size")
    public String includedPaths;

    /**
     * The paths to exclude for this label type.
     */

        });
        sambaHelper.init();

        // Test unavailable SID type (type 3 - DOMAIN)
        assertNull(sambaHelper.getAccountId(createMockSID(3, "Domain")));

        // Test unavailable SID type (type 6 - DELETED)
        assertNull(sambaHelper.getAccountId(createMockSID(6, "Deleted Account")));

        // Test unavailable SID type (type 7 - INVALID)

   */
  public static <T> Class<T> wrap(Class<T> type) {
    checkNotNull(type);

    // cast is safe: long.class and Long.class are both of type Class<Long>
    @SuppressWarnings("unchecked")
    Class<T> wrapped = (Class<T>) PRIMITIVE_TO_WRAPPER_TYPE.get(type);
    return (wrapped == null) ? type : wrapped;
  }

  /**
   * Returns the corresponding primitive type of {@code type} if it is a wrapper type; otherwise