for (char value : VALUES) {
      assertThat(Chars.checkedCast((long) value)).isEqualTo(value);
    }
    assertCastFails(GREATEST + 1L);
    assertCastFails(LEAST - 1L);
    assertCastFails(Long.MAX_VALUE);
    assertCastFails(Long.MIN_VALUE);
  }

  public void testSaturatedCast() {
    for (char value : VALUES) {
      assertThat(Chars.saturatedCast((long) value)).isEqualTo(value);
    }

            final long startRecordNumber = data.getCurrentStartRecordNumber();
            final long endRecordNumber = data.getCurrentEndRecordNumber();
            final List<String> pageNumbers = data.getPageNumberList();
            final boolean partial = data.isPartialResults();
            final String searchQuery = data.getSearchQuery();
            final long requestedTime = data.getRequestedTime();

        req.threshold(0); // always create tmp file

        // ## Act ##
        long before = countTmpFiles();
        logger.info("Before request. Number of temp files: " + before);
        req.execute(res -> {
            logger.info("Processing request. Number of temp files: " + countTmpFiles());
        }, e -> {});
        long after = countTmpFiles();
        logger.info("After close response. Number of temp files: " + after);

 */
@GwtCompatible
public class DerivedComparable extends BaseComparable {
  public DerivedComparable(String s) {
    super(s);
  }

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

    /**
     * Default constructor for Response.
     */
    public Response() {
        // Default constructor
    }

    /**
     * The expiration time for this response in milliseconds.
     */
    public long expiration;
    /**
     * Flag indicating whether this response has been received.
     */
    public boolean isReceived;

        }

        this.revision = Byte.parseByte(st.nextToken());
        final String tmp = st.nextToken();
        long id = 0;
        if (tmp.startsWith("0x")) {
            id = Long.parseLong(tmp.substring(2), 16);
        } else {
            id = Long.parseLong(tmp);
        }

        this.identifier_authority = new byte[6];
        for (int i = 5; id > 0; i--) {

     */
    @Override
    public Configuration getConfig() {
        return this.treeConnection.getConfig();
    }

    /**
     * @return the currently connected tree id
     */
    public long getTreeId() {
        return this.treeConnection.getTreeId();
    }

    /**
     *
     * @param req
     * @param params
     * @return response
     * @throws CIFSException
     */

                return tempBuf.toString();
            }).collect(Collectors.joining(","));
            buf.append(json);
            buf.append('}');
        } else if (value instanceof Long || value instanceof Integer) {
            buf.append(((Number) value).longValue());
        } else if (value instanceof Number) {
            buf.append(((Number) value).doubleValue());
        } else {

     * @throws XmlPullParserException XmlPullParserException if
     * any.
     * @return long
     */
    private long getLongValue(String s, String attribute, XmlPullParser parser, boolean strict)
            throws XmlPullParserException {
        if (s != null) {
            try {
                return Long.valueOf(s).longValue();
            } catch (NumberFormatException nfe) {
                if (strict) {

   *     or less than {@link Character#MIN_VALUE}
   */
  public static char checkedCast(long value) {
    char result = (char) value;
    checkArgument(result == value, "Out of range: %s", value);
    return result;
  }

  /**
   * Returns the {@code char} nearest in value to {@code value}.
   *
   * @param value any {@code long} value
   * @return the same value cast to {@code char} if it is in the range of the {@code char} type,