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))"
            }

    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();

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

        result.newPrompt == null

        where:
        input  | expected
        '2'    | 2
        '4'    | 4
        '1209' | 1209
        ' 2 '  | 2
        Integer.MAX_VALUE.toString() | Integer.MAX_VALUE
    }

    def "uses default value on empty input"() {
        def event = new IntQuestionPromptEvent(123, "question?", 2, 4)

        expect:
        def result = event.convert("")

        builder.append("): ");
        return builder.toString();
    }

    @Override
    public PromptResult<Integer> convert(String text) {
        if (text.isEmpty()) {
            return PromptResult.response(defaultValue);
        }
        String trimmed = text.trim();
        try {
            int result = Integer.parseInt(trimmed);
            if (result >= minValue) {
                return PromptResult.response(result);

        def registry = new DefaultServiceRegistry()
        registry.addProvider(new ServiceRegistrationProvider() {
            @Provides
            String createString(Integer value) {
                return value.toString()
            }

            @Provides
            Integer createInteger() {
                return 12
            }

            @Provides
            Long createLong(BigDecimal value) {

            def output = objects.property(Integer)
            output.with {
                $propertyConfig
            }
            task producer(type: InputFileTask) {
                inFile = file("in.txt")
                outFile = layout.buildDirectory.file("out.txt")
            }
            output.set(producer.outFile.map { f -> f.asFile.text as Integer }.map { i -> i + 2 })

     * kotlin.Int is mapped to I
     * Type aliases are mapped to their expanded form
     */
    DEFAULT_UAST,

    /**
     * kotlin.Int is mapped to Ljava/lang/Integer;
     */
    GENERIC_ARGUMENT,

    /**
     * kotlin.Int is mapped to Ljava/lang/Integer;
     * No projections allowed in immediate arguments
     */
    SUPER_TYPE,

    /**

            return String.format("1.%d", version);
        }
        return Integer.toString(version);
    }

    @Override
    public boolean canCompileOrRun(JavaLanguageVersion other) {
        return compareTo(other) >= 0;
    }

    @Override
    public int compareTo(JavaLanguageVersion other) {
        return Integer.compare(version, other.asInt());
    }

    @Override

 */

package org.gradle.tooling.internal.provider;

import java.io.Serializable;

public class CustomPayload implements Serializable, PayloadInterface {
    Object value;
    boolean ok;
    Integer[] anArray = new Integer[0];

    public String getValue() {
        return value.toString();
    }