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 NearCacheListenNoneAggregateTest()
{
LocalNamedCache localcache = new LocalNamedCache();
INamedCache safecache = CacheFactory.GetCache(CacheName);
NearCache nearcache = new NearCache(localcache, safecache, CompositeCacheStrategyType.ListenNone);
nearcache.Clear();
Hashtable ht = new Hashtable();
ht.Add("Aleks", 1);
ht.Add("Ana", 2);
ht.Add("Goran", 3);
ht.Add("Ivan", 4);
nearcache.InsertAll(ht);
IEntryAggregator aggregator = new Count();
object count = nearcache.Aggregate(nearcache.Keys, aggregator);
Assert.AreEqual(ht.Count, count);
IFilter filter = new LessFilter(IdentityExtractor.Instance, 3);
count = nearcache.Aggregate(filter, aggregator);
Assert.AreEqual(2, count);
nearcache.Clear();
nearcache.Release();
Assert.IsFalse(nearcache.IsActive);
CacheFactory.Shutdown();
}
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 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 TestGetValues()
{
IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;
IXmlDocument config = XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-local-cache-config.xml");
ccf.Config = config;
INamedCache cache = CacheFactory.GetCache("local-default");
cache.Clear();
Hashtable ht = new Hashtable();
ht.Add("key1", 100.0);
ht.Add("key2", 80.5);
ht.Add("key3", 19.5);
ht.Add("key4", 2.0);
cache.InsertAll(ht);
Assert.AreEqual(4, cache.Count);
IFilter lessFilter = new LessFilter(IdentityExtractor.Instance, 80.5);
object[] result = cache.GetValues(lessFilter);
Assert.AreEqual(2, result.Length);
foreach (object o in result)
{
Assert.IsTrue((Convert.ToDouble(o) == 19.5) || (Convert.ToDouble(o) == 2.0));
}
CacheFactory.Shutdown();
}
public void SetUp()
{
string nestedDependencyFilename = Path.Combine("a", "b", "variables.less");
string nestedDependencyText = "@import \"dependency.less\";";
dependencyFilename = Path.Combine("a", "b", "dependency.less");
var dependencyText = "@color: #4D926F;";
source = "@import \"variables.less\";#header {color: @color;}h2 {color: @color;}";
expected = "#header{color:#4d926f}h2{color:#4d926f}";
arguments = new Dictionary <string, object> {
{
"item",
new Dictionary <string, object> {
{ "filename", Path.Combine("a", "b", "c.less") }
}
}
};
fileSystem = Substitute.For <IFileSystem>();
fileSystem.FileExists(nestedDependencyFilename).Returns(true);
fileSystem.ReadStringFromFile(nestedDependencyFilename).Returns(nestedDependencyText);
fileSystem.FileExists(dependencyFilename).Returns(true);
fileSystem.ReadStringFromFile(dependencyFilename).Returns(dependencyText);
lessFilter = new LessFilter(fileSystem);
}
public void TestConditionalRemove()
{
ConditionalRemove conditionalRemove = new ConditionalRemove(new GreaterFilter(IdentityExtractor.Instance, 100), true);
ConditionalRemove conditionalRemove1 = new ConditionalRemove(new GreaterFilter(IdentityExtractor.Instance, 100), true);
Assert.AreEqual(conditionalRemove, conditionalRemove1);
Assert.AreEqual(conditionalRemove.ToString(), conditionalRemove1.ToString());
Assert.AreEqual(conditionalRemove.GetHashCode(), conditionalRemove1.GetHashCode());
IInvocableCacheEntry entry = new LocalCache.Entry(new LocalCache(), "key1", 1200);
Object result = conditionalRemove.Process(entry);
Assert.IsNull(entry.Value);
entry = new LocalCache.Entry(new LocalCache(), "key1", 50);
result = conditionalRemove.Process(entry);
Assert.AreEqual(50, entry.Value);
// testing on remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Hashtable ht = new Hashtable();
ht.Add("conditionalPutAllKey1", 435);
ht.Add("conditionalPutAllKey2", 253);
ht.Add("conditionalPutAllKey3", 200);
ht.Add("conditionalPutAllKey4", 333);
cache.InsertAll(ht);
IFilter greaterThen300 = new GreaterFilter(IdentityExtractor.Instance, 300);
IFilter lessThen300 = new LessFilter(IdentityExtractor.Instance, 300);
Assert.IsTrue(cache.Count == 4);
// remove key1 with greaterThen300 filter applied
ConditionalRemove processor = new ConditionalRemove(greaterThen300, false);
cache.Invoke("conditionalPutAllKey1", processor);
Assert.IsTrue(cache.Count == 3);
// remove all entries that satisfy filter criteria
processor = new ConditionalRemove(greaterThen300, false);
cache.InvokeAll(ht.Keys, processor);
Assert.IsTrue(cache.Count == 2);
Assert.IsNotNull(cache["conditionalPutAllKey2"]);
Assert.IsNotNull(cache["conditionalPutAllKey3"]);
processor = new ConditionalRemove(lessThen300, false);
cache.InvokeAll(new GreaterFilter(IdentityExtractor.Instance, 200), processor);
Assert.IsTrue(cache.Count == 1);
Assert.IsNotNull(cache["conditionalPutAllKey3"]);
CacheFactory.Shutdown();
}
public void testGetIndexContents()
{
var map = new HashDictionary
{
{ "one", 1 },
{ "another_one", 1 },
{ "one_more", 1 },
{ "two", 2 },
{ "three", 3 },
{ "four", 4 },
{ "four_again", 4 },
{ "five", 5 },
{ "five_a", 5 },
{ "five_b", 5 },
{ "five_c", 5 },
{ "five_d", 5 }
};
IValueExtractor extractor = new IdentityExtractor();
IFilter filter = new LessFilter(extractor, 5);
ConditionalIndex index = createIndex(map, filter, extractor, true);
IDictionary indexContents = index.IndexContents;
var setOne = indexContents[1] as HashSet;
Assert.IsNotNull(setOne);
Assert.AreEqual(3, setOne.Count);
Assert.IsTrue(setOne.Contains("one"));
Assert.IsTrue(setOne.Contains("another_one"));
Assert.IsTrue(setOne.Contains("one_more"));
var setTwo = indexContents[2] as HashSet;
Assert.IsNotNull(setTwo);
Assert.AreEqual(1, setTwo.Count);
Assert.IsTrue(setTwo.Contains("two"));
var setThree = indexContents[3] as HashSet;
Assert.IsNotNull(setThree);
Assert.AreEqual(1, setThree.Count);
Assert.IsTrue(setThree.Contains("three"));
var setFour = indexContents[4] as HashSet;
Assert.IsNotNull(setFour);
Assert.AreEqual(2, setFour.Count);
Assert.IsTrue(setFour.Contains("four"));
Assert.IsTrue(setFour.Contains("four_again"));
var setFive = indexContents[5] as ICollection;
Assert.IsNull(setFive);
}
public void TestRemove()
{
IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;
IXmlDocument config = XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-local-cache-config.xml");
ccf.Config = config;
INamedCache cache = CacheFactory.GetCache("local-default");
cache.Clear();
Hashtable ht = new Hashtable();
ht.Add("conditionalPutAllKey1", 435);
ht.Add("conditionalPutAllKey2", 253);
ht.Add("conditionalPutAllKey3", 200);
ht.Add("conditionalPutAllKey4", 333);
cache.InsertAll(ht);
IFilter greaterThen300 = new GreaterFilter(IdentityExtractor.Instance, 300);
IFilter lessThen300 = new LessFilter(IdentityExtractor.Instance, 300);
IFilter key3 = new LikeFilter(new KeyExtractor(IdentityExtractor.Instance), "%Key3", '\\', false);
Assert.IsTrue(cache.Count == 4);
// remove key1 with greaterThen300 filter applied
ConditionalRemove processor = new ConditionalRemove(greaterThen300, false);
cache.Invoke("conditionalPutAllKey1", processor);
Assert.IsTrue(cache.Count == 3);
// remove all entries that satisfy filter criteria
processor = new ConditionalRemove(greaterThen300, false);
cache.InvokeAll(ht.Keys, processor);
Assert.IsTrue(cache.Count == 2);
Assert.IsNotNull(cache["conditionalPutAllKey2"]);
Assert.IsNotNull(cache["conditionalPutAllKey3"]);
processor = new ConditionalRemove(lessThen300, false);
cache.InvokeAll(new GreaterFilter(IdentityExtractor.Instance, 200), processor);
Assert.IsTrue(cache.Count == 1);
Assert.IsNotNull(cache["conditionalPutAllKey3"]);
processor = new ConditionalRemove(key3, false);
cache.InvokeAll(new GreaterFilter(IdentityExtractor.Instance, 100), processor);
Assert.IsTrue(cache.Count == 0);
CacheFactory.Shutdown();
}
public void TestConditional()
{
IFilter lessThen250 = new LessFilter(IdentityExtractor.Instance, 250);
ConditionalProcessor condProcessor = new ConditionalProcessor(new GreaterFilter(IdentityExtractor.Instance, 200), new ConditionalRemove(lessThen250, false));
ConditionalProcessor condProcessor1 = new ConditionalProcessor(new GreaterFilter(IdentityExtractor.Instance, 200), new ConditionalRemove(lessThen250, false));
Assert.AreEqual(condProcessor, condProcessor1);
Assert.AreEqual(condProcessor.GetHashCode(), condProcessor1.GetHashCode());
Assert.AreEqual(condProcessor.ToString(), condProcessor1.ToString());
LocalCache.Entry entry = new LocalCache.Entry(new LocalCache(), "key1", 225);
condProcessor.Process(entry);
Assert.IsNull(entry.Value);
entry = new LocalCache.Entry(new LocalCache(), "key1", 150);
condProcessor.Process(entry);
Assert.AreEqual(150, entry.Value);
// testing on Remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Hashtable ht = new Hashtable();
ht.Add("conditionalKey1", 200);
ht.Add("conditionalKey2", 250);
ht.Add("conditionalKey3", 300);
ht.Add("conditionalKey4", 400);
cache.InsertAll(ht);
IFilter lessThen300 = new LessFilter(IdentityExtractor.Instance, 300);
ConditionalProcessor processor = new ConditionalProcessor(new GreaterFilter(IdentityExtractor.Instance, 200), new ConditionalRemove(lessThen300, false));
Assert.IsTrue(cache.Count == 4);
cache.Invoke("conditionalKey4", processor);
Assert.IsTrue(cache.Count == 4);
cache.Invoke("conditionalKey3", processor);
Assert.IsTrue(cache.Count == 4);
cache.Invoke("conditionalKey2", processor);
Assert.IsTrue(cache.Count == 3);
CacheFactory.Shutdown();
}
public void should_be_able_to_transform_source()
{
string source = "@color: #4D926F;#header {color: @color;}h2 {color: @color;}";
string expected = "#header{color:#4d926f}h2{color:#4d926f}";
var arguments = new Dictionary <string, object> {
{
"item",
new Dictionary <string, object> {
{ "filename", Path.Combine("a", "b", "c.less") }
}
}
};
var fileSystem = Substitute.For <IFileSystem>();
var lessFilter = new LessFilter(fileSystem);
string result = lessFilter.Execute(source, arguments);
result.ShouldBe(expected);
}
public void testDelete_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;
Object oExtracted = 1;
ICacheEntry entry = new CacheEntry(oKey, oValue);
ICacheEntry delEntry = new CacheEntry(oKey, oValue, oValue);
// begin test
// assert the the inverse map does not contain an entry for the extracted value
Assert.IsFalse(mapIndex.IndexContents.Contains(oExtracted));
// insert into the index
mapIndex.Insert(entry);
// assert the the inverse map does contain an entry for the extracted value
Assert.IsTrue(mapIndex.IndexContents.Contains(oExtracted));
mapIndex.Delete(delEntry);
// 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 = (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 extracted value.");
}
public void TestConditional()
{
IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;
IXmlDocument config = XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-local-cache-config.xml");
ccf.Config = config;
INamedCache cache = CacheFactory.GetCache("local-default");
cache.Clear();
Hashtable ht = new Hashtable();
ht.Add("conditionalKey1", 200);
ht.Add("conditionalKey2", 250);
ht.Add("conditionalKey3", 300);
ht.Add("conditionalKey4", 400);
cache.InsertAll(ht);
IFilter lessThen300 = new LessFilter(IdentityExtractor.Instance, 300);
ConditionalProcessor processor = new ConditionalProcessor(
new GreaterFilter(IdentityExtractor.Instance, 200),
new ConditionalRemove(lessThen300, false));
Assert.IsTrue(cache.Count == 4);
cache.Invoke("conditionalKey4", processor);
Assert.IsTrue(cache.Count == 4);
cache.Invoke("conditionalKey3", processor);
Assert.IsTrue(cache.Count == 4);
cache.Invoke("conditionalKey2", processor);
Assert.IsTrue(cache.Count == 3);
CacheFactory.Shutdown();
}
public void NearCacheListenNoneInvokeAllTest()
{
LocalNamedCache localcache = new LocalNamedCache();
INamedCache safecache = CacheFactory.GetCache(CacheName);
NearCache nearcache = new NearCache(localcache, safecache, CompositeCacheStrategyType.ListenNone);
nearcache.Clear();
Hashtable ht = new Hashtable();
ht.Add("Aleks", 1);
ht.Add("Ana", 2);
ht.Add("Goran", 3);
ht.Add("Ivan", 4);
nearcache.InsertAll(ht);
Hashtable htput = new Hashtable();
htput.Add("Aleks", 195);
htput.Add("Ana", 205);
IFilter filter = new LessFilter(IdentityExtractor.Instance, 2);
IEntryProcessor processor = new ConditionalPutAll(AlwaysFilter.Instance, htput);
nearcache.InvokeAll(filter, processor);
Assert.AreEqual(195, nearcache.BackCache["Aleks"]);
Assert.AreEqual(2, nearcache.BackCache["Ana"]);
nearcache.InvokeAll(htput.Keys, processor);
Assert.AreEqual(205, nearcache.BackCache["Ana"]);
nearcache.Clear();
nearcache.Release();
Assert.IsFalse(nearcache.IsActive);
CacheFactory.Shutdown();
}
public void TestDistinctValuesAggregator()
{
DistinctValues agg1 = new DistinctValues(IdentityExtractor.Instance);
Assert.IsNotNull(agg1);
Assert.AreSame(IdentityExtractor.Instance, agg1.Extractor);
DistinctValues agg2 = new DistinctValues("dummy");
Assert.IsNotNull(agg2);
Assert.IsInstanceOf(typeof(ReflectionExtractor), agg2.Extractor);
DistinctValues agg3 = new DistinctValues("another.dummy");
Assert.IsNotNull(agg3);
Assert.IsInstanceOf(typeof(ChainedExtractor), agg3.Extractor);
ArrayList al = new ArrayList();
al.Add(new TestInvocableCacheEntry("Ivan", 173));
al.Add(new TestInvocableCacheEntry("Milica", 173));
al.Add(new TestInvocableCacheEntry("Goran", 185));
al.Add(new TestInvocableCacheEntry("Ana", 164));
ICollection coll = (ICollection)agg1.Aggregate(al);
Assert.AreEqual(3, coll.Count);
agg1 = new DistinctValues(IdentityExtractor.Instance);
al.Clear();
coll = (ICollection)agg1.Aggregate(al);
Assert.AreEqual(0, coll.Count);
Assert.IsInstanceOf(typeof(NullImplementation.NullCollection), coll);
string[] array1 = new string[] { "Ana", "Ivan", "Goran" };
string[] array2 = new string[] { "Aleks", "Jason", "Ana" };
coll = (ICollection)agg1.AggregateResults(new object[] { array1, array2 });
Assert.AreEqual(6, coll.Count);
// aggragation on remote cache
Hashtable ht = new Hashtable();
ht.Add("distinctValuesKey1", 435);
ht.Add("distinctValuesKey2", 253);
ht.Add("distinctValuesKey3", 3);
ht.Add("distinctValuesKey4", 3);
ht.Add("distinctValuesKey5", 3);
ht.Add("distinctValuesKey6", null);
ht.Add("distinctValuesKey7", null);
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
cache.InsertAll(ht);
IEntryAggregator aggregator = new DistinctValues(IdentityExtractor.Instance);
object result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(3, ((ICollection)result).Count);
foreach (object o in ht.Values)
{
Assert.IsTrue(((IList)result).Contains(o) || o == null);
}
IFilter filter = new LessFilter(IdentityExtractor.Instance, 100);
result = cache.Aggregate(filter, aggregator);
Assert.AreEqual(1, ((ICollection)result).Count);
//test case for COHNET-109
filter = new LessFilter(IdentityExtractor.Instance, 0);
result = cache.Aggregate(filter, aggregator);
Assert.AreEqual(0, ((ICollection)result).Count);
Assert.IsInstanceOf(typeof(NullImplementation.NullCollection), result);
CacheFactory.Shutdown();
}
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));
}
public void TestAggregate()
{
IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;
IXmlDocument config = XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-local-cache-config.xml");
ccf.Config = config;
INamedCache cache = CacheFactory.GetCache("local-default");
cache.Clear();
Hashtable ht = new Hashtable();
ht.Add("comparableMaxKey1", 100);
ht.Add("comparableMaxKey2", 80.5);
ht.Add("comparableMaxKey3", 19.5);
ht.Add("comparableMaxKey4", 2);
cache.InsertAll(ht);
IEntryAggregator aggregator = new DoubleAverage(IdentityExtractor.Instance);
object result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(50.5, result);
cache.Insert("comparableKey5", null);
result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(50.5, result);
IFilter alwaysFilter = new AlwaysFilter();
result = cache.Aggregate(alwaysFilter, aggregator);
Assert.AreEqual(50.5, result);
cache.Clear();
ht = new Hashtable();
ht.Add("comparableMaxKey1", 435);
ht.Add("comparableMaxKey2", 253);
ht.Add("comparableMaxKey3", 3);
ht.Add("comparableMaxKey4", null);
ht.Add("comparableMaxKey5", -3);
cache.InsertAll(ht);
aggregator = new ComparableMax(IdentityExtractor.Instance);
object max = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(max, 435);
max = cache.Aggregate(alwaysFilter, aggregator);
Assert.AreEqual(max, 435);
cache.Clear();
ht = new Hashtable();
ht.Add("comparableMaxKey1", 435);
ht.Add("comparableMaxKey2", 253);
ht.Add("comparableMaxKey3", 3);
ht.Add("comparableMaxKey4", 3);
ht.Add("comparableMaxKey5", 3);
ht.Add("comparableMaxKey6", null);
ht.Add("comparableMaxKey7", null);
cache.InsertAll(ht);
aggregator = new DistinctValues(IdentityExtractor.Instance);
result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(3, ((ICollection)result).Count);
foreach (object o in ht.Values)
{
Assert.IsTrue(((IList)result).Contains(o) || o == null);
}
IFilter lessFilter = new LessFilter(IdentityExtractor.Instance, 100);
result = cache.Aggregate(lessFilter, aggregator);
Assert.AreEqual(1, ((ICollection)result).Count);
cache.Clear();
ht = new Hashtable();
ht.Add("key1", 100);
ht.Add("key2", 80.5);
ht.Add("key3", 19.5);
ht.Add("key4", 2);
cache.InsertAll(ht);
aggregator = new DoubleSum(IdentityExtractor.Instance);
result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(202, result);
IFilter filter = new AlwaysFilter();
result = cache.Aggregate(filter, aggregator);
Assert.AreEqual(202, result);
cache.Clear();
ht = new Hashtable();
ht.Add("key1", 100);
ht.Add("key2", 80);
ht.Add("key3", 19);
ht.Add("key4", 2);
ht.Add("key5", null);
cache.InsertAll(ht);
aggregator = new LongSum(IdentityExtractor.Instance);
result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(201, result);
IFilter greaterFilter = new GreaterFilter(IdentityExtractor.Instance, 1);
result = cache.Aggregate(greaterFilter, aggregator);
Assert.AreEqual(201, result);
CacheFactory.Shutdown();
}
