assertEquals(80, HostAndPort.fromString("host:80").getPortOrDefault(123));
    assertEquals(123, HostAndPort.fromString("host").getPortOrDefault(123));
  }

  public void testHashCodeAndEquals() {
    HostAndPort hpNoPort1 = HostAndPort.fromString("foo::123");
    HostAndPort hpNoPort2 = HostAndPort.fromString("foo::123");
    HostAndPort hpNoPort3 = HostAndPort.fromString("[foo::123]");

    assertEquals(80, HostAndPort.fromString("host:80").getPortOrDefault(123));
    assertEquals(123, HostAndPort.fromString("host").getPortOrDefault(123));
  }

  public void testHashCodeAndEquals() {
    HostAndPort hpNoPort1 = HostAndPort.fromString("foo::123");
    HostAndPort hpNoPort2 = HostAndPort.fromString("foo::123");
    HostAndPort hpNoPort3 = HostAndPort.fromString("[foo::123]");

		return nil, errIncorrectSQLFunctionArgumentType(err)
	}
	return FromString(strings.ToLower(s)), nil
}

func upperCase(v *Value) (*Value, error) {
	inferTypeAsString(v)
	s, ok := v.ToString()
	if !ok {
		err := fmt.Errorf("%s expects a string argument", sqlFnUpper)
		return nil, errIncorrectSQLFunctionArgumentType(err)
	}
	return FromString(strings.ToUpper(s)), nil
}

final class ParseRequest {
  final String rawValue;
  final int radix;

  private ParseRequest(String rawValue, int radix) {
    this.rawValue = rawValue;
    this.radix = radix;
  }

  static ParseRequest fromString(String stringValue) {
    if (stringValue.length() == 0) {
      throw new NumberFormatException("empty string");
    }

    // Handle radix specifier if present
    String rawValue;
    int radix;

      if (views.contains("posix")) {
        filePermissions = () -> asFileAttribute(PosixFilePermissions.fromString("rw-------"));
        directoryPermissions = () -> asFileAttribute(PosixFilePermissions.fromString("rwx------"));
      } else if (views.contains("acl")) {
        filePermissions = directoryPermissions = userPermissions();
      } else {
        filePermissions =

        @Override
        public boolean canConvert(Class<?> type) {
            return Path.class.equals(type);
        }

        @Override
        protected Object fromString(String value) throws ComponentConfigurationException {
            return Paths.get(value.replace('/' == File.separatorChar ? '\\' : '/', File.separatorChar));
        }

        @Override

   */
  public static HostSpecifier fromValid(String specifier) {
    // Verify that no port was specified, and strip optional brackets from
    // IPv6 literals.
    HostAndPort parsedHost = HostAndPort.fromString(specifier);
    Preconditions.checkArgument(!parsedHost.hasPort());
    String host = parsedHost.getHost();

    // Try to interpret the specifier as an IP address. Note we build

   * lenient {@code base 16} decoding, please use {@link com.google.common.io.BaseEncoding#decode}
   * (and pass the result to {@link #fromBytes}).
   *
   * @since 15.0
   */
  public static HashCode fromString(String string) {
    checkArgument(
        string.length() >= 2, "input string (%s) must have at least 2 characters", string);
    checkArgument(
        string.length() % 2 == 0,

    assertThat(cache.size()).isEqualTo(0);
    assertThat(cache.asMap().containsKey(key)).isFalse();
  }

  public void testCacheBuilderFrom_string() {
    CacheBuilder<?, ?> fromString =
        CacheBuilder.from(
            "initialCapacity=10,maximumSize=20,concurrencyLevel=30,"
                + "weakKeys,weakValues,expireAfterAccess=10m");
    CacheBuilder<?, ?> expected =

		return FromInt(0x1337)
	},
	func() *Value {
		t, err := time.Parse(time.RFC3339, "2006-01-02T15:04:05Z")
		if err != nil {
			panic(err)
		}
		return FromTimestamp(t)
	},
	func() *Value {
		return FromString("string contents")
	},
}

// altValueBuilders contains one constructor for each value type.
// Values are zero values and should NOT match the values in valueBuilders, except Null type.