public void BinaryTreeAanmakenMetBranchTweeMaal()
{
//Arrange
BinaryTree <int> tree = new Empty <int>();
//Act
tree = tree.Add(4);
tree = tree.Add(3);
//Arrange
Assert.IsInstanceOfType(tree, typeof(Branch <int>));
Assert.AreEqual(2, tree.Count);
}
public void ModelTrackerCollection_NewCollection_AddRemoveModel_RemoveReturnsTrue()
{
var m = new TestModel();
Empty.Add(m);
Assert.IsTrue(Empty.Remove(m));
}
/// <summary>
/// Slices this collection, returning a new collection containing only
/// positions matching the specified <paramref name="comparison"/> and <paramref name="expiration"/>
/// </summary>
public OptionPositionCollection Slice(BinaryComparison comparison, DateTime expiration, bool includeUnderlying = true)
{
var expirations = comparison.Filter(_expirations, expiration);
if (expirations.IsEmpty)
{
return(includeUnderlying && HasUnderlying?Empty.Add(UnderlyingPosition) : Empty);
}
var positions = ImmutableDictionary <Symbol, OptionPosition> .Empty;
if (includeUnderlying)
{
OptionPosition underlyingPosition;
if (_positions.TryGetValue(Underlying, out underlyingPosition))
{
positions = positions.Add(Underlying, underlyingPosition);
}
}
var sides = ImmutableDictionary <PositionSide, ImmutableHashSet <Symbol> > .Empty;
var rights = ImmutableDictionary <OptionRight, ImmutableHashSet <Symbol> > .Empty;
var strikes = ImmutableSortedDictionary <decimal, ImmutableHashSet <Symbol> > .Empty;
foreach (var symbol in expirations.SelectMany(kvp => kvp.Value))
{
var position = _positions[symbol];
sides = sides.Add(position.Side, symbol);
positions = positions.Add(symbol, position);
rights = rights.Add(symbol.ID.OptionRight, symbol);
strikes = strikes.Add(symbol.ID.StrikePrice, symbol);
}
return(new OptionPositionCollection(positions, rights, sides, strikes, expirations));
}
public void TestForEach()
{
var target = new Empty <int>();
var boom = target.Add(7);
boom.Add(4);
boom.Add(3);
boom.Add(8);
boom.Add(2);
var result = new List <int>();
var expected = new List <int>()
{
2,
3,
4,
7,
8
};
foreach (var item in boom)
{
result.Add(item);
}
Assert.AreEqual(expected[0], result[0]);
Assert.AreEqual(expected[1], result[1]);
Assert.AreEqual(expected[2], result[2]);
Assert.AreEqual(expected[3], result[3]);
Assert.AreEqual(expected[4], result[4]);
}
public void LegeBoomAanmakenEnAddgetal()
{
var target = new Empty <int>();
var result = target.Add(7);
Assert.AreEqual(1, result.Count);
}
public void ModelTrackerCollection_NewCollection_AddModel_IndexReturnsModel()
{
var m = new TestModel();
Empty.Add(m);
Assert.IsNotNull(Empty[m.Id]);
Assert.AreEqual(m, Empty[m.Id]);
}
public void ModelTrackerCollection_NewCollection_AddRemoveModel_ContainsModel_ReturnsFalse()
{
var m = new TestModel();
Empty.Add(m);
Empty.Remove(m);
Assert.IsFalse(Empty.Contains(m));
}
public void ModelTrackerCollection_NewCollection_AddModel_ClearCollection_CollectionEmpty()
{
var m = new TestModel();
Empty.Add(m);
Empty.Clear();
Assert.IsTrue(Empty.Count == 0);
}
public void ModelTrackerCollection_NewCollection_AddModel_CountIncreased()
{
var m = new TestModel();
int c = Empty.Count;
Empty.Add(m);
Assert.IsTrue(Empty.Count > c);
}
public void ModelTrackerCollection_NewCollection_DisposeCollection_CollectionDisposed()
{
var m = new TestModel();
Empty.Add(m);
Empty.Dispose();
Assert.IsTrue(Empty.Disposed);
}
public void ModelTrackerCollection_NewCollection_AddRmoveModel_CountUnchanged()
{
var m = new TestModel();
var c = Empty.Count;
Empty.Add(m);
Empty.Remove(m);
Assert.AreEqual(Empty.Count, c);
}
public void LegeBoomAanmakenEnTweegetallenToevoegen()
{
var target = new Empty <int>();
var result = target.Add(7);
result.Add(4);
Assert.AreEqual(2, result.Count);
}
public void ContainsTest()
{
var target = new Empty <int>();
var result = target.Add(7);
result.Add(4);
Assert.IsTrue(result.Contains(4));
Assert.AreEqual(2, result.Count);
}
public void BinaryTreeAanmakenMetBranch()
{
//Arrange
BinaryTree <int> tree = new Empty <int>();
//Act
tree = tree.Add(4);
//Arrange
Assert.AreEqual(1, tree.Count);
}
private void UpdateEmptyCollection()
{
// If the source collection is empty, push an "Empty" id into the Empty colleciton
if (Ids.Count == 0)
{
Empty.Add(new Id("Empty"));
}
// Otherwise (has Ids), clear the Empty collection
else
{
Empty.Clear();
}
}
public void ModelTrackerCollection_NewCollection_AddModel_IdAssigned()
{
var m = new TestModel();
var m2 = new TestModel();
m.Id = 10000000;
Empty.Add(m);
Empty.Add(m2);
Assert.IsTrue(m.Id != 10000000);
Assert.IsTrue(m2.Id != 10000000);
Assert.IsTrue(m.Id != m2.Id);
}
public void ModelTrackerCollection_NewCollection_AddRemoveModel_IdRecycled()
{
var m = new TestModel();
var m2 = new TestModel();
Empty.Add(m);
var id = m.Id;
Empty.Remove(m);
Empty.Add(m2);
Assert.IsTrue(id == m2.Id);
}
public void Get0Test()
{
var target = new Empty <int>();
var result = target.Add(7);
result.Add(4);
result.Add(3);
result.Add(8);
result.Add(2);
Assert.AreEqual(2, result[0]);
}
public void ModelTrackerCollection_NewCollection_AddModel_EventInvoked()
{
bool added = false;
var m = new TestModel();
Empty.ModelAddedEvent += (s, e) => {
Assert.AreEqual(e.Model.Id, m.Id);
Assert.AreEqual(e.Model.Data, m.Data);
added = true;
};
Empty.Add(m);
Assert.IsTrue(added);
}
public static ProcessArguments FromCommandAndArguments(string command, IEnumerable <string> arguments)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
var processArguments = Empty.Add(command);
if (arguments != null)
{
processArguments = processArguments.AddRange(arguments);
}
return(processArguments);
}
public static BinairyTree <string> CreateTreeWithNames()
{
BinairyTree <string> target = new Empty <string>();
var tree = target.Add("Yael");
tree.AddRange
(
new List <string>()
{
"Rouke", "Wesley", "Simon", "Martin", "Jelle",
"Martijn", "Robert-Jan", "Rob", "Pim", "Vincent", "Wouter",
"Misha", "Steven", "Jeroen", "Max", "Menno", "Rory",
"Jan", "Jan-Paul", "Michiel", "Gert", "Lars", "Joery",
}
);
return(tree);
}
public void Get4Test()
{
var target = new Empty <int>();
var boom = target.Add(7);
boom.Add(4);
boom.Add(3);
boom.Add(8);
boom.Add(2);
boom.Add(1);
Assert.AreEqual(1, boom[0]);
Assert.AreEqual(2, boom[1]);
Assert.AreEqual(3, boom[2]);
Assert.AreEqual(4, boom[3]);
Assert.AreEqual(7, boom[4]);
Assert.AreEqual(8, boom[5]);
}