case HALF_UP:
              return (x >= 0) ? roundCeilingAsDouble : roundFloorAsDouble;
            default:
              throw new AssertionError("impossible");
          }
        }
    }
    throw new AssertionError("impossible");
  }

  private LongMath() {}

      override fun lookup(hostname: String): List<InetAddress> {
        try {
          return InetAddress.getAllByName(hostname).toList()
        } catch (e: NullPointerException) {
          throw UnknownHostException("Broken system behaviour for dns lookup of $hostname").apply {
            initCause(e)
          }
        }
      }
    }
  }

    resetContainer(getSubjectGenerator().create(array));
  }

  /**
   * Equivalent to {@link #expectMissing(Object[]) expectMissing}{@code (null)} except that the call
   * to {@code contains(null)} is permitted to throw a {@code NullPointerException}.
   *
   * @param message message to use upon assertion failure
   */
  protected void expectNullMissingWhenNullUnsupported(String message) {
    try {

      @Override
      Object operate(Stream<?> stream) {
        try {
          return stream.collect(onlyElement());
        } catch (IllegalArgumentException | NoSuchElementException e) {
          throw new SkipThisScenarioException();
        }
      }
    },
    STREAMS_FIND_LAST {
      @Override
      Object operate(Stream<?> stream) {
        return Streams.findLast(stream);
      }
    },

      return HttpUrl(
        scheme = scheme ?: throw IllegalStateException("scheme == null"),
        username = encodedUsername.percentDecode(),
        password = encodedPassword.percentDecode(),
        host = host ?: throw IllegalStateException("host == null"),
        port = effectivePort(),

  static PublicSuffixType fromCode(char code) {
    for (PublicSuffixType value : values()) {
      if (value.getInnerNodeCode() == code || value.getLeafNodeCode() == code) {
        return value;
      }
    }
    throw new IllegalArgumentException("No enum corresponding to given code: " + code);
  }

            try (InputStream in = Files.newInputStream(userToolchainsFile.toPath())) {
                toolchains = new PersistedToolchains(new MavenToolchainsStaxReader().read(in));
            } catch (Exception e) {
                throw new MisconfiguredToolchainException(
                        "Cannot read toolchains file at " + userToolchainsFile.getAbsolutePath(), e);
            }

        } else if (userToolchainsFile != null) {

  @Override
  protected Map<String, Integer> makeEmptyMap() {
    return ImmutableBiMap.of();
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {
    return ImmutableBiMap.of("one", 1, "two", 2, "three", 3);
  }

  @Override
  protected String getKeyNotInPopulatedMap() {
    return "minus one";
  }

  @Override
  protected Integer getValueNotInPopulatedMap() {
    return -1;
  }

              SerializableTester.reserializeAndAssert(instance);
            } else {
              SerializableTester.reserialize(instance);
            }
          }
        } catch (Throwable e) {
          throw sanityError(classToTest, SERIALIZABLE_TEST_METHOD_NAMES, "serializable test", e);
        }
      }
    }
  }

  /**

                    throw new ChildUrlsException(Collections.emptySet(), "#processMetaRobots");
                }
                if (noindex) {
                    logger.info("META(robots=noindex): {}", responseData.getUrl());
                    storeChildUrls(responseData, resultData);
                    throw new ChildUrlsException(resultData.getChildUrlSet(), "#processMetaRobots");