public void ConverterCacheEventArgsTests()
{
IObservableCache cache = InstantiateCache();
IObservableCache newCache = InstantiateCache();
IConverter cDown = new ConvertDown();
IConverter cUp = new ConvertUp();
CacheEventArgs evt =
new CacheEventArgs(cache, CacheEventType.Inserted, cDown.Convert("key"), cDown.Convert("valueOld"), cDown.Convert("valueNew"), false);
CacheEventArgs convEvt = ConverterCollections.GetCacheEventArgs(newCache, evt, cUp, cUp);
Assert.IsNotNull(convEvt);
Assert.AreEqual(convEvt.Cache, newCache);
Assert.IsFalse(convEvt.Cache.Equals(evt.Cache));
Assert.AreEqual(convEvt.EventType, evt.EventType);
Assert.AreEqual(convEvt.IsSynthetic, evt.IsSynthetic);
Assert.AreEqual(convEvt.OldValue, cUp.Convert(evt.OldValue));
Assert.AreEqual(convEvt.NewValue, cUp.Convert(evt.NewValue));
Assert.AreEqual(convEvt.Key, cUp.Convert(evt.Key));
Assert.IsInstanceOf(typeof(ConverterCollections.ConverterCacheEventArgs), convEvt);
ConverterCollections.ConverterCacheEventArgs ccea = convEvt as ConverterCollections.ConverterCacheEventArgs;
Assert.IsNotNull(ccea);
Assert.AreEqual(ccea.CacheEvent, evt);
Assert.AreEqual(ccea.ConverterKeyUp, cUp);
Assert.AreEqual(ccea.ConverterValueUp, cUp);
}
public void TestTransform()
{
ExtractorEventTransformer transformer = new ExtractorEventTransformer(null, IdentityExtractor.Instance);
LocalCache cache = new LocalCache();
CacheEventArgs evt = new CacheEventArgs(cache, CacheEventType.Inserted, "inserted", "old value", "new value", false);
CacheEventArgs evtNew = transformer.Transform(evt);
Assert.IsNotNull(evtNew);
Assert.AreEqual(evt.Cache, evtNew.Cache);
Assert.AreEqual(evt.EventType, evtNew.EventType);
Assert.AreEqual(evt.Key, evtNew.Key);
Assert.AreNotEqual(evt.OldValue, evtNew.OldValue);
Assert.IsNotNull(evt.OldValue);
Assert.IsNull(evtNew.OldValue);
Assert.AreEqual(evt.NewValue, evtNew.NewValue);
Assert.AreEqual(evt.IsSynthetic, evtNew.IsSynthetic);
evt = ConverterCollections.GetCacheEventArgs(cache, evt,
NullImplementation.GetConverter(), NullImplementation.GetConverter());
Assert.IsNotNull(evt);
Assert.IsInstanceOf(typeof(ConverterCollections.ConverterCacheEventArgs), evt);
ConverterCollections.ConverterCacheEventArgs convEvt = evt as ConverterCollections.ConverterCacheEventArgs;
Assert.IsNotNull(convEvt);
evtNew = transformer.Transform(convEvt);
Assert.IsNotNull(evtNew);
}
/// <summary>
/// Invoke the passed <see cref="IEntryProcessor"/> against the
/// entries specified by the passed cache and entries.
/// </summary>
/// <remarks>
/// The invocation is made thread safe by locking the corresponding
/// keys on the cache. If an attempt to lock all the entries at once
/// fails, they will be processed individually one-by-one.
/// </remarks>
/// <param name="cache">
/// The <see cref="IConcurrentCache"/> that the
/// <b>IEntryProcessor</b> works against.
/// </param>
/// <param name="entries">
/// A collection of <see cref="IInvocableCacheEntry"/> objects to
/// process.
/// </param>
/// <param name="agent">
/// The <b>IEntryProcessor</b> to use to process the specified keys.
/// </param>
/// <returns>
/// An <b>IDictionary</b> containing the results of invoking the
/// <b>IEntryProcessor</b> against each of the specified entry.
/// </returns>
public static IDictionary InvokeAllLocked(IConcurrentCache cache,
ICollection entries, IEntryProcessor agent)
{
ICollection keys = ConverterCollections.GetCollection(entries,
ENTRY_TO_KEY_CONVERTER, NullImplementation.GetConverter());
// try to lock them all at once
var listLocked = LockAll(cache, keys, 0);
if (listLocked == null)
{
// the attempt failed; do it one-by-one
var result = new HashDictionary(entries.Count);
foreach (IInvocableCacheEntry entry in entries)
{
result[entry.Key] = InvokeLocked(cache, entry, agent);
}
return(result);
}
try
{
return(agent.ProcessAll(entries));
}
finally
{
UnlockAll(cache, listLocked);
}
}
/// <summary>
/// Process a set of <see cref="IInvocableCacheEntry"/> objects
/// in order to produce an aggregated result.
/// </summary>
/// <param name="entries">
/// A collection of read-only <b>IInvocableCacheEntry</b>
/// objects to aggregate.
/// </param>
/// <returns>
/// The aggregated result from processing the entries.
/// </returns>
public virtual object Aggregate(ICollection entries)
{
PartialResult resultPartial = new PartialResult(Comparer);
IConverter converter = new ExtractingConverter(Extractor);
AddToResult(ConverterCollections.GetCollection(entries, converter, converter), resultPartial);
return(IsParallel
? (object)resultPartial
: (object)FinalizeResult(resultPartial));
}
public void TestConvertArray()
{
object[] a1 = new object[] { 1, 2, 3 };
IConverter c1 = new ConvertDown();
ConverterCollections.ConvertArray(a1, c1);
Assert.AreEqual(a1.Length, 3);
for (int i = 0; i < a1.Length; i++)
{
Assert.AreEqual(a1[i], c1.Convert(i + 1));
}
a1 = new object[] { 1, 2, 3 };
object[] a2 = new object[0];
//destination array is not large enough
Assert.Greater(a1.Length, a2.Length);
object[] a3 = ConverterCollections.ConvertArray(a1, c1, a2);
Assert.AreEqual(a2.Length, 0);
Assert.AreEqual(a1.Length, a3.Length);
for (int i = 0; i < a1.Length; i++)
{
Assert.AreEqual(a3[i], c1.Convert(a1[i]));
}
a1 = new object[] { 1, 2, 3 };
a2 = new object[3];
//destination array is large enough
Assert.AreEqual(a1.Length, a2.Length);
a3 = ConverterCollections.ConvertArray(a1, c1, a2);
Assert.AreEqual(a1.Length, a2.Length);
Assert.AreEqual(a1.Length, a3.Length);
for (int i = 0; i < a1.Length; i++)
{
Assert.AreEqual(a2[i], c1.Convert(a1[i]));
Assert.AreEqual(a3[i], c1.Convert(a1[i]));
}
a1 = new object[] { 1, 2, 3 };
a2 = new object[5];
//destination array is larger than source
Assert.Less(a1.Length, a2.Length);
a3 = ConverterCollections.ConvertArray(a1, c1, a2);
Assert.Less(a1.Length, a2.Length);
Assert.AreEqual(a2.Length, a3.Length);
for (int i = 0; i < a1.Length; i++)
{
Assert.AreEqual(a2[i], c1.Convert(a1[i]));
Assert.AreEqual(a3[i], c1.Convert(a1[i]));
}
Assert.IsNull(a2[3]);
}
public void ConverterQueryCacheTests()
{
IQueryCache cache = InstantiateCache();
IConverter cDown = new ConvertDown();
IConverter cUp = new ConvertUp();
IQueryCache convCache = ConverterCollections.GetQueryCache(cache, cUp, cDown, cUp, cDown);
Assert.IsNotNull(convCache);
for (int i = 0; i < 5; i++)
{
convCache.Add(i, i + 1);
}
Assert.AreEqual(convCache.Count, 5);
IFilter filter = new EqualsFilter(IdentityExtractor.Instance, cDown.Convert("4"));
object[] keys = convCache.GetKeys(filter);
Assert.IsNotNull(keys);
Assert.AreEqual(keys.Length, 1);
Assert.AreEqual(keys[0], "3");
filter = new GreaterEqualsFilter(IdentityExtractor.Instance, "2");
object[] values = convCache.GetValues(filter);
Assert.IsNotNull(values);
Assert.AreEqual(values.Length, 4);
values = convCache.GetValues(filter, Comparer.DefaultInvariant);
Assert.IsNotNull(values);
Assert.AreEqual(values.Length, 4);
Assert.AreEqual(values[0], "2");
object[] entries = convCache.GetEntries(filter);
Assert.IsNotNull(entries);
Assert.AreEqual(entries.Length, 4);
entries = convCache.GetEntries(filter, new KeyExtractor(IdentityExtractor.Instance));
Assert.IsNotNull(entries);
Assert.AreEqual(entries.Length, 4);
Assert.IsInstanceOf(typeof(ICacheEntry), entries[0]);
ICacheEntry e = entries[0] as ICacheEntry;
Assert.IsNotNull(e);
Assert.AreEqual(e.Key, "1");
Assert.AreEqual(e.Value, "2");
Assert.IsInstanceOf(typeof(ConverterCollections.ConverterQueryCache), convCache);
ConverterCollections.ConverterQueryCache cqc = convCache as ConverterCollections.ConverterQueryCache;
Assert.IsNotNull(cqc);
Assert.AreEqual(cqc.QueryCache, cache);
}
public void ConverterConcurrentCacheTests()
{
IConcurrentCache cache = InstantiateCache();
IConverter cDown = new ConvertDown();
IConverter cUp = new ConvertUp();
IConcurrentCache convCache = ConverterCollections.GetConcurrentCache(cache, cUp, cDown, cUp, cDown);
Assert.IsNotNull(convCache);
Assert.IsInstanceOf(typeof(ConverterCollections.ConverterConcurrentCache), convCache);
ConverterCollections.ConverterConcurrentCache cc =
convCache as ConverterCollections.ConverterConcurrentCache;
Assert.IsNotNull(cc);
Assert.AreEqual(cc.ConcurrentCache, cache);
}
/// <summary>
/// Transform the specified <see cref="CacheEventArgs"/>.
/// </summary>
/// <remarks>
/// The values contained by the returned <b>CacheEventArgs</b> object
/// will be the ones given (sent) to the corresponding listener.
/// </remarks>
/// <param name="evt">
/// The original <b>CacheEventArgs</b> object.
/// </param>
/// <returns>
/// Modified <b>CacheEventArgs</b> object or <c>null</c> to discard
/// the event.
/// </returns>
public virtual CacheEventArgs Transform(CacheEventArgs evt)
{
if (evt is ConverterCollections.ConverterCacheEventArgs)
{
ConverterCollections.ConverterCacheEventArgs evtConv = (ConverterCollections.ConverterCacheEventArgs)evt;
CacheEventArgs evtOrig = evtConv.CacheEvent;
return(ConverterCollections.GetCacheEventArgs(evtConv.Cache,
new CacheEventArgs(evtOrig.Cache, evtOrig.EventType, evtOrig.Key, null, evtOrig.NewValue, evt.IsSynthetic, evt.IsPriming),
evtConv.ConverterKeyUp, evtConv.ConverterValueUp));
}
else
{
return(new CacheEventArgs(evt.Cache, evt.EventType, evt.Key, null, evt.NewValue, evt.IsSynthetic, evt.IsPriming));
}
}
public void ConverterNamedCacheTests()
{
INamedCache cache = InstantiateNamedCache();
IConverter cDown = new ConvertDown();
IConverter cUp = new ConvertUp();
INamedCache convCache = ConverterCollections.GetNamedCache(cache, cUp, cDown, cUp, cDown);
Assert.IsNotNull(convCache);
Assert.IsInstanceOf(typeof(ConverterCollections.ConverterNamedCache), convCache);
ConverterCollections.ConverterNamedCache cc =
convCache as ConverterCollections.ConverterNamedCache;
Assert.IsNotNull(cc);
Assert.AreEqual(cc.NamedCache, cache);
Assert.AreEqual(cc.CacheName, cache.CacheName);
Assert.AreEqual(cc.CacheService, cache.CacheService);
Assert.AreEqual(cc.IsActive, cache.IsActive);
}
public void ConverterCacheListenerTests()
{
TestCacheListener listener = new TestCacheListener();
IObservableCache cache = InstantiateCache();
IConverter cUp = new ConvertUp();
CacheEventArgs evt =
new CacheEventArgs(cache, CacheEventType.Inserted, "key", "oldvalue", "newvalue", false);
ConverterCollections.ConverterCacheEventArgs convEvt =
(ConverterCollections.ConverterCacheEventArgs)ConverterCollections.GetCacheEventArgs(cache, evt, cUp, cUp);
ICacheListener convListener = new ConverterCollections.ConverterCacheListener(cache, listener, cUp, cUp);
Assert.IsNotNull(convListener);
Assert.AreEqual(listener.inserted, 0);
convListener.EntryInserted(evt);
Assert.AreEqual(listener.inserted, 1);
Assert.IsNotNull(listener.evt);
CacheEventArgs listenerEvt = listener.evt;
Assert.AreEqual(listenerEvt.Cache, convEvt.Cache);
Assert.AreEqual(listenerEvt.EventType, convEvt.EventType);
Assert.AreEqual(listenerEvt.IsSynthetic, convEvt.IsSynthetic);
Assert.AreEqual(listenerEvt.Key, convEvt.Key);
Assert.AreEqual(listenerEvt.NewValue, convEvt.NewValue);
Assert.AreEqual(listenerEvt.OldValue, convEvt.OldValue);
Assert.AreEqual(listener.updated, 0);
convListener.EntryUpdated(evt);
Assert.AreEqual(listener.updated, 1);
Assert.AreEqual(listener.deleted, 0);
convListener.EntryDeleted(evt);
Assert.AreEqual(listener.deleted, 1);
Assert.IsInstanceOf(typeof(ConverterCollections.ConverterCacheListener), convListener);
ConverterCollections.ConverterCacheListener ccl =
convListener as ConverterCollections.ConverterCacheListener;
Assert.IsNotNull(ccl);
Assert.AreEqual(ccl.CacheListener, listener);
Assert.AreEqual(ccl.ConverterKeyUp, cUp);
Assert.AreEqual(ccl.ConverterValueUp, cUp);
Assert.AreEqual(ccl.ObservableCache, cache);
}
public void ConverterCollectionTests()
{
ArrayList list = new ArrayList();
IConverter cDown = new ConvertDown();
IConverter cUp = new ConvertUp();
list.Add(cDown.Convert(1));
list.Add(cDown.Convert(2));
list.Add(cDown.Convert(3));
ICollection convCol = ConverterCollections.GetCollection(list, cUp, cDown);
Assert.IsNotNull(convCol);
Assert.AreEqual(convCol.Count, list.Count);
Assert.AreEqual(convCol.IsSynchronized, list.IsSynchronized);
Assert.AreEqual(convCol.SyncRoot, list.SyncRoot);
object[] a = new object[convCol.Count];
convCol.CopyTo(a, 0);
Assert.AreEqual(a.Length, convCol.Count);
for (int i = 0; i < convCol.Count; i++)
{
Assert.AreEqual(a[i], cUp.Convert(list[i]));
}
foreach (object o in convCol)
{
Assert.IsTrue(list.Contains(cDown.Convert(o)));
}
Assert.IsInstanceOf(typeof(ConverterCollections.ConverterCollection), convCol);
ConverterCollections.ConverterCollection cc = convCol as ConverterCollections.ConverterCollection;
Assert.IsNotNull(cc);
Assert.AreEqual(cc.Collection, list);
Assert.AreEqual(cc.ConverterDown, cDown);
Assert.AreEqual(cc.ConverterUp, cUp);
cc.Invalidate();
Assert.IsNull(cc.Collection);
Assert.IsNull(cc.ConverterDown);
Assert.IsNull(cc.ConverterUp);
}
public void ConverterCacheEntryTests()
{
IConverter cDown = new ConvertDown();
IConverter cUp = new ConvertUp();
ICacheEntry entry = new CacheEntry(cDown.Convert("key"), cDown.Convert("value"));
ICacheEntry convEntry = ConverterCollections.GetCacheEntry(entry, cUp, cUp, cDown);
Assert.IsNotNull(convEntry);
Assert.AreEqual(convEntry.Key, cUp.Convert(entry.Key));
Assert.AreEqual(convEntry.Value, cUp.Convert(entry.Value));
convEntry.Value = "newvalue";
Assert.AreEqual(entry.Value, cDown.Convert("newvalue"));
Assert.IsInstanceOf(typeof(ConverterCollections.ConverterCacheEntry), convEntry);
ConverterCollections.ConverterCacheEntry ce = convEntry as ConverterCollections.ConverterCacheEntry;
Assert.IsNotNull(ce);
Assert.AreEqual(ce.Entry, entry);
}
public void ConverterCacheEntriesTests()
{
ICache cache = InstantiateCache();
IConverter cDown = new ConvertDown();
IConverter cUp = new ConvertUp();
for (int i = 0; i < 3; i++)
{
cache.Add(cDown.Convert(i), cDown.Convert(i + 1));
}
ICollection convEntries = ConverterCollections.GetCacheEntries(cache.Entries, cUp, cDown, cUp, cDown);
Assert.IsNotNull(convEntries);
Assert.AreEqual(convEntries.Count, 3);
ArrayList list = new ArrayList(convEntries);
Assert.AreEqual(list.Count, 3);
object o = list[0];
Assert.IsNotNull(o);
Assert.IsInstanceOf(typeof(ICacheEntry), o);
ICacheEntry entry = o as ICacheEntry;
Assert.IsNotNull(entry);
Assert.AreEqual(Convert.ToInt32(entry.Key) + 1, Convert.ToInt32(entry.Value));
IEnumerator enumerator = convEntries.GetEnumerator();
Assert.IsNotNull(enumerator);
enumerator.Reset();
Assert.IsTrue(enumerator.MoveNext());
o = enumerator.Current;
Assert.IsNotNull(o);
Assert.IsInstanceOf(typeof(ICacheEntry), o);
entry = o as ICacheEntry;
Assert.IsNotNull(entry);
Assert.AreEqual(Convert.ToInt32(entry.Key) + 1, Convert.ToInt32(entry.Value));
}
public void ConverterDictionaryEnumeratorTests()
{
IDictionary dict = new Hashtable();
IConverter conv = new ConvertDown();
for (int i = 0; i < 3; i++)
{
dict.Add(i, i + 1);
}
IDictionaryEnumerator enmr = dict.GetEnumerator();
IDictionaryEnumerator convEnum = ConverterCollections.GetDictionaryEnumerator(enmr, conv, conv);
Assert.IsNotNull(convEnum);
Assert.IsTrue(convEnum.MoveNext());
convEnum.MoveNext();
convEnum.MoveNext();
Assert.IsFalse(convEnum.MoveNext());
convEnum.Reset();
Assert.IsTrue(convEnum.MoveNext());
object o = convEnum.Current;
DictionaryEntry entry = convEnum.Entry;
Assert.AreEqual(o, entry);
Assert.AreEqual(entry.Key, convEnum.Key);
Assert.AreEqual(entry.Value, convEnum.Value);
Assert.AreEqual(entry.Key, conv.Convert(enmr.Key));
Assert.AreEqual(entry.Value, conv.Convert(enmr.Value));
Assert.IsInstanceOf(typeof(ConverterCollections.ConverterDictionaryEnumerator), convEnum);
ConverterCollections.ConverterDictionaryEnumerator cde =
convEnum as ConverterCollections.ConverterDictionaryEnumerator;
Assert.IsNotNull(cde);
Assert.AreEqual(cde.ConverterKeyUp, conv);
Assert.AreEqual(cde.ConverterValueUp, conv);
}
public void ConverterCacheEnumeratorTests()
{
ICache cache = InstantiateCache();
IConverter conv = new ConvertDown();
for (int i = 0; i < 3; i++)
{
cache.Add(i, i + 1);
}
ICacheEnumerator cacheEnumerator = cache.GetEnumerator();
ICacheEnumerator convEnum = ConverterCollections.GetCacheEnumerator(cacheEnumerator, conv, conv, conv);
Assert.IsNotNull(convEnum);
Assert.IsTrue(convEnum.MoveNext());
convEnum.MoveNext();
convEnum.MoveNext();
Assert.IsFalse(convEnum.MoveNext());
convEnum.Reset();
Assert.IsTrue(convEnum.MoveNext());
object o = convEnum.Current;
ICacheEntry entry = convEnum.Entry;
Assert.AreEqual(o, entry);
Assert.AreEqual(entry.Key, convEnum.Key);
Assert.AreEqual(entry.Value, convEnum.Value);
Assert.AreEqual(entry.Key, conv.Convert(cacheEnumerator.Key));
Assert.AreEqual(entry.Value, conv.Convert(cacheEnumerator.Value));
Assert.IsInstanceOf(typeof(ConverterCollections.ConverterCacheEnumerator), convEnum);
ConverterCollections.ConverterCacheEnumerator cce =
convEnum as ConverterCollections.ConverterCacheEnumerator;
Assert.IsNotNull(cce);
Assert.AreEqual(cce.ConverterKeyUp, conv);
Assert.AreEqual(cce.ConverterValueUp, conv);
}
public void ConverterInvocableCacheTests()
{
IInvocableCache cache = InstantiateCache();
IConverter cDown = new ConvertDown();
IConverter cUp = new ConvertUp();
IEntryProcessor processor = new ConditionalPut(AlwaysFilter.Instance, "value_converted", false);
IInvocableCache convCache = ConverterCollections.GetInvocableCache(cache, cUp, cDown, cUp, cDown);
Assert.IsNotNull(convCache);
Assert.AreEqual(cache.Count, 0);
convCache.Invoke("key", processor);
Assert.AreEqual(cache.Count, 1);
Assert.AreEqual(convCache["key"], cUp.Convert("value_converted"));
ArrayList keys = new ArrayList();
keys.Add("key");
keys.Add("anotherkey");
processor = new ConditionalPut(AlwaysFilter.Instance, "newvalue_converted", false);
IDictionary result = convCache.InvokeAll(keys, processor);
//results should be empty since return is set to false
Assert.AreEqual(result.Count, 0);
Assert.AreEqual(convCache.Count, 2);
foreach (object key in result.Keys)
{
Assert.IsTrue(convCache.Contains(key));
Assert.AreEqual(convCache[key], cUp.Convert("newvalue_converted"));
}
processor = new ConditionalPut(AlwaysFilter.Instance, "value_converted", false);
result = convCache.InvokeAll(AlwaysFilter.Instance, processor);
//results should be empty since return is set to false
Assert.AreEqual(result.Count, 0);
Assert.AreEqual(convCache.Count, 2);
foreach (object key in result.Keys)
{
Assert.IsTrue(convCache.Contains(key));
Assert.AreEqual(convCache[key], cUp.Convert("value_converted"));
}
convCache.Clear();
for (int i = 0; i < 5; i++)
{
convCache.Add(i, i + 1);
}
IEntryAggregator aggregator = new ComparableMax(IdentityExtractor.Instance);
keys.Clear();
keys.Add("2");
keys.Add("3");
object o = convCache.Aggregate(keys, aggregator);
Assert.IsNotNull(o);
Assert.AreEqual(o, "4");
o = convCache.Aggregate(AlwaysFilter.Instance, aggregator);
Assert.IsNotNull(o);
Assert.AreEqual(o, "5");
Assert.IsInstanceOf(typeof(ConverterCollections.ConverterInvocableCache), convCache);
ConverterCollections.ConverterInvocableCache cc =
convCache as ConverterCollections.ConverterInvocableCache;
Assert.IsNotNull(cc);
Assert.AreEqual(cc.InvocableCache, cache);
}
public void ConverterDictionaryTests()
{
IDictionary dict = new Hashtable();
IConverter cDown = new ConvertDown();
IConverter cUp = new ConvertUp();
dict.Add(cDown.Convert(0), cDown.Convert(1));
IDictionary convDict = ConverterCollections.GetDictionary(dict, cUp, cDown, cUp, cDown);
Assert.IsNotNull(convDict);
Assert.AreEqual(convDict.Count, dict.Count);
Assert.AreEqual(convDict.IsFixedSize, dict.IsFixedSize);
Assert.AreEqual(convDict.IsReadOnly, dict.IsReadOnly);
Assert.AreEqual(convDict.IsSynchronized, dict.IsSynchronized);
Assert.AreEqual(convDict.SyncRoot, dict.SyncRoot);
Assert.IsTrue(convDict.Contains(0));
Assert.IsTrue(dict.Contains(cDown.Convert(0)));
Assert.IsFalse(convDict.Contains(1));
Assert.AreEqual(cUp.Convert(dict[cDown.Convert(0)]), convDict[0]);
convDict[0] = "2";
Assert.AreEqual(cUp.Convert(dict[cDown.Convert(0)]), convDict[0]);
convDict.Add("ana", "cikic");
Assert.AreEqual(dict.Count, 2);
Assert.IsTrue(dict.Contains(cDown.Convert("ana")));
Assert.AreEqual(cUp.Convert(dict[cDown.Convert("ana")]), "cikic");
convDict.Remove("ana");
Assert.AreEqual(dict.Count, 1);
Assert.IsInstanceOf(typeof(ConverterCollections.ConverterDictionary), convDict);
ConverterCollections.ConverterDictionary cd = convDict as ConverterCollections.ConverterDictionary;
Assert.IsNotNull(cd);
Assert.AreEqual(cd.ConverterKeyDown, cDown);
Assert.AreEqual(cd.ConverterKeyUp, cUp);
Assert.AreEqual(cd.ConverterValueDown, cDown);
Assert.AreEqual(cd.ConverterValueUp, cUp);
Assert.AreEqual(cd.Dictionary, dict);
convDict.Clear();
Assert.AreEqual(convDict.Count, 0);
Assert.AreEqual(convDict.Count, dict.Count);
for (int i = 0; i < 5; i++)
{
convDict.Add(i, i + 1);
}
Assert.AreEqual(convDict.Count, 5);
ArrayList keys = new ArrayList(convDict.Keys);
Assert.AreEqual(keys.Count, 5);
ArrayList values = new ArrayList(convDict.Values);
Assert.AreEqual(values.Count, 5);
object[] entries = new object[convDict.Count];
int c = 0;
foreach (object o in convDict)
{
Assert.IsInstanceOf(typeof(DictionaryEntry), o);
DictionaryEntry entry = (DictionaryEntry)o;
Assert.IsNotNull(entry);
entries[c++] = entry;
Assert.IsTrue(keys.Contains(entry.Key));
Assert.IsTrue(values.Contains(entry.Value));
}
object[] a = new object[convDict.Count];
convDict.CopyTo(a, 0);
Assert.IsTrue(CollectionUtils.EqualsDeep(a, entries));
}
public void ConverterObservableCacheTests()
{
IObservableCache cache = InstantiateCache();
IConverter cDown = new ConvertDown();
IConverter cUp = new ConvertUp();
TestCacheListener listener = new TestCacheListener();
IObservableCache convCache = ConverterCollections.GetObservableCache(cache, cUp, cDown, cUp, cDown);
Assert.IsNotNull(convCache);
//AddCacheListener(listener)
convCache.AddCacheListener(listener);
Assert.AreEqual(listener.inserted, 0);
convCache.Add(1, 1);
Assert.AreEqual(listener.inserted, 1);
Assert.AreEqual(listener.updated, 0);
convCache[1] = 2;
Assert.AreEqual(listener.updated, 1);
Assert.AreEqual(listener.deleted, 0);
convCache.Remove(1);
Assert.AreEqual(listener.deleted, 1);
//RemoveCacheListener(listener)
convCache.RemoveCacheListener(listener);
Assert.AreEqual(listener.inserted, 1);
convCache.Add(1, 1);
Assert.AreEqual(listener.inserted, 1);
listener.inserted = listener.updated = listener.deleted = 0;
convCache.Clear();
//AddCacheListener(listener, key, isLite);
convCache.AddCacheListener(listener, "1", true);
for (int i = 0; i < 3; i++)
{
convCache.Add(i, i);
}
Assert.AreEqual(listener.inserted, 1);
Assert.AreEqual(listener.updated, 0);
Assert.AreEqual(listener.deleted, 0);
for (int i = 0; i < 3; i++)
{
convCache[i] = i + 1;
}
Assert.AreEqual(listener.inserted, 1);
Assert.AreEqual(listener.updated, 1);
Assert.AreEqual(listener.deleted, 0);
convCache.Clear();
Assert.AreEqual(listener.inserted, 1);
Assert.AreEqual(listener.updated, 1);
Assert.AreEqual(listener.deleted, 1);
//RemoveCacheListener(listener, key)
convCache.RemoveCacheListener(listener, "1");
convCache.Add(1, 1);
Assert.AreEqual(listener.inserted, 1);
listener.inserted = listener.updated = listener.deleted = 0;
convCache.Clear();
IFilter filter = AlwaysFilter.Instance;
//AddCacheListener(listener, filter, isLite)
convCache.AddCacheListener(listener, filter, true);
for (int i = 0; i < 3; i++)
{
convCache.Add(i, i);
}
Assert.AreEqual(listener.inserted, 3);
Assert.AreEqual(listener.updated, 0);
Assert.AreEqual(listener.deleted, 0);
for (int i = 0; i < 3; i++)
{
convCache[i] = i + 1;
}
Assert.AreEqual(listener.inserted, 3);
Assert.AreEqual(listener.updated, 3);
Assert.AreEqual(listener.deleted, 0);
convCache.Clear();
Assert.AreEqual(listener.inserted, 3);
Assert.AreEqual(listener.updated, 3);
Assert.AreEqual(listener.deleted, 3);
//RemoveCacheListener(listener, filter)
convCache.RemoveCacheListener(listener, filter);
convCache.Add(1, 1);
Assert.AreEqual(listener.inserted, 3);
Assert.IsInstanceOf(typeof(ConverterCollections.ConverterObservableCache), convCache);
ConverterCollections.ConverterObservableCache coc =
convCache as ConverterCollections.ConverterObservableCache;
Assert.IsNotNull(coc);
Assert.AreEqual(coc.ObservableCache, cache);
}
public void ConverterCacheTests()
{
ICache cache = InstantiateCache();
IConverter cDown = new ConvertDown();
IConverter cUp = new ConvertUp();
for (int i = 1; i <= 3; i++)
{
cache.Add(cDown.Convert(i), cDown.Convert(i + 1));
}
ICache convCache = ConverterCollections.GetCache(cache, cUp, cDown, cUp, cDown);
Assert.IsNotNull(convCache);
Assert.AreEqual(convCache.Count, 3);
convCache.Insert(4, 5);
Assert.AreEqual(convCache.Count, 4);
Assert.AreEqual(convCache["4"], "5");
Assert.AreEqual(cache[cDown.Convert(4)], cDown.Convert(5));
ICollection entries = convCache.Entries;
Assert.IsNotNull(entries);
Assert.AreEqual(entries.Count, 4);
ArrayList list = new ArrayList(entries);
ICacheEnumerator cacheEnumerator = convCache.GetEnumerator();
Assert.IsNotNull(cacheEnumerator);
Assert.IsTrue(cacheEnumerator.MoveNext());
cacheEnumerator.Reset();
for (int i = 0; i < list.Count && cacheEnumerator.MoveNext(); i++)
{
object o1 = list[i];
object o2 = cacheEnumerator.Current;
Assert.IsNotNull(o1);
Assert.IsNotNull(o2);
Assert.IsInstanceOf(typeof(ICacheEntry), o1);
Assert.IsInstanceOf(typeof(ICacheEntry), o2);
ICacheEntry e1 = o1 as ICacheEntry;
ICacheEntry e2 = o2 as ICacheEntry;
Assert.IsNotNull(e1);
Assert.IsNotNull(e2);
Assert.AreEqual(e1.Key, e2.Key);
Assert.AreEqual(e1.Value, e2.Value);
}
ArrayList keys = new ArrayList();
keys.Add(1);
keys.Add(3);
IDictionary result = convCache.GetAll(keys);
Assert.IsNotNull(result);
Assert.AreEqual(result.Count, 2);
Assert.AreEqual(result["1"], "2");
Assert.AreEqual(result["3"], "4");
IDictionary d = new Hashtable();
for (int i = 5; i < 7; i++)
{
d.Add(i, i + 1);
}
convCache.InsertAll(d);
Assert.AreEqual(convCache.Count, 6);
Assert.AreEqual(convCache["6"], "7");
Assert.IsInstanceOf(typeof(ConverterCollections.ConverterCache), convCache);
ConverterCollections.ConverterCache cc = convCache as ConverterCollections.ConverterCache;
Assert.IsNotNull(cc);
Assert.AreEqual(cc.Cache, cache);
}
