.isEqualTo(InetAddresses.forString("127.0.0.1"));

    // ::1 special case
    assertThat(InetAddresses.getCoercedIPv4Address(InetAddresses.forString("::1")))
        .isEqualTo(InetAddresses.forString("127.0.0.1"));

    // :: special case
    assertThat(InetAddresses.getCoercedIPv4Address(InetAddresses.forString("::")))
        .isEqualTo(InetAddresses.forString("0.0.0.0"));

                                       std::to_string(operand_index));

  if (defining_op && matchPattern(defining_op, m_Constant(&const_attr))) {
    tensorflow::Tensor tensor;
    auto status = tensorflow::ConvertToTensor(const_attr, &tensor);
    if (!status.ok()) {
      op->emitRemark() << "skipping legalization due to failed const conversion"
                       << status.ToString();

    receiver?.toString()?.plus(".").orEmpty() + buildString {
        if (function is DataConstructor) {
            val fqn = when (val ref = function.dataClass) {
                is DataTypeRef.Name -> ref.fqName.toString()
                is DataTypeRef.Type -> (ref.dataType as? DataClass)?.name?.qualifiedName
                    ?: ref.dataType.toString()
            }
            append(fqn)

        JavaVersion.VERSION_1_6.toString() == "1.6"
        JavaVersion.VERSION_1_7.toString() == "1.7"
        JavaVersion.VERSION_1_8.toString() == "1.8"
        JavaVersion.VERSION_1_9.toString() == "9"
        JavaVersion.VERSION_1_10.toString() == "10"
        JavaVersion.VERSION_11.toString() == "11"
        JavaVersion.VERSION_12.toString() == "12"
        JavaVersion.VERSION_13.toString() == "13"

                .setStandardError(new TeeOutputStream(error, System.err))
                .get()
            OutputScrapingExecutionResult.from(output.toString(), error.toString())
        }
        return model
    }

    void fetchModelFails(Class type = SomeToolingModel.class) {
        failure = toolingApiExecutor.runFailingBuildWithToolingConnection { connection ->

        return OutputScrapingExecutionResult.from(stdout.toString(), stderr.toString())
    }

    ExecutionFailure getFailure() {
        return OutputScrapingExecutionFailure.from(stdout.toString(), stderr.toString())
    }

    def validateOutput() {
        def assertion = new ResultAssertion(0, [], false, shouldCheckForDeprecationWarnings(), true)
        assertion.validate(stdout.toString(), "stdout")

        def toolchain = queryService.findMatchingToolchain(filter)

        then:
        toolchain.languageVersion == JavaVersion.toVersion(versionToFind)
        toolchain.javaHome.toString() == systemSpecificAbsolutePath(expectedPath)

        where:
        versionToFind | expectedPath
        9             | "/path/9"
        12            | "/path/12"
    }

        def toolchain = queryService.findMatchingToolchain(filter).get()

        then:
        toolchain.languageVersion == versionToFind
        toolchain.getInstallationPath().toString() == systemSpecificAbsolutePath(expectedPath)

        where:
        versionToFind              | expectedPath
        JavaLanguageVersion.of(9)  | "/path/9"
        JavaLanguageVersion.of(12) | "/path/12"
    }

    // Two futures should not have the same toString, to avoid people asserting on it
    assertThat(SettableFuture.create().toString()).isNotEqualTo(SettableFuture.create().toString());
  }

  public void testToString_oom() throws Exception {
    SettableFuture<Object> future = SettableFuture.create();
    future.set(
        new Object() {
          @Override
          public String toString() {
            throw new OutOfMemoryError();

        }

        @Override
        public int size() {
            return Iterables.size(value);
        }

        @Override
        public String toString() {
            return value.toString();
        }
    }

    public static class ElementsFromCollectionProvider<T> implements ProvidedCollector<T> {
        private final ProviderInternal<? extends Iterable<? extends T>> provider;