return new ImmutableLongArray(new long[] {e0, e1, e2, e3});
  }

  /** Returns an immutable array containing the given values, in order. */
  public static ImmutableLongArray of(long e0, long e1, long e2, long e3, long e4) {
    return new ImmutableLongArray(new long[] {e0, e1, e2, e3, e4});
  }

  /** Returns an immutable array containing the given values, in order. */

            if (!timings.isEmpty()) {
                double avgTime = timings.stream().mapToLong(Long::longValue).average().orElse(0.0);
                long maxTime = timings.stream().mapToLong(Long::longValue).max().orElse(0L);
                long minTime = timings.stream().mapToLong(Long::longValue).min().orElse(0L);

                double variance = (maxTime - minTime) / avgTime;

      Long[] suffix = {86L, 99L};
      Long[] all = concat(concat(prefix, elements), suffix);
      return makeArray(all).subArray(2, elements.length + 2).asList();
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // used only from suite
  @AndroidIncompatible
  private static Long[] concat(Long[] a, Long[] b) {
    return ObjectArrays.concat(a, b, Long.class);
  }

  @J2ktIncompatible

@NullUnmarked
public class ConverterTest extends TestCase {

  private static final Converter<String, Long> STR_TO_LONG =
      new Converter<String, Long>() {
        @Override
        protected Long doForward(String object) {
          return Long.valueOf(object);
        }

        @Override
        protected String doBackward(Long object) {
          return String.valueOf(object);
        }

        @Override

  // Double#doubleToRawLongBits(double)} spec.
  static final long SIGNIFICAND_MASK = 0x000fffffffffffffL;

  // The mask for the exponent, according to the {@link
  // Double#doubleToRawLongBits(double)} spec.
  static final long EXPONENT_MASK = 0x7ff0000000000000L;

  // The mask for the sign, according to the {@link
  // Double#doubleToRawLongBits(double)} spec.
  static final long SIGN_MASK = 0x8000000000000000L;

 */
public class CrawlingInfoParam extends BsCrawlingInfoParam {

    private static final long serialVersionUID = 1L;

    private OptionalEntity<CrawlingInfo> crawlingInfo;

    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    public Long getVersionNo() {
        return asDocMeta().version();
    }

     *
     * @param ts the timestamp value in Windows FILETIME format
     */
    public AvTimestamp(final long ts) {
        this(encode(ts));
    }

    /**
     * @param ts
     * @return
     */
    private static byte[] encode(final long ts) {
        final byte[] data = new byte[8];
        SMBUtil.writeInt8(ts, data, 0);
        return data;
    }

    /**

        final ExceptionMessageBuilder br = new ExceptionMessageBuilder();
        br.addNotice("Too long boundary size so treats it as 404.");
        br.addItem("Advice");
        br.addElement("Against for CVE-2014-0050 (JVN14876762).");
        br.addElement("Boundary size is limited by Framework.");
        br.addElement("Too long boundary is treated as 404 because it's thought of as attack.");
        br.addElement("");

    /**
     * Converts the given object to a {@link Long}.
     *
     * @param o
     *            the object to convert
     * @param pattern
     *            the pattern string
     * @return the converted {@link Long}
     */
    public static Long toLong(final Object o, final String pattern) {
        return switch (o) {
        case null -> null;
        case Long l -> l;
        case Number n -> n.longValue();

        value = "${spaces}";
        assertEquals("   ", ResourceUtil.resolve(value));

        // Test long property name
        System.setProperty("very.long.property.name.with.many.dots", "long");
        value = "${very.long.property.name.with.many.dots}";
        assertEquals("long", ResourceUtil.resolve(value));

        // Test multiple occurrences of same variable
        System.setProperty("repeat", "X");