*
     */
    @Test
    public void testIsAssignableFrom() {
        assertThat(ClassUtil.isAssignableFrom(Number.class, Integer.class), is(true));
        assertThat(ClassUtil.isAssignableFrom(Integer.class, Number.class), is(not(true)));
        assertThat(ClassUtil.isAssignableFrom(int.class, Integer.class), is(true));
    }

    /**
     *
     */
    @Test
    public void testGetPackageName() {

                return "Integer.getInteger(\"$name\", $defaultValue)"
            }
        }
    }

    static SystemPropertyRead integerGetIntegerWithIntegerDefault(String name, int defaultValue) {
        return new SystemPropertyRead() {
            @Override
            String getJavaExpression() {
                return "Integer.getInteger(\"$name\", Integer.valueOf($defaultValue))"
            }

    @ValidateTypeFailure
    public Integer failureCountThreshold;

    @Size(max = 10)
    public String popularWord;

    @Required
    @Size(max = 20)
    public String csvFileEncoding;

    @Min(-1)
    @Max(100000)
    @ValidateTypeFailure
    public Integer purgeSearchLogDay;

    @Min(-1)
    @Max(100000)
    @ValidateTypeFailure
    public Integer purgeJobLogDay;

    @Min(-1)

    ImmutableMultimap<String, Integer> multimap =
        new Builder<String, Integer>().put(Maps.immutableEntry("one", 1)).build();
    assertEquals(Arrays.asList(1), multimap.get("one"));
  }

  public void testBuilder_withImmutableEntryAndNullContents() {
    Builder<String, Integer> builder = new Builder<>();
    try {
      builder.put(Maps.immutableEntry("one", (Integer) null));
      fail();

                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "foo",
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value is not a valid integer",

by the IsStack flag. These events also have a trailing unsigned integer argument
describing the number of stack frame descriptors that follow. Each stack frame
descriptor is on its own line following the event, consisting of four signed
integer arguments: the PC, an integer describing the function name, an integer
describing the file name, and the line number in that file that function was at

    GradleBuildExperimentSpec(
        String displayName,
        String projectName,
        File workingDirectory,
        GradleInvocationSpec invocation,
        boolean crossVersion,
        Integer warmUpCount,
        Integer invocationCount,
        ImmutableList<Function<InvocationSettings, BuildMutator>> buildMutators,
        ImmutableList<String> measuredBuildOperations, boolean measureGarbageCollection
    ) {

                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "foo",
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["body", "__key__"],
                    "msg": "value is not a valid integer",

        }
        write(_, _) >> { Encoder encoder, Integer value ->
            encoder.writeSmallInt(value)
        }
    }

    def "can query whether type can be serialized"() {
        given:
        def registry = new DefaultSerializerRegistry()
        registry.register(Long, longSerializer)
        registry.register(Integer, intSerializer)
        registry.useJavaSerialization(StringBuilder)

    super(false, true, false);
  }

  @Override
  protected Map<String, Collection<Integer>> makeEmptyMap() {
    return Multimaps.unmodifiableMultimap(LinkedHashMultimap.<String, Integer>create()).asMap();
  }

  @Override
  protected Map<String, Collection<Integer>> makePopulatedMap() {
    Multimap<String, Integer> delegate = LinkedHashMultimap.create();
    populate(delegate);