// TODO(user): different versions of this for different factories?
    InternetDomainName domain = InternetDomainName.from(host);

    if (domain.hasPublicSuffix()) {
      return new HostSpecifier(domain.toString());
    }

    throw new IllegalArgumentException(
        "Domain name does not have a recognized public suffix: " + host);
  }

  /**

            build.run()
        }

        then:
        stdout.toString().contains('this is stdout')
        stdout.toString().contains('A warning using SLF4j')
        stdout.toString().contains('A warning using JCL')
        stdout.toString().contains('A warning using Log4j')
        stdout.toString().contains('A warning using JUL')
        if (targetVersion.baseVersion >= GradleVersion.version('4.7')) {

        container.size == 1
        container.popConflict().toString() == "b:1,2"
    }

    def "contains multiple conflicting elements"() {
        container.newElement("a", [1, 2], null)
        container.newElement("b", [3, 4], null)
        expect:
        container.size == 2
        container.popConflict().toString() == "a:1,2"
        container.popConflict().toString() == "b:3,4"
    }

    def "pops conflicts orderly"() {

        new NamedWithToString(name: null)    | "toString():null"
        new NamedWithToString(name: "Lajos") | "toString():Lajos"
    }

    def "returns '#expected' when toString() returns #toStringReturns"() {
        def value = Mock(Object)

        when:
        def result = RendererUtils.displayValueOf(value)

        then:
        result == expected
        _ * value.toString() >> toStringReturns

        where:

        value.toString() == "c two three"
        value.toString() == "d two three"
        value.capitalizedDisplayName == "E two three"
        value.capitalizedDisplayName == "F two three"
    }

    def "creates from type and name"() {
        expect:
        def value = Describables.withTypeAndName("some type", "name")
        value.displayName == "some type 'name'"
        value.toString() == "some type 'name'"

    }

    public void debug(CharSequence content) {
        if (isDebugEnabled()) {
            logger.debug(toString(content));
        }
    }

    private String toString(CharSequence content) {
        if (content == null) {
            return "";
        } else {
            return content.toString();
        }
    }

    @Override
    public void debug(CharSequence content, Throwable error) {

    def "string"() {
        expect:
        MethodDescription.name("a").toString() == "a"
        MethodDescription.name("a").returns(String).toString() == "java.lang.String a"
        MethodDescription.name("a").returns(String).takes().toString() == "java.lang.String a()"
        MethodDescription.name("a").returns(String).owner(String).takes().toString() == "java.lang.String java.lang.String#a()"

  public void testToString_minimal() {
    assertNotNull("toString() should not return null", getMap().toString());
  }

  @CollectionSize.Require(ZERO)
  @CollectionFeature.Require(absent = NON_STANDARD_TOSTRING)
  public void testToString_size0() {
    assertEquals("emptyMap.toString should return {}", "{}", getMap().toString());
  }

  @CollectionSize.Require(ONE)

        def original = new Exception("original exception") {
            String toString() {
                "fancy customized toString"
            }
        }
        def placeholder = new PlaceholderException(original.getClass().name, original.message, null, original.toString(), null, original.cause)

        expect:
        placeholder.toString() == original.toString()
    }

        then:
        output1.toString().contains(ARG_1)
        output1.toString().contains(ARG_2)

        when:
        String output2 = runBuild { launcher -> launcher.addArguments(["-P$ARG_1" as String]).addArguments(["-P$ARG_2" as String]) }

        then:
        output2.toString().contains(ARG_1)
        output2.toString().contains(ARG_2)
    }