import java.util.Objects;
import org.jspecify.annotations.Nullable;

/**
 * An immutable representation of a host and port.
 *
 * <p>Example usage:
 *
 * {@snippet :
 * HostAndPort hp =
 *     HostAndPort.fromString("[2001:db8::1]")
 *         .withDefaultPort(80)
 *         .requireBracketsForIPv6();
 * hp.getHost();  // returns "2001:db8::1"
 * hp.getPort();  // returns 80
 * hp.toString(); // returns "[2001:db8::1]:80"
 * }

    public void testExceptionOnEmpty() {
        new BwcVersions(asList("foo", "bar"), Version.fromString("7.0.0"));
    }

    @Test(expected = IllegalStateException.class)
    public void testExceptionOnNonCurrent() {
        new BwcVersions(singletonList(formatVersionToLine("6.5.0")), Version.fromString("7.0.0"));
    }

    @Test(expected = IllegalStateException.class)

		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
}

    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 =

   * 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,

		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.

	}
}

// jsonToValue will convert the json value to an internal value.
func jsonToValue(result any) (*Value, error) {
	switch rval := result.(type) {
	case string:
		return FromString(rval), nil
	case float64:
		return FromFloat(rval), nil
	case int64:
		return FromInt(rval), nil
	case uint64:
		if rval <= math.MaxInt64 {
			return FromInt(int64(rval)), nil
		}

func FromFloat(f float64) *Value {
	return &Value{value: f}
}

// FromInt creates a Value from an int
func FromInt(f int64) *Value {
	return &Value{value: f}
}

// FromString creates a Value from a string
func FromString(str string) *Value {
	return &Value{value: str}
}

// FromBool creates a Value from a bool
func FromBool(b bool) *Value {
	return &Value{value: b}
}

    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]");

    assertThrows(IllegalArgumentException.class, () -> HashCode.fromString("7"));
    HashCode unused = HashCode.fromString("7f");
  }

  public void testFromStringFailsWithOddLengthInput() {
    assertThrows(IllegalArgumentException.class, () -> HashCode.fromString("7f8"));
  }

  public void testIntWriteBytesTo() {
    byte[] dest = new byte[4];