String url, exp;
        final FessFileTransformer transformer = createInstance();

        url = null;
        exp = "";
        assertEquals(exp, transformer.getHostOnFile(url));

        url = "example:";
        exp = "unknown";
        assertEquals(exp, transformer.getHostOnFile(url));

        url = "file:";
        exp = "localhost";
        assertEquals(exp, transformer.getHostOnFile(url));

		sort.Slice(got, byResourceUID{got}.Less)
		// printEntries(exp)
		// printEntries(got)
		for i, e := range exp {
			if !e.Timestamp.Equal(got[i].Timestamp) {
				return i, false
			}
			// Skip checking elapsed since it's time sensitive.
			// if e.Elapsed != got[i].Elapsed {
			// 	return false
			// }
			if e.Resource != got[i].Resource {
				return i, false
			}

	switch exp := expI.(type) {
	case string:
		expAt, err = strconv.ParseInt(exp, 10, 64)
	case float64:
		expAt, err = int64(exp), nil
	case int64:
		expAt, err = exp, nil
	case int:
		expAt, err = int64(exp), nil
	case uint64:
		expAt, err = int64(exp), nil
	case uint:
		expAt, err = int64(exp), nil
	case json.Number:
		expAt, err = exp.Int64()
	case time.Duration:

     */
    @Override
    public int encode(final byte[] dst, final int dstIndex) {
        final int len = super.encode(dst, dstIndex);
        final int exp = size();
        final int actual = getLength();
        if (exp != actual) {
            // Log the size mismatch for debugging but don't throw exception
            // This can occur due to padding alignment differences between size8() and pad8()

        assertEquals(testEx, concreteResponse.getException());

        // Test expiration
        assertNull(concreteResponse.getExpiration());
        Long exp = System.currentTimeMillis() + 10000L;
        concreteResponse.setExpiration(exp);
        assertEquals(exp, concreteResponse.getExpiration());

        // Test granted credits
        assertEquals(32, concreteResponse.getGrantedCredits());

				"foo": "bar",
			},
		},
		true,
		0,
	},
	{
		"basic expired",
		"", // autogen
		defaultKeyFunc,
		&MapClaims{
			MapClaims: jwt.MapClaims{
				"foo": "bar",
				"exp": float64(time.Now().Unix() - 100),
			},
		},
		false,
		-1,
	},
	{
		"basic nbf",
		"", // autogen
		defaultKeyFunc,
		&MapClaims{
			MapClaims: jwt.MapClaims{
				"foo": "bar",

     *
     * @return the message timeout
     */
    Long getExpiration();

    /**
     * Sets the expiration time for this response.
     *
     * @param exp the message timeout to set
     */
    void setExpiration(Long exp);

    /**
     * Resets this response to its initial state.
     */
    void reset();

    /**
     * Gets the exception associated with this response.
     *

				return err
			}
		case 'e':
			if string(key) == "exp" {
				if dataType != jsonparser.Number {
					return errors.New("exp: Expected number")
				}
				c.ExpiresAt, err = jsonparser.ParseInt(value)
				return err
			}
		case 'i':
			if string(key) == "iat" {
				if dataType != jsonparser.Number {
					return errors.New("exp: Expected number")
				}
				c.IssuedAt, err = jsonparser.ParseInt(value)

            // Now call the ServerMessageBlock2Request's encode which will do the validation
            int exp = size();
            int actual = getLength();
            if (exp != actual) {
                throw new IllegalStateException(String.format("Wrong size calculation have %d expect %d", exp, actual));
            }

            return calculatedLength;
        }

    // We don't expect perfect rounding accuracy.
    for (int exp : asList(-1022, -50, -1, 0, 1, 2, 3, 4, 100, 1022, 1023)) {
      for (RoundingMode mode : asList(HALF_EVEN, HALF_UP, HALF_DOWN)) {
        double x = Math.scalb(Math.sqrt(2) + 0.001, exp);
        double y = Math.scalb(Math.sqrt(2) - 0.001, exp);
        assertEquals(exp + 1, DoubleMath.log2(x, mode));
        assertEquals(exp, DoubleMath.log2(y, mode));
      }
    }
  }