DBATest.java

package me.xhh.hector06;

import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertNotNull;
import static org.testng.Assert.assertNull;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import me.xhh.hector06.DBA;
import me.xhh.hector06.DBUtil;
import me.xhh.hector06.DBA.ColumnFamily;
import me.xhh.hector06.DBA.ColumnMap;
import me.xhh.hector06.DBA.ColumnName;
import me.xhh.hector06.ExampleBaseDBA.DemoDB;

import org.apache.cassandra.thrift.Column;
import org.apache.cassandra.thrift.ColumnPath;
import org.apache.cassandra.thrift.SuperColumn;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

public class DBATest extends DaoProvider {
	/**
	 * NOTE: Test this class manually! It has been excluded from the build.xml testing part.
	 */

	private DBA dba;

	/** Column family to test with */
	private static final ColumnFamily CF = DemoDB.ExampleColumnFamily;
	/** Super column family to test with */
	private static final ColumnFamily SCF = DemoDB.ExampleSuperColumnFamily;
	
	/* ---------------- Example Keyspace config for testing ----------------
	 <Keyspace Name="Keyspace1">
       <ColumnFamily Name="ExampleColumnFamily" CompareWith="UTF8Type" />
       <ColumnFamily Name="ExampleSuperColumnFamily" ColumnType="Super" CompareWith="LongType" CompareSubcolumnsWith="UTF8Type" />
       <ReplicaPlacementStrategy>org.apache.cassandra.locator.RackUnawareStrategy</ReplicaPlacementStrategy>
       <ReplicationFactor>1</ReplicationFactor>
       <EndPointSnitch>org.apache.cassandra.locator.EndPointSnitch</EndPointSnitch>
   </Keyspace>
	 */

	enum CN implements ColumnName {
		column0, column1, column2, column3, column4, column5, column6, column7, column8, column9, column_not_exist, column_not_exist_2
	}

	@BeforeClass
	public void prepareConnection() throws Exception {
		dba = prepareDao(DBA.class);
	}

	@BeforeMethod
	public void setUp() {
		// prepare data for testing
		List<String> keys = new ArrayList<String>(10);
		List<Column> columns = new ArrayList<Column>(10);
		// List<SuperColumn> superCols = new ArrayList<SuperColumn>(10);
		List<SuperColumn> superColsTypeLong = new ArrayList<SuperColumn>(10);
		for (int i = 0; i < 10; i++) {
			keys.add("key" + i);
			columns.add(DBUtil.createColumn("column" + i, "value" + i));
		}
		for (int i = 0; i < 10; i++) {
			// superCols.add( DBUtil.superColumn( "super" + i, columns ) );
			superColsTypeLong.add(DBUtil.createSuperColumn(new Long(i), columns));
		}

		Map<String, List<Column>> colMap = new HashMap<String, List<Column>>(1);
		colMap.put(CF.toString(), columns);
		Map<String, List<SuperColumn>> superColMap = new HashMap<String, List<SuperColumn>>(1);
		superColMap.put(SCF.toString(), superColsTypeLong);
		for (String key : keys) {
			dba.insertColumns(CF, key, columns);
			dba.insertColumnsOrSuperColumns(SCF, key, null, superColsTypeLong);
		}
	}

	@Override
	protected ColumnFamily[] getColumnFamilies() {
		return new ColumnFamily[]{CF, SCF};
	}

	@Test
	public void testCreateColumnPath() {
		ColumnPath cp = dba.createColumnPath(CF, null, "column-name");
		assertEquals(cp.getColumn_family(), CF.toString());
		assertNull(cp.getSuper_column());
		assertEquals(DBUtil.string(cp.getColumn()), "column-name");

		cp = dba.createColumnPath(SCF, "super-name", "column-name");
		assertEquals(cp.getColumn_family(), SCF.toString());
		assertEquals(DBUtil.string(cp.getSuper_column()), "super-name");
		assertEquals(DBUtil.string(cp.getColumn()), "column-name");

		cp = dba.createColumnPath(SCF, 123l, "column-name");
		assertEquals(cp.getColumn_family(), SCF.toString());
		assertEquals(DBUtil.longFromBytes(cp.getSuper_column()).longValue(), 123l);
		assertEquals(DBUtil.string(cp.getColumn()), "column-name");
	}

	@Test
	public void test_insertValue_ColumnFamily() {
		String key = "test_insert_1";
		dba.insertValue(CF, key, "first_name", "first_name_1");
		dba.insertValue(CF, key, "last_name", "last_name_1");

		assertEquals(dba.getValue(CF, key, "first_name"), "first_name_1");
		assertEquals(dba.getValue(CF, key, "last_name"), "last_name_1");
		assertNull(dba.getValue(CF, key, "not-exist-3j2o38"));

		dba.insertValue(CF, key, "first_name", "first_name_updated");
		assertEquals(dba.getValue(CF, key, "first_name"), "first_name_updated");
	}

	@Test
	public void test_insertValue_SuperColumnFamily() {
		String key = "test_insert_2";
		dba.insertValue(SCF, key, 123l, "subject", "subject text");
		dba.insertValue(SCF, key, 123l, "body", "body text");

		assertEquals(dba.getValue(SCF, key, 123l, "subject"), "subject text");
		assertEquals(dba.getValue(SCF, key, 123l, "body"), "body text");
		assertNull(dba.getValue(SCF, key, 123l, "not-exist-j32jf"));
		assertNull(dba.getValue(SCF, key, 283492l, "not-exist-j32jf"));

		dba.insertValue(SCF, key, 123l, "body", "body updated");
		assertEquals(dba.getValue(SCF, key, 123l, "body"), "body updated");
	}

	@Test
	public void test_insertColumns() {
		final String key = "test_insert_columns";
		assertTrue(dba.isKeyEmpty(CF, key));
		assertTrue(dba.isKeyEmpty(SCF, key));

		List<Column> colList = new ArrayList<Column>(2);
		colList.add(DBUtil.createColumn("name", "Alice"));
		colList.add(DBUtil.createColumn("title", "kid"));
		// Map<String, List<Column>> colMap = new HashMap<String,
		// List<Column>>(1);
		// colMap.put( CF.name(), colList );
		// Map<String, List<SuperColumn>> superColMap = new HashMap<String,
		// List<SuperColumn>>(1);
		List<SuperColumn> superColList = new ArrayList<SuperColumn>(2);
		superColList.add(new SuperColumn(DBUtil.bytesForName(100l), colList));
		superColList.add(new SuperColumn(DBUtil.bytesForName(200l), colList));
		// superColMap.put( SCF.name(), superColList );

		dba.insertColumns(CF, key, colList);
		dba.insertColumnsOrSuperColumns(SCF, key, null, superColList);

		assertFalse(dba.isKeyEmpty(CF, key));
		ColumnMap<String> data = dba.getAllColumnsToMap(CF, key);
		assertEquals(data.size(), 2);
		assertEquals(data.get("name"), "Alice");
		assertEquals(data.get("title"), "kid");

		assertFalse(dba.isKeyEmpty(SCF, key));
		List<SuperColumn> superCols = dba.getAllSuperColumns(SCF, key);
		assertEquals(superCols.size(), 2);
		SuperColumn superCol0 = superCols.get(0);
		Long superName0 = DBUtil.longFromBytes(superCol0.name);
		assertTrue(superName0 == 100l || superName0 == 200l);
		data = DBUtil.columnsToMap(superCol0.getColumns());
		assertEquals(data.size(), 2);
		assertEquals(data.get("name"), "Alice");
		assertEquals(data.get("title"), "kid");
	}

	// TODO batch - not implemented yet
	/*
	 * @Test public void
	 * testInsertColumnsStringMapOfStringListOfColumnMapOfStringListOfSuperColumn
	 * () { fail( "Not yet implemented" ); }
	 * 
	 * @Test public void testMutateColumnsMapOfStringMapOfStringListOfMutation()
	 * { fail( "Not yet implemented" ); }
	 * 
	 * @Test public void testMutateColumnsBatchMutation() { fail(
	 * "Not yet implemented" ); }
	 */

	@Test
	public void test_getValue() {
		assertEquals(dba.getValue(CF, "key0", CN.column0), "value0");
		assertEquals(dba.getValue(CF, "key0", "column1"), "value1");
		assertEquals(dba.getValue(CF, "key1", "column1"), "value1");
		assertEquals(dba.getValue(CF, "key1", "column9"), "value9");
		assertEquals(dba.getValue(CF, "key9", "column9"), "value9");
		assertNull(dba.getValue(CF, "key-not-exist", "column1"));
		assertNull(dba.getValue(CF, "key1", "column-not-exist"));

		assertEquals(dba.getValue(SCF, "key0", 0l, CN.column0), "value0");
		assertEquals(dba.getValue(SCF, "key1", 1l, "column7"), "value7");
		assertEquals(dba.getValue(SCF, "key9", 9l, "column9"), "value9");
		assertNull(dba.getValue(SCF, "key-not-exist", 0l, "column1"));
		assertNull(dba.getValue(SCF, "key0", 10001l, "column1"));
		assertNull(dba.getValue(SCF, "key1", 9l, "column-not-exist"));

		super.clearData();
		assertNull(dba.getValue(CF, "key0", CN.column0));
		assertNull(dba.getValue(CF, "key0", "column1"));
		assertNull(dba.getValue(CF, "key9", "column9"));
	}

	@Test
	public void test_columnExists() {
		assertTrue(dba.columnExists(CF, "key0", CN.column0));
		assertTrue(dba.columnExists(CF, "key5", "column9"));
		assertTrue(dba.columnExists(CF, "key9", CN.column0));
		assertTrue(dba.columnExists(CF, "key9", "column9"));
		assertFalse(dba.columnExists(CF, "key0", "column-not-exist"));
		assertFalse(dba.columnExists(CF, "key-not-exist", CN.column0));
		assertFalse(dba.columnExists(CF, "test-key", "test-col"));
		dba.insertValue(CF, "test-key", "test-col", "test-val");
		assertTrue(dba.columnExists(CF, "test-key", "test-col"));

		assertTrue(dba.columnExists(SCF, "key0", 0l, CN.column0));
		assertTrue(dba.columnExists(SCF, "key0", 0l, "column5"));
		assertTrue(dba.columnExists(SCF, "key0", 9l, CN.column0));
		assertTrue(dba.columnExists(SCF, "key9", 0l, CN.column0));
		assertTrue(dba.columnExists(SCF, "key9", 4l, "column7"));
		assertFalse(dba.columnExists(SCF, "key9", 4l, "column-not-exist"));
		assertFalse(dba.columnExists(SCF, "key9", 10001l, "column9"));
		assertFalse(dba.columnExists(SCF, "key9", 4l, "column-not-exist"));
		assertFalse(dba.columnExists(SCF, "test-key", 10009l, "test-col"));
		dba.insertValue(SCF, "test-key", 10009l, "test-col", "test-val");
		assertTrue(dba.columnExists(SCF, "test-key", 10009l, "test-col"));
	}

	@Test
	public void test_superColumnExists() {
		assertTrue(dba.superColumnExists(SCF, "key0", 0l));
		assertTrue(dba.superColumnExists(SCF, "key0", 6l));
		assertTrue(dba.superColumnExists(SCF, "key9", 0l));
		assertFalse(dba.superColumnExists(SCF, "key0", 10001l));
		assertFalse(dba.superColumnExists(SCF, "key-not-exist", 0l));

		assertFalse(dba.superColumnExists(SCF, "test-key", 10009l));
		dba.insertValue(SCF, "test-key", 10009l, "test-col", "test-val");
		assertTrue(dba.superColumnExists(SCF, "test-key", 10009l));
		dba.deleteColumn(SCF, "test-key", 10009l, "test-col");
		assertFalse(dba.superColumnExists(SCF, "test-key", 10009l));
	}

	@Test
	public void test_getFirstColumn() {
		Column col = dba.getFirstColumn(CF, "key0");
		assertNotNull(col);
		assertEquals(DBUtil.string(col.name), CN.column0.toString());
		assertEquals(DBUtil.string(col.value), "value0");
		assertNull(dba.getFirstColumn(CF, "key-not-exist"));

		col = dba.getFirstColumn(SCF, "key0", 0l);
		assertNotNull(col);
		assertEquals(DBUtil.string(col.name), CN.column0.toString());
		assertEquals(DBUtil.string(col.value), "value0");
		assertNull(dba.getFirstColumn(SCF, "key-not-exist", 0l));
		assertNull(dba.getFirstColumn(SCF, "key0", 10001l));
	}

	@Test
	public void test_getFirstColumnName() {
		byte[] colName = dba.getFirstColumnName(CF, "key0");
		assertEquals(DBUtil.string(colName), CN.column0.toString());
		assertNull(dba.getFirstColumnName(CF, "key-not-exist"));

		colName = dba.getFirstColumnName(SCF, "key0", 0l);
		assertEquals(DBUtil.string(colName), "column0");
		assertNull(dba.getFirstColumnName(SCF, "key-not-exist", 0l));
		assertNull(dba.getFirstColumnName(SCF, "key0", 10001l));
	}

	@Test
	public void test_getFirstValue() {
		assertEquals(dba.getFirstValue(CF, "key0"), "value0");
		assertNull(dba.getFirstValue(CF, "key-not-exist"));

		assertEquals(dba.getFirstValue(SCF, "key9", 9l), "value0");
		assertNull(dba.getFirstValue(SCF, "key-not-exist", 0l));
		assertNull(dba.getFirstValue(SCF, "key0", 10001l));
	}

	@Test
	public void test_getLastColumn() {
		Column col = dba.getLastColumn(CF, "key0");
		assertNotNull(col);
		assertEquals(DBUtil.string(col.name), "column9");
		assertEquals(DBUtil.string(col.value), "value9");
		assertNull(dba.getLastColumn(CF, "key-not-exist"));

		col = dba.getLastColumn(SCF, "key7", 2l);
		assertNotNull(col);
		assertEquals(DBUtil.string(col.name), "column9");
		assertEquals(DBUtil.string(col.value), "value9");
		assertNull(dba.getLastColumn(SCF, "key-not-exist", 3l));
		assertNull(dba.getLastColumn(SCF, "key9", 10001l));
	}

	@Test
	public void test_getLastColumnName() {
		byte[] colName = dba.getLastColumnName(CF, "key0");
		assertEquals(DBUtil.string(colName), "column9");
		assertNull(dba.getLastColumnName(CF, "key-not-exist"));

		colName = dba.getLastColumnName(SCF, "key5", 7l);
		assertEquals(DBUtil.string(colName), "column9");
		assertNull(dba.getLastColumnName(SCF, "key-not-exist", 0l));
		assertNull(dba.getLastColumnName(SCF, "key0", 10001l));
	}

	@Test
	public void test_getLastValue() {
		assertEquals(dba.getLastValue(CF, "key0"), "value9");
		assertNull(dba.getLastValue(CF, "key-not-exist"));

		assertEquals(dba.getLastValue(SCF, "key9", 9l), "value9");
		assertNull(dba.getLastValue(SCF, "key-not-exist", 0l));
		assertNull(dba.getLastValue(SCF, "key0", 10001l));
	}

	@Test
	public void test_getColumns_and_getAllColumns() {
		assertEquals(dba.getColumns(CF, "key3", null, 5).size(), 5);

		dba.deleteColumns(CF, "key3", null, Arrays.asList((Object) 1, 2, 3));
		super.clearData();
		setUp();
		assertEquals(dba.getColumns(CF, "key3", null, 5).size(), 5);

		assertEquals(dba.getAllColumns(CF, "key3").size(), 10);
		assertEquals(dba.getAllColumns(CF, "key3", null, 7, false).size(), 10);
		assertEquals(dba.getAllColumns(CF, "key0", null, 2, true).size(), 10);

		List<ColumnName> colNames = new ArrayList<ColumnName>();
		colNames.add(CN.column0);
		colNames.add(CN.column1);
		colNames.add(CN.column6);
		colNames.add(CN.column9);
		List<Column> cols = dba.getColumns(CF, "key3", null, colNames, null, null, 0, false);
		assertEquals(cols.size(), 4);
		assertEquals(DBUtil.string(cols.get(0).getName()), CN.column0.toString());
		assertEquals(DBUtil.string(cols.get(0).getValue()), "value0");
		assertEquals(DBUtil.string(cols.get(2).getValue()), "value6");

		colNames.add(CN.column_not_exist);
		cols = dba.getColumns(CF, "key3", null, colNames, null, null, 0, false);
		assertEquals(cols.size(), 4);
		colNames.remove(CN.column_not_exist);

		cols = dba.getColumns(CF, "key5", null, null, null, null, 2, false);
		assertEquals(cols.size(), 2);
		assertEquals(DBUtil.string(cols.get(0).getName()), CN.column0.toString());
		assertEquals(DBUtil.string(cols.get(1).getValue()), "value1");

		cols = dba.getColumns(CF, "key1", null, null, null, null, 2, true);
		assertEquals(cols.size(), 2);
		assertEquals(DBUtil.string(cols.get(0).getName()), CN.column9.toString());
		assertEquals(DBUtil.string(cols.get(0).getValue()), "value9");
		assertEquals(DBUtil.string(cols.get(1).getValue()), "value8");

		cols = dba.getColumns(CF, "key0", null, null, null, null, 0, false);
		assertEquals(cols.size(), 10);
		assertEquals(DBUtil.string(cols.get(0).getName()), CN.column0.toString());
		assertEquals(DBUtil.string(cols.get(0).getValue()), "value0");
		assertEquals(DBUtil.string(cols.get(2).getValue()), "value2");
		assertEquals(DBUtil.string(cols.get(9).getValue()), "value9");

		cols = dba.getColumns(CF, "key0", null, null, DBUtil.bytesForName(CN.column8), DBUtil.bytesForName(CN.column5), 0, true);
		assertEquals(cols.size(), 4);
		assertEquals(DBUtil.string(cols.get(0).getName()), CN.column8.toString());
		assertEquals(DBUtil.string(cols.get(0).getValue()), "value8");
		assertEquals(DBUtil.string(cols.get(1).getValue()), "value7");
		assertEquals(DBUtil.string(cols.get(3).getValue()), "value5");

		cols = dba.getColumns(CF, "key4", null, null, DBUtil.bytesForName(CN.column8), null, 0, false);
		assertEquals(cols.size(), 2);
		assertEquals(DBUtil.string(cols.get(0).getName()), CN.column8.toString());
		assertEquals(DBUtil.string(cols.get(1).getValue()), "value9");

		cols = dba.getColumns(CF, "key9", null, null, DBUtil.bytesForName(CN.column2), null, 0, true);
		assertEquals(cols.size(), 3);
		assertEquals(DBUtil.string(cols.get(0).getName()), CN.column2.toString());
		assertEquals(DBUtil.string(cols.get(2).getValue()), "value0");

		cols = dba.getColumns(CF, "key9", null, null, DBUtil.bytesForName(CN.column_not_exist), null, 0, false);
		assertEquals(cols.size(), 0);

		cols = dba.getColumns(CF, "key9", null, Arrays.asList((ColumnName) CN.column_not_exist, CN.column_not_exist_2), null, null, 0,
				true);
		assertEquals(cols.size(), 0);

		cols = dba.getColumns(CF, "key-not-exist", null, null, null, null, 0, false);
		assertEquals(cols.size(), 0);

		cols = dba.getColumns(SCF, "key0", 0l, null, null, null, 0, false);
		assertEquals(cols.size(), 10);
		assertEquals(DBUtil.string(cols.get(0).getName()), CN.column0.toString());
		assertEquals(DBUtil.string(cols.get(0).getValue()), "value0");
		assertEquals(DBUtil.string(cols.get(2).getValue()), "value2");
		assertEquals(DBUtil.string(cols.get(9).getValue()), "value9");

		cols = dba.getColumns(SCF, "key4", 3l, null, DBUtil.bytesForName(CN.column8), DBUtil.bytesForName(CN.column5), 0, true);
		assertEquals(cols.size(), 4);
		assertEquals(DBUtil.string(cols.get(0).getName()), CN.column8.toString());
		assertEquals(DBUtil.string(cols.get(0).getValue()), "value8");
		assertEquals(DBUtil.string(cols.get(1).getValue()), "value7");
		assertEquals(DBUtil.string(cols.get(3).getValue()), "value5");

		cols = dba.getColumns(SCF, "key9", 8l, null, DBUtil.bytesForName(CN.column8), null, 0, false);
		assertEquals(cols.size(), 2);
		assertEquals(DBUtil.string(cols.get(0).getName()), CN.column8.toString());
		assertEquals(DBUtil.string(cols.get(1).getValue()), "value9");

		cols = dba.getColumns(SCF, "key9", 0l, null, DBUtil.bytesForName(CN.column_not_exist), null, 0, false);
		assertEquals(cols.size(), 0);

		cols = dba.getColumns(SCF, "key9", 7l, Arrays.asList((ColumnName) CN.column_not_exist, CN.column_not_exist_2), null, null, 0,
				true);
		assertEquals(cols.size(), 0);

		cols = dba.getColumns(SCF, "key9", 10001l, null, null, null, 0, false);
		assertEquals(cols.size(), 0);

		cols = dba.getColumns(SCF, "key-not-exist", 1l, null, null, null, 0, false);
		assertEquals(cols.size(), 0);
	}

	@Test
	public void test_getColumnsMap() {
		List<ColumnName> colNames = new ArrayList<ColumnName>();
		colNames.add(CN.column0);
		colNames.add(CN.column1);
		colNames.add(CN.column6);
		colNames.add(CN.column9);
		colNames.add(CN.column_not_exist);
		ColumnMap<String> data = dba.getColumnsToMap(CF, "key3", null, colNames);
		assertEquals(data.size(), 4);
		assertEquals(data.get(CN.column0), "value0");
		assertEquals(data.get(CN.column1), "value1");
		assertEquals(data.get(CN.column9), "value9");

		data = dba.getColumnsToMap(CF, "key-not-exist", null, colNames);
		assertEquals(data.size(), 0);
	}

	@Test
	public void test_getCount() {
		assertEquals(dba.getCount(CF, "key0"), 10);
		dba.deleteColumn(CF, "key0", CN.column0);
		assertEquals(dba.getCount(CF, "key0"), 9);
		dba.deleteColumn(CF, "key0", CN.column5);
		assertEquals(dba.getCount(CF, "key0"), 8);
		dba.deleteColumn(CF, "key0", CN.column_not_exist);
		assertEquals(dba.getCount(CF, "key0"), 8);

		assertEquals(dba.getCount(SCF, "key0"), 10);
		assertEquals(dba.getCount(SCF, "key0", 0l), 10);
		dba.deleteColumn(SCF, "key0", 0l, CN.column0);
		assertEquals(dba.getCount(SCF, "key0", 0l), 9);
		assertEquals(dba.getCount(SCF, "key0"), 10);
		dba.deleteSuperColumn(SCF, "key0", 9l);
		assertEquals(dba.getCount(SCF, "key0"), 9);
	}

	@Test
	public void test_getSuperColumn() {
		SuperColumn sc = dba.getSuperColumn(SCF, "key0", 0l);
		assertEquals(DBUtil.longFromBytes(sc.getName()).longValue(), 0l);
		assertEquals(10, sc.getColumns().size());
		assertEquals(DBUtil.string(sc.getColumnsIterator().next().getName()), CN.column0.toString());
		assertNull(dba.getSuperColumn(SCF, "key0", 10001l));
		assertNull(dba.getSuperColumn(SCF, "key-not-exist", 0l));

		sc = dba.getSuperColumn(SCF, "key0", 0l, true, 2);
		assertEquals(DBUtil.longFromBytes(sc.getName()).longValue(), 0l);
		assertEquals(2, sc.getColumns().size());
		assertEquals(DBUtil.string(sc.getColumnsIterator().next().getName()), CN.column9.toString());
	}

	@Test
	public void test_getFirstSuperColumn() {
		SuperColumn sc = dba.getFirstSuperColumn(SCF, "key0");
		assertEquals(DBUtil.longFromBytes(sc.getName()).longValue(), 0l);
		assertEquals(10, sc.getColumns().size());
		assertNull(dba.getFirstSuperColumn(SCF, "key-not-exist"));
	}

	@Test
	public void test_getLastSuperColumn() {
		SuperColumn sc = dba.getLastSuperColumn(SCF, "key0");
		assertEquals(DBUtil.longFromBytes(sc.getName()).longValue(), 9l);
		assertEquals(10, sc.getColumns().size());
		assertNull(dba.getLastSuperColumn(SCF, "key-not-exist"));
	}

	@Test
	public void test_getKeys_and_getAllKeys() {
		List<String> keys = dba.getKeys(CF, null, null, 1000);
		assertEquals(keys.size(), 10);
		assertTrue(keys.contains("key0"));
		assertTrue(keys.contains("key6"));
		assertFalse(keys.contains("key-not-exist"));

		keys = dba.getKeys(CF, null, null, 7);
		assertEquals(keys.size(), 7);

		keys = dba.getKeys(CF, null, null, 2);
		assertEquals(keys.size(), 2);

		keys = dba.getKeys(SCF, null, null, 7);
		assertEquals(keys.size(), 7);

		keys = dba.getAllKeys(CF);
		assertEquals(keys.size(), 10);
		assertTrue(keys.contains("key0"));
		assertTrue(keys.contains("key6"));
		assertFalse(keys.contains("key-not-exist"));

		keys = dba.getAllKeys(SCF);
		assertEquals(keys.size(), 10);
		assertTrue(keys.contains("key1"));
		assertTrue(keys.contains("key7"));
		assertFalse(keys.contains("key-not-exist"));
	}

	@Test
	public void test_isKeyEmpty() {
		assertTrue(dba.isKeyEmpty(CF, "key-not-exist"));
		assertFalse(dba.isKeyEmpty(CF, "key0"));
		assertFalse(dba.isKeyEmpty(CF, "key3"));
		assertFalse(dba.isKeyEmpty(CF, "key9"));
		assertTrue(dba.isKeyEmpty(CF, "key10"));
		dba.deleteKey(CF, "key9");
		assertTrue(dba.isKeyEmpty(CF, "key9"));
		for (int i = 0; i < 10; i++)
			dba.deleteColumn(CF, "key0", CN.valueOf("column" + i));
		assertTrue(dba.isKeyEmpty(CF, "key0"));

		assertFalse(dba.isKeyEmpty(SCF, "key9"));
		dba.deleteKey(SCF, "key9");
		assertTrue(dba.isKeyEmpty(SCF, "key9"));
		assertFalse(dba.isKeyEmpty(SCF, "key0"));
		for (int i = 0; i < 10; i++)
			dba.deleteSuperColumn(SCF, "key0", i);
		assertTrue(dba.isKeyEmpty(SCF, "key0"));
	}

	@Test
	public void test_getKeysAndColumns_and_getAllKeysAndColumns() {
		List<Object> colNames = Arrays.asList((Object) CN.column3, CN.column6, CN.column9);
		Map<String, List<Column>> data = dba.getKeysAndColumns(CF, null, null, 1000, null, colNames);
		assertEquals(data.size(), 10);
		assertEquals(data.get("key0").size(), 3);
		List<Column> columns = data.get("key8");
		assertEquals(columns.size(), 3);
		ColumnMap<String> colMap = DBUtil.columnsToMap(columns);
		assertTrue(colMap.containsKey(CN.column3));
		assertTrue(colMap.containsKey(CN.column6));
		assertTrue(colMap.containsKey(CN.column9));
		assertEquals(colMap.get(CN.column6), "value6");

		data = dba.getKeysAndColumns(SCF, null, null, 100, 9l, colNames);
		assertEquals(data.size(), 10);
		assertEquals(data.get("key0").size(), 3);
		columns = data.get("key8");
		assertEquals(columns.size(), 3);
		colMap = DBUtil.columnsToMap(columns);
		assertTrue(colMap.containsKey(CN.column3));
		assertTrue(colMap.containsKey(CN.column6));
		assertTrue(colMap.containsKey(CN.column9));
		assertFalse(colMap.containsKey(CN.column_not_exist));
		assertEquals(colMap.get(CN.column6), "value6");

		data = dba.getAllKeysAndColumns(CF, null);
		assertEquals(data.size(), 10);
		Set<String> keys = data.keySet();
		assertTrue(keys.contains("key0"));
		assertTrue(keys.contains("key9"));
		assertTrue(keys.contains("key3"));
		assertFalse(keys.contains("key-not-exist"));
		colMap = DBUtil.columnsToMap(data.get("key9"));
		assertTrue(colMap.containsKey(CN.column3));
		assertTrue(colMap.containsKey(CN.column6));
		assertTrue(colMap.containsKey(CN.column9));
		assertFalse(colMap.containsKey(CN.column_not_exist));

		data = dba.getAllKeysAndColumns(SCF, null);
		assertEquals(data.size(), 10);
		assertTrue(keys.contains("key0"));
		assertTrue(keys.contains("key9"));
		assertTrue(keys.contains("key3"));
		assertFalse(keys.contains("key-not-exist"));
	}

	@Test
	public void test_deleteColumns() {
		assertEquals(dba.getAllColumns(CF, "key3").size(), 10);
		List<Object> colNames = Arrays.asList((Object) CN.column0, CN.column7, CN.column_not_exist);
		dba.deleteColumns(CF, "key3", null, colNames);
		assertEquals(dba.getAllColumns(CF, "key3").size(), 8);

		assertEquals(dba.getAllColumns(SCF, "key1", 5l).size(), 10);
		colNames = Arrays.asList((Object) CN.column4, CN.column9, CN.column_not_exist);
		dba.deleteColumns(SCF, "key1", 5l, colNames);
		assertEquals(dba.getAllColumns(SCF, "key1", 5l).size(), 8);
	}

	@Test
	public void test_getAllSuperColumns_and_deleteSuperColumns() {
		final String key = "key2";
		final String another_key = "key0";
		assertEquals(dba.getAllSuperColumns(SCF, key).size(), 10);
		assertEquals(dba.getAllSuperColumns(SCF, key, 9, true).size(), 10);
		try {
			dba.getAllSuperColumns(SCF, key, 1, true);
			fail("should throw exception for count: 1");
		} catch (Exception e) {
		}
		dba.deleteSuperColumns(SCF, key, Arrays.asList((Object) 0, 1, 5, 7));
		assertEquals(dba.getAllSuperColumns(SCF, key).size(), 6);
		dba.deleteSuperColumns(SCF, another_key, Arrays.asList((Object) 2, 3));
		assertEquals(dba.getAllSuperColumns(SCF, key).size(), 6);
		dba.deleteSuperColumns(SCF, key, Arrays.asList((Object) 0, 1, 5, 7));
		assertEquals(dba.getAllSuperColumns(SCF, key).size(), 6);
		dba.deleteSuperColumns(SCF, another_key, Arrays.asList((Object) 10001, 10002));
		assertEquals(dba.getAllSuperColumns(SCF, key).size(), 6);
		dba.deleteSuperColumns(SCF, key, new SuperColumn[]{DBUtil.createSuperColumn(9l, null, null),
				DBUtil.createSuperColumn(10l, null, null)});
		assertEquals(dba.getAllSuperColumns(SCF, key).size(), 5);
	}

	@Test
	public void test_deleteKey() {
		assertFalse(dba.isKeyEmpty(CF, "key0"));
		dba.deleteKey(CF, "key0");
		assertTrue(dba.isKeyEmpty(CF, "key0"));
		assertTrue(dba.isKeyEmpty(CF, "key-not-exist"));

		assertFalse(dba.isKeyEmpty(SCF, "key3"));
		dba.deleteKey(SCF, "key3");
		assertTrue(dba.isKeyEmpty(SCF, "key3"));
		assertTrue(dba.isKeyEmpty(SCF, "key-not-exist"));
	}

	@Test
	public void test_deleteSuperColumn() {
		assertEquals(dba.getAllSuperColumns(SCF, "key9").size(), 10);
		dba.deleteSuperColumn(SCF, "key9", 0l);
		assertEquals(dba.getAllSuperColumns(SCF, "key9").size(), 9);
		dba.deleteSuperColumn(SCF, "key9", 10001l);
		assertEquals(dba.getAllSuperColumns(SCF, "key9").size(), 9);
	}

	@Test
	public void test_deleteColumn() {
		assertEquals(dba.getAllColumns(CF, "key0").size(), 10);
		dba.deleteColumn(CF, "key0", CN.column0);
		dba.deleteColumn(CF, "key0", CN.column9);
		assertEquals(dba.getAllColumns(CF, "key0").size(), 8);
		dba.deleteColumn(CF, "key0", CN.column_not_exist);
		assertEquals(dba.getAllColumns(CF, "key0").size(), 8);
	}

	/**
	 * NOTE: Test this class manually! It has been excluded from the build.xml testing part.
	 */
	
}