Project: Flume-Hive
/**
 * Licensed to Cloudera, Inc. under one 
 * or more contributor license agreements.  See the NOTICE file 
 * distributed with this work for additional information 
 * regarding copyright ownership.  Cloudera, Inc. licenses this file 
 * to you under the Apache License, Version 2.0 (the 
 * "License"); you may not use this file except in compliance 
 * with the License.  You may obtain a copy of the License at 
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */
package com.cloudera.util; 
 
import java.io.ByteArrayInputStream; 
import java.io.IOException; 
import java.io.InputStream; 
import java.nio.ByteBuffer; 
import java.nio.channels.Channels; 
import java.nio.channels.ReadableByteChannel; 
 
import org.junit.Assert; 
import org.junit.Test; 
 
/**
 * This is a sandbox to test the semantics of ByteBuffer. This will provide 
 * insight into how/if to use them them in when converting the events away from 
 * <String,byte[]>'s 
 */
 
public class TestByteBufferSemantics  { 
 
  @Test 
  public void testToArray() { 
    ByteBuffer buf = ByteBuffer.allocate(100); 
    buf.putInt(0xdead); 
    buf.putInt(0xbeef); 
 
    // returns the backing array -- the entire thing regardless of how much 
    // of it is filled. 
    Assert.assertEquals(100, buf.array().length); 
    Assert.assertEquals(100, buf.capacity()); // same as array().length 
    Assert.assertEquals(92, buf.remaining()); 
    Assert.assertEquals(8, buf.position()); 
 
    // byte offset for these. 
    Assert.assertEquals(0xdead, buf.getInt(0)); 
    Assert.assertEquals(0xbeef, buf.getInt(4)); 
 
    // didn't go anywhere. whoa! 
    Assert.assertEquals(100, buf.array().length); 
    Assert.assertEquals(100, buf.capacity()); // same as array().length 
    Assert.assertEquals(92, buf.remaining()); 
    Assert.assertEquals(8, buf.position()); 
 
    buf.flip(); 
    Assert.assertEquals(0xdead, buf.getInt()); 
    Assert.assertEquals(0xbeef, buf.getInt()); 
    // still in the same place 
    Assert.assertEquals(0xdead, buf.getInt(0)); 
    Assert.assertEquals(0xbeef, buf.getInt(4)); 
 
    Assert.assertEquals(100, buf.array().length); 
    Assert.assertEquals(100, buf.capacity()); // same as array().length 
    Assert.assertEquals(0, buf.remaining()); 
    Assert.assertEquals(8, buf.position()); 
 
    buf.flip(); 
    Assert.assertEquals(100, buf.array().length); 
    Assert.assertEquals(100, buf.capacity()); // same as array().length 
    Assert.assertEquals(8, buf.remaining()); 
    Assert.assertEquals(0, buf.position()); 
 
    buf.clear(); // just resets pointers 
    Assert.assertEquals(100, buf.array().length); 
    Assert.assertEquals(100, buf.capacity()); // same as array().length 
    Assert.assertEquals(100, buf.remaining()); 
    Assert.assertEquals(0, buf.position()); 
    // note: still not erased. 
    Assert.assertEquals(0xdead, buf.getInt(0)); 
    Assert.assertEquals(0xbeef, buf.getInt(4)); 
 
    // this overwrites. 
    buf.putInt(0xf00d); 
    buf.putInt(0xcafe); 
    Assert.assertEquals(0xf00d, buf.getInt(0)); 
    Assert.assertEquals(0xcafe, buf.getInt(4)); 
 
  } 
 
  @Test 
  public void testBuffers() throws IOException { 
    byte[] bs = new byte[100]; 
    for (int i = 0; i < bs.length; i++) { 
      bs[i] = (byte) i; 
    } 
    InputStream is = new ByteArrayInputStream(bs); 
    ReadableByteChannel rch = Channels.newChannel(is); 
 
    ByteBuffer buf = ByteBuffer.allocate(100); 
    buf.limit(8); 
    System.out.println("artificially set limit to :" + buf.limit()); 
    rch.read(buf); 
    Assert.assertEquals(0, buf.get(0)); 
    Assert.assertEquals(1, buf.get(1)); 
    Assert.assertEquals(7, buf.get(7)); 
    buf.clear(); 
 
    System.out.println("after clear limit is :" + buf.limit()); 
    Assert.assertEquals(100, buf.limit()); 
 
    // reset limit to 8. 
    buf.limit(8); 
    // read the next 8 bytes 
    rch.read(buf); 
    Assert.assertEquals(8, buf.get(0)); 
    Assert.assertEquals(9, buf.get(1)); 
    Assert.assertEquals(15, buf.get(7)); 
 
    // now can read 16 
    System.out.println("limit was :" + buf.limit()); 
    buf.limit(buf.limit() + 8); 
    System.out.println("limit now bumped up to :" + buf.limit()); 
    rch.read(buf); 
    // still same as before 
    Assert.assertEquals(8, buf.get(0)); 
    Assert.assertEquals(9, buf.get(1)); 
    Assert.assertEquals(15, buf.get(7)); 
    // but now new data is read as well! 
    Assert.assertEquals(16, buf.get(8)); 
    Assert.assertEquals(17, buf.get(9)); 
    Assert.assertEquals(23, buf.get(15)); 
 
  } 
 
}