public void InsertRangeInsertsCollectionInRightPosition(Position position)
{
var index = PositionToIndex(position);
var samples = Samples;
var sampleSize = SampleSize;
var sut = new CopyOnWriteList <T>(samples);
var c = new[]
{
TestData <T> .M1,
TestData <T> .M2,
TestData <T> .M3,
};
sut.InsertRange(index, c);
for (int i = 0; i < index; i++)
{
Assert.That(sut[i], Is.EqualTo(samples[i]));
}
var addCount = c.Length;
for (int i = 0; i < addCount; i++)
{
Assert.That(sut[index + i], Is.EqualTo(c[i]));
}
for (int i = index + addCount; i < sampleSize; i++)
{
Assert.That(sut[i + addCount], Is.EqualTo(samples[i]));
}
}
[Test] public void InsertRangeChokesOnNullCollection()
{
var sut = new CopyOnWriteList <T>(Samples);
var e = Assert.Catch <ArgumentNullException>(() => sut.InsertRange(0, null));
Assert.That(e.ParamName, Is.EqualTo("collection"));
}
[Test] public void InsertRangeInsertCollectionIntoEmptyList()
{
var sut = new CopyOnWriteList <T>();
sut.InsertRange(0, Samples);
CollectionAssert.AreEqual(Samples, sut);
}
[Test] public void AddRangeIfAbsentNopOnEmptyCollection()
{
var sut = new CopyOnWriteList <T>(Samples);
sut.AddRangeAbsent(new T[0]);
Assert.That(sut.Count, Is.EqualTo(SampleSize));
}
[Test] public void RemoveRangeChokesOnBadCount()
{
var sut = new CopyOnWriteList <T>(Samples);
var e = Assert.Catch <ArgumentOutOfRangeException>(() => sut.RemoveRange(0, -1));
Assert.That(e.ParamName, Is.EqualTo("count"));
}
[Test] public void FindAllReturnsNewCopyOnWriteListWithMatchItems()
{
var sut = new CopyOnWriteList <T>(Samples);
var size = SampleSize;
var odd = new List <T>((size + 1) / 2);
var even = new List <T>((size + 1) / 2);
for (int i = 0; i < size; i++)
{
var item = TestData <T> .MakeData(i);
if (i % 2 == 0)
{
even.Add(item);
}
else
{
odd.Add(item);
}
}
Assert.That(sut.FindAll(i => false).Count, Is.EqualTo(0));
CollectionAssert.AreEqual(odd, sut.FindAll(odd.Contains));
CollectionAssert.AreEqual(even, sut.FindAll(even.Contains));
var all = sut.FindAll(i => true);
CollectionAssert.AreEqual(sut, all);
all[0] = TestData <T> .M1;
Assert.That(sut[0], Is.Not.EqualTo(TestData <T> .M1));
}
internal static DynamicPropertyDescriptorByMethod GetPopulateCache(
CopyOnWriteList <DynamicPropertyDescriptorByMethod> cache,
DynamicPropertyGetterByMethodOrPropertyBase dynamicPropertyGetterBase,
object obj,
EventBeanTypedEventFactory eventBeanTypedEventFactory)
{
var desc = DynamicPropertyCacheCheck(cache, obj);
if (desc != null)
{
return(desc);
}
// need to add it
lock (dynamicPropertyGetterBase) {
desc = DynamicPropertyCacheCheck(cache, obj);
if (desc != null)
{
return(desc);
}
// Lookup method to use
var method = dynamicPropertyGetterBase.DetermineMethod(obj.GetType());
// Cache descriptor and create fast method
desc = DynamicPropertyCacheAdd(obj.GetType(), method, cache);
return(desc);
}
}
[Test] public void SyncRootCanBlockWriteNotRead()
{
IList list = new CopyOnWriteList <T>(MakeTestArray(9));
var syncRoot = list.SyncRoot;
Assert.IsNotNull(syncRoot);
var readCompete = new AtomicBoolean(false);
var writeComplete = new AtomicBoolean(false);
lock (syncRoot)
{
ThreadManager.StartAndAssertRegistered(
"TRead",
() =>
{
Assert.That(list[0], Is.EqualTo(Zero));
readCompete.Value = true;
});
ThreadManager.StartAndAssertRegistered(
"TWrite",
() =>
{
list[0] = M1;
writeComplete.Value = true;
});
Thread.Sleep(Delays.Short);
Assert.IsTrue(readCompete);
Assert.IsFalse(writeComplete);
}
ThreadManager.JoinAndVerify();
}
[Test] public void AddIfAbsentDoesNotAddWhenExist()
{
var sut = new CopyOnWriteList <T>(Samples);
sut.AddIfAbsent(TestData <T> .One);
Assert.That(sut.Count, Is.EqualTo(SampleSize));
}
// Checks type and adds to cache
private static bool CheckAddType(
Type[] classes,
Type type,
CopyOnWriteList<Pair<Type, bool>> resultCache)
{
lock (resultCache) {
// check again in synchronized block
foreach (Pair<Type, bool> pair in resultCache) {
if (pair.First == type) {
return pair.Second;
}
}
// get the types superclasses and interfaces, and their superclasses and interfaces
ISet<Type> classesToCheck = new HashSet<Type>();
TypeHelper.GetBase(type, classesToCheck);
classesToCheck.Add(type);
// check type against each class
var fits = false;
foreach (var clazz in classes) {
if (classesToCheck.Contains(clazz)) {
fits = true;
break;
}
}
resultCache.Add(new Pair<Type, bool>(type, fits));
return fits;
}
}
[Test] public void AddIfAbsentDoesAddWhenNotExist()
{
var sut = new CopyOnWriteList <T>(Samples);
sut.AddIfAbsent(TestData <T> .M1);
Assert.IsTrue(sut.Contains(TestData <T> .M1));
}
[Test] public void RemoveAllKeepListUnchangedWhenNoMatch()
{
var sut = new CopyOnWriteList <T>(Samples);
Assert.That(sut.RemoveAll(r => false), Is.EqualTo(0));
CollectionAssert.AreEqual(Samples, sut);
}
public void FindIndexChokesOnBadIndex(Position position)
{
var index = PositionToIndex(position);
var sut = new CopyOnWriteList <T>(Samples);
Assert.Catch <ArgumentOutOfRangeException>(() => sut.FindIndex(index, i => true));
Assert.Catch <ArgumentOutOfRangeException>(() => sut.FindIndex(index, 0, i => true));
}
[Test] public void FindIndexChokesOnNullMatchCriteria()
{
var sut = new CopyOnWriteList <T>(Samples);
Assert.Catch <ArgumentNullException>(() => sut.FindIndex(null));
Assert.Catch <ArgumentNullException>(() => sut.FindIndex(0, null));
Assert.Catch <ArgumentNullException>(() => sut.FindIndex(0, 0, null));
}
public void LastIndexOfChokesOnBadIndex(Position position)
{
var index = PositionToIndex(position);
var sut = new CopyOnWriteList <T>(Samples);
Assert.Catch <ArgumentOutOfRangeException>(() => sut.LastIndexOf(TestData <T> .One, index));
Assert.Catch <ArgumentOutOfRangeException>(() => sut.LastIndexOf(TestData <T> .One, index, 0));
}
[Test] public void ForEachCallsActionWithEachItem()
{
var sut = new CopyOnWriteList <T>(Samples);
var all = new List <T>(SampleSize);
sut.ForEach(all.Add);
CollectionAssert.AreEqual(sut, all);
}
[Test] public void RemoveRangeChokesOnBadIndex(Position position)
{
var index = PositionToIndex(position);
var sut = new CopyOnWriteList <T>(Samples);
var e = Assert.Catch <ArgumentOutOfRangeException>(() => sut.RemoveRange(index, 1));
Assert.That(e.ParamName, Is.EqualTo("index"));
}
[Test] public void RemoveAllChokesOnNullMatchCriteria()
{
var sut = new CopyOnWriteList <T>(Samples);
var e = Assert.Catch <ArgumentNullException>(
() => sut.RemoveAll(null));
Assert.That(e.ParamName, Is.EqualTo("match"));
}
public DynamicPropertyGetterByFieldBase(
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BeanEventTypeFactory beanEventTypeFactory)
{
this._beanEventTypeFactory = beanEventTypeFactory;
_cache = new CopyOnWriteList <DynamicPropertyDescriptorByField>();
this._eventBeanTypedEventFactory = eventBeanTypedEventFactory;
}
public void AddListener(ContextPartitionStateListener listener)
{
if (listenersLazy == null) {
listenersLazy = new CopyOnWriteList<ContextPartitionStateListener>();
}
listenersLazy.Add(listener);
}
public DynamicPropertyGetterByMethodOrPropertyBase(
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BeanEventTypeFactory beanEventTypeFactory)
{
_beanEventTypeFactory = beanEventTypeFactory;
_cache = new CopyOnWriteList <DynamicPropertyDescriptorByMethod>();
_eventBeanTypedEventFactory = eventBeanTypedEventFactory;
}
public void CopyOnWriteList_Should_Add_And_Count()
{
var list = new CopyOnWriteList<string>();
list.Add("one");
list.Add("two");
Assert.AreEqual(2, list.Count);
CollectionAssert.AreEqual(new[] { "one", "two" }, list);
}
/// <summary>
/// Adds a consuming (selecting) statement to the named window.
/// </summary>
/// <param name="consumerDesc">The consumer desc.</param>
/// <param name="isSubselect">if set to <c>true</c> [is subselect].</param>
/// <returns>
/// consumer view
/// </returns>
public NamedWindowConsumerView AddConsumer(NamedWindowConsumerDesc consumerDesc, bool isSubselect)
{
NamedWindowConsumerCallback consumerCallback = new ProxyNamedWindowConsumerCallback()
{
ProcGetEnumerator = GetEnumerator,
ProcStopped = RemoveConsumer,
};
// Construct consumer view, allow a callback to this view to remove the consumer
var audit = AuditEnum.STREAM.GetAudit(consumerDesc.AgentInstanceContext.StatementContext.Annotations) != null;
var consumerView = new NamedWindowConsumerView(
ExprNodeUtility.GetEvaluators(consumerDesc.FilterList),
consumerDesc.OptPropertyEvaluator,
_tailView.EventType,
consumerCallback,
consumerDesc.AgentInstanceContext,
audit);
// indicate to virtual data window that a consumer was added
var virtualDWView = _rootViewInstance.VirtualDataWindow;
if (virtualDWView != null)
{
virtualDWView.VirtualDataWindow.HandleEvent(
new VirtualDataWindowEventConsumerAdd(
_tailView.EventType.Name,
consumerView,
consumerDesc.AgentInstanceContext.StatementName,
consumerDesc.AgentInstanceContext.AgentInstanceId,
ExprNodeUtility.ToArray(consumerDesc.FilterList),
_agentInstanceContext));
}
// Keep a list of consumer views per statement to accommodate joins and subqueries
var viewsPerStatements = _consumersInContext.Get(consumerDesc.AgentInstanceContext.EpStatementAgentInstanceHandle);
if (viewsPerStatements == null)
{
viewsPerStatements = new CopyOnWriteList <NamedWindowConsumerView>();
// avoid concurrent modification as a thread may currently iterate over consumers as its dispatching
// without the engine lock
var newConsumers = NamedWindowUtil.CreateConsumerMap(_tailView.IsPrioritized);
newConsumers.PutAll(_consumersInContext);
newConsumers.Put(consumerDesc.AgentInstanceContext.EpStatementAgentInstanceHandle, viewsPerStatements);
_consumersInContext = newConsumers;
}
if (isSubselect)
{
viewsPerStatements.Insert(0, consumerView);
}
else
{
viewsPerStatements.Add(consumerView);
}
return(consumerView);
}
[Test] public void ConvertAllConvertsToAnotherCopyOnWriteList()
{
var sut = new CopyOnWriteList <T>(Samples);
var converted = sut.ConvertAll <object>(i => i);
CollectionAssert.AreEqual(sut, converted);
converted[0] = TestData <T> .M1;
Assert.That(sut[0], Is.Not.EqualTo(TestData <T> .M1));
}
[Test] public void FindLastIndexReturnsLastPositionWhenFoundOtherwiseNegativeOne()
{
var sut = new CopyOnWriteList <T>(Samples.Concat(Samples));
var size = SampleSize;
Assert.That(sut.FindLastIndex(i => i.Equals(TestData <T> .M1)), Is.EqualTo(-1));
Assert.That(sut.FindLastIndex(i => i.Equals(TestData <T> .Two)), Is.EqualTo(size + 2));
Assert.That(sut.FindLastIndex(i => i.Equals(TestData <T> .MakeData(size - 1))), Is.EqualTo(size * 2 - 1));
}
[Test] public void ExistsReportsExistenceOfItemMatchCriteria()
{
var sut = new CopyOnWriteList <T>(Samples);
Assert.IsFalse(sut.Exists(b => b.Equals(TestData <T> .M1)));
Assert.IsTrue(sut.Exists(b => b.Equals(TestData <T> .Zero)));
Assert.IsTrue(sut.Exists(b => b.Equals(TestData <T> .MakeData(SampleSize - 1))));
Assert.IsTrue(sut.Exists(b => b.Equals(TestData <T> .MakeData(SampleSize / 2))));
}
[Test] public void TrueForAllReturnsLastItemMatchCriteriaOtherwiseDefaultValue()
{
var sut = new CopyOnWriteList <T>(Samples);
Assert.IsTrue(sut.TrueForAll(b => !b.Equals(TestData <T> .M1)));
Assert.IsFalse(sut.TrueForAll(b => !b.Equals(TestData <T> .Zero)));
Assert.IsFalse(sut.TrueForAll(b => !b.Equals(TestData <T> .MakeData(SampleSize - 1))));
Assert.IsFalse(sut.TrueForAll(b => !b.Equals(TestData <T> .MakeData(SampleSize / 2))));
}
/// <summary>
/// NOTE: Code-generation-invoked method, method name and parameter order matters
/// </summary>
/// <param name="cache">cache</param>
/// <param name="getter">getter</param>
/// <param name="object">object</param>
/// <param name="eventAdapterService">event server</param>
/// <returns>exists-flag</returns>
public static bool CacheAndExists(CopyOnWriteList <DynamicPropertyDescriptor> cache, DynamicPropertyGetterBase getter, Object @object, EventAdapterService eventAdapterService)
{
var desc = GetPopulateCache(cache, getter, @object, eventAdapterService);
if (desc.Method == null)
{
return(false);
}
return(true);
}
/// <summary>
/// NOTE: Code-generation-invoked method, method name and parameter order matters
/// </summary>
/// <param name="cache">cache</param>
/// <param name="getter">getter</param>
/// <param name="object">object</param>
/// <param name="eventAdapterService">event server</param>
/// <returns>property</returns>
public static Object CacheAndCall(CopyOnWriteList <DynamicPropertyDescriptor> cache, DynamicPropertyGetterBase getter, Object @object, EventAdapterService eventAdapterService)
{
var desc = GetPopulateCache(cache, getter, @object, eventAdapterService);
if (desc.Method == null)
{
return(null);
}
return(getter.Call(desc, @object));
}
/// <summary>
/// NOTE: Code-generation-invoked method, method name and parameter order matters
/// </summary>
/// <param name="clazz">class</param>
/// <param name="field">field</param>
/// <param name="cache">cache</param>
/// <returns>descriptor</returns>
public static DynamicPropertyDescriptorByField DynamicPropertyCacheAdd(
Type clazz,
FieldInfo field,
CopyOnWriteList <DynamicPropertyDescriptorByField> cache)
{
var propertyDescriptor = new DynamicPropertyDescriptorByField(clazz, field);
cache.Add(propertyDescriptor);
return(propertyDescriptor);
}
public void CopyOnWriteList_Should_Add_And_Remove()
{
var list = new CopyOnWriteList<string> {"one", "two", "three", "four", "five"};
Assert.AreEqual(5, list.Count);
list.Remove("three");
CollectionAssert.AreEqual(new[] { "one", "two", "four", "five" }, list);
list.Remove("one");
CollectionAssert.AreEqual(new[] { "two", "four", "five" }, list);
list.Remove("five");
CollectionAssert.AreEqual(new[] { "two", "four" }, list);
list.Remove("four");
CollectionAssert.AreEqual(new[] { "two" }, list);
CollectionAssert.AreEqual(new[] { "two" }, list.ToArray());
list.Remove("two");
CollectionAssert.AreEqual(new string[0], list);
}
public void CopyOnWriteList_Should_Allow_Parallel_Calls_To_Remove()
{
var actions = new List<Action>();
var list = new CopyOnWriteList<int>();
for (var i = 0; i < 100; i++)
{
list.Add(i);
}
Assert.AreEqual(100, list.Count);
for (var i = 0; i < 100; i++)
{
var item = i;
actions.Add(() =>
{
list.Remove(item);
});
}
TestHelper.ParallelInvoke(actions);
Assert.AreEqual(0, list.Count);
}
public void CopyOnWriteList_Should_Allow_Parallel_Calls_To_Add()
{
var actions = new List<Action>();
var list = new CopyOnWriteList<int>();
for (var i = 0; i < 100; i++)
{
var item = i;
actions.Add(() =>
{
list.Add(item);
});
}
TestHelper.ParallelInvoke(actions);
Assert.AreEqual(100, list.Count);
for (var i = 0; i < 100; i++)
{
Assert.True(list.Contains(i));
}
var counter = 0;
CollectionAssert.AreEquivalent(Enumerable.Repeat(0, 100).Select(_ => counter++), list);
}
