public void TestCollections()
{
var numbers = new EditableCollection <int>();
var results = new EditableCollection <int>();
using (results.SyncWith(numbers, x => x))
{
var viewableResults = results.AsViewableCollection();
// when doing more than one change:
// use beginupdate/endupdate to reduce syncing events
numbers.BeginUpdate();
try
{
numbers.Add(4);
numbers.Add(7);
}
finally
{
numbers.EndUpdate();
}
// Magically results (x) are already added to the Results list
CollectionAssert.AreEqual(numbers, viewableResults);
// You can't add a result to the public Results list
// Results.Add(17);
// again: change source collection:
numbers.Add(8);
// synced results collection is already updated.
CollectionAssert.AreEqual(numbers, viewableResults);
}
}
/// <summary>
/// Registers the inverse change (READY TO BE UNDONE) of a supplied controlled collection and its owning instance, to be undone/redone in the future.
/// This must happen as part of a grouping combined variation (a command being performed).
/// Also, it will not be performed if already an undo/redo operation is running.
/// </summary>
public static void RegisterInverseCollectionChange(IModelEntity Instance, EditableCollection SourceCollection, char AlterCode, params object[] Parameters)
{
if (Instance == null || Instance.EditEngine == null ||
Instance.EditEngine.ExecutionStatus != EExecutionStatus.Running)
{
return;
}
// If no engine controlling or not within command variation declaration then abandon.
if (!Instance.EditEngine.IsVariating)
{
//T Console.WriteLine("No variating at collection change.");
return;
}
// IMPORTANT: EDIT-ENGINES MUST MATCH FOR CHANGING VALUES.
if (Instance.EditEngine != ActiveEntityEditor)
{
throw new UsageAnomaly("Active Entity-Editor differs (for collection) from that of the changing Entity '" + Instance.ToStringAlways() + "'.");
}
// Stores the variation into the command being declared.
var MemberDef = SourceCollection.VariatingInstance.ClassDefinition.GetMemberDef(SourceCollection.Name, false);
Instance.EditEngine.StoreVariation(new CollectionVariation(SourceCollection, AlterCode, Parameters),
(MemberDef != null && MemberDef.ChangesExistenceStatus));
}
public void TestEventsFired()
{
bool eventFired = false;
var sampleData = GenerateSampleData(10);
IEditableCollection <int> sourceCollection = new EditableCollection <int>();
IEditableCollection <int> targetCollection = new EditableCollection <int>();
var syncer = targetCollection.SyncWith(sourceCollection, (itemB) => itemB);
syncer.Synced += delegate(object sender, SyncEventArgs <int, int> args) { eventFired = true; };
sourceCollection.Add(sampleData[0]);
Assert.AreEqual(true, eventFired);
eventFired = false;
sourceCollection.Remove(sampleData[0]);
Assert.AreEqual(true, eventFired);
eventFired = false;
sourceCollection.BeginUpdate();
sourceCollection.Add(sampleData[0]);
sourceCollection.Add(sampleData[1]);
sourceCollection.EndUpdate();
Assert.AreEqual(true, eventFired);
}
public CollectionVariation GenerateInverseDictionaryVariation(EditableCollection TargetCollection, char AlterCode, object[] Parameters)
{
var NewCode = GenerateInverseDictionaryAlterCode(AlterCode);
var Result = new CollectionVariation(TargetCollection, NewCode, Parameters);
return(Result);
}
public void TestRemove()
{
var characteristic1 = new Characteristic()
{
CharacteristicName = "test1"
};
var characteristic2 = new Characteristic()
{
CharacteristicName = "test2"
};
var characteristic3 = new Characteristic()
{
CharacteristicName = "test3"
};
var characteristic4 = new Characteristic()
{
CharacteristicName = "test4"
};
var characteristic5 = new Characteristic()
{
CharacteristicName = "test5"
};
var characteristics = new EditableCollection <Characteristic>();
characteristics.Add(characteristic1);
characteristics.Add(characteristic2);
characteristics.Add(characteristic3);
characteristics.Add(characteristic4);
characteristics.Add(characteristic5);
var wrappedCharacteristics =
new WrappedEditableCollection <CharacteristicUsage, Characteristic>(characteristics);
characteristics.Count.Should().Be(5);
wrappedCharacteristics.Count.Should().Be(characteristics.Count);
characteristics[0].Should().Be(characteristic1);
characteristics[1].Should().Be(characteristic2);
characteristics[2].Should().Be(characteristic3);
characteristics[3].Should().Be(characteristic4);
characteristics[4].Should().Be(characteristic5);
CompareList(characteristics, wrappedCharacteristics);
wrappedCharacteristics.RemoveAt(2);
characteristics.Count.Should().Be(4);
CompareList(characteristics, wrappedCharacteristics);
characteristics.RemoveAt(2);
wrappedCharacteristics.Count.Should().Be(3);
CompareList(characteristics, wrappedCharacteristics);
wrappedCharacteristics.RemoveFirst();
characteristics.Count.Should().Be(2);
CompareList(characteristics, wrappedCharacteristics);
characteristics.RemoveFirst();
wrappedCharacteristics.Count.Should().Be(1);
CompareList(characteristics, wrappedCharacteristics);
}
public void TestTrackedCollectionSpeed()
{
var foo = new EditableCollection <Company>();
for (int i = 0; i < 10000; i++)
{
foo.Add(new Company());
}
}
private void CompareList(EditableCollection <Characteristic> original,
WrappedEditableCollection <CharacteristicUsage, Characteristic> wrapped)
{
wrapped.Count.Should().Be(original.Count);
for (var i = 0; i < wrapped.Count; i++)
{
wrapped[i].Characteristic.Should().Be(original[i]);
}
}
private void MigrateBankFiles(ICollection <BankFile> oldBankFiles,
EditableCollection <NewModels.BankFile> newBankFiles)
{
foreach (var oldBankFile in oldBankFiles)
{
newBankFiles.Add(new NewModels.BankFile
{
Path = oldBankFile.Path, BankName = oldBankFile.BankName, ProgramRange = oldBankFile.ProgramRange
});
}
}
public void TestInit()
{
var characteristics = new EditableCollection <Characteristic>();
characteristics.Add(new Characteristic());
var wrappedCharacteristics =
new WrappedEditableCollection <CharacteristicUsage, Characteristic>(characteristics);
wrappedCharacteristics.Count.Should().Be(characteristics.Count);
wrappedCharacteristics.First().Characteristic.Should().Be(characteristics.First());
}
public FilteredParentProvider(ModelMapper mapper)
{
var defaultParentProvider = new DefaultParentProvider(mapper);
var children = defaultParentProvider.Childs;
if (children != null)
{
var collection = new EditableCollection <object>();
FSyncer = collection.SyncWith(children, CreateTargetItem, DestroyTargetItem, FilterPredicate);
Childs = collection.AsViewableCollection();
}
}
private void CompareBankFiles(ICollection <OldBankFile> oldBankFiles, EditableCollection <BankFile> newBankFiles)
{
newBankFiles.Count.Should().Be(oldBankFiles.Count);
foreach (var oldBankFile in oldBankFiles)
{
var found = (from t in newBankFiles
where t.BankName == oldBankFile.BankName &&
t.ProgramRange == oldBankFile.ProgramRange &&
t.Path == oldBankFile.Path
select t).Any();
found.Should().BeTrue();
}
}
public void TestObjectLifetime()
{
int createCount = 0;
int destroyCount = 0;
var source = new SortedEditableList <MockObject, int>(mo => mo.Order);
var target = new EditableCollection <MockObject>();
Func <MockObject, MockObject> createMo = mo =>
{
createCount++;
return(new MockObject(mo.Order));
};
Action <MockObject> destroyMo = mo =>
{
destroyCount++;
};
target.SyncWith(source, createMo, destroyMo);
source.Add(new MockObject(0));
Assert.AreEqual(1, createCount, "Create count");
Assert.AreEqual(0, destroyCount, "Destroy count");
var mock = new MockObject(-1);
source.Add(mock);
source.Add(new MockObject(-2));
source.Add(new MockObject(10));
Assert.AreEqual(4, createCount, "Create count");
Assert.AreEqual(0, destroyCount, "Destroy count");
source.Remove(mock);
Assert.AreEqual(4, createCount, "Create count");
Assert.AreEqual(1, destroyCount, "Destroy count");
Assert.AreEqual(source.Count, target.Count);
source.Clear();
Assert.AreEqual(source.Count, target.Count);
Assert.AreEqual(createCount, destroyCount, "Create count doesn't match destroy count after source.Clear()");
}
public void TestEditableCollectionAndEditableIDList()
{
var sampleData = new IIDItem[] { new IDItem("item1"), new IDItem("item2"), new IDItem("item3"), new IDItem("item4"), new IDItem("item5"), new IDItem("item6") };
var sourceCollection = new EditableIDList <IIDItem>("source");
var targetCollection = new EditableCollection <IIDItem>();
var syncer = targetCollection.SyncWith(sourceCollection, (itemB) => itemB);
sourceCollection.AddRange(sampleData);
CollectionAssert.AreEqual(sourceCollection, targetCollection);
sourceCollection.Remove(sampleData[0]);
CollectionAssert.AreEqual(sourceCollection, targetCollection);
sourceCollection.Clear();
CollectionAssert.AreEqual(sourceCollection, targetCollection, "Clear() on EditableIDList failed.");
}
public void TestEditableCollectionAndViewableList()
{
var sampleData = GenerateSampleData(10);
var sourceCollection = new ViewableList <int>();
IEditableCollection <int> targetCollection = new EditableCollection <int>();
var syncer = targetCollection.SyncWith(sourceCollection, (itemB) => itemB);
sourceCollection.AddRange(sampleData);
CollectionAssert.AreEqual(sourceCollection, targetCollection);
sourceCollection.Remove(sampleData[0]);
CollectionAssert.AreEqual(sourceCollection, targetCollection);
sourceCollection.Clear();
CollectionAssert.AreEqual(sourceCollection, targetCollection);
}
public void TestEditableCollectionAndViewableCollection()
{
var sampleData = GenerateSampleData(10);
var sourceCollection = new ViewableCollection <int>();
IEditableCollection <int> targetCollection = new EditableCollection <int>();
var syncer = targetCollection.SyncWith(sourceCollection, (itemB) => itemB);
sourceCollection.AddRange(sampleData);
CollectionAssert.AreEqual(sourceCollection, targetCollection);
sourceCollection.Remove(sampleData[0]);
CollectionAssert.AreEqual(sourceCollection, targetCollection);
// Make sure a Clear triggers following event chaing: UpdateBegun / Removed ... / Cleared / Updated
int updateBegunCount = 0;
sourceCollection.UpdateBegun += delegate(IViewableCollection collection) { updateBegunCount++; };
int removedCount = 0;
int removeCount = sourceCollection.Count;
sourceCollection.Removed += delegate(IViewableCollection <int> collection, int item) { removedCount++; };
int clearedCount = 0;
sourceCollection.Cleared += delegate(IViewableCollection <int> collection) { clearedCount++; };
int updatedCount = 0;
sourceCollection.Updated += delegate(IViewableCollection collection) { updatedCount++; };
sourceCollection.Clear();
Assert.AreEqual(1, updateBegunCount);
Assert.AreEqual(1, updatedCount);
Assert.AreEqual(removeCount, removedCount);
Assert.AreEqual(1, clearedCount);
CollectionAssert.AreEqual(sourceCollection, targetCollection);
}
public void TestSyncerChain()
{
var sampleData = GenerateSampleData(10);
IEditableCollection <int> sourceCollection = new EditableCollection <int>();
IEditableCollection <int> interCollection = new EditableCollection <int>();
IEditableCollection <int> targetCollection = new EditableCollection <int>();
var syncer1 = targetCollection.SyncWith(interCollection, (itemB) => itemB);
var syncer2 = interCollection.SyncWith(sourceCollection, (itemB) => itemB);
sourceCollection.BeginUpdate();
sourceCollection.Add(sampleData[0]);
sourceCollection.Add(sampleData[1]);
sourceCollection.Add(sampleData[2]);
CollectionAssert.AreNotEqual(sourceCollection, targetCollection);
sourceCollection.Remove(sampleData[0]);
CollectionAssert.AreNotEqual(sourceCollection, targetCollection);
bool eventFired = false;
syncer1.Synced += delegate(object sender, SyncEventArgs <int, int> args) { eventFired = true; };
sourceCollection.EndUpdate();
Assert.AreEqual(true, eventFired);
CollectionAssert.AreEqual(sourceCollection, targetCollection);
sourceCollection.AddRange(sampleData);
CollectionAssert.AreEqual(sourceCollection, targetCollection);
sourceCollection.Clear();
CollectionAssert.AreEqual(sourceCollection, targetCollection);
}
public void TestBatchUpdate()
{
var sampleData = GenerateSampleData(10);
IEditableCollection <int> sourceCollection = new EditableCollection <int>();
IEditableCollection <int> targetCollection = new EditableCollection <int>();
var syncer = targetCollection.SyncWith(sourceCollection, (itemB) => itemB);
sourceCollection.BeginUpdate();
sourceCollection.Add(sampleData[0]);
sourceCollection.Add(sampleData[1]);
sourceCollection.Add(sampleData[2]);
CollectionAssert.AreNotEqual(sourceCollection, targetCollection);
sourceCollection.Remove(sampleData[0]);
sourceCollection.Remove(sampleData[2]);
CollectionAssert.AreNotEqual(sourceCollection, targetCollection);
sourceCollection.EndUpdate();
CollectionAssert.AreEqual(sourceCollection, targetCollection);
}
/// <summary>
/// Constructor.
/// </summary>
internal CollectionVariation(EditableCollection VariatingCollection, char VariatingAlterCode, object[] PassedParameters)
{
this.VariatingCollection = VariatingCollection;
this.VariatingAlterCode = VariatingAlterCode;
this.PassedParameters = PassedParameters;
}
public TeamEditable()
{
_players = new EditableCollection <PlayerEditable>();
}
