@Generates
  Integer generateInteger() {
    return new Integer(generateInt());
  }

  @Generates
  long generateLong() {
    return generateInt();
  }

  @SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
  @Generates
  Long generateLongObject() {
    return new Long(generateLong());
  }

  @Generates
  float generateFloat() {
    return generateInt();
  }

      for (Entry<Range<K>, V> entry : mapOfRanges.entrySet()) {
        builder.put(entry.getKey(), entry.getValue());
      }
      return builder.build();
    }

    @J2ktIncompatible private static final long serialVersionUID = 0;
  }

  Object writeReplace() {
    return new SerializedForm<>(asMapOfRanges());
  }

  @J2ktIncompatible // java.io.ObjectInputStream

     */
    public int maxNumberVcs;
    /**
     * Maximum raw buffer size for raw read/write operations.
     */
    public int maxRawSize;
    /**
     * Server's system time.
     */
    public long serverTime;
    /**
     * Server's time zone offset in minutes from UTC.
     */
    public int serverTimeZone;
    /**
     * Length of the encryption key.
     */
    public int encryptionKeyLength;

            return null;
        }

        @Override
        public Cookie[] getCookies() {
            return new Cookie[0];
        }

        @Override
        public long getDateHeader(String name) {
            return -1;
        }

        @Override
        public Enumeration<String> getHeaders(String name) {
            return null;
        }

        @Override

    try {
      super.get();
    } catch (ExecutionException e) {
      rethrow(e);
    }
    throw new AssertionError("Unreachable");
  }

  @Override
  public V get(long timeout, TimeUnit unit)
      throws InterruptedException, ExecutionException, TimeoutException {
    try {
      super.get(timeout, unit);
    } catch (ExecutionException e) {
      rethrow(e);
    }

                    ai++;
                    t.numIter = Integer.parseInt(args[ai]);
                } else if (args[ai].equals("-d")) {
                    ai++;
                    t.delay = Long.parseLong(args[ai]);
                } else {
                    t.url = args[ai];
                }
            }

            assertEquals(expectedUrl, t.url, "URL should be correctly parsed");

                }
            }

            @Override
            public Long getAsLong(String propertyKey) {
                String value = get(propertyKey);
                if (value == null) {
                    return null;
                }
                try {
                    return Long.valueOf(value);
                } catch (NumberFormatException e) {
                    return null;

    assertFalse(multimap().containsEntry(k0(), v0()));
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(SUPPORTS_REMOVE)
  /*
   * We are comparing Multimaps of the same type, so as long as they have value collections that
   * implement equals() (as with ListMultimap or SetMultimap, as opposed to a QueueMultimap or
   * something), our equality check is value-based.
   */
  @SuppressWarnings("UndefinedEquals")

     * @return a SuggestItem created from the given search words and associated data
     */
    SuggestItem parseSearchWords(String[] words, String[][] readings, String[] fields, String[] tags, String[] roles, long score,
            ReadingConverter readingConverter, Normalizer normalizer, SuggestAnalyzer analyzer, String[] langs);

    /**
     * Parses the given query log and returns a list of suggest items.
     *

testing/*/build/test-results-*.zip => results
testing/*/build/tmp/**/log.txt => failure-logs
testing/*/build/tmp/**/profile.log => failure-logs
testing/*/build/tmp/**/daemon-*.out.log => failure-logs
"""

// to avoid pathname too long error
fun BuildSteps.substDirOnWindows(os: Os) {
    if (os == Os.WINDOWS) {
        script {
            name = "SETUP_VIRTUAL_DISK_FOR_PERF_TEST"
            executionMode = BuildStep.ExecutionMode.ALWAYS