public void TestComparableMinAggregator()
{
ComparableMin agg1 = new ComparableMin(IdentityExtractor.Instance);
Assert.IsNotNull(agg1);
Assert.AreSame(IdentityExtractor.Instance, agg1.Extractor);
ComparableMin agg2 = new ComparableMin("dummy");
Assert.IsNotNull(agg2);
Assert.IsInstanceOf(typeof(ReflectionExtractor), agg2.Extractor);
ComparableMin agg3 = new ComparableMin("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("Goran", 185));
al.Add(new TestInvocableCacheEntry("Ana", 164));
Assert.AreEqual(164, agg1.Aggregate(al));
string[] array = new string[] { "Ana", "Ivan", "Goran" };
Assert.AreEqual("Ana", agg1.AggregateResults(array));
// aggragation on remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Hashtable ht = new Hashtable();
ht.Add("comparableMinKey1", 435);
ht.Add("comparableMinKey2", 253);
ht.Add("comparableMinKey3", 3);
ht.Add("comparableMinKey4", null);
ht.Add("comparableMinKey5", -3);
cache.InsertAll(ht);
IEntryAggregator aggregator = new ComparableMin(IdentityExtractor.Instance);
object min = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(min, -3);
IFilter filter = new AlwaysFilter();
min = cache.Aggregate(filter, aggregator);
Assert.AreEqual(min, -3);
CacheFactory.Shutdown();
}
public void TestComparableComparerAggregator()
{
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Hashtable ht = new Hashtable();
ht.Add("1", new Address("street", "city", "state", "00000"));
ht.Add("2", new Address("street", "city", "state", "20000"));
ht.Add("3", new Address("street", "city", "state", "60000"));
ht.Add("4", new Address("street", "city", "state", "50000"));
ht.Add("5", new Address("street", "city", "state", "10000"));
cache.InsertAll(ht);
ArrayList al = new ArrayList(ht.Values);
// setup for ComparableMax tests
ComparableMax maxAgg = new ComparableMax(IdentityExtractor.Instance,
new SimpleAddressComparer());
Assert.IsNotNull(maxAgg);
Assert.AreSame(IdentityExtractor.Instance, maxAgg.Extractor);
// local aggregation
Assert.AreEqual("60000", ((Address)maxAgg.AggregateResults(al)).ZIP);
// remote aggregation
Address maxAddr = (Address)cache.Aggregate(new AlwaysFilter(), maxAgg);
Assert.AreEqual("60000", maxAddr.ZIP);
// setup for ComparableMin tests
ComparableMin minAgg = new ComparableMin(IdentityExtractor.Instance,
new SimpleAddressComparer());
Assert.IsNotNull(minAgg);
Assert.AreSame(IdentityExtractor.Instance, minAgg.Extractor);
// local aggregation
Assert.AreEqual("00000", ((Address)minAgg.AggregateResults(al)).ZIP);
// remote aggregation
Address minAddr = (Address)cache.Aggregate(new AlwaysFilter(), minAgg);
Assert.AreEqual("00000", minAddr.ZIP);
CacheFactory.Shutdown();
}
public void TestAggregatorSerialization()
{
ConfigurablePofContext ctx = new ConfigurablePofContext("assembly://Coherence.Tests/Tangosol.Resources/s4hc-test-config.xml");
Assert.IsNotNull(ctx);
ComparableMax comparableMax = new ComparableMax("member1");
ComparableMin comparableMin = new ComparableMin("member2");
CompositeAggregator compositeAggregator = new CompositeAggregator();
DecimalAverage decimalAverage = new DecimalAverage("member3");
DecimalMax decimalMax = new DecimalMax("member4");
DecimalMin decimalMin = new DecimalMin("member5");
DecimalSum decimalSum = new DecimalSum("member6");
DistinctValues distinctValues = new DistinctValues("member7");
DoubleAverage doubleAverage = new DoubleAverage("member8");
DoubleMax doubleMax = new DoubleMax("member9");
DoubleMin doubleMin = new DoubleMin("member10");
DoubleSum doubleSum = new DoubleSum("member11");
GroupAggregator groupAggregator = new GroupAggregator();
LongMax longMax = new LongMax("member12");
LongMin longMin = new LongMin("member13");
LongSum longSum = new LongSum("member14");
PriorityAggregator priorityAggregator = new PriorityAggregator();
Count count = new Count();
Stream stream = new MemoryStream();
ctx.Serialize(new DataWriter(stream), comparableMax);
ctx.Serialize(new DataWriter(stream), comparableMin);
ctx.Serialize(new DataWriter(stream), compositeAggregator);
ctx.Serialize(new DataWriter(stream), decimalAverage);
ctx.Serialize(new DataWriter(stream), decimalMax);
ctx.Serialize(new DataWriter(stream), decimalMin);
ctx.Serialize(new DataWriter(stream), decimalSum);
ctx.Serialize(new DataWriter(stream), distinctValues);
ctx.Serialize(new DataWriter(stream), doubleAverage);
ctx.Serialize(new DataWriter(stream), doubleMax);
ctx.Serialize(new DataWriter(stream), doubleMin);
ctx.Serialize(new DataWriter(stream), doubleSum);
ctx.Serialize(new DataWriter(stream), groupAggregator);
ctx.Serialize(new DataWriter(stream), longMax);
ctx.Serialize(new DataWriter(stream), longMin);
ctx.Serialize(new DataWriter(stream), longSum);
ctx.Serialize(new DataWriter(stream), priorityAggregator);
ctx.Serialize(new DataWriter(stream), count);
stream.Position = 0;
Assert.AreEqual(comparableMax, ctx.Deserialize(new DataReader(stream)));
Assert.AreEqual(comparableMin, ctx.Deserialize(new DataReader(stream)));
Assert.AreEqual(compositeAggregator, ctx.Deserialize(new DataReader(stream)));
Assert.AreEqual(decimalAverage, ctx.Deserialize(new DataReader(stream)));
Assert.AreEqual(decimalMax, ctx.Deserialize(new DataReader(stream)));
Assert.AreEqual(decimalMin, ctx.Deserialize(new DataReader(stream)));
Assert.AreEqual(decimalSum, ctx.Deserialize(new DataReader(stream)));
Assert.AreEqual(distinctValues, ctx.Deserialize(new DataReader(stream)));
Assert.AreEqual(doubleAverage, ctx.Deserialize(new DataReader(stream)));
Assert.AreEqual(doubleMax, ctx.Deserialize(new DataReader(stream)));
Assert.AreEqual(doubleMin, ctx.Deserialize(new DataReader(stream)));
Assert.AreEqual(doubleSum, ctx.Deserialize(new DataReader(stream)));
Assert.AreEqual(groupAggregator, ctx.Deserialize(new DataReader(stream)));
Assert.AreEqual(longMax, ctx.Deserialize(new DataReader(stream)));
Assert.AreEqual(longMin, ctx.Deserialize(new DataReader(stream)));
Assert.AreEqual(longSum, ctx.Deserialize(new DataReader(stream)));
Assert.AreEqual(priorityAggregator.GetType(), ctx.Deserialize(new DataReader(stream)).GetType());
Assert.AreEqual(count.GetType(), ctx.Deserialize(new DataReader(stream)).GetType());
stream.Close();
}