{`long///foo.txt`, `\\?\C:\cwd\long\foo.txt`},
		{`long\.\foo.txt`, `\\?\C:\cwd\long\foo.txt`},
		{`long\..\foo.txt`, `\\?\C:\cwd\foo.txt`},
		{`.\long\foo.txt`, `\\?\C:\cwd\long\foo.txt`},

		// UNC Absolute
		{`\\srv\share\long`, `\\?\UNC\srv\share\long`},
		{`//srv/share/long`, `\\?\UNC\srv\share\long`},
		{`/\srv/share/long`, `\\?\UNC\srv\share\long`},
		{`\\srv\share\long\`, `\\?\UNC\srv\share\long\`},

        .isEqualTo(1);
    assertThat(
            Longs.indexOf(
                new long[] {(long) 2, (long) 3, (long) 2, (long) 3, (long) 4, (long) 2, (long) 3},
                new long[] {(long) 2, (long) 3, (long) 4}))
        .isEqualTo(2);
    assertThat(
            Longs.indexOf(
                new long[] {(long) 2, (long) 2, (long) 3, (long) 4, (long) 2, (long) 3, (long) 4},

   * 0} and {@code 2^64 - 1} inclusive.
   *
   * <p><b>Java 8+ users:</b> use {@link Long#compareUnsigned(long, long)} instead.
   *
   * @param a the first unsigned {@code long} to compare
   * @param b the second unsigned {@code long} to compare
   * @return a negative value if {@code a} is less than {@code b}; a positive value if {@code a} is

        long _10_bytes = 10L;
        assertEquals("10 B", format.format(_10_bytes));

        long _15_bytes = 15L;
        assertEquals("15 B", format.format(_15_bytes));

        long _999_bytes = 999L;
        assertEquals("999 B", format.format(_999_bytes));

        long _1000_bytes = 1000L;
        assertEquals("1.0 kB", format.format(_1000_bytes));

        long _5500_bytes = 5500L;

    // slightly nearer.
    long floatConversionTest = 0xfffffe8000000002L;
    long doubleConversionTest = 0xfffffffffffff402L;

    for (long i = -3; i <= 3; i++) {
      testLongsBuilder
          .add(i)
          .add(Long.MAX_VALUE + i)
          .add(Long.MIN_VALUE + i)
          .add(Integer.MIN_VALUE + i)
          .add(Integer.MAX_VALUE + i)

/**
 * {@link Long}用の変換ユーティリティです。
 *
 * @author higa
 */
public abstract class LongConversionUtil {

    /**
     * {@link Long}に変換します。
     *
     * @param o
     *            変換元のオブジェクト
     * @return 変換された{@link Long}
     */
    public static Long toLong(final Object o) {
        return toLong(o, null);
    }

    /**
     * {@link Long}に変換します。
     *
     * @param o

    int leadingZeros =
        Long.numberOfLeadingZeros(a)
            + Long.numberOfLeadingZeros(~a)
            + Long.numberOfLeadingZeros(b)
            + Long.numberOfLeadingZeros(~b);
    if (leadingZeros > Long.SIZE + 1) {
      return a * b;
    }
    // the return value if we will overflow (which we calculate by overflowing a long :) )
    long limit = Long.MAX_VALUE + ((a ^ b) >>> (Long.SIZE - 1));

   * 0} and {@code 2^64 - 1} inclusive.
   *
   * <p><b>Java 8+ users:</b> use {@link Long#compareUnsigned(long, long)} instead.
   *
   * @param a the first unsigned {@code long} to compare
   * @param b the second unsigned {@code long} to compare
   * @return a negative value if {@code a} is less than {@code b}; a positive value if {@code a} is

    assertMean(0, 0, 0);
    assertMean(-1, -1, -1);
    assertMean(Long.MIN_VALUE, Long.MIN_VALUE, Long.MIN_VALUE);
    assertMean(Long.MAX_VALUE, Long.MAX_VALUE, Long.MAX_VALUE);

    // Exhaustive checks
    for (long x : ALL_LONG_CANDIDATES) {
      for (long y : ALL_LONG_CANDIDATES) {
        assertMean(x, y);
      }
    }
  }

  /** Helper method that asserts the arithmetic mean of x and y is equal to the expectedMean. */

//	stream: message ...
//	message: prefix body
//	prefix: 4 byte uint32 in BigEndian order, denotes length of body
//	body: bytes (0..prefix)
//
// If the buffer passed to Read is not long enough to contain an entire frame, io.ErrShortRead
// will be returned along with the number of bytes read.
func NewLengthDelimitedFrameReader(r io.ReadCloser) io.ReadCloser {
	return &lengthDelimitedFrameReader{r: r}
}