wehub-resource-sync
296 lines
8.7 KiB
C#
296 lines
8.7 KiB
C#
/*
|
|
* QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
|
|
* Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using NUnit.Framework;
|
|
using QuantConnect.Data.Consolidators;
|
|
using QuantConnect.Data.Market;
|
|
using QuantConnect.Util;
|
|
|
|
namespace QuantConnect.Tests.Common.Util
|
|
{
|
|
[TestFixture]
|
|
public class ConcurrentSetTests
|
|
{
|
|
[Test]
|
|
public void UnionWith_Matches_HashSet()
|
|
{
|
|
var set = new ConcurrentSet<int> { 1, 2, 3, 4 };
|
|
var other = new HashSet<int> { 4, 5, 6 };
|
|
|
|
CompareWithHashSet(set, s => { s.UnionWith(other); return s; });
|
|
}
|
|
|
|
[Test]
|
|
public void IntersectWith_Matches_HashSet()
|
|
{
|
|
var set = new ConcurrentSet<int> { 1, 2, 3, 4 };
|
|
var other = new HashSet<int> { 4, 5, 6 };
|
|
|
|
CompareWithHashSet(set, s => { s.IntersectWith(other); return s; });
|
|
}
|
|
|
|
[Test]
|
|
public void ExceptWith_Matches_HashSet()
|
|
{
|
|
var set = new ConcurrentSet<int> { 1, 2, 3, 4 };
|
|
var other = new HashSet<int> { 4, 5, 6 };
|
|
|
|
CompareWithHashSet(set, s => { s.ExceptWith(other); return s; });
|
|
}
|
|
|
|
[Test]
|
|
public void SymmetricExceptWith_Matches_HashSet()
|
|
{
|
|
var set = new ConcurrentSet<int> { 1, 2, 3, 4 };
|
|
var other = new HashSet<int> { 4, 5, 6 };
|
|
|
|
CompareWithHashSet(set, s => { s.SymmetricExceptWith(other); return s; });
|
|
}
|
|
|
|
[Test]
|
|
public void IsSubsetOf_Matches_HashSet_True_NonStrict()
|
|
{
|
|
var set = new ConcurrentSet<int> { 4, 5, 6 };
|
|
var other = new HashSet<int> { 4, 5, 6 };
|
|
|
|
CompareWithHashSet(set, s => { s.IsSubsetOf(other); return s; });
|
|
}
|
|
|
|
[Test]
|
|
public void IsSubsetOf_Matches_HashSet_True_Strict()
|
|
{
|
|
var set = new ConcurrentSet<int> { 4, 5 };
|
|
var other = new HashSet<int> { 4, 5, 6 };
|
|
|
|
CompareWithHashSet(set, s => { s.IsSubsetOf(other); return s; });
|
|
}
|
|
|
|
[Test]
|
|
public void IsSubsetOf_Matches_HashSet_False()
|
|
{
|
|
var set = new ConcurrentSet<int> { 4, 5, 6, 7 };
|
|
var other = new HashSet<int> { 4, 5, 6 };
|
|
|
|
CompareWithHashSet(set, s => { s.IsSubsetOf(other); return s; });
|
|
}
|
|
|
|
[Test]
|
|
public void IsSupersetOf_Matches_HashSet_True_NonStrict()
|
|
{
|
|
var set = new ConcurrentSet<int> { 4, 5, 6 };
|
|
var other = new HashSet<int> { 4, 5, 6 };
|
|
|
|
CompareWithHashSet(set, s => { s.IsSubsetOf(other); return s; });
|
|
}
|
|
|
|
[Test]
|
|
public void IsSupersetOf_Matches_HashSet_True_Strict()
|
|
{
|
|
var set = new ConcurrentSet<int> { 4, 5, 6, 7 };
|
|
var other = new HashSet<int> { 4, 5, 6 };
|
|
|
|
CompareWithHashSet(set, s => { s.IsSubsetOf(other); return s; });
|
|
}
|
|
|
|
[Test]
|
|
public void IsSupersetOf_Matches_HashSet_False()
|
|
{
|
|
var set = new ConcurrentSet<int> { 4, 5 };
|
|
var other = new HashSet<int> { 4, 5, 6 };
|
|
|
|
CompareWithHashSet(set, s => { s.IsSubsetOf(other); return s; });
|
|
}
|
|
|
|
[Test]
|
|
public void IsProperSupersetOf_Matches_HashSet_True()
|
|
{
|
|
var set = new ConcurrentSet<int> { 4, 5, 6, 7 };
|
|
var other = new HashSet<int> { 4, 5, 6 };
|
|
|
|
CompareWithHashSet(set, s => { s.IsSubsetOf(other); return s; });
|
|
}
|
|
|
|
[Test]
|
|
public void IsProperSupersetOf_Matches_HashSet_False()
|
|
{
|
|
var set = new ConcurrentSet<int> { 4, 5, 6 };
|
|
var other = new HashSet<int> { 4, 5, 6 };
|
|
|
|
CompareWithHashSet(set, s => { s.IsSubsetOf(other); return s; });
|
|
}
|
|
|
|
[Test]
|
|
public void IsProperSubsetOf_Matches_HashSet_True()
|
|
{
|
|
var set = new ConcurrentSet<int> { 4, 5 };
|
|
var other = new HashSet<int> { 4, 5, 6 };
|
|
|
|
CompareWithHashSet(set, s => { s.IsSubsetOf(other); return s; });
|
|
}
|
|
|
|
[Test]
|
|
public void IsProperSubsetOf_Matches_HashSet_False()
|
|
{
|
|
var set = new ConcurrentSet<int> { 4, 5, 6 };
|
|
var other = new HashSet<int> { 4, 5, 6 };
|
|
|
|
CompareWithHashSet(set, s => { s.IsSubsetOf(other); return s; });
|
|
}
|
|
|
|
[Test]
|
|
public void Overlaps_Matches_HashSet_True()
|
|
{
|
|
var set = new ConcurrentSet<int> { 4, 5 };
|
|
var other = new HashSet<int> { 4, 5, 6 };
|
|
|
|
CompareWithHashSet(set, s => { s.IsSubsetOf(other); return s; });
|
|
}
|
|
|
|
[Test]
|
|
public void Overlaps_Matches_HashSet_False()
|
|
{
|
|
var set = new ConcurrentSet<int> { 4, 5 };
|
|
var other = new HashSet<int> { 6, 7 };
|
|
|
|
CompareWithHashSet(set, s => { s.IsSubsetOf(other); return s; });
|
|
}
|
|
|
|
[Test]
|
|
public void KeepsInsertionOrder_UnionWith()
|
|
{
|
|
var set = new ConcurrentSet<int> { 0, 4, 2, 5 };
|
|
var other = new HashSet<int> { 6, 7, 1, 3 };
|
|
|
|
set.UnionWith(other);
|
|
CollectionAssert.AreEqual(set, new[] { 0, 4, 2, 5, 6, 7, 1, 3 });
|
|
}
|
|
|
|
[Test]
|
|
public void KeepsInsertionOrder_Add()
|
|
{
|
|
var set = new ConcurrentSet<int> { 0, 4, 2, 5 };
|
|
|
|
set.Add(-1);
|
|
set.Add(11);
|
|
CollectionAssert.AreEqual(set, new[] { 0, 4, 2, 5, -1, 11 });
|
|
}
|
|
|
|
[Test]
|
|
public void IgnoresDuplicates()
|
|
{
|
|
var set = new ConcurrentSet<int> { 0, 4, 2, 5 };
|
|
|
|
set.Add(-1);
|
|
set.Add(-1);
|
|
set.Add(-1);
|
|
CollectionAssert.AreEqual(set, new[] { 0, 4, 2, 5, -1 });
|
|
}
|
|
|
|
[Test]
|
|
public void RemoveItem()
|
|
{
|
|
var set = new ConcurrentSet<int> { 0, 4, 2, 5 };
|
|
|
|
set.Remove(4);
|
|
set.Remove(4);
|
|
CollectionAssert.AreEqual(set, new[] { 0, 2, 5 });
|
|
}
|
|
|
|
[Test]
|
|
public void ClearCollection()
|
|
{
|
|
var set = new ConcurrentSet<int> { 0, 4, 2, 5 };
|
|
|
|
set.Clear();
|
|
CollectionAssert.AreEqual(set, new int[] { });
|
|
}
|
|
|
|
[Test]
|
|
public void KeepsInsertionOrder_Remove()
|
|
{
|
|
var set = new ConcurrentSet<int> { 0, 4, 2, 5 };
|
|
|
|
set.Remove(2);
|
|
CollectionAssert.AreEqual(set, new[] { 0, 4, 5 });
|
|
}
|
|
|
|
[Test]
|
|
public void KeepsInsertionOrder()
|
|
{
|
|
var set = new ConcurrentSet<int> { 0, 4, 2, 5, 6, 7, 1, 3 };
|
|
|
|
CollectionAssert.AreEqual(set, new[] { 0, 4, 2, 5, 6, 7, 1, 3 });
|
|
}
|
|
|
|
[Test]
|
|
public void EnumerableIsThreadSafe()
|
|
{
|
|
var set = new ConcurrentSet<int> { 0, 4, 2, 5, 6, 7, 1, 3 };
|
|
|
|
foreach (var value in set)
|
|
{
|
|
set.Remove(value);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ConsolidatorsEnumeratedInOrder()
|
|
{
|
|
var set = new ConcurrentSet<IDataConsolidator>();
|
|
for (var i = 0; i < 500; i++)
|
|
{
|
|
set.Add(new TestConsolidator(i));
|
|
}
|
|
|
|
var j = 0;
|
|
foreach (var value in set)
|
|
{
|
|
Assert.AreEqual(j, (value as TestConsolidator).Id);
|
|
j++;
|
|
}
|
|
}
|
|
|
|
private void CompareWithHashSet<T>(ConcurrentSet<T> set, Func<ISet<T>, ISet<T>> func)
|
|
{
|
|
var asHashSet = set.ToHashSet();
|
|
var expected = func(asHashSet);
|
|
var actual = func(set);
|
|
CollectionAssert.AreEquivalent(expected, actual);
|
|
}
|
|
|
|
private class TestConsolidator : PeriodCountConsolidatorBase<QuoteBar, QuoteBar>
|
|
{
|
|
public int Id { get; }
|
|
|
|
public TestConsolidator(int maxCount) : base(maxCount)
|
|
{
|
|
Id = maxCount;
|
|
}
|
|
|
|
public override void Reset()
|
|
{
|
|
}
|
|
|
|
protected override void AggregateBar(ref QuoteBar workingBar, QuoteBar data)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
}
|
|
}
|