Circular buffer implementation for buffering TCP socket messages
A few minor notes:


Comments like the following are unnecessary:

private T[] array; // storage


You could call the field as storage and remove the comment.
A "solution" for the warning in the constructor:

@SuppressWarnings("unchecked")
private T[] newArray(int length) {
    return (T[]) new Object[length];
}


Reference: Java how to: Generic Array creation
camelCase variable and method names are more common in Java than underscored ones. (Code Conventions for the Java Programming Language, 9 - Naming Conventions)
From Code Complete, 2nd Edition, p761:


  Use only one data declaration per line
  
  [...] 
  
  It’s easier to modify declarations because each declaration is self-contained.
  
  [...]
  
  It’s easier to find specific variables because you can scan a single
  column rather than reading each line. It’s easier to find and fix
  syntax errors because the line number the compiler gives you has 
  only one declaration on it.

Setting default integer field values to zero is unnecessary in the constructor since zero is the default int value:

getIdx = 0;
putIdx = 0;
count = 0;

Does it make sense to create a CircularBuffer instance with zero size? If not check it and throw an IllegalArgumentException in the constructor.
The second insert method might be a premature optimization. 
I'd throw IllegalStateException instead of ArrayIndexOutOfBoundsException. The clients of the class should not know that it uses an array (or anything else) for storage.
Here are a few unit tests:

@Test(expected = IllegalArgumentException.class)
public void testZeroSize() {
    new CircularBuffer&lt;String&gt;(0);
}

@Test
public void testIsEmptyOnNewBuffer() {
    final CircularBuffer&lt;String&gt; buffer = new CircularBuffer&lt;String&gt;(3);
    assertTrue(buffer.isEmpty());
}

@Test
public void testIsFullOnNewBuffer() {
    final CircularBuffer&lt;String&gt; buffer = new CircularBuffer&lt;String&gt;(3);
    assertFalse(buffer.isFull());
}

@Test
public void testIsEmpty() {
    final CircularBuffer&lt;String&gt; buffer = new CircularBuffer&lt;String&gt;(3);
    buffer.insert("a");
    assertFalse(buffer.isEmpty());
}

@Test
public void testIsFull() {
    final CircularBuffer&lt;String&gt; buffer = new CircularBuffer&lt;String&gt;(3);
    buffer.insert("a");
    buffer.insert("b");
    buffer.insert("c");
    assertTrue(buffer.isFull());
}

@Test
public void testIsEmptyAfterReset() {
    final CircularBuffer&lt;String&gt; buffer = new CircularBuffer&lt;String&gt;(3);
    buffer.insert("a");
    buffer.reset();
    assertTrue(buffer.isEmpty());
}

@Test
public void testIsFullAfterReset() {
    final CircularBuffer&lt;String&gt; buffer = new CircularBuffer&lt;String&gt;(3);
    buffer.insert("a");
    buffer.insert("b");
    buffer.insert("c");
    buffer.reset();
    assertFalse(buffer.isFull());
}

@Test
public void testIsEmptyOnUsedBuffer() {
    final CircularBuffer&lt;String&gt; buffer = new CircularBuffer&lt;String&gt;(3);
    buffer.insert("a");
    buffer.insert("b");
    buffer.insert("c");

    assertFalse("isEmpty 1", buffer.isEmpty());
    buffer.get();
    assertFalse("isEmpty 2", buffer.isEmpty());
    buffer.get();
    assertFalse("isEmpty 3", buffer.isEmpty());
    buffer.get();
    assertTrue("isEmpty 4", buffer.isEmpty());
}

@Test
public void testIsFullOnUsedBuffer() {
    final CircularBuffer&lt;String&gt; buffer = new CircularBuffer&lt;String&gt;(3);
    buffer.insert("a");
    buffer.insert("b");
    buffer.insert("c");
    buffer.get();

    assertFalse("isFull 1", buffer.isFull());
    buffer.get();
    assertFalse("isFull 2", buffer.isFull());
    buffer.get();
    assertFalse("isFull 3", buffer.isFull());
}

@Test
public void testInsert() {
    final CircularBuffer&lt;String&gt; buffer = new CircularBuffer&lt;String&gt;(3);
    buffer.insert("a");
    buffer.insert("b");
    buffer.insert("c");
}

@Test(expected = IllegalStateException.class)
public void testInsertFull() {
    final CircularBuffer&lt;String&gt; buffer = new CircularBuffer&lt;String&gt;(3);
    buffer.insert("a");
    buffer.insert("b");
    buffer.insert("c");
    buffer.insert("d");
}

@Test(expected = IllegalStateException.class)
public void testGetOnEmptyBuffer() {
    final CircularBuffer&lt;String&gt; buffer = new CircularBuffer&lt;String&gt;(3);
    buffer.get();
}

@Test(expected = IllegalStateException.class)
public void testGetOnEmptyUsedBuffer() {
    final CircularBuffer&lt;String&gt; buffer = new CircularBuffer&lt;String&gt;(3);
    buffer.insert("a");
    buffer.get();

    buffer.get();
}

@Test
public void testGet() {
    final CircularBuffer&lt;String&gt; buffer = new CircularBuffer&lt;String&gt;(3);
    buffer.insert("a");
    assertEquals("a", buffer.get());
    buffer.insert("b");
    buffer.insert("c");
}

@Test
public void testDelayedGet() {
    final CircularBuffer&lt;String&gt; buffer = new CircularBuffer&lt;String&gt;(3);
    buffer.insert("a");
    buffer.insert("b");
    buffer.insert("c");
    assertEquals("a", buffer.get());
}

@Test
public void testInsertAndGetTwice() {
    final CircularBuffer&lt;String&gt; buffer = new CircularBuffer&lt;String&gt;(3);
    buffer.insert("a");
    buffer.insert("b");
    buffer.insert("c");
    assertEquals("a", buffer.get());
    assertEquals("b", buffer.get());
    assertEquals("c", buffer.get());

    buffer.insert("d");
    buffer.insert("e");
    buffer.insert("f");
    assertEquals("d", buffer.get());
    assertEquals("e", buffer.get());
    assertEquals("f", buffer.get());
}

@Test
public void testGetAndInsert() {
    final CircularBuffer&lt;String&gt; buffer = new CircularBuffer&lt;String&gt;(3);
    buffer.insert("a");
    assertEquals("a", buffer.get());

    buffer.insert("b");
    assertEquals("b", buffer.get());

    buffer.insert("c");
    assertEquals("c", buffer.get());

    buffer.insert("d");
    buffer.insert("e");
    assertEquals("d", buffer.get());
    assertEquals("e", buffer.get());

    buffer.insert("f");
    assertEquals("f", buffer.get());

    assertTrue("empty", buffer.isEmpty());
}


(I've renamed a few methods.)