public void InsertItemTest()
{
//Arrange
ObservableSet<string> target = new ObservableSet<string>();
var item = "Item";
//Act
target.Add(item);
target.Add(item);
//Assert
Assert.AreEqual(1, target.Count);
}
public void TestAdd()
{
var list = new List<string> { "aaa", "bbb", "ccc" };
var set = new ObservableSet<string>(list);
bool propertyChangedInvoked = false;
bool collectionChangedInvoked = false;
Assert.AreEqual(set.Count, list.Count);
set.PropertyChanged += (sender, e) =>
{
Assert.AreEqual(e.PropertyName, nameof(ObservableSet<string>.Count));
propertyChangedInvoked = true;
};
set.CollectionChanged += (sender, e) =>
{
Assert.AreEqual(e.Action, NotifyCollectionChangedAction.Add);
Assert.AreEqual(e.NewStartingIndex, 3);
Assert.NotNull(e.NewItems);
Assert.AreEqual(e.NewItems.Count, 1);
Assert.AreEqual(e.NewItems[0], "ddd");
collectionChangedInvoked = true;
};
set.Add("ddd");
Assert.AreEqual(set[0], "aaa");
Assert.AreEqual(set[1], "bbb");
Assert.AreEqual(set[2], "ccc");
Assert.AreEqual(set[3], "ddd");
Assert.True(propertyChangedInvoked);
Assert.True(collectionChangedInvoked);
}
public void SetOperationsTest()
{
const int initialCount = 15;
const int removeItems = 4;
const int insertItems = 2;
var items = new[] { 40, 63, 98, 20, 24, 76, 96, 53, 5, 11, 29, 12, 46, 59, 7, 45, 86, 91, 57, 95 };
var indexes = new[] { 6, 2, 5, 11, 0, 3, 13, 1 };
var originalSet = new HashSet <Person>(items.Take(initialCount).Select(x => new Person(x)), new PersonEqualityComparer());
var set = new ObservableSet <Person>(originalSet);
var sorted = new SortedReadOnlyObservableList <Person>(set, (x, y) => x.Age.CompareTo(y.Age),
new PersonEqualityComparer(), nameof(Person.Age));
Assert.AreEqual(initialCount, set.Count);
Assert.AreEqual(initialCount, sorted.Count);
Assert.IsTrue(items.Take(initialCount).Select(x => new Person(x)).OrderBy(p => p.Age).SequenceEqual(sorted, new PersonEqualityComparer()));
foreach (var person in indexes.Take(removeItems).Select(i => new Person(items[i])))
{
set.Remove(person);
}
Assert.AreEqual(initialCount - removeItems, set.Count);
Assert.AreEqual(initialCount - removeItems, sorted.Count);
Assert.IsTrue(originalSet.OrderBy(p => p.Age).SequenceEqual(sorted, new PersonEqualityComparer()));
foreach (var person in items.Skip(initialCount).Take(insertItems).Select(x => new Person(x)))
{
set.Add(person);
}
Assert.AreEqual(initialCount - removeItems + insertItems, set.Count);
Assert.AreEqual(initialCount - removeItems + insertItems, sorted.Count);
Assert.IsTrue(originalSet.OrderBy(p => p.Age).SequenceEqual(sorted, new PersonEqualityComparer()));
foreach (var result in indexes.Skip(removeItems)
.Zip(items.Skip(initialCount + insertItems),
(i, x) => new { OldItem = new Person(items[i]), NewItem = new Person(x) }))
{
set.SymmetricExceptWith(new[] { result.OldItem, result.NewItem });
}
Assert.AreEqual(initialCount - removeItems + insertItems, set.Count);
Assert.AreEqual(initialCount - removeItems + insertItems, sorted.Count);
Assert.IsTrue(originalSet.OrderBy(p => p.Age).SequenceEqual(sorted, new PersonEqualityComparer()));
set.Clear();
Assert.AreEqual(0, set.Count);
Assert.AreEqual(0, sorted.Count);
}
public void Reentrancy_SingleListener_DoesNotThrow()
{
bool handlerCalled = false;
var collection = new ObservableSet <int>();
collection.CollectionChanged += (sender, e) =>
{
if (!handlerCalled)
{
handlerCalled = true;
// Single listener; does not throw.
collection.Add(2);
}
};
collection.Add(1);
Assert.True(handlerCalled);
Assert.Equal(2, collection.Count);
Assert.Equal(1, collection.ToArray()[0]);
Assert.Equal(2, collection.ToArray()[1]);
}
public void TestAdd()
{
ExpectCollectionChange(NotifyCollectionChangedAction.Add, "item");
_set.Add("item");
ExpectChangeCalls(1);
_set.Add("item");
ExpectChangeCalls(0);
}
public void TestAdd()
{
ExpectCollectionAdd("item");
_set.Add("item");
ExpectChangeCalls(1);
_set.Add("item");
ExpectChangeCalls(0);
}
public void add_object_should_raise_collectionchanged()
{
int value = 1;
var observableSet = new ObservableSet <int>();
bool eventWasRaised = false;
observableSet.CollectionChanged += (sender, args) =>
{
sender.Should().Be.EqualTo(observableSet);
args.Action.Should().Be.EqualTo(NotifyCollectionChangedAction.Add);
args.NewItems[0].Should().Be.EqualTo(value);
eventWasRaised = true;
};
observableSet.Add(value);
eventWasRaised.Should().Be.True();
}
public void TestIndexOf()
{
var list = new List <string> {
"aaa", "bbb", "ccc"
};
var set = new ObservableSet <string>(list);
Assert.Equal(0, set.IndexOf("aaa"));
Assert.Equal(1, set.IndexOf("bbb"));
Assert.Equal(2, set.IndexOf("ccc"));
Assert.Equal(-1, set.IndexOf("ddd"));
set.Add("ddd");
Assert.Equal(3, set.IndexOf("ddd"));
set.Remove("bbb");
Assert.Equal(-1, set.IndexOf("bbb"));
Assert.Equal(2, set.IndexOf("ddd"));
}
public void TestIndexOf()
{
var list = new List <string> {
"aaa", "bbb", "ccc"
};
var set = new ObservableSet <string>(list);
Assert.Equal(set.IndexOf("aaa"), 0);
Assert.Equal(set.IndexOf("bbb"), 1);
Assert.Equal(set.IndexOf("ccc"), 2);
Assert.Equal(set.IndexOf("ddd"), -1);
set.Add("ddd");
Assert.Equal(set.IndexOf("ddd"), 3);
set.Remove("bbb");
Assert.Equal(set.IndexOf("bbb"), -1);
Assert.Equal(set.IndexOf("ddd"), 2);
}
public DummyPluginManager(string pluginsFile, IGameMode gameMode, IMod mod)
{
StreamReader reader = new StreamReader(pluginsFile);
string installationPath = Path.Combine(gameMode.GameModeEnvironmentInfo.InstallationPath, gameMode.GetModFormatAdjustedPath(mod.Format, null, false));
string line;
while ((line = reader.ReadLine()) != null)
{
if (line[0] != '#')
{
m_Plugins.Add(new Plugin(Path.Combine(installationPath, line.ToLower()), line, null));
}
}
((INotifyCollectionChanged)m_Plugins).CollectionChanged += new NotifyCollectionChangedEventHandler(ActivePlugins_CollectionChanged);
m_ROOLPlugins = new ReadOnlyObservableList <Plugin>(m_Plugins);
}
private void ReadSerial()
{
try
{
serialPort.Open();
}
catch (Exception e)
{
MessageBox.Show($"Failed to open port: {e.Message}", "Serial Inspector");
return;
}
OnPropertyChanged(nameof(IsRunning));
int errorCount = 0;
while (keepRunning && serialPort.IsOpen && errorCount < 50)
{
try
{
string line = serialPort.ReadLine();
SerialMessage message = SerialMessage.Parse(line, FirstChunkMath, SecondChunkMath);
var addItem = new Action(() => messages.Add(message));
Application.Current?.Dispatcher.Invoke(DispatcherPriority.Background, addItem);
}
catch (IOException e)
{
MessageBox.Show($"I/O exception occurred: {e.Message}", "Serial Inspector");
break;
}
catch (Exception e)
{
Debug.WriteLine($"An exception occurred: {e.Message}");
++errorCount;
continue;
}
}
serialPort?.Close();
OnPropertyChanged(nameof(IsRunning));
}
public void SetOperationsTest()
{
var values = new[] { 15, 14, 89, 56, 8, 68, 17, 39, 31, 93, 78, 80, 87, 85, 57, 20, 6, 1 };
var people = new ObservableSet <Observable>(values.Select(x => new Observable(x)).ToList());
var transfList = new DynamicTransformingReadOnlyObservableList <Observable, int>(people,
x => x.Subject);
var copy = new TransformingReadOnlyObservableList <int, int>(transfList, x => x);
Assert.AreEqual(people.Count, transfList.Count);
Assert.IsTrue(new HashSet <int>(people.Select(x => x.Prop)).SetEquals(transfList));
Assert.IsTrue(new HashSet <int>(people.Select(x => x.Prop)).SetEquals(copy));
people.Add(new Observable(19));
people.First().Prop = 82;
people.Remove(people.Last());
Assert.AreEqual(people.Count, transfList.Count);
Assert.IsTrue(new HashSet <int>(people.Select(x => x.Prop)).SetEquals(transfList));
Assert.IsTrue(new HashSet <int>(people.Select(x => x.Prop)).SetEquals(copy));
}
/// <summary>
/// Loads the data from the Install Log file.
/// </summary>
private void LoadPluginLog()
{
if (m_ostActivePlugins != null)
{
m_ostActivePlugins.Clear();
}
else
{
m_ostActivePlugins = new ObservableSet <Plugin>(PluginComparer.Filename);
}
if (LogSerializer != null)
{
foreach (string strPlugin in LogSerializer.LoadPluginLog())
{
if (!String.IsNullOrEmpty(strPlugin))
{
m_ostActivePlugins.Add(ManagedPluginRegistry.GetPlugin(strPlugin));
}
}
}
}
public SceneRootViewModel([NotNull] SceneEditorViewModel editor, [NotNull] SceneViewModel scene, AsyncLock loadMutex)
: base(editor, scene, "Scene root")
{
this.loadMutex = loadMutex;
sceneId = Guid.NewGuid();
foreach (var childScene in scene.Children)
{
var child = new SceneRootViewModel(editor, childScene, loadMutex)
{
Parent = this
};
childScenes.Add(child);
}
AddItems(ChildScenes);
scene.Children.CollectionChanged += SceneChildrenCollectionChanged;
var offsetNode = Editor.NodeContainer.GetNode(scene.Asset)[nameof(scene.Asset.Offset)];
offsetNodeBinding = new MemberGraphNodeBinding <Vector3>(offsetNode, nameof(Offset), OnPropertyChanging, OnPropertyChanged, Editor.UndoRedoService);
LoadSettings().Forget();
}
private void OnNewMethod(MethodFacts mfacts)
{
mfacts.OnNewMethodCalled = true;
MethodBase method = mfacts.Method;
AddType(method.DeclaringType);
IOnMethodDiscovery disc = (IOnMethodDiscovery)method.GetCustomOrInjectedAttribute(typeof(IOnMethodDiscovery));
if (disc != null)
{
disc.OnDiscovery(method, EMethodDiscoveryStage.Processing);
}
RealizationsOf(method).AutoDo(AddMethod);
if (mfacts.IsDecompilable)
{
mfacts.INVA.CalledMethods.AutoDo(AddMethod);
mfacts.INVA.ConstructedObjects.AutoDo(AddConstructor);
mfacts.INVA.ReferencedTypes.AutoDo(AddType);
mfacts.INVA.ReadFields.AutoDo(OnFieldSeen);
mfacts.INVA.WrittenFields.AutoDo(OnFieldSeen);
mfacts.INVA.ReferencedFields.AutoDo(OnFieldSeen);
mfacts.INVA.ElementSources
.Where(src => src is AllocationSite)
.Select(src => (AllocationSite)src)
.AutoDo(src => _allocSites.Add(src));
mfacts.INVA.Run();
if (method is MethodInfo)
{
mfacts.Realizations = RealizationsOf((MethodInfo)method).ToBufferedEnumerable();
}
else
{
mfacts.Realizations = Enumerable.Repeat(method, 1);
}
}
}
public void ObserveSkillsGeneratesCorrectValues()
{
var modifiers = CreateModifiers(6);
var skills = CreateSkills();
var parseResults = CreateParseResults(modifiers);
var expected = new[]
{
new CalculatorUpdate(parseResults[0].Modifiers, new Modifier[0]),
new CalculatorUpdate(new Modifier[0], parseResults[0].Modifiers),
};
var parser = MockSkillParser(skills, parseResults);
var sut = CreateSut(parser);
var observableCollection = new ObservableSet <IReadOnlyList <Skill> >();
var actual = new List <CalculatorUpdate>();
using (sut.ObserveSkills(observableCollection).Subscribe(actual.Add))
{
observableCollection.Add(skills[0]);
observableCollection.Remove(skills[0]);
}
Assert.AreEqual(expected, actual);
}
public void add_object_should_raise_propertychanged()
{
int value = 1;
var observableSet = new ObservableSet <int>();
bool eventWasRaisedForCount = false;
bool eventWasRaisedForIsEmpty = false;
observableSet.PropertyChanged += (sender, args) =>
{
sender.Should().Be.EqualTo(observableSet);
if (args.PropertyName == COUNT_PROPERTY_NAME)
{
eventWasRaisedForCount = true;
}
if (args.PropertyName == ISEMPTY_PROPERTY_NAME)
{
eventWasRaisedForIsEmpty = true;
}
};
observableSet.Add(value);
eventWasRaisedForCount.Should().Be.True();
eventWasRaisedForIsEmpty.Should().Be.True();
}
public void TestIndexOf()
{
var list = new List<string> { "aaa", "bbb", "ccc" };
var set = new ObservableSet<string>(list);
Assert.AreEqual(set.IndexOf("aaa"), 0);
Assert.AreEqual(set.IndexOf("bbb"), 1);
Assert.AreEqual(set.IndexOf("ccc"), 2);
Assert.AreEqual(set.IndexOf("ddd"), -1);
set.Add("ddd");
Assert.AreEqual(set.IndexOf("ddd"), 3);
set.Remove("bbb");
Assert.AreEqual(set.IndexOf("bbb"), -1);
Assert.AreEqual(set.IndexOf("ddd"), 2);
}
