//  @Test
  public void playTest() throws Exception {
    logger.info("start playTest");
    SourceDataLine audioLine = null;
    MediaAudio samples = beepSamples();
    logger.info("sample is ready");

    AudioFormat format =
        new AudioFormat(
            (float) samples.getSampleRate(),
            (int) samples.getBytesPerSample() * 8,
            samples.getChannels(),
            true,
            false);
    DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);
    audioLine = (SourceDataLine) AudioSystem.getLine(info);
    audioLine.open(format);
    logger.info("beepstart");
    audioLine.start();
    Buffer buffer = samples.getData(0);
    audioLine.write(
        buffer.getByteArray(0, samples.getDataPlaneSize(0)), 0, samples.getDataPlaneSize(0));
    audioLine.drain();
    logger.info("beepend");
    audioLine.close();
    audioLine = null;
  }
  /**
   * Tests if we can create an Buffer from a Java direct ByteBuffer, and then modify the data from
   * the original Java byte buffer
   */
  @Test
  public void testCreationFromJavaDirectByteBufferAndModify() {
    int numBytes = 10;
    ByteBuffer directByteBuffer = ByteBuffer.allocateDirect(numBytes);
    // assertTrue(directByteBuffer.isDirect());
    for (int i = 0; i < numBytes; i++) {
      directByteBuffer.put(i, (byte) i);
    }

    //
    Buffer ibuf = Buffer.make(null, directByteBuffer, 0, numBytes);
    assertNotNull(ibuf);

    ByteBuffer outputDirectByteBuffer = ibuf.getByteBuffer(0, numBytes);
    assertNotNull(numBytes);
    assertEquals(numBytes, outputDirectByteBuffer.capacity());
    for (int i = 0; i < numBytes; i++) {
      assertEquals(i, outputDirectByteBuffer.get(i));
    }

    // Now modify the original data
    for (int i = 0; i < numBytes; i++) {
      directByteBuffer.put(i, (byte) (numBytes - i - 1));
    }

    // And make sure the copy we got out points to the same data
    for (int i = 0; i < numBytes; i++) {
      assertEquals(numBytes - i - 1, outputDirectByteBuffer.get(i));
    }
  }
  /** Test we can create an Buffer, then modify the direct bytes in native code. */
  @Test
  public void testCanDirectlyModifyNativeBytes() {
    byte buffer[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    Buffer buf = Buffer.make(null, buffer, 0, buffer.length);
    assertNotNull(buf);
    assertEquals(buf.getBufferSize(), buffer.length);

    // this give us the native bytes
    java.nio.ByteBuffer nativeBytes = buf.getByteBuffer(0, buffer.length);
    assertNotNull(nativeBytes);
    for (int i = 0; i < buffer.length; i++) {
      nativeBytes.put(i, (byte) (9 - buffer[i])); // reverse the order of the integers
    }
    // we can release it.  no "update" method should be required.  It should
    // have modified the underlying C++ bytes.
    nativeBytes = null;

    // now, get a copy of the bytes in the Buffer and make sure
    // the order of bytes was reversed.
    byte outBuffer[] = buf.getByteArray(0, buffer.length);
    assertNotNull(outBuffer);
    assertEquals(outBuffer.length, buffer.length);
    assertNotSame(buf, outBuffer);
    for (int i = 0; i < buffer.length; i++) {
      assertEquals(9 - buffer[i], outBuffer[i]);
    }
  }
 /**
  * This method allocates one large Buffer and then repeatedly creates a java.nio.ByteBuffer to
  * access them
  *
  * <p>If the system is not leaking, the garbage collector will ensure we don't run out of heap
  * space. If we're leaking, bad things will occur.
  */
 @Test
 public void testNoLeakingMemoryOnDirectAccess() {
   Buffer buf = Buffer.make(null, 1024 * 1024); // 1 MB
   assertNotNull(buf);
   for (int i = 0; i < 100000; i++) {
     java.nio.ByteBuffer nativeBytes = buf.getByteBuffer(0, buf.getBufferSize());
     // and we do nothing with the outBytes
     assertEquals(nativeBytes.limit(), buf.getBufferSize());
     nativeBytes = null;
   }
 }
 /**
  * Test that we can create a Buffer from a Java byte[] array, and that we can copy the same data
  * out of an Buffer (via copy).
  */
 @Test
 public void testCreateFromBytes() {
   byte buffer[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
   Buffer buf = Buffer.make(null, buffer, 0, buffer.length);
   assertNotNull(buf);
   assertEquals(buf.getBufferSize(), buffer.length);
   byte outBuffer[] = buf.getByteArray(0, buffer.length);
   assertNotNull(outBuffer);
   assertEquals(outBuffer.length, buffer.length);
   assertNotSame(buf, outBuffer);
   for (int i = 0; i < buffer.length; i++) {
     assertEquals(buffer[i], outBuffer[i]);
   }
 }
 @Test
 public void testFloatGetPut() {
   // free up any references from other tests
   JNIMemoryManager.getMgr().flush();
   float[] in = new float[] {0x38, 0x2C, 0x18, 0x7F};
   float[] out = new float[in.length];
   Buffer buf = Buffer.make(null, 1024);
   buf.put(in, 0, 0, in.length);
   buf.get(0, out, 0, in.length);
   for (int i = 0; i < in.length; i++) assertEquals("mismatched bytes at " + i, in[i], out[i]);
   buf.delete();
   assertEquals(
       "more objects around than expected", 0, JNIMemoryManager.getMgr().getNumPinnedObjects());
 }
  /**
   * This test makes sure that Humble Video sets the byte order of the returned ByteBuffer to native
   * order
   */
  @Test
  public void testByteOrderIsCorrect() {
    Buffer buf = Buffer.make(null, 1024 * 1024); // 1 MB
    assertNotNull(buf);

    assertEquals(1, buf.getCurrentRefCount());

    java.nio.ByteBuffer jbuf = buf.getByteBuffer(0, buf.getBufferSize());
    assertNotNull(buf);

    // Set 4 bytes that have a pattern that is reversible.  On a big
    // endian machine this is FOO and on a little endian it's BAR
    jbuf.put(0, (byte) 0xFF);
    jbuf.put(1, (byte) 0);
    jbuf.put(2, (byte) 0xFF);
    jbuf.put(3, (byte) 0);

    int bigOrderVal = 0xFF00FF00;
    int littleOrderVal = 0x00FF00FF;
    int expectedVal;
    if (ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) expectedVal = bigOrderVal;
    else expectedVal = littleOrderVal;
    java.nio.IntBuffer ibuf = jbuf.asIntBuffer();
    assertNotNull(ibuf);

    int val = ibuf.get(0);
    assertEquals(expectedVal, val);

    // now let's try changing byte orders
    jbuf.order(ByteOrder.BIG_ENDIAN);
    ibuf = jbuf.asIntBuffer();
    assertNotNull(ibuf);

    val = ibuf.get(0);
    assertEquals(bigOrderVal, val);

    jbuf.order(ByteOrder.LITTLE_ENDIAN);
    ibuf = jbuf.asIntBuffer();
    assertNotNull(ibuf);

    val = ibuf.get(0);
    assertEquals(littleOrderVal, val);
  }
  /** Tests if we can create an Buffer from a Java direct ByteBuffer. */
  @Test
  public void testCreationFromJavaDirectByteBuffer() {
    int numBytes = 10;
    ByteBuffer directByteBuffer = ByteBuffer.allocateDirect(numBytes);
    // assertTrue(directByteBuffer.isDirect());
    for (int i = 0; i < numBytes; i++) {
      directByteBuffer.put(i, (byte) i);
    }

    //
    Buffer ibuf = Buffer.make(null, directByteBuffer, 0, numBytes);
    assertNotNull(ibuf);

    ByteBuffer outputDirectByteBuffer = ibuf.getByteBuffer(0, numBytes);
    assertNotNull(numBytes);
    assertEquals(numBytes, outputDirectByteBuffer.capacity());
    for (int i = 0; i < numBytes; i++) {
      assertEquals(i, outputDirectByteBuffer.get(i));
    }
  }
  /**
   * This is a crazy test to make sure that a direct byte buffer will still be accessible even if
   * the Buffer it came from goes out of scope and is collected.
   */
  @Test(timeout = 60 * 1000)
  public void testDirectByteBufferCanBeAccessedAfterBufferDisappears() {
    Buffer buf = Buffer.make(null, 1024 * 1024); // 1 MB
    assertNotNull(buf);

    assertEquals(1, buf.getCurrentRefCount());

    java.nio.ByteBuffer jbuf = buf.getByteBuffer(0, buf.getBufferSize());
    assertNotNull(buf);

    // now release the reference
    buf.delete();
    buf = null;

    // in versions prior to 1.22, this would have caused a hard
    // crash, but with 1.22 the getByteBuffer should have incremented
    // the native ref count until this java ByteBuffer gets collected
    // and we do a JNIMemoryManager gc.
    jbuf.put(0, (byte) 0xFF);
  }
 @Test(expected = IllegalArgumentException.class)
 public void testCreationFailsWithoutDirectByteBuffer() {
   ByteBuffer directByteBuffer = ByteBuffer.allocate(10);
   Buffer.make(null, directByteBuffer, 0, 10);
 }
 /** Test we can create an ibuffer of the right size. */
 @Test
 public void testCreation() {
   Buffer buf = Buffer.make(null, 1024);
   assertNotNull(buf);
   assertTrue(buf.getBufferSize() >= 1024);
 }
  @Test
  public void testGetInvalidArgs() {
    Buffer buf = Buffer.make(null, 1);

    byte[] in = new byte[] {0x38, 0x2C};
    byte[] out = new byte[] {0x53, 0x7C};
    try {
      buf.put(in, 0, 0, 2);
      fail("should fail on 2 bytes");
    } catch (IndexOutOfBoundsException e) {
    }
    try {
      buf.get(0, out, 0, 2);
      fail("should fail on 2 bytes");
    } catch (IndexOutOfBoundsException e) {
    }
    try {
      buf.put(in, -1, 0, 1);
      fail("should fail on 2 bytes");
    } catch (IndexOutOfBoundsException e) {
    }
    try {
      buf.get(-1, out, 0, 1);
      fail("should fail on 2 bytes");
    } catch (IndexOutOfBoundsException e) {
    }
    try {
      buf.put(in, 0, -1, 1);
      fail("should fail on 2 bytes");
    } catch (IndexOutOfBoundsException e) {
    }
    try {
      buf.get(0, out, -1, 1);
      fail("should fail on 2 bytes");
    } catch (IndexOutOfBoundsException e) {
    }
    try {
      buf.put(in, 0, 1, 1);
      fail("should fail on 2 bytes");
    } catch (IndexOutOfBoundsException e) {
    }
    try {
      buf.get(0, out, 3, 1);
      fail("should fail on 2 bytes");
    } catch (IndexOutOfBoundsException e) {
    }
    try {
      buf.put(in, 3, 0, 1);
      fail("should fail on 2 bytes");
    } catch (IndexOutOfBoundsException e) {
    }
    try {
      buf.get(1, out, 0, 1);
      fail("should fail on 2 bytes");
    } catch (IndexOutOfBoundsException e) {
    }
    buf.put(in, 0, 0, 1);
    buf.get(0, out, 0, 1);
    assertEquals(in[0], out[0]);
    assertNotSame(in[1], out[1]);

    buf.delete();
  }