419 строки
13 KiB
C#
419 строки
13 KiB
C#
//
|
|
// Unit tests for NSMutableOrderedSet Generic support
|
|
//
|
|
// Authors:
|
|
// Alex Soto <alex.soto@xamarin.com>
|
|
//
|
|
//
|
|
// Copyright 2015 Xamarin Inc. All rights reserved.
|
|
//
|
|
|
|
#if XAMCORE_2_0
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
|
|
using NUnit.Framework;
|
|
|
|
using Foundation;
|
|
|
|
namespace MonoTouchFixtures.Foundation {
|
|
|
|
[TestFixture]
|
|
public class NSMutableOrderedSet1Test {
|
|
|
|
[Test]
|
|
public void Ctor ()
|
|
{
|
|
var oset = new NSMutableOrderedSet<NSData> ();
|
|
|
|
Assert.AreEqual (0, oset.Count, "NSMutableOrderedSet Count");
|
|
}
|
|
|
|
[Test]
|
|
public void Ctor_Capacity ()
|
|
{
|
|
var oset = new NSMutableOrderedSet<NSData> (10);
|
|
|
|
Assert.AreEqual (0, oset.Count, "NSMutableOrderedSet Count");
|
|
}
|
|
|
|
[Test]
|
|
public void Ctor_Start ()
|
|
{
|
|
var oSet = new NSMutableOrderedSet<NSString> (start: (NSString) "foo");
|
|
|
|
Assert.AreEqual (1, oSet.Count, "NSMutableOrderedSet Count");
|
|
}
|
|
|
|
[Test]
|
|
public void Ctor_Params ()
|
|
{
|
|
var oSet = new NSMutableOrderedSet<NSString> ((NSString) "foo", (NSString) "bar", (NSString) "xyz");
|
|
|
|
Assert.AreEqual (3, oSet.Count, "NSMutableOrderedSet Count");
|
|
}
|
|
|
|
[Test]
|
|
public void Ctor_NSSet ()
|
|
{
|
|
var set = new NSSet<NSString> ((NSString) "foo", (NSString) "bar", (NSString) "xyz");
|
|
var oSet = new NSMutableOrderedSet<NSString> (set);
|
|
|
|
Assert.AreEqual (set.Count, oSet.Count, "NSMutableOrderedSet Count");
|
|
}
|
|
|
|
[Test]
|
|
public void Ctor_NSOrderedSet ()
|
|
{
|
|
var oSetSource = new NSOrderedSet<NSString> ((NSString) "foo", (NSString) "bar", (NSString) "xyz");
|
|
var oSet = new NSMutableOrderedSet<NSString> (oSetSource);
|
|
|
|
Assert.AreEqual (oSetSource.Count, oSet.Count, "NSOrderedSet1Test Count");
|
|
}
|
|
|
|
[Test]
|
|
public void Ctor_NSMutableOrderedSet ()
|
|
{
|
|
var oMutableSet = new NSMutableOrderedSet<NSString> ((NSString) "foo", (NSString) "bar", (NSString) "xyz");
|
|
var oSet = new NSMutableOrderedSet<NSString> (oMutableSet);
|
|
|
|
Assert.AreEqual (oMutableSet.Count, oSet.Count, "NSOrderedSet1Test Count");
|
|
}
|
|
|
|
[Test]
|
|
public void IndexerTest ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var oSet = new NSMutableOrderedSet<NSString> (str1, str2, str3);
|
|
|
|
Assert.AreEqual (3, oSet.Count, "NSOrderedSet1Test Count");
|
|
Assert.AreSame (str2, oSet[1], "NSOrderedSet1Test IndexOf");
|
|
Assert.Throws<ArgumentNullException> (()=> oSet[1] = null);
|
|
}
|
|
|
|
[Test]
|
|
public void AsSetTest ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var oSet = new NSMutableOrderedSet<NSString> (str1, str2, str3);
|
|
NSSet<NSString> set = oSet.AsSet ();
|
|
|
|
Assert.AreEqual (3, oSet.Count, "NSOrderedSet1Test Count");
|
|
Assert.AreEqual (3, set.Count, "NSOrderedSet1Test Count");
|
|
Assert.AreSame (str3, set.LookupMember (str3), "NSOrderedSet1Test IndexOf");
|
|
}
|
|
|
|
[Test]
|
|
public void InsertTest ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var oSet = new NSMutableOrderedSet<NSString> ();
|
|
Assert.AreEqual (0, oSet.Count, "InsertTest Count");
|
|
|
|
oSet.Insert (str1, 0);
|
|
oSet.Insert (str2, 1);
|
|
oSet.Insert (str3, 2);
|
|
Assert.AreEqual (3, oSet.Count, "InsertTest Count");
|
|
}
|
|
|
|
[Test]
|
|
public void ReplaceTest ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var str4 = (NSString) "4";
|
|
var oSet = new NSMutableOrderedSet<NSString> (str1, str2, str3);
|
|
|
|
oSet.Replace (0, str4);
|
|
|
|
Assert.IsTrue (oSet.Contains (str4), "ReplaceTesr Contains 4");
|
|
Assert.IsFalse (oSet.Contains (str1), "ReplaceTesr Contains 4");
|
|
}
|
|
|
|
[Test]
|
|
public void AddTest ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var oSet = new NSMutableOrderedSet<NSString> {
|
|
str1, str2, str3
|
|
};
|
|
|
|
Assert.AreEqual (3, oSet.Count, "AddTest Count");
|
|
Assert.IsTrue (oSet.Contains (str1), "AddTest Contains 1");
|
|
Assert.IsTrue (oSet.Contains (str2), "AddTest Contains 2");
|
|
Assert.IsTrue (oSet.Contains (str3), "AddTest Contains 3");
|
|
}
|
|
|
|
[Test]
|
|
public void AddObjectsTest ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var oSet = new NSMutableOrderedSet<NSString> ();
|
|
oSet.AddObjects (str1, str2, str3);
|
|
|
|
Assert.AreEqual (3, oSet.Count, "AddObjectsTest Count");
|
|
Assert.IsTrue (oSet.Contains (str1), "AddObjectsTest Contains 1");
|
|
Assert.IsTrue (oSet.Contains (str2), "AddObjectsTest Contains 2");
|
|
Assert.IsTrue (oSet.Contains (str3), "AddObjectsTest Contains 3");
|
|
}
|
|
|
|
[Test]
|
|
public void InsertObjectsTest ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var str4 = (NSString) "4";
|
|
var oSet = new NSMutableOrderedSet<NSString> (str4);
|
|
oSet.InsertObjects (new[] {str1, str2, str3}, NSIndexSet.FromNSRange (new NSRange (0, 3)));
|
|
|
|
Assert.AreEqual (4, oSet.Count, "InsertObjectsTest Count");
|
|
Assert.IsTrue (oSet.Contains (str1), "InsertObjectsTest Contains 1");
|
|
Assert.IsTrue (oSet.Contains (str2), "InsertObjectsTest Contains 2");
|
|
Assert.IsTrue (oSet.Contains (str3), "InsertObjectsTest Contains 3");
|
|
Assert.IsTrue (oSet.Contains (str4), "InsertObjectsTest Contains 4");
|
|
Assert.AreSame (str1, oSet[0], "InsertObjectsTest 1 == 1");
|
|
Assert.AreSame (str4, oSet[3], "InsertObjectsTest 4 == 4");
|
|
}
|
|
|
|
[Test]
|
|
public void ReplaceObjectsTest ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var str4 = (NSString) "4";
|
|
|
|
var oSet = new NSMutableOrderedSet<NSString> (str1, str2);
|
|
Assert.AreEqual (2, oSet.Count, "ReplaceObjectsTest Count");
|
|
Assert.AreSame (str1, oSet[0], "ReplaceObjectsTest 1 == 1");
|
|
Assert.AreSame (str2, oSet[1], "ReplaceObjectsTest 2 == 2");
|
|
|
|
oSet.ReplaceObjects (NSIndexSet.FromNSRange (new NSRange (0, 2)), str3, str4);
|
|
Assert.AreSame (str3, oSet[0], "ReplaceObjectsTest 3 == 3");
|
|
Assert.AreSame (str4, oSet[1], "ReplaceObjectsTest 4 == 4");
|
|
}
|
|
|
|
[Test]
|
|
public void RemoveObjectTest ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var oSet = new NSMutableOrderedSet<NSString> (str1, str2, str3);
|
|
Assert.AreEqual (3, oSet.Count, "RemoveObjectTest Count");
|
|
|
|
oSet.RemoveObject (str2);
|
|
Assert.AreEqual (2, oSet.Count, "RemoveObjectTest Count");
|
|
Assert.IsFalse (oSet.Contains (str2), "RemoveObjectTest must not contain 2");
|
|
Assert.IsTrue (oSet.Contains (str1), "RemoveObjectTest Contains 1");
|
|
Assert.IsTrue (oSet.Contains (str3), "RemoveObjectTest Contains 3");
|
|
}
|
|
|
|
[Test]
|
|
public void RemoveObjectsTest ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var oSet = new NSMutableOrderedSet<NSString> (str1, str2, str3);
|
|
Assert.AreEqual (3, oSet.Count, "RemoveObjectsTest Count");
|
|
|
|
oSet.RemoveObjects (str1, str2);
|
|
Assert.AreEqual (1, oSet.Count, "RemoveObjectsTest Count");
|
|
Assert.IsFalse (oSet.Contains (str1), "RemoveObjectsTest must not contain 1");
|
|
Assert.IsFalse (oSet.Contains (str2), "RemoveObjectsTest must not contain 2");
|
|
Assert.IsTrue (oSet.Contains (str3), "RemoveObjectsTest Contains 3");
|
|
}
|
|
|
|
[Test]
|
|
public void IEnumerable1Test ()
|
|
{
|
|
const int C = 16 * 2 + 3; // NSFastEnumerator has a array of size 16, use more than that, and not an exact multiple.
|
|
var values = new NSString [C];
|
|
for (int i = 0; i < C; i++)
|
|
values [i] = (NSString) i.ToString ();
|
|
|
|
var st = new NSMutableOrderedSet<NSString> (values);
|
|
Assert.AreEqual (C, st.Count, "Count 1");
|
|
|
|
var lst = new List<NSString> ();
|
|
foreach (var a in (IEnumerable<NSString>) st) {
|
|
Assert.IsNotNull (a, "null item iterator");
|
|
Assert.IsFalse (lst.Contains (a), "duplicated item iterator");
|
|
lst.Add (a);
|
|
Assert.IsTrue (Array.IndexOf (values, a) >= 0, "different object");
|
|
}
|
|
Assert.AreEqual (C, lst.Count, "iterator count");
|
|
}
|
|
|
|
[Test]
|
|
public void IEnumerableTest ()
|
|
{
|
|
const int C = 16 * 2 + 3; // NSFastEnumerator has a array of size 16, use more than that, and not an exact multiple.
|
|
var values = new NSString [C];
|
|
for (int i = 0; i < C; i++)
|
|
values [i] = (NSString) i.ToString ();
|
|
|
|
var st = new NSMutableOrderedSet<NSString> (values);
|
|
Assert.AreEqual (C, st.Count, "Count 1");
|
|
|
|
var lst = new List<NSString> ();
|
|
foreach (NSString a in (IEnumerable) st) {
|
|
Assert.IsNotNull (a, "null item iterator");
|
|
Assert.IsFalse (lst.Contains (a), "duplicated item iterator");
|
|
lst.Add (a);
|
|
Assert.IsTrue (Array.IndexOf (values, a) >= 0, "different object");
|
|
}
|
|
Assert.AreEqual (C, lst.Count, "iterator count");
|
|
}
|
|
|
|
[Test]
|
|
public void OperatorAddTest ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var str4 = (NSString) "4";
|
|
|
|
var first = new NSMutableOrderedSet<NSString> (str1, str2);
|
|
var second = new NSMutableOrderedSet<NSString> (str3, str4);
|
|
var third = first + second;
|
|
Assert.AreEqual (4, third.Count, "OperatorAdd Count");
|
|
Assert.IsTrue (third.Contains (str1), "OperatorAdd 1");
|
|
Assert.IsTrue (third.Contains (str2), "OperatorAdd 2");
|
|
Assert.IsTrue (third.Contains (str3), "OperatorAdd 3");
|
|
Assert.IsTrue (third.Contains (str4), "OperatorAdd 4");
|
|
}
|
|
|
|
[Test]
|
|
public void OperatorAddTest2 ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var str4 = (NSString) "4";
|
|
|
|
var first = new NSMutableOrderedSet<NSString> (str1, str2);
|
|
var second = new NSSet<NSString> (str3, str4);
|
|
var third = first + second;
|
|
Assert.AreEqual (4, third.Count, "OperatorAdd Count");
|
|
Assert.IsTrue (third.Contains (str1), "OperatorAdd 1");
|
|
Assert.IsTrue (third.Contains (str2), "OperatorAdd 2");
|
|
Assert.IsTrue (third.Contains (str3), "OperatorAdd 3");
|
|
Assert.IsTrue (third.Contains (str4), "OperatorAdd 4");
|
|
}
|
|
|
|
[Test]
|
|
public void OperatorAddTest3 ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var str4 = (NSString) "4";
|
|
|
|
var first = new NSMutableOrderedSet<NSString> (str1, str2);
|
|
var second = new NSOrderedSet<NSString> (str3, str4);
|
|
var third = first + second;
|
|
Assert.AreEqual (4, third.Count, "OperatorAdd Count");
|
|
Assert.IsTrue (third.Contains (str1), "OperatorAdd 1");
|
|
Assert.IsTrue (third.Contains (str2), "OperatorAdd 2");
|
|
Assert.IsTrue (third.Contains (str3), "OperatorAdd 3");
|
|
Assert.IsTrue (third.Contains (str4), "OperatorAdd 4");
|
|
}
|
|
|
|
[Test]
|
|
public void OperatorSubtractTest ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var str4 = (NSString) "4";
|
|
|
|
var first = new NSMutableOrderedSet<NSString> (str1, str2, str3, str4);
|
|
var second = new NSMutableOrderedSet<NSString> (str3, str4);
|
|
var third = first - second;
|
|
|
|
Assert.AreEqual (2, third.Count, "OperatorSubtract Count");
|
|
Assert.IsTrue (third.Contains (str1), "OperatorSubtract 1");
|
|
Assert.IsTrue (third.Contains (str2), "OperatorSubtract 2");
|
|
Assert.IsFalse (third.Contains (str3), "OperatorSubtract 3");
|
|
Assert.IsFalse (third.Contains (str4), "OperatorSubtract 4");
|
|
}
|
|
|
|
[Test]
|
|
public void OperatorSubtractTest2 ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var str4 = (NSString) "4";
|
|
|
|
var first = new NSMutableOrderedSet<NSString> (str1, str2, str3, str4);
|
|
var second = new NSSet<NSString> (str3, str4);
|
|
var third = first - second;
|
|
|
|
Assert.AreEqual (2, third.Count, "OperatorSubtract Count");
|
|
Assert.IsTrue (third.Contains (str1), "OperatorSubtract 1");
|
|
Assert.IsTrue (third.Contains (str2), "OperatorSubtract 2");
|
|
Assert.IsFalse (third.Contains (str3), "OperatorSubtract 3");
|
|
Assert.IsFalse (third.Contains (str4), "OperatorSubtract 4");
|
|
}
|
|
|
|
[Test]
|
|
public void OperatorSubtractTest3 ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var str4 = (NSString) "4";
|
|
|
|
var first = new NSMutableOrderedSet<NSString> (str1, str2, str3, str4);
|
|
var second = new NSOrderedSet<NSString> (str3, str4);
|
|
var third = first - second;
|
|
|
|
Assert.AreEqual (2, third.Count, "OperatorSubtract Count");
|
|
Assert.IsTrue (third.Contains (str1), "OperatorSubtract 1");
|
|
Assert.IsTrue (third.Contains (str2), "OperatorSubtract 2");
|
|
Assert.IsFalse (third.Contains (str3), "OperatorSubtract 3");
|
|
Assert.IsFalse (third.Contains (str4), "OperatorSubtract 4");
|
|
}
|
|
|
|
[Test]
|
|
public void OperatorPlusReferenceTest ()
|
|
{
|
|
var str1 = (NSString) "1";
|
|
var str2 = (NSString) "2";
|
|
var str3 = (NSString) "3";
|
|
var str4 = (NSString) "4";
|
|
var str5 = (NSString) "5";
|
|
var str6 = (NSString) "6";
|
|
|
|
var one = new NSMutableOrderedSet<NSString> (str1, str2, str3);
|
|
var two = new NSMutableOrderedSet<NSString> (str4, str5, str6);
|
|
NSMutableOrderedSet<NSString> nil = null;
|
|
using (var sum = one + nil)
|
|
using (var sum2 = two + one)
|
|
using (var sum3 = one + two) {
|
|
|
|
}
|
|
Assert.AreNotEqual (IntPtr.Zero, one.Handle, "Handle must be != IntPtr.Zero");
|
|
Assert.AreNotEqual (IntPtr.Zero, two.Handle, "Handle must be != IntPtr.Zero");
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif // XAMCORE_2_0 |