* supported, nor is the {@link #remove()} method.
 *
 * <p>Example:
 *
 * {@snippet :
 * Iterator<Integer> powersOfTwo =
 *     new AbstractSequentialIterator<Integer>(1) {
 *       protected Integer computeNext(Integer previous) {
 *         return (previous == 1 << 30) ? null : previous * 2;
 *       }
 *     };
 * }
 *
 * @author Chris Povirk

    assert response.json() == {
        "detail": [
            {
                "type": "int_parsing",
                "loc": ["query", "query"],
                "msg": "Input should be a valid integer, unable to parse string as an integer",
                "input": "42.5",
            }
        ]
    }


def test_query_int_query_baz():
    response = client.get("/query/int?query=baz")
    assert response.status_code == 422

  public void testNewParameterizedType_ownerTypeImplied() throws Exception {
    ParameterizedType jvmType =
        (ParameterizedType) new TypeCapture<Entry<String, Integer>>() {}.capture();
    ParameterizedType ourType =
        Types.newParameterizedType(Entry.class, String.class, Integer.class);
    assertEquals(jvmType, ourType);
    assertEquals(Map.class, ourType.getOwnerType());
  }

  public void testNewParameterizedType() {

    ms.add("a", Integer.MAX_VALUE);
    ms.add("b", Integer.MAX_VALUE);
    ms.add("c", 3);

    assertEquals(Integer.MAX_VALUE, ms.count("a"));
    assertEquals(Integer.MAX_VALUE, ms.count("b"));
    assertEquals(3, ms.count("c"));

    assertEquals(Integer.MAX_VALUE, ms.headMultiset("c", CLOSED).size());
    assertEquals(Integer.MAX_VALUE, ms.headMultiset("b", CLOSED).size());

            try {
                this.smbConnectionTimeout = Integer.parseInt(value);
            } catch (NumberFormatException e) {
                // Invalid value ignored
            }
        }

        value = props.getProperty("jcifs.smb.client.soTimeout");
        if (value != null) {
            try {
                this.smbSocketTimeout = Integer.parseInt(value);
            } catch (NumberFormatException e) {

    assertFalse(Assignability.of().isAssignable());
    assertTrue(new Assignability<Integer, Integer>() {}.isAssignable());
    assertTrue(new Assignability<Integer, Object>() {}.isAssignable());
    assertFalse(new Assignability<Integer, String>() {}.isAssignable());
    TypeTokenTest.<Number, Integer>assignabilityTestWithTypeVariables();
  }

  }

  @Override
  Table<Character, String, Integer> makeTable() {
    RowSortedTable<Character, String, Integer> table = TreeBasedTable.create();
    return unmodifiableRowSortedTable(table);
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {
    RowSortedTable<Character, String, Integer> table = TreeBasedTable.create();
    table.put('a', "one", 1);
    table.put('a', "two", 2);

    super(false, false, false, false);
  }

  @Override
  Table<Integer, String, Character> makeTable() {
    Table<Integer, String, Character> original = HashBasedTable.create();
    return unmodifiableTable(original);
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    Table<Integer, String, Character> table = HashBasedTable.create();
    table.put(1, "foo", 'a');

            try {
                logger.debug("Processing SID: {} {} {}", type, sid, sid.toDisplayString());
            } catch (final Exception e) {
                // ignore
            }
        }
        final Integer id = fessConfig.getAvailableSmbSidType(type);
        if (id != null) {
            return createSearchRole(id, sid.getAccountName());
        }
        if (logger.isDebugEnabled()) {

                            "name": "item_id",
                            "required": True,
                            "schema": {
                                "title": "Item Id",
                                "type": "integer",
                            },
                        },
                    ],
                    "responses": {
                        "200": {