}

  public void testComplexBuilder() {
    List<Integer> colorElem = asList(0x00, 0x33, 0x66, 0x99, 0xCC, 0xFF);
    ImmutableList.Builder<Integer> webSafeColorsBuilder = ImmutableList.builder();
    for (Integer red : colorElem) {
      for (Integer green : colorElem) {
        for (Integer blue : colorElem) {
          webSafeColorsBuilder.add((red << 16) + (green << 8) + blue);
        }

  private static final Joiner J = Joiner.on("-");

  // <Integer> needed to prevent warning :(
  private static final Iterable<Integer> iterable = Arrays.<Integer>asList();
  private static final Iterable<Integer> iterable1 = Arrays.asList(1);
  private static final Iterable<Integer> iterable12 = Arrays.asList(1, 2);
  private static final Iterable<Integer> iterable123 = Arrays.asList(1, 2, 3);

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  public void testForMapWithDefault_null_compareWithSerializable() {
    ImmutableMap<String, Integer> map = ImmutableMap.of("One", 1);
    Function<String, Integer> function = Functions.forMap(map, null);

    assertEquals((Integer) 1, function.apply("One"));
    assertThat(function.apply("Two")).isNull();

    // check basic sanity of equals and hashCode
    new EqualsTester()

        assertEquals("/test/path", defaultPath);
    }

    // Test default expire
    @Test
    public void test_provideDefaultExpire() {
        Integer defaultExpire = cookieResourceProvider.provideDefaultExpire();
        assertEquals(Integer.valueOf(3600), defaultExpire);
    }

    // Test cookie cipher
    @Test
    public void test_provideCookieCipher() {

    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

  }

  private static final class MyIntegerDomain extends DiscreteDomain<Integer> {
    static final DiscreteDomain<Integer> DELEGATE = DiscreteDomain.integers();

    @Override
    public Integer next(Integer value) {
      return DELEGATE.next(value);
    }

    @Override
    public Integer previous(Integer value) {
      return DELEGATE.previous(value);

        int expected3 = 999;
        doc.put("key3", expected3);
        assertEquals(expected3, DocumentUtil.getValue(doc, "key3", Integer.class));

        doc.put("key9", new ArrayList<Integer>(Arrays.asList(777, 888, 999)));
        assertEquals(777, DocumentUtil.getValue(doc, "key9", Integer.class));
    }

    @Test
    public void test_date() {
        Map<String, Object> doc = new HashMap<>();

    // need explicit type parameter to avoid javac warning!?
    List<Integer> none = Arrays.<Integer>asList();
    assertThat(Ints.toArray(none)).isEqualTo(EMPTY);

    List<Integer> one = Arrays.asList((int) 1);
    assertThat(Ints.toArray(one)).isEqualTo(ARRAY1);

    int[] array = {(int) 0, (int) 1, (int) 0xdeadbeef};

    List<Integer> three = Arrays.asList((int) 0, (int) 1, (int) 0xdeadbeef);

        if (actualVersion.isCompatibleWith(requiredVersion) == false) {
            throwInvalidJavaHomeException(
                description,
                javaHome,
                Integer.parseInt(requiredVersion.getMajorVersion()),
                Integer.parseInt(actualVersion.getMajorVersion())
            );
        }

        return actualVersion;
    }

    ImmutableNetwork.Builder<String, Integer> immutableNetworkBuilder =
        networkBuilder.<String, Integer>immutable();

    // Update NetworkBuilder, but this shouldn't impact immutableNetworkBuilder
    networkBuilder.allowsSelfLoops(false).nodeOrder(ElementOrder.<String>unordered());

    ImmutableNetwork<String, Integer> emptyNetwork = immutableNetworkBuilder.build();