public void testDelete()
{
// create the ConditionalIndex to be tested
IValueExtractor extractor = new IdentityExtractor();
IFilter filter = new LessFilter(extractor, 15);
var mapIndex = new ConditionalIndex(filter, extractor, true, null, true);
// define the keys and values
const string oKey = "key";
Object oValue = 1;
Object oExtracted = 1;
ICacheEntry entry = new CacheEntry(oKey, oValue, oValue);
// begin test
// verify that the index does not contain a value for the tested keys
Assert.AreEqual(ObjectUtils.NO_VALUE, mapIndex.Get(oKey));
// insert into the index
mapIndex.Insert(entry);
object extractedValue = mapIndex.Get(oKey);
Assert.AreEqual(oExtracted, extractedValue,
"The index should contain the extracted value for key.");
mapIndex.Delete(entry);
Assert.AreEqual(ObjectUtils.NO_VALUE, mapIndex.Get(oKey));
}
public void testGet()
{
IDictionary map = new HashDictionary {
{ "one", 1 }, { "two", 2 },
{ "three", 3 }, { "four", 4 }, { "five", 5 }
};
IValueExtractor extractor = new IdentityExtractor();
IFilter filter = new LessFilter(extractor, 5);
ConditionalIndex index = createIndex(map, filter, extractor, true);
Assert.AreEqual(1, index.Get("one"));
Assert.AreEqual(2, index.Get("two"));
Assert.AreEqual(3, index.Get("three"));
Assert.AreEqual(4, index.Get("four"));
Assert.AreEqual(ObjectUtils.NO_VALUE, index.Get("five"));
// forward map support == false
index = createIndex(map, filter, extractor, false);
Assert.AreEqual(ObjectUtils.NO_VALUE, index.Get("one"));
Assert.AreEqual(ObjectUtils.NO_VALUE, index.Get("two"));
Assert.AreEqual(ObjectUtils.NO_VALUE, index.Get("three"));
Assert.AreEqual(ObjectUtils.NO_VALUE, index.Get("four"));
Assert.AreEqual(ObjectUtils.NO_VALUE, index.Get("five"));
}
public void testInsert_forwardIndexFalse()
{
// create the ConditionalIndex to be tested
IValueExtractor extractor = new IdentityExtractor();
IFilter filter = new LessFilter(extractor, 15);
var mapIndex = new ConditionalIndex(filter, extractor, true, null, false);
// define the keys and values for the mock entries
const string oKey = "key";
Object oValue = 1;
const string oKey2 = "key2";
Object oValue2 = 2;
const string oKey3 = "key3";
Object oValue3 = 25;
ICacheEntry entry = new CacheEntry(oKey, oValue);
ICacheEntry entry2 = new CacheEntry(oKey2, oValue2);
ICacheEntry entry3 = new CacheEntry(oKey3, oValue3);
// verify that the index does not contain a value for the tested keys
Assert.AreEqual(ObjectUtils.NO_VALUE, mapIndex.Get(oKey));
Assert.AreEqual(ObjectUtils.NO_VALUE, mapIndex.Get(oKey2));
Assert.AreEqual(ObjectUtils.NO_VALUE, mapIndex.Get(oKey3));
// insert into the index
mapIndex.Insert(entry);
mapIndex.Insert(entry2);
mapIndex.Insert(entry3);
// all gets should return NO_VALUE since forward index is not supported
// verify no value from the index for key
object oIndexValue = mapIndex.Get(oKey);
Assert.AreEqual(ObjectUtils.NO_VALUE, oIndexValue);
// verify no value from the index for key2
object oIndexValue2 = mapIndex.Get(oKey2);
Assert.AreEqual(ObjectUtils.NO_VALUE, oIndexValue2);
// verify no value in the index for key3
object oIndexValue3 = mapIndex.Get(oKey3);
Assert.AreEqual(ObjectUtils.NO_VALUE, oIndexValue3);
// verify that the value for key and key2 is the same instance
Assert.AreSame(oIndexValue, oIndexValue2,
"The value for key and key2 should be the same instance.");
// get the inverse map
IDictionary mapInverse = mapIndex.IndexContents;
// get the entry from the inverse map keyed by the extracted value
var inverseEntry = mapInverse[oValue] as HashSet;
Assert.IsNotNull(inverseEntry);
// verify that the set of keys contains key
Assert.IsTrue(inverseEntry.Contains(oKey),
"The index's inverse map should contain the key.");
}
public void testUpdate_forwardIndexFalse()
{
// create the ConditionalIndex to be tested
IValueExtractor extractor = new IdentityExtractor();
IFilter filter = new LessFilter(extractor, 15);
var mapIndex = new ConditionalIndex(filter, extractor, true, null, false);
// define the keys and values
const string oKey = "key";
Object oValue = 0;
Object oExtracted = 0;
Object oNewValue = 1;
Object oExtractedNew = 1;
const string oKey2 = "key2";
Object oValue2 = 2;
Object oExtracted2 = 2;
const string oKey3 = "key3";
Object oValue3 = 21;
Object oNewValue2 = 4;
Object oExtractedNew2 = 4;
ICacheEntry entry = new CacheEntry(oKey, oValue);
ICacheEntry entry2 = new CacheEntry(oKey2, oValue2, oValue);
ICacheEntry entry3 = new CacheEntry(oKey3, oValue3, oValue2);
ICacheEntry entryNew = new CacheEntry(oKey, oNewValue, oValue);
ICacheEntry entryNew2 = new CacheEntry(oKey2, oNewValue2, oValue2);
// begin test
// verify that the index does not contain a value for the tested keys
Assert.AreEqual(ObjectUtils.NO_VALUE, mapIndex.Get(oKey));
Assert.AreEqual(ObjectUtils.NO_VALUE, mapIndex.Get(oKey2));
Assert.AreEqual(ObjectUtils.NO_VALUE, mapIndex.Get(oKey3));
// insert into the index
mapIndex.Insert(entry); // key, oExtracted
mapIndex.Insert(entry2); // key, oExtracted2
mapIndex.Insert(entry3); // key, oExtracted3
// all gets should return NO_VALUE since forward index is not supported
// verify no value from the index for key
object oIndexValue = mapIndex.Get(oKey);
Assert.AreEqual(ObjectUtils.NO_VALUE, oIndexValue);
// verify no value from the index for key2
object oIndexValue2 = mapIndex.Get(oKey2);
Assert.AreEqual(ObjectUtils.NO_VALUE, oIndexValue2);
// verify no value in the index for key3
object oIndexValue3 = mapIndex.Get(oKey3);
Assert.AreEqual(ObjectUtils.NO_VALUE, oIndexValue3);
// update the index
mapIndex.Update(entryNew); // key, oExtractedNew
mapIndex.Update(entryNew2); // key2, oExtractedNew2
// all gets should return NO_VALUE since forward index is not supported
// verify no value from the index for key
oIndexValue = mapIndex.Get(oKey);
Assert.AreEqual(ObjectUtils.NO_VALUE, oIndexValue);
oIndexValue2 = mapIndex.Get(oKey2);
Assert.AreEqual(ObjectUtils.NO_VALUE, oIndexValue2);
// get the inverse map
var mapInverse = (SynchronizedDictionary)mapIndex.IndexContents;
// get the set of keys from the inverse map keyed by the extracted
// value for key
var set = mapInverse[oExtractedNew] as HashSet;
Assert.IsNotNull(set);
// verify that the set of keys contains key
Assert.IsTrue(set.Contains(oKey),
"The index's inverse map should contain the key.");
// get the set of keys from the inverse map keyed by the old extracted
// value for key
set = (HashSet)mapInverse[oExtracted];
// verify that the set of keys does not contain key
Assert.IsTrue(set == null || !set.Contains(oKey),
"The index's inverse map should not contain the key for the old extracted value.");
// get the set of keys from the inverse map keyed by the extracted
// value for key2
set = mapInverse[oExtractedNew2] as HashSet;
Assert.IsNotNull(set);
// verify that the set of keys contains key2
Assert.IsTrue(set.Contains(oKey2),
"The index's inverse map should contain the key2.");
// get the set of keys from the inverse map keyed by the old extracted
// value for key2
set = mapInverse[oExtracted2] as HashSet;
// verify that the set of keys does not contain key2
Assert.IsTrue(set == null || !set.Contains(oKey2),
"The index's inverse map should not contain key2 for the old extracted value.");
}
public void testUpdate()
{
// create the ConditionalIndex to be tested
IValueExtractor extractor = new IdentityExtractor();
IFilter filter = new LessFilter(extractor, 15);
var mapIndex = new ConditionalIndex(filter, extractor, true, null, true);
// define the keys and values
const string oKey = "key";
Object oValue = 0;
Object oExtracted = 0;
const string oKey2 = "key2";
Object oValue2 = 11;
Object oExtracted2 = 11;
const string oKey3 = "key3";
Object oValue3 = 21;
Object oExtracted3 = 21;
Object oNewValue = oValue2;
Object oExtractedNew = 11;
Object oNewValue2 = 30;
Object oExtractedNew2 = 30;
ICacheEntry entry = new CacheEntry(oKey, oValue);
ICacheEntry entry2 = new CacheEntry(oKey2, oValue2);
ICacheEntry entry3 = new CacheEntry(oKey3, oValue3);
ICacheEntry entryNew = new CacheEntry(oKey, oNewValue, oValue);
ICacheEntry entryNew2 = new CacheEntry(oKey2, oNewValue2, oValue2);
// begin test
// verify that the index does not contain a value for the tested keys
Assert.AreEqual(ObjectUtils.NO_VALUE, mapIndex.Get(oKey));
Assert.AreEqual(ObjectUtils.NO_VALUE, mapIndex.Get(oKey2));
Assert.AreEqual(ObjectUtils.NO_VALUE, mapIndex.Get(oKey3));
// insert into the index
mapIndex.Insert(entry); //key (extracted value : 0)
mapIndex.Insert(entry2); //key2 (extracted value : 2)
mapIndex.Insert(entry3); //key3 (extracted value : 21)
// verify the value from the index for key
object oIndexValue = mapIndex.Get(oKey);
Assert.AreEqual(oExtracted, oIndexValue,
"The index should contain the extracted value for key.");
// verify the value from the index for key2
object oIndexValue2 = mapIndex.Get(oKey2);
Assert.AreEqual(oExtracted2, oIndexValue2,
"The index should contain the extracted value for key2.");
// since the extracted value (21) for key3 fails the filter check
// LessFilter(extractor, new Integer(15)), it should not be part of
// the index
object oIndexValue3 = mapIndex.Get(oKey3);
Assert.AreEqual(ObjectUtils.NO_VALUE, oIndexValue3);
// get the inverse map
var mapInverse = (SynchronizedDictionary)mapIndex.IndexContents;
// assert the the inverse map does contain an entry for the
// extracted values for key
Assert.IsTrue(mapInverse.Contains(oExtracted));
// assert that the set mapped to the extracted value for key contains
// key
var set = mapInverse[oExtracted] as HashSet;
Assert.IsNotNull(set);
Assert.IsTrue(set.Contains(oKey),
"The index's inverse map should contain the key.");
// assert the the inverse map does contain an entry for the
// extracted values for key2
Assert.IsTrue(mapInverse.Contains(oExtracted2));
// assert that the set mapped to the extracted value for key2 contains
// key2
set = mapInverse[oExtracted2] as HashSet;
Assert.IsNotNull(set);
Assert.IsTrue(set.Contains(oKey2),
"The index's inverse map should contain the key2.");
// assert the the inverse map does not contain an entry for the
// extracted value for key3
Assert.IsFalse(mapInverse.Contains(oExtracted3));
// update the index
mapIndex.Update(entryNew); // key (extracted value : 11)
mapIndex.Update(entryNew2); // key2 (extracted value : 30)
// assert the the index now contains the updated value for key
oIndexValue = mapIndex.Get(oKey);
Assert.AreEqual(oExtractedNew, oIndexValue,
"The index should contain the updated value for key.");
// assert that the instance for the extracted value 11 is reused
Assert.AreSame(oIndexValue, oIndexValue2,
"The value for key and key2 should be the same instance.");
// verify the value for key2 is no longer available from the index
// since the updated extracted value (30) for key2 fails the filter
// check : LessFilter(extractor, new Integer(15)), it should not be
// part of the index
oIndexValue2 = mapIndex.Get(oKey2);
Assert.AreEqual(ObjectUtils.NO_VALUE, oIndexValue2,
"The index should not contain the extracted value for key2.");
// assert the inverse map does contain an entry for the
// extracted value for key
mapInverse = (SynchronizedDictionary)mapIndex.IndexContents;
Assert.IsTrue(mapInverse.Contains(oExtractedNew));
// assert that the set mapped to the old extracted value for key
// no longer contains key... result of update
set = mapInverse[oExtracted] as HashSet;
Assert.IsTrue(set == null || !set.Contains(oKey),
"The index's inverse map should not contain key.");
// assert that the set mapped to the extracted value for key contains
// key
set = mapInverse[oExtractedNew] as HashSet;
Assert.IsNotNull(set);
Assert.IsTrue(set.Contains(oKey), "The index's inverse map should contain key.");
// assert that the set mapped to the old extracted value for key2
// no longer contains key2... result of update
set = mapInverse[oExtracted2] as HashSet;
Assert.IsTrue(set == null || !set.Contains(oKey2),
"The index's inverse map should not contain key2.");
// assert the the inverse map does not contain an entry for the new
// extracted value for key2... fails filter check
set = mapInverse[oExtractedNew2] as HashSet;
Assert.IsTrue(set == null || !set.Contains(oKey2),
"The index's inverse map should not contain key2.");
}
public void testInsert()
{
// create the ConditionalIndex to be tested
IValueExtractor extractor = new IdentityExtractor();
IFilter filter = new LessFilter(extractor, 15);
var mapIndex = new ConditionalIndex(filter, extractor, true, null, true);
// define the keys and values for the mock entries
const string oKey = "key";
Object oValue = 11;
const string oKey2 = "key2";
Object oValue2 = oValue;
const string oKey3 = "key3";
Object oValue3 = 25;
ICacheEntry entry = new CacheEntry(oKey, oValue);
ICacheEntry entry2 = new CacheEntry(oKey2, oValue2);
ICacheEntry entry3 = new CacheEntry(oKey3, oValue3);
// begin test
// verify that the index does not contain a value for the tested keys
Assert.AreEqual(ObjectUtils.NO_VALUE, mapIndex.Get(oKey));
Assert.AreEqual(ObjectUtils.NO_VALUE, mapIndex.Get(oKey2));
Assert.AreEqual(ObjectUtils.NO_VALUE, mapIndex.Get(oKey3));
// assert the the inverse map does not contain an entry for the extracted values
Assert.IsFalse(mapIndex.IndexContents.Contains(oValue));
Assert.IsFalse(mapIndex.IndexContents.Contains(oValue2));
// insert into the index
mapIndex.Insert(entry);
mapIndex.Insert(entry2);
mapIndex.Insert(entry3);
// verify the value from the index for key
object oIndexValue = mapIndex.Get(oKey);
Assert.AreEqual(oValue, oIndexValue);
// verify the value from the index for key2
object oIndexValue2 = mapIndex.Get(oKey2);
Assert.AreEqual(oValue2, oIndexValue2);
// verify no value in the index for key3
object oIndexValue3 = mapIndex.Get(oKey3);
Assert.AreEqual(ObjectUtils.NO_VALUE, oIndexValue3);
// verify that the value for key and key2 is the same instance
Assert.AreSame(oIndexValue, oIndexValue2);
// get the inverse map
var mapInverse = (SynchronizedDictionary)mapIndex.IndexContents;
// get the entry from the inverse map keyed by the extracted value
var inverseEntry = mapInverse[oValue] as HashSet;
Assert.IsNotNull(inverseEntry);
Assert.IsNotEmpty(inverseEntry);
Assert.IsTrue(inverseEntry.Contains(oKey));
// get the entry from the inverse map keyed by the extracted value
var inverseEntry2 = mapInverse[oIndexValue2] as HashSet;
Assert.IsNotNull(inverseEntry2);
Assert.IsNotEmpty(inverseEntry2);
// verify that the set of keys contains key
Assert.IsTrue(inverseEntry2.Contains(oKey2));
// get the set of keys from the inverse map keyed by the extracted
// value for key
var set = mapInverse[oIndexValue] as HashSet;
Assert.IsNotNull(set);
// verify that the set of keys contains key
Assert.IsTrue(set.Contains(oKey));
// get the set of keys from the inverse map keyed by the extracted
// value for key2
set = mapInverse[oIndexValue2] as HashSet;
Assert.IsNotNull(set);
// verify that the set of keys contains key2
Assert.IsTrue(set.Contains(oKey2));
}
