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); }