Moved all unit test files into a separate directory in preparation for splitting the project
This commit is contained in:
Markus Ewald
cygon
parent
28b96fd557
commit
ba5234f701
58 changed files with 0 additions and 853 deletions
668
Tests/Collections/WeakCollectionTest.cs
Normal file
668
Tests/Collections/WeakCollectionTest.cs
Normal file
|
|
@ -0,0 +1,668 @@
|
|||
#region Apache License 2.0
|
||||
/*
|
||||
Nuclex .NET Framework
|
||||
Copyright (C) 2002-2024 Markus Ewald / Nuclex Development Labs
|
||||
|
||||
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.
|
||||
*/
|
||||
#endregion // Apache License 2.0
|
||||
|
||||
using System;
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
|
||||
#if UNITTEST
|
||||
|
||||
using NUnit.Framework;
|
||||
|
||||
namespace Nuclex.Support.Collections {
|
||||
|
||||
/// <summary>Unit Test for the weak collection wrapper</summary>
|
||||
[TestFixture]
|
||||
internal class WeakCollectionTest {
|
||||
|
||||
#region class Dummy
|
||||
|
||||
/// <summary>Dummy class used to test the weakly referencing collection</summary>
|
||||
private class Dummy {
|
||||
|
||||
/// <summary>Initializes a new dummy</summary>
|
||||
/// <param name="value">Value that will be stored by the dummy</param>
|
||||
public Dummy(int value) {
|
||||
this.Value = value;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Determines whether the specified System.Object is equal to
|
||||
/// the current Dummy object.
|
||||
/// </summary>
|
||||
/// <param name="otherAsObject">
|
||||
/// The System.Object to compare with the current Dummy object
|
||||
/// </param>
|
||||
/// <returns>
|
||||
/// True if the specified System.Object is equal to the current Dummy object;
|
||||
/// otherwise, false.
|
||||
/// </returns>
|
||||
public override bool Equals(object otherAsObject) {
|
||||
Dummy other = otherAsObject as Dummy;
|
||||
if(other == null) {
|
||||
return false;
|
||||
}
|
||||
return this.Value.Equals(other.Value);
|
||||
}
|
||||
|
||||
/// <summary>Serves as a hash function for a particular type.</summary>
|
||||
/// <returns>A hash code for the current System.Object.</returns>
|
||||
public override int GetHashCode() {
|
||||
return this.Value.GetHashCode();
|
||||
}
|
||||
|
||||
/// <summary>Some value that can be used for testing</summary>
|
||||
public int Value;
|
||||
|
||||
}
|
||||
|
||||
#endregion // class Dummy
|
||||
|
||||
#region class ListWithoutICollection
|
||||
|
||||
private class ListWithoutICollection : IList<WeakReference<Dummy>> {
|
||||
public int IndexOf(WeakReference<Dummy> item) { throw new NotImplementedException(); }
|
||||
public void Insert(int index, WeakReference<Dummy> item) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
public void RemoveAt(int index) { throw new NotImplementedException(); }
|
||||
public WeakReference<Dummy> this[int index] {
|
||||
get { throw new NotImplementedException(); }
|
||||
set { throw new NotImplementedException(); }
|
||||
}
|
||||
public void Add(WeakReference<Dummy> item) { throw new NotImplementedException(); }
|
||||
public void Clear() { throw new NotImplementedException(); }
|
||||
public bool Contains(WeakReference<Dummy> item) { throw new NotImplementedException(); }
|
||||
public void CopyTo(WeakReference<Dummy>[] array, int arrayIndex) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
public int Count { get { return 12345; } }
|
||||
public bool IsReadOnly { get { throw new NotImplementedException(); } }
|
||||
public bool Remove(WeakReference<Dummy> item) { throw new NotImplementedException(); }
|
||||
public IEnumerator<WeakReference<Dummy>> GetEnumerator() {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
IEnumerator IEnumerable.GetEnumerator() { throw new NotImplementedException(); }
|
||||
}
|
||||
|
||||
#endregion // class ListWithoutICollection
|
||||
|
||||
/// <summary>Verifies that the constructor of the weak collection is working</summary>
|
||||
[Test]
|
||||
public void TestConstructor() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Assert.IsNotNull(dummies);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test whether the non-typesafe Add() method of the weak collection works
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestAddAsObject() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
|
||||
Dummy oneTwoThreeDummy = new Dummy(12345);
|
||||
(dummies as IList).Add((object)oneTwoThreeDummy);
|
||||
|
||||
CollectionAssert.Contains(dummies, oneTwoThreeDummy);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test whether the non-typesafe Add() method throws an exception if an object is
|
||||
/// added that is not compatible to the collection's item type
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestThrowOnAddIncompatibleObject() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
|
||||
Assert.Throws<ArgumentException>(
|
||||
delegate() { (dummies as IList).Add(new object()); }
|
||||
);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test whether the generic Add() method of the weak collection works
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestAdd() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
|
||||
Dummy oneTwoThreeDummy = new Dummy(12345);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
|
||||
CollectionAssert.Contains(dummies, oneTwoThreeDummy);
|
||||
}
|
||||
|
||||
/// <summary>Tests whether the Clear() method works</summary>
|
||||
[Test]
|
||||
public void TestClear() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
|
||||
Dummy oneTwoThreeDummy = new Dummy(12345);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
Dummy threeTwoOneDummy = new Dummy(54321);
|
||||
dummies.Add(threeTwoOneDummy);
|
||||
|
||||
Assert.AreEqual(2, dummies.Count);
|
||||
|
||||
dummies.Clear();
|
||||
|
||||
Assert.AreEqual(0, dummies.Count);
|
||||
}
|
||||
|
||||
/// <summary>Tests whether the Contains() method works</summary>
|
||||
[Test]
|
||||
public void TestContains() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
|
||||
Dummy oneTwoThreeDummy = new Dummy(12345);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
Dummy threeTwoOneDummy = new Dummy(54321);
|
||||
|
||||
Assert.IsTrue(dummies.Contains(oneTwoThreeDummy));
|
||||
Assert.IsFalse(dummies.Contains(threeTwoOneDummy));
|
||||
}
|
||||
|
||||
/// <summary>Tests whether the non-typesafe Contains() method works</summary>
|
||||
[Test]
|
||||
public void TestContainsWithObject() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
|
||||
Dummy oneTwoThreeDummy = new Dummy(12345);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
Dummy threeTwoOneDummy = new Dummy(54321);
|
||||
|
||||
Assert.IsTrue((dummies as IList).Contains((object)oneTwoThreeDummy));
|
||||
Assert.IsFalse((dummies as IList).Contains((object)threeTwoOneDummy));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Verifies that the Enumerator of the dummy collection correctly
|
||||
/// implements the Reset() method
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestEnumeratorReset() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
Dummy fourFiveSixDummy = new Dummy(456);
|
||||
dummies.Add(fourFiveSixDummy);
|
||||
|
||||
IEnumerator<Dummy> dummyEnumerator = dummies.GetEnumerator();
|
||||
Assert.IsTrue(dummyEnumerator.MoveNext());
|
||||
Assert.IsTrue(dummyEnumerator.MoveNext());
|
||||
Assert.IsFalse(dummyEnumerator.MoveNext());
|
||||
|
||||
dummyEnumerator.Reset();
|
||||
|
||||
Assert.IsTrue(dummyEnumerator.MoveNext());
|
||||
Assert.IsTrue(dummyEnumerator.MoveNext());
|
||||
Assert.IsFalse(dummyEnumerator.MoveNext());
|
||||
}
|
||||
|
||||
/// <summary>Verifies that the IndexOf() method is working as intended</summary>
|
||||
[Test]
|
||||
public void TestIndexOf() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
Dummy fourFiveSixDummy = new Dummy(456);
|
||||
dummies.Add(fourFiveSixDummy);
|
||||
Dummy sevenEightNineDummy = new Dummy(789);
|
||||
|
||||
Assert.AreEqual(0, dummies.IndexOf(oneTwoThreeDummy));
|
||||
Assert.AreEqual(1, dummies.IndexOf(fourFiveSixDummy));
|
||||
Assert.AreEqual(-1, dummies.IndexOf(sevenEightNineDummy));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Verifies that the non-typesafe IndexOf() method is working as intended
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestIndexOfWithObject() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
Dummy fourFiveSixDummy = new Dummy(456);
|
||||
dummies.Add(fourFiveSixDummy);
|
||||
Dummy sevenEightNineDummy = new Dummy(789);
|
||||
|
||||
Assert.AreEqual(0, (dummies as IList).IndexOf((object)oneTwoThreeDummy));
|
||||
Assert.AreEqual(1, (dummies as IList).IndexOf((object)fourFiveSixDummy));
|
||||
Assert.AreEqual(-1, (dummies as IList).IndexOf((object)sevenEightNineDummy));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Verifies that an exception is thrown if an incompatible object is passed to
|
||||
/// the non-typesafe variant of the IndexOf() method
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestThrowOnIndexOfWithIncompatibleObject() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
|
||||
Assert.Throws<ArgumentException>(
|
||||
delegate() { Assert.IsNull((dummies as IList).IndexOf(new object())); }
|
||||
);
|
||||
}
|
||||
|
||||
/// <summary>Test whether the IndexOf() method can cope with null references</summary>
|
||||
[Test]
|
||||
public void TestIndexOfNull() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
|
||||
Assert.AreEqual(-1, dummies.IndexOf(null));
|
||||
dummies.Add(null);
|
||||
Assert.AreEqual(0, dummies.IndexOf(null));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Verifies that the CopyTo() method of the weak collection works
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestCopyToArray() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
Dummy fourFiveSixDummy = new Dummy(456);
|
||||
dummies.Add(fourFiveSixDummy);
|
||||
|
||||
Dummy[] inputDummies = new Dummy[] { oneTwoThreeDummy, fourFiveSixDummy };
|
||||
Dummy[] outputDummies = new Dummy[dummies.Count];
|
||||
|
||||
dummies.CopyTo(outputDummies, 0);
|
||||
|
||||
CollectionAssert.AreEqual(inputDummies, outputDummies);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Verifies that the CopyTo() method of the weak collection throws an exception
|
||||
/// if the target array is too small to hold the collection's contents
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestThrowOnCopyToTooSmallArray() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
Dummy fourFiveSixDummy = new Dummy(456);
|
||||
dummies.Add(fourFiveSixDummy);
|
||||
|
||||
Dummy[] outputStrings = new Dummy[dummies.Count - 1];
|
||||
Assert.Throws<ArgumentException>(
|
||||
delegate() { dummies.CopyTo(outputStrings, 0); }
|
||||
);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Verifies that the CopyTo() method of the transforming read only collection
|
||||
/// works if invoked via the ICollection interface
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestCopyToArrayViaICollection() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
Dummy fourFiveSixDummy = new Dummy(456);
|
||||
dummies.Add(fourFiveSixDummy);
|
||||
|
||||
Dummy[] inputDummies = new Dummy[] { oneTwoThreeDummy, fourFiveSixDummy };
|
||||
Dummy[] outputDummies = new Dummy[dummies.Count];
|
||||
|
||||
(dummies as ICollection).CopyTo(outputDummies, 0);
|
||||
|
||||
CollectionAssert.AreEqual(inputDummies, outputDummies);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Verifies that the Insert() method correctly shifts items in the collection
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestInsert() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
|
||||
Dummy fourFiveSixDummy = new Dummy(456);
|
||||
dummies.Insert(0, fourFiveSixDummy);
|
||||
|
||||
Assert.AreEqual(2, dummies.Count);
|
||||
Assert.AreSame(fourFiveSixDummy, dummies[0]);
|
||||
Assert.AreSame(oneTwoThreeDummy, dummies[1]);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Verifies that the non-typesafe Insert() method correctly shifts items in
|
||||
/// the collection
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestInsertObject() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
|
||||
Dummy fourFiveSixDummy = new Dummy(456);
|
||||
(dummies as IList).Insert(0, (object)fourFiveSixDummy);
|
||||
|
||||
Assert.AreEqual(2, dummies.Count);
|
||||
Assert.AreSame(fourFiveSixDummy, dummies[0]);
|
||||
Assert.AreSame(oneTwoThreeDummy, dummies[1]);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Verifies that the non-typesafe Insert() method correctly shifts items in
|
||||
/// the collection
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestThrowOnInsertIncompatibleObject() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
|
||||
Assert.Throws<ArgumentException>(
|
||||
delegate() { (dummies as IList).Insert(0, new object()); }
|
||||
);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Checks whether the IsFixedSize property of the weak collection returns
|
||||
/// the expected result for a weak collection based on a fixed array
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestIsFixedSizeViaIList() {
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
Dummy fourFiveSixDummy = new Dummy(456);
|
||||
|
||||
WeakReference<Dummy>[] dummyReferences = new WeakReference<Dummy>[] {
|
||||
new WeakReference<Dummy>(oneTwoThreeDummy),
|
||||
new WeakReference<Dummy>(fourFiveSixDummy)
|
||||
};
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(dummyReferences);
|
||||
|
||||
Assert.IsTrue((dummies as IList).IsFixedSize);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tests whether the IsReadOnly property of the weak collection works
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestIsReadOnly() {
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
Dummy fourFiveSixDummy = new Dummy(456);
|
||||
|
||||
List<WeakReference<Dummy>> dummyReferences = new List<WeakReference<Dummy>>();
|
||||
dummyReferences.Add(new WeakReference<Dummy>(oneTwoThreeDummy));
|
||||
dummyReferences.Add(new WeakReference<Dummy>(fourFiveSixDummy));
|
||||
|
||||
ReadOnlyList<WeakReference<Dummy>> readOnlyDummyReferences =
|
||||
new ReadOnlyList<WeakReference<Dummy>>(dummyReferences);
|
||||
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(dummyReferences);
|
||||
WeakCollection<Dummy> readOnlydummies = new WeakCollection<Dummy>(
|
||||
readOnlyDummyReferences
|
||||
);
|
||||
|
||||
Assert.IsFalse(dummies.IsReadOnly);
|
||||
Assert.IsTrue(readOnlydummies.IsReadOnly);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tests whether the IsSynchronized property of the weak collection works
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestIsSynchronized() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
|
||||
Assert.IsFalse((dummies as IList).IsSynchronized);
|
||||
}
|
||||
|
||||
/// <summary>Tests the indexer of the weak collection</summary>
|
||||
[Test]
|
||||
public void TestIndexer() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
Dummy fourFiveSixDummy = new Dummy(456);
|
||||
dummies.Add(fourFiveSixDummy);
|
||||
|
||||
Assert.AreSame(oneTwoThreeDummy, dummies[0]);
|
||||
Assert.AreSame(fourFiveSixDummy, dummies[1]);
|
||||
|
||||
dummies[0] = fourFiveSixDummy;
|
||||
|
||||
Assert.AreSame(fourFiveSixDummy, dummies[0]);
|
||||
}
|
||||
|
||||
/// <summary>Tests the non-typesafe indexer of the weak collection</summary>
|
||||
[Test]
|
||||
public void TestIndexerWithObject() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
Dummy fourFiveSixDummy = new Dummy(456);
|
||||
dummies.Add(fourFiveSixDummy);
|
||||
|
||||
Assert.AreSame((object)oneTwoThreeDummy, (dummies as IList)[0]);
|
||||
Assert.AreSame((object)fourFiveSixDummy, (dummies as IList)[1]);
|
||||
|
||||
(dummies as IList)[0] = (object)fourFiveSixDummy;
|
||||
|
||||
Assert.AreSame((object)fourFiveSixDummy, (dummies as IList)[0]);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tests whether the non-typesafe indexer of the weak collection throws
|
||||
/// the correct exception if an incompatible object is assigned
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestThrowOnIndexerWithIncompatibleObject() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
|
||||
Assert.Throws<ArgumentException>(
|
||||
delegate() { (dummies as IList)[0] = new object(); }
|
||||
);
|
||||
}
|
||||
|
||||
/// <summary>Tests the Remove() method of the weak collection</summary>
|
||||
[Test]
|
||||
public void TestRemove() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
Dummy fourFiveSixDummy = new Dummy(456);
|
||||
dummies.Add(fourFiveSixDummy);
|
||||
|
||||
Assert.AreEqual(2, dummies.Count);
|
||||
Assert.IsTrue(dummies.Remove(oneTwoThreeDummy));
|
||||
Assert.AreEqual(1, dummies.Count);
|
||||
Assert.IsFalse(dummies.Remove(oneTwoThreeDummy));
|
||||
}
|
||||
|
||||
/// <summary>Tests the non-typesafe Remove() method of the weak collection</summary>
|
||||
[Test]
|
||||
public void TestRemoveObject() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
Dummy fourFiveSixDummy = new Dummy(456);
|
||||
dummies.Add(fourFiveSixDummy);
|
||||
|
||||
Assert.AreEqual(2, dummies.Count);
|
||||
(dummies as IList).Remove((object)oneTwoThreeDummy);
|
||||
Assert.AreEqual(1, dummies.Count);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tests whether a null object can be managed by and removed from the weak collection
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestRemoveNull() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
dummies.Add(null);
|
||||
|
||||
Assert.AreEqual(1, dummies.Count);
|
||||
Assert.IsTrue(dummies.Remove(null));
|
||||
Assert.AreEqual(0, dummies.Count);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tests whether the non-typesafe Remove() method of the weak collection throws
|
||||
/// an exception if an object is tried to be removed that is incompatible with
|
||||
/// the collection's item type
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestThrowOnRemoveIncompatibleObject() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Assert.Throws<ArgumentException>(
|
||||
delegate() { (dummies as IList).Remove(new object()); }
|
||||
);
|
||||
}
|
||||
|
||||
/// <summary>Tests the RemoveAt() method of the weak collection</summary>
|
||||
[Test]
|
||||
public void TestRemoveAt() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
dummies.Add(oneTwoThreeDummy);
|
||||
Dummy fourFiveSixDummy = new Dummy(456);
|
||||
dummies.Add(fourFiveSixDummy);
|
||||
|
||||
Assert.AreSame(oneTwoThreeDummy, dummies[0]);
|
||||
dummies.RemoveAt(0);
|
||||
Assert.AreSame(fourFiveSixDummy, dummies[0]);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Verifies that the IsSynchronized property and the SyncRoot property are working
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestSynchronization() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new List<WeakReference<Dummy>>()
|
||||
);
|
||||
|
||||
if(!(dummies as ICollection).IsSynchronized) {
|
||||
lock((dummies as ICollection).SyncRoot) {
|
||||
Assert.AreEqual(0, dummies.Count);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Verifies that the IsSynchronized property and the SyncRoot property are working
|
||||
/// on transforming read only collections based on IList<>s that do not
|
||||
/// implement the ICollection interface
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestSynchronizationOfIListWithoutICollection() {
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(
|
||||
new ListWithoutICollection()
|
||||
);
|
||||
|
||||
if(!(dummies as ICollection).IsSynchronized) {
|
||||
lock((dummies as ICollection).SyncRoot) {
|
||||
int count = dummies.Count;
|
||||
Assert.AreEqual(12345, count); // ;-)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Tests the RemoveDeadItems() method</summary>
|
||||
[Test]
|
||||
public void TestRemoveDeadItems() {
|
||||
List<WeakReference<Dummy>> dummyReferences = new List<WeakReference<Dummy>>();
|
||||
|
||||
Dummy oneTwoThreeDummy = new Dummy(123);
|
||||
dummyReferences.Add(new WeakReference<Dummy>(oneTwoThreeDummy));
|
||||
|
||||
dummyReferences.Add(new WeakReference<Dummy>(null));
|
||||
|
||||
Dummy fourFiveSixDummy = new Dummy(456);
|
||||
dummyReferences.Add(new WeakReference<Dummy>(fourFiveSixDummy));
|
||||
|
||||
WeakCollection<Dummy> dummies = new WeakCollection<Dummy>(dummyReferences);
|
||||
|
||||
Assert.AreEqual(3, dummies.Count);
|
||||
|
||||
dummies.RemoveDeadItems();
|
||||
|
||||
Assert.AreEqual(2, dummies.Count);
|
||||
Assert.AreSame(oneTwoThreeDummy, dummies[0]);
|
||||
Assert.AreSame(fourFiveSixDummy, dummies[1]);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
} // namespace Nuclex.Support.Collections
|
||||
|
||||
#endif // UNITTEST
|
||||
Loading…
Add table
Add a link
Reference in a new issue