public void TestRaiseValueChanged()
{
Order order = new Order();
PropertyAccessing <string> propertyAccessing = order.PropertyAccessing <string>("Num").For(consumer);
string result = null;
bool raised = false;
propertyAccessing.PropertyChanged += (sender, eventArgs) =>
{
if (eventArgs.PropertyName != nameof(PropertyAccessing <string> .Value))
{
return;
}
string currentResult = propertyAccessing.Value;
raised = true;
Assert.IsTrue(currentResult == result);
};
Assert.IsTrue(propertyAccessing.Value == null);
result = "1";
order.Num = result;
Assert.IsTrue(raised);
Assert.IsTrue(propertyAccessing.Value == result);
raised = false;
result = "2";
order.Num = result;
Assert.IsTrue(raised);
Assert.IsTrue(propertyAccessing.Value == result);
result = null;
consumer.Dispose();
}
public void Casting_Initialization_01()
{
ObservableCollection <DerivedItem> items = new ObservableCollection <DerivedItem>();
Casting <BaseItem> casting = items.Casting <BaseItem>().For(consumer);
casting.ValidateInternalConsistency();
consumer.Dispose();
}
public void OfTypeComputing_Initialization_01()
{
ObservableCollection <DerivedItem> items = new ObservableCollection <DerivedItem>();
OfTypeComputing <BaseItem> ofTypeComputing = items.OfTypeComputing <BaseItem>();
ofTypeComputing.ValidateInternalConsistency();
consumer.Dispose();
}
private void test(
CollectionProcessing <Item, object> collectionProcessing,
ObservableCollection <Item> items,
Item[] sourceCollection,
bool batch)
{
if (batch)
{
Assert.AreEqual(collectionProcessing.NewItemsProcessor, _newItemsProcessor);
Assert.AreEqual(collectionProcessing.OldItemsProcessor, _oldItemsProcessor);
}
else
{
Assert.AreEqual(collectionProcessing.NewItemProcessor, _newItemProcessor);
Assert.AreEqual(collectionProcessing.OldItemProcessor, _oldItemProcessor);
}
Assert.AreEqual(collectionProcessing.MoveItemProcessor, _moveItemProcessor);
Assert.IsTrue(items.All(item => item.ProcessedAsNew == 1));
items.RemoveAt(0);
Assert.IsTrue(sourceCollection[0].ProcessedAsNew == 1);
Assert.IsTrue(sourceCollection[0].ProcessedAsOld == 1);
Item item1 = new Item();
items.Insert(0, item1);
Assert.IsTrue(item1.ProcessedAsNew == 1);
Assert.IsTrue(item1.ProcessedAsOld == 0);
items.Move(1, 2);
Item item2 = new Item();
items[0] = item2;
Assert.IsTrue(item1.ProcessedAsNew == 1);
Assert.IsTrue(item1.ProcessedAsOld == 1);
Assert.IsTrue(item2.ProcessedAsNew == 1);
Assert.IsTrue(item2.ProcessedAsOld == 0);
items.Move(1, 2);
items.Clear();
foreach (Item item in items)
{
Assert.IsTrue(item.ProcessedAsNew == 1);
Assert.IsTrue(item.ProcessedAsOld == 1);
}
consumer.Dispose();
}
public void TestResetRootSourceWrapper()
{
OcConsumer consumer = new OcConsumer();
MyObservableCollection <int> items1 = new MyObservableCollection <int>(new []
{
0,
1,
2
});
var selecting = items1.Selecting(i => i).For(consumer);
items1.Reset(new []
{
0,
1,
2,
3,
4,
5
});
selecting.ValidateInternalConsistency();
consumer.Dispose();
}
public void ScalarProcessing_Test()
{
Item item = new Item();
Scalar <Item> itemScalar = new Scalar <Item>(item);
object token = null;
itemScalar.ScalarProcessing <Item, object>(
(newItem, current) =>
{
newItem.ProcessedAsNew = true;
return(newItem.Token);
},
(oldItem, current, retVal) =>
{
Assert.AreEqual(retVal, token);
oldItem.ProcessedAsOld = true;
}).For(consumer);
Assert.IsTrue(item.ProcessedAsNew);
token = item.Token;
Item newItem1 = new Item();
itemScalar.Change(newItem1);
Assert.IsTrue(item.ProcessedAsNew);
Assert.IsTrue(item.ProcessedAsOld);
Assert.IsTrue(newItem1.ProcessedAsNew);
token = newItem1.Token;
consumer.Dispose();
Assert.IsTrue(item.ProcessedAsNew);
Assert.IsTrue(item.ProcessedAsOld);
Assert.IsTrue(newItem1.ProcessedAsNew);
Assert.IsTrue(newItem1.ProcessedAsOld);
}
public void ScalarProcessingVoid_Test()
{
Item item = new Item();
Scalar <Item> itemScalar = new Scalar <Item>(item);
itemScalar.ScalarProcessing(
(newItem, current) =>
{
newItem.ProcessedAsNew = true;
},
(oldItem, current) =>
{
oldItem.ProcessedAsOld = true;
}).For(consumer);
Assert.IsTrue(item.ProcessedAsNew);
Item newItem1 = new Item();
itemScalar.Change(newItem1);
Assert.IsTrue(item.ProcessedAsNew);
Assert.IsTrue(item.ProcessedAsOld);
Assert.IsTrue(newItem1.ProcessedAsNew);
consumer.Dispose();
Assert.IsTrue(item.ProcessedAsNew);
Assert.IsTrue(item.ProcessedAsOld);
Assert.IsTrue(newItem1.ProcessedAsNew);
Assert.IsTrue(newItem1.ProcessedAsOld);
}
public void TestScalarPausing()
{
OcConsumer consumer = new OcConsumer("Tag");
Assert.AreEqual(consumer.Tag, "Tag");
Scalar <int> scalar = new Scalar <int>(0);
ScalarPausing <int> scalarPausing = scalar.ScalarPausing(3).For(consumer);
Assert.AreEqual(scalarPausing.IsPaused, false);
scalarPausing.IsPaused = true;
scalar.Change(1);
scalar.Change(2);
scalar.Change(3);
scalar.Change(4);
scalarPausing.LastChangesToApplyOnResumeCount = 2;
int[] values = new [] { 3, 4 };
int index = 0;
scalarPausing.PropertyChanged += (sender, args) =>
{
if (args.PropertyName == "Value" && !scalarPausing.InactivationInProgress)
{
Assert.AreEqual(scalarPausing.Value, values[index++]);
Assert.Throws <ObservableComputationsInconsistencyException>(() => scalarPausing.IsPaused = true);
}
};
scalarPausing.IsPaused = false;
Assert.AreEqual(scalarPausing.Value, 4);
consumer.Dispose();
}
public void Test4()
{
OcConsumer consumer = new OcConsumer();
ObservableCollection <int> sourceCollection = (new ObservableCollection <int>(new [] { 1, 2, 3 }));
Extending <int> collection = sourceCollection.Extending().For(consumer);
collection.InsertItemRequestHandler = (index, newItem) =>
{
sourceCollection.Insert(index, newItem);
};
collection.RemoveItemRequestHandler = (index) =>
{
sourceCollection.Remove(index);
};
collection.SetItemRequestHandler = (index, newItem) =>
{
sourceCollection[index] = newItem;
};
collection.MoveItemRequestHandler = (oldIndex, newIndex) =>
{
sourceCollection.Move(oldIndex, newIndex);
};
collection.ClearItemsRequestHandler = () =>
{
sourceCollection.Clear();
};
test(collection);
consumer.Dispose();
}
public void TestGroupJoining()
{
ObservableCollection <int> innerItems = new ObservableCollection <int>(
new int[]
{
1,
2,
3
});
ObservableCollection <int> outerItems = new ObservableCollection <int>(
new int[]
{
1,
2,
3
});
OcConsumer consumer = new OcConsumer();
PredicateGroupJoining <int, int> groupJoining =
outerItems.PredicateGroupJoining(innerItems, (i, i1) => i == i1).For(consumer);
Assert.AreEqual(groupJoining[0].Key, 1);
consumer.Dispose();
}
public void TestConcatenating2()
{
ObservableCollection <ObservableCollection <Item> > items = new ObservableCollection <ObservableCollection <Item> >(
new[]
{
new ObservableCollection <Item>(
new[]
{
new Item(),
new Item(),
new Item(),
new Item()
}
),
new ObservableCollection <Item>(
new[]
{
new Item(),
new Item(),
new Item(),
new Item()
}
)
}
);
OcConsumer consumer = new OcConsumer();
Concatenating <Item> concatenating1 = items.Concatenating();
Selecting <Item, Item> concatenating = concatenating1.Selecting(i => i).For(consumer);
concatenating1.For(consumer);
concatenating.ValidateInternalConsistency();
consumer.Dispose();
}
public void IndicesComputing_Initialization_01()
{
ObservableCollection <Item> items = new ObservableCollection <Item>();
IndicesComputing <Item> indicesComputing = items.IndicesComputing(item => item.IsActive).For(consumer);
indicesComputing.ValidateConsistency();
consumer.Dispose();
}
public void ScalarProcessing_Test()
{
Item item = new Item();
Scalar <Item> itemScalar = new Scalar <Item>(item);
ScalarProcessing <Item, object> scalarProcessing = itemScalar.ScalarProcessing <Item, object>(
_newValueProcessor,
_oldValueProcessor).For(consumer);
Assert.AreEqual(scalarProcessing.Source, itemScalar);
Assert.AreEqual(scalarProcessing.NewValueProcessor, _newValueProcessor);
Assert.AreEqual(scalarProcessing.OldValueProcessor, _oldValueProcessor);
Assert.IsTrue(scalarProcessing.Sources.Contains(itemScalar));
test(item, itemScalar);
consumer.Dispose();
}
public void Test4()
{
OcConsumer consumer = new OcConsumer();
ObservableCollection <int> sourceCollection = (new ObservableCollection <int>(new [] { 1, 2, 3 }));
sourceCollection.CollectionChanged += (sender, args) =>
{
_lastNotifyCollectionChangedEventArgs = args;
};
Extending <int> collection = sourceCollection.Extending().For(consumer);
Action <int, int> collectionInsertItemRequestHandler = (index, newItem) =>
{
sourceCollection.Insert(index, newItem);
};
collection.InsertItemRequestHandler = collectionInsertItemRequestHandler;
Assert.IsTrue(collection.InsertItemRequestHandler == collectionInsertItemRequestHandler);
Action <int> collectionRemoveItemRequestHandler = (index) =>
{
sourceCollection.Remove(index);
};
collection.RemoveItemRequestHandler = collectionRemoveItemRequestHandler;
Assert.IsTrue(collection.RemoveItemRequestHandler == collectionRemoveItemRequestHandler);
Action <int, int> collectionSetItemRequestHandler = (index, newItem) =>
{
sourceCollection[index] = newItem;
};
collection.SetItemRequestHandler = collectionSetItemRequestHandler;
Assert.IsTrue(collection.SetItemRequestHandler == collectionSetItemRequestHandler);
Action <int, int> collectionMoveItemRequestHandler = (oldIndex, newIndex) =>
{
sourceCollection.Move(oldIndex, newIndex);
};
collection.MoveItemRequestHandler = collectionMoveItemRequestHandler;
Assert.IsTrue(collection.MoveItemRequestHandler == collectionMoveItemRequestHandler);
Action collectionClearItemsRequestHandler = () =>
{
sourceCollection.Clear();
};
collection.ClearItemsRequestHandler = collectionClearItemsRequestHandler;
Assert.IsTrue(collection.ClearItemsRequestHandler == collectionClearItemsRequestHandler);
test(collection);
consumer.Dispose();
}
public void TestComputingsExecutingUserCode()
{
OcConfiguration.TrackComputingsExecutingUserCode = true;
_computing = new Computing <int>(() => test());
OcConsumer consumer = new OcConsumer();
_computing.For(consumer);
consumer.Dispose();
}
public void MinimizingModeTest()
{
ObservableCollection <int> observableCollection = new ObservableCollection <int>();
OcConsumer ocConsumer = new OcConsumer();
var maximazing = observableCollection.Minimazing().For(ocConsumer);
Assert.IsTrue(maximazing.Mode == MinimazingOrMaximazingMode.Minimazing);
ocConsumer.Dispose();
}
public void CollectionComputingConsumers()
{
ObservableCollection <int> observableCollection = new ObservableCollection <int>();
OcConsumer ocConsumer = new OcConsumer();
var selecting = observableCollection.Selecting(i => i);
var selecting2 = selecting.Selecting(i => i).For(ocConsumer);
Assert.IsTrue(selecting.Consumers.Contains(ocConsumer));
ocConsumer.Dispose();
}
public void First_Initialization_01()
{
ObservableCollection <Item> items = new ObservableCollection <Item>();
FirstComputing <Item> first = items.FirstComputing().For(consumer);
first.ValidateConsistency();
consumer.Dispose();
}
public void ContainsComputing_Initialization_01()
{
ObservableCollection <Item> items = new ObservableCollection <Item>();
ContainsComputing <Item> anyComputing = items.ContainsComputing(new Item(true)).For(consumer);
anyComputing.ValidateConsistency();
consumer.Dispose();
}
public void Distincting_Initialization_01()
{
ObservableCollection <int> items = new ObservableCollection <int>();
Distincting <int> distincting = items.Distincting().For(consumer);
distincting.ValidateConsistency();
consumer.Dispose();
}
public void Prepending_Initialization_01()
{
ObservableCollection <Item> items = new ObservableCollection <Item>();
Prepending <Item> prepending = items.Prepending(new Item()).For(consumer);
prepending.ValidateConsistency();
consumer.Dispose();
}
public void Taking_Initialization_01()
{
ObservableCollection <Item> items = new ObservableCollection <Item>();
Taking <Item> itemComputing = items.Taking(0, 0).For(consumer);;
itemComputing.ValidateConsistency();
consumer.Dispose();
}
public void ItemComputing_Initialization_01()
{
ObservableCollection <Item> items = new ObservableCollection <Item>();
ItemComputing <Item> itemComputing = items.ItemComputing(0);
itemComputing.ValidateInternalConsistency();
consumer.Dispose();
}
public void Appending_Initialization_01()
{
ObservableCollection <Item> items = new ObservableCollection <Item>();
Appending <Item> appending = items.Appending(new Item()).For(consumer);
appending.ValidateInternalConsistency();
consumer.Dispose();
}
public void Reversing_Initialization_01()
{
ObservableCollection <Item> items = new ObservableCollection <Item>();
Reversing <Item> reversing = items.Reversing().For(consumer);
reversing.ValidateInternalConsistency();
consumer.Dispose();
}
public void Last_Initialization_01()
{
ObservableCollection <Item> items = new ObservableCollection <Item>();
LastComputing <Item> last = items.LastComputing().For(consumer);
last.ValidateInternalConsistency();
consumer.Dispose();
}
private void test(StringsConcatenating stringsConcatenating, Scalar <string> separatorScalar)
{
stringsConcatenating.ValidateConsistency();
separatorScalar.Change("");
stringsConcatenating.ValidateConsistency();
separatorScalar.Change("~!");
stringsConcatenating.ValidateConsistency();
separatorScalar.Change("#$%");
stringsConcatenating.ValidateConsistency();
separatorScalar.Change("^&");
stringsConcatenating.ValidateConsistency();
consumer.Dispose();
}
public void TestJoining()
{
ObservableCollection <Item> leftItems = new ObservableCollection <Item>(
new Item[]
{
new Item(10, "11"),
new Item(10, "12"),
new Item(20, "21"),
new Item(30, "31"),
new Item(30, "32"),
new Item(30, "33")
});
ObservableCollection <Item> rightItems = new ObservableCollection <Item>(
new Item[]
{
new Item(10, "10"),
new Item(20, "20"),
new Item(30, "30")
});
OcConsumer consumer = new OcConsumer();
Joining <Item, Item> joining =
leftItems.Joining(rightItems, (li, ri) => ri.Id == li.Id).For(consumer);
Action <JoinPair <Item, Item>, Item> setLeftItemRequestHandler = (pair, item) =>
{
leftItems[joining.IndexOf(pair)] = item;
};
joining.SetLeftItemRequestHandler = setLeftItemRequestHandler;
Assert.AreEqual(joining.SetLeftItemRequestHandler, setLeftItemRequestHandler);
Action <JoinPair <Item, Item>, Item> setRightItemRequestHandler = (pair, item) =>
{
leftItems[leftItems.IndexOf(pair.LeftItem)] = item;
};
joining.SetRightItemRequestHandler = setRightItemRequestHandler;
Assert.AreEqual(joining.SetRightItemRequestHandler, setRightItemRequestHandler);
Assert.AreEqual(joining[2].Joining, joining);
Assert.NotNull(joining[2].ToString());
joining[2].LeftItem = new Item(50, "50");
joining[3].RightItem = new Item(70, "70");
joining.ValidateInternalConsistency();
consumer.Dispose();
}
public void Test3()
{
ObservableCollection <Item> source = new ObservableCollection <Item>(
new[]
{
new Item()
}
);
OcConsumer consumer = new OcConsumer();
test(Expr.Is(() => source).CollectionDisposing().For(consumer), source);
consumer.Dispose();
}
public void Test2()
{
ObservableCollection <Item> source = new ObservableCollection <Item>(
new[]
{
new Item()
}
);
OcConsumer consumer = new OcConsumer();
test(new Scalar <ObservableCollection <Item> >(source).CollectionDisposing().For(consumer), source);
consumer.Dispose();
}
