package me.xhh.hector07;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
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.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import me.prettyprint.hector.api.beans.HColumn;
import me.prettyprint.hector.api.beans.HSuperColumn;
import me.xhh.hector06.DaoProvider;
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 project testing.
*/
private DBA dba;
private static final StringColumnFamily CF = new StringColumnFamily("Standard2");
private static final StringLongSuperColumnFamily SCF = new StringLongSuperColumnFamily("Super3");
@BeforeClass
public void prepareConnection() throws Exception {
dba = prepareDao(DBA.class, new DBConfig("localhost:9160", "Keyspace1", "Test Cluster", null, null));
}
@BeforeMethod
public void setUp() {
// prepare data for testing
List<String> keys = new ArrayList<String>(10);
List<HColumn<String, String>> columns = new ArrayList<HColumn<String, String>>(10);
// List<HSuperColumn<Long, String, String>> superCols = new ArrayList<HSuperColumn<Long, String, String>>(10);
List<HSuperColumn<Long, String, String>> superColsTypeLong = new ArrayList<HSuperColumn<Long, String, String>>(10);
for (int i = 0; i < 10; i++) {
keys.add("key" + i);
columns.add(CF.createColumn("column" + i, "value" + i));
}
for (int i = 0; i < 10; i++) {
// superCols.add( DBUtil.superColumn( "super" + i, columns ) );
superColsTypeLong.add(SCF.createSuperColumn(new Long(i), columns));
}
Map<String, List<HColumn<String, String>>> colMap = new HashMap<String, List<HColumn<String, String>>>(1);
colMap.put(CF.toString(), columns);
Map<String, List<HSuperColumn<Long, String, String>>> superColMap = new HashMap<String, List<HSuperColumn<Long, String, String>>>(
1);
superColMap.put(SCF.toString(), superColsTypeLong);
for (String key : keys) {
dba.insertColumns(CF, key, columns);
dba.insertSuperColumns(SCF, key, superColsTypeLong);
}
}
@Override
protected ColumnFamilyBase<?, ?, ?>[] getColumnFamilies() {
return new ColumnFamilyBase[]{CF, SCF};
}
@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<HColumn<String, String>> colList = new ArrayList<HColumn<String, String>>(2);
colList.add(CF.createColumn("name", "Alice"));
colList.add(CF.createColumn("title", "kid"));
// Map<String, List<HColumn<String, String>>> colMap = new HashMap<String,
// List<HColumn<String, String>>>(1);
// colMap.put( CF.name(), colList );
// Map<String, List<HSuperColumn<Long, String, String>>> superColMap = new HashMap<String,
// List<HSuperColumn<Long, String, String>>>(1);
List<HSuperColumn<Long, String, String>> superColList = new ArrayList<HSuperColumn<Long, String, String>>(2);
superColList.add(SCF.createSuperColumn(100l, colList));
SCF.addSuperColumn(100l, superColList, colList);
SCF.addSuperColumn(200l, superColList, colList);
// superColMap.put( SCF.name(), superColList );
dba.insertColumns(CF, key, colList);
dba.insertSuperColumns(SCF, key, superColList);
assertFalse(dba.isKeyEmpty(CF, key));
Map<String, 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<HSuperColumn<Long, String, String>> superCols = dba.getAllSuperColumns(SCF, key);
assertEquals(superCols.size(), 2);
HSuperColumn<Long, String, String> superCol0 = superCols.get(0);
Long superName0 = superCol0.getName();
assertTrue(superName0 == 100l || superName0 == 200l);
data = DBUtil.columnsToMap(superCol0.getColumns());
assertEquals(data.size(), 2);
assertEquals(data.get("name"), "Alice");
assertEquals(data.get("title"), "kid");
}
@Test
public void test_getValue() {
assertEquals(dba.getValue(CF, "key0", "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, "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", "column0"));
assertNull(dba.getValue(CF, "key0", "column1"));
assertNull(dba.getValue(CF, "key9", "column9"));
}
@Test
public void test_columnExists() {
assertTrue(dba.columnExists(CF, "key0", "column0"));
assertTrue(dba.columnExists(CF, "key5", "column9"));
assertTrue(dba.columnExists(CF, "key9", "column0"));
assertTrue(dba.columnExists(CF, "key9", "column9"));
assertFalse(dba.columnExists(CF, "key0", "column-not-exist"));
assertFalse(dba.columnExists(CF, "key-not-exist", "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, "column0"));
assertTrue(dba.columnExists(SCF, "key0", 0l, "column5"));
assertTrue(dba.columnExists(SCF, "key0", 9l, "column0"));
assertTrue(dba.columnExists(SCF, "key9", 0l, "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((col.name), "column0");
assertEquals((col.value), "value0");
assertNull(dba.getFirstColumn(CF, "key-not-exist"));
col = dba.getFirstColumn(SCF, "key0", 0l);
assertNotNull(col);
assertEquals((col.name), "column0");
assertEquals((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((colName), "column0");
assertNull(dba.getFirstColumnName(CF, "key-not-exist"));
colName = dba.getFirstColumnName(SCF, "key0", 0l);
assertEquals((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((col.name), "column9");
assertEquals((col.value), "value9");
assertNull(dba.getLastColumn(CF, "key-not-exist"));
col = dba.getLastColumn(SCF, "key7", 2l);
assertNotNull(col);
assertEquals((col.name), "column9");
assertEquals((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((colName), "column9");
assertNull(dba.getLastColumnName(CF, "key-not-exist"));
colName = dba.getLastColumnName(SCF, "key5", 7l);
assertEquals((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_getFirstSuperColumn() {
SuperColumn sc = dba.getFirstSuperColumn(SCF, "key0");
assertEquals(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(sc.getName()).longValue(), 9l);
assertEquals(10, sc.getColumns().size());
assertNull(dba.getLastSuperColumn(SCF, "key-not-exist"));
}
*/
@Test
public void test_getColumns_and_getAllColumns() {
assertEquals(dba.getColumns(CF, "key3", null, 5).size(), 5);
dba.deleteColumns(CF, "key3", "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", 7, false).size(), 10);
assertEquals(dba.getAllColumns(CF, "key0", 2, true).size(), 10);
List<String> colNames = new ArrayList<String>();
colNames.add("column0");
colNames.add("column1");
colNames.add("column6");
colNames.add("column9");
List<HColumn<String, String>> cols = dba.getColumns(CF, "key3", colNames.toArray(new String[colNames.size()]), null, null, 0,
false);
assertEquals(cols.size(), 4);
assertEquals((cols.get(0).getName()), "column0");
assertEquals((cols.get(0).getValue()), "value0");
assertEquals((cols.get(2).getValue()), "value6");
colNames.add("column_not_exist");
cols = dba.getColumns(CF, "key3", colNames.toArray(new String[0]), null, null, 0, false);
assertEquals(cols.size(), 4);
colNames.remove("column_not_exist");
cols = dba.getColumns(CF, "key5", null, null, null, 2, false);
assertEquals(cols.size(), 2);
assertEquals((cols.get(0).getName()), "column0");
assertEquals((cols.get(1).getValue()), "value1");
cols = dba.getColumns(CF, "key1", null, null, null, 2, true);
assertEquals(cols.size(), 2);
assertEquals((cols.get(0).getName()), "column9");
assertEquals((cols.get(0).getValue()), "value9");
assertEquals((cols.get(1).getValue()), "value8");
cols = dba.getColumns(CF, "key0", null, null, null, 100, false);
assertEquals(cols.size(), 10);
assertEquals((cols.get(0).getName()), "column0");
assertEquals((cols.get(0).getValue()), "value0");
assertEquals((cols.get(2).getValue()), "value2");
assertEquals((cols.get(9).getValue()), "value9");
cols = dba.getColumns(CF, "key0", "column8", "column5", 100, true);
assertEquals(cols.size(), 4);
assertEquals((cols.get(0).getName()), "column8");
assertEquals((cols.get(0).getValue()), "value8");
assertEquals((cols.get(1).getValue()), "value7");
assertEquals((cols.get(3).getValue()), "value5");
cols = dba.getColumns(CF, "key4", "column8", 100, false);
assertEquals(cols.size(), 2);
assertEquals((cols.get(0).getName()), "column8");
assertEquals((cols.get(1).getValue()), "value9");
cols = dba.getColumns(CF, "key9", "column2", 100, true);
assertEquals(cols.size(), 3);
assertEquals((cols.get(0).getName()), "column2");
assertEquals((cols.get(2).getValue()), "value0");
cols = dba.getColumns(CF, "key9", "column_not_exist", 100, false);
assertEquals(cols.size(), 0);
cols = dba.getColumns(CF, "key9", "column_not_exist", "column_not_exist_2");
assertEquals(cols.size(), 0);
cols = dba.getColumns(CF, "key-not-exist", null, 100);
assertEquals(cols.size(), 0);
cols = dba.getColumns(SCF, "key0", 0l, null, null, null, 100, false);
assertEquals(cols.size(), 10);
assertEquals((cols.get(0).getName()), "column0");
assertEquals((cols.get(0).getValue()), "value0");
assertEquals((cols.get(2).getValue()), "value2");
assertEquals((cols.get(9).getValue()), "value9");
cols = dba.getColumns(SCF, "key4", 3l, null, "column8", "column5", 100, true);
assertEquals(cols.size(), 4);
assertEquals((cols.get(0).getName()), "column8");
assertEquals((cols.get(0).getValue()), "value8");
assertEquals((cols.get(1).getValue()), "value7");
assertEquals((cols.get(3).getValue()), "value5");
cols = dba.getColumns(SCF, "key9", 8l, null, "column8", null, 100, false);
assertEquals(cols.size(), 2);
assertEquals((cols.get(0).getName()), "column8");
assertEquals((cols.get(1).getValue()), "value9");
cols = dba.getColumns(SCF, "key9", 0l, null, "column_not_exist", null, 100, false);
assertEquals(cols.size(), 0);
cols = dba.getColumns(SCF, "key9", 7l, "column_not_exist", "column_not_exist_2");
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<String> colNames = new ArrayList<String>();
colNames.add("column0");
colNames.add("column1");
colNames.add("column6");
colNames.add("column9");
colNames.add("column_not_exist");
Map<String, String> data = dba.getColumnsToMap(CF, "key3", colNames);
assertEquals(data.size(), 4);
assertEquals(data.get("column0"), "value0");
assertEquals(data.get("column1"), "value1");
assertEquals(data.get("column9"), "value9");
data = dba.getColumnsToMap(CF, "key-not-exist", colNames);
assertEquals(data.size(), 0);
}
@Test
public void test_getCount_getSuperCount() {
assertEquals(dba.getCount(CF, "key0"), 10);
dba.deleteColumn(CF, "key0", "column0");
assertEquals(dba.getCount(CF, "key0"), 9);
dba.deleteColumn(CF, "key0", "column5");
assertEquals(dba.getCount(CF, "key0"), 8);
dba.deleteColumn(CF, "key0", "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, "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() {
HSuperColumn<Long, String, String> sc = dba.getSuperColumn(SCF, "key0", 0l);
assertEquals(sc.getName().longValue(), 0l);
assertEquals(sc.getColumns().size(), 10);
assertEquals((sc.getColumns().iterator().next().getName()), "column0");
assertNull(dba.getSuperColumn(SCF, "key0", 10001l));
assertNull(dba.getSuperColumn(SCF, "key-not-exist", 0l));
}
@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", "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", new Long(i));
assertTrue(dba.isKeyEmpty(SCF, "key0"));
}
@Test
public void test_getKeysAndColumns_getAllKeysAndColumns_getNonemptyKeysAndColumns_getAllNonemptyKeysAndColumns_getNonemptyKeys_getAllNonempyKeys_getKeys_and_getAllKeys() {
String[] colNames = {"column3", "column6", "column9"};
assertTrue(dba.getKeysAndColumns(CF, null, null, 1000, colNames).size() >= 10);
Map<String, List<HColumn<String, String>>> data = dba.getNonemptyKeysAndColumns(CF, null, null, 1000, colNames);
assertEquals(data.size(), 10);
assertEquals(data.get("key0").size(), 3);
List<HColumn<String, String>> columns = data.get("key8");
assertEquals(columns.size(), 3);
Map<String, String> colMap = DBUtil.columnsToMap(columns);
assertTrue(colMap.containsKey("column3"));
assertTrue(colMap.containsKey("column6"));
assertTrue(colMap.containsKey("column9"));
assertEquals(colMap.get("column6"), "value6");
assertTrue(dba.getKeysAndColumns(SCF, null, null, 100, 9l, colNames).size() >= 10);
data = dba.getNonemptyKeysAndColumns(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("column3"));
assertTrue(colMap.containsKey("column6"));
assertTrue(colMap.containsKey("column9"));
assertFalse(colMap.containsKey("column_not_exist"));
assertEquals(colMap.get("column6"), "value6");
assertTrue(dba.getAllKeysAndColumns(CF).size() >= 10);
data = dba.getAllNonemptyKeysAndColumns(CF);
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("column3"));
assertTrue(colMap.containsKey("column6"));
assertTrue(colMap.containsKey("column9"));
assertFalse(colMap.containsKey("column_not_exist"));
assertTrue(dba.getAllKeys(CF).size() >= 10);
List<String> allKeys = dba.getAllNonemptyKeys(CF);
assertEquals(allKeys.size(), 10);
assertTrue(allKeys.contains("key0"));
assertTrue(allKeys.contains("key9"));
assertTrue(allKeys.contains("key3"));
assertTrue(dba.getAllKeysAndColumns(SCF, 0L).size() >= 10);
data = dba.getAllNonemptyKeysAndColumns(SCF, 0L);
assertEquals(data.size(), 10);
keys = data.keySet();
assertTrue(keys.contains("key0"));
assertTrue(keys.contains("key9"));
assertTrue(keys.contains("key3"));
assertFalse(keys.contains("key-not-exist"));
assertTrue(dba.getAllKeys(SCF).size() >= 10);
allKeys = dba.getAllNonemptyKeys(SCF);
assertEquals(allKeys.size(), 10);
assertTrue(allKeys.contains("key1"));
assertTrue(allKeys.contains("key2"));
assertTrue(allKeys.contains("key7"));
assertFalse(allKeys.contains("key-not-exist"));
}
@Test
public void test_deleteColumns() {
assertEquals(dba.getAllColumns(CF, "key3").size(), 10);
String[] colNames = {"column0", "column7", "column_not_exist"};
dba.deleteColumns(CF, "key3", colNames);
assertEquals(dba.getAllColumns(CF, "key3").size(), 8);
assertEquals(dba.getAllColumns(SCF, "key1", 5l).size(), 10);
colNames = new String[]{"column4", "column9", "column_not_exist"};
dba.deleteColumns(SCF, "key1", 5l, colNames);
assertEquals(dba.getAllColumns(SCF, "key1", 5l).size(), 8);
}
@SuppressWarnings("unchecked")
@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, 0L, 1L, 5L, 7L);
assertEquals(dba.getAllSuperColumns(SCF, key).size(), 6);
dba.deleteSuperColumns(SCF, another_key, 2L, 3L);
assertEquals(dba.getAllSuperColumns(SCF, key).size(), 6);
dba.deleteSuperColumns(SCF, key, 0L, 1L, 5L, 7L);
assertEquals(dba.getAllSuperColumns(SCF, key).size(), 6);
dba.deleteSuperColumns(SCF, another_key, 10001L, 10002L);
assertEquals(dba.getAllSuperColumns(SCF, key).size(), 6);
List<HColumn<String, String>> columns = new ArrayList<HColumn<String, String>>();
for (int i = 0; i < 10; i++) {
SCF.addColumn("column" + i, "", columns);
}
dba.deleteSuperColumns(SCF, key, SCF.createSuperColumn(9L, columns), SCF.createSuperColumn(10L, columns));
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", "column0");
dba.deleteColumn(CF, "key0", "column9");
assertEquals(dba.getAllColumns(CF, "key0").size(), 8);
dba.deleteColumn(CF, "key0", "column_not_exist");
assertEquals(dba.getAllColumns(CF, "key0").size(), 8);
}
/**
* NOTE: Test this class manually! It has been excluded from the project testing.
*/
}