Add System.Collections.ObjectModel.ObservableCollection<> test cases to ...

Tests/SimpleTestCases/ObservableCollectionConstructor.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.ObjectModel;
+
+public static class Program {
+
+ public class CustomClass
+ {
+ public string Field1;
+ public string Field2;
+
+ public override string ToString()
+ {
+ return Field1 + "/" + Field2;
+ }
+ }
+ public static void Main (string[] args) {
+
+ ObservableCollection<string> slist;
+
+ slist = new ObservableCollection<string>();
+ Console.WriteLine(slist.Count);
+
+ var list = new System.Collections.Generic.List<string>(10);
+ Console.WriteLine("String ObservableCollection with 10 elements");
+ slist = new ObservableCollection<string>(list);
+ Console.WriteLine(slist.Count);
+
+
+ for (int i = 0; i < slist.Count; i++)
+ {
+ PrintBool(slist[i]==null);
+ }
+
+
+ Console.WriteLine("Int ObservableCollection with 10 elements");
+ System.Collections.Generic.List<int> intList= new System.Collections.Generic.List<int>(10);
+ var intObs = new ObservableCollection<int>(intList);
+ Console.WriteLine(intObs.Count);
+
+
+ for (int i = 0; i < intObs.Count; i++)
+ {
+ PrintBool(intObs[i] == 0);
+ }
+
+
+ Console.WriteLine("String ObservableCollection with initializer ");
+ slist = new ObservableCollection<string> { "zero", "one", "two", "three" };
+
+
+ for (int i = 0; i < slist.Count; i++)
+ {
+ Console.WriteLine(slist[i]);
+ }
+
+
+ Console.WriteLine("String ObservableCollection with array constructor ");
+
+ string[] sArray = { "apple","orange","plum"};
+
+ slist = new ObservableCollection<string>(sArray); 
+ for (int i = 0; i < slist.Count; i++)
+ {
+ Console.WriteLine(slist[i]);
+ }
+
+ Console.WriteLine("ListWith custom Class Initializer");
+
+
+ ObservableCollection<CustomClass> ccList = new ObservableCollection<CustomClass>() { new CustomClass() { Field1 = "1.first", Field2 = "1.Second" }, new CustomClass() { Field1 = "2.first", Field2 = "2.Second" } };
+
+ for (int i = 0; i < ccList.Count; i++)
+ {
+ Console.WriteLine(ccList[i].ToString());
+ }
+
+ var cc= new CustomClass() { Field1="one", Field2 = "two" };
+ ccList = new ObservableCollection<CustomClass>() { cc };
+ PrintBool(ccList[0]==cc);
+
+ }
+
+ static void PrintBool(bool b)
+ {
+ Console.WriteLine(b ? 1 : 0);
+ }
+}

Tests/SimpleTestCases/ObservableCollectionContains.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.ObjectModel;
+
+public static class Program {
+ public static void Main (string[] args) {
+
+ var list = new ObservableCollection<string> { "zero", "one", "two", "three" };
+
+ PrintBool(list.Contains("two"));
+ PrintBool(list.Contains("zero"));
+ PrintBool(list.Contains("two-shouldNotExits"));
+ PrintBool(list.Contains("three"));
+
+ }
+
+ static void PrintBool(bool b)
+ {
+ Console.WriteLine(b ? 1 : 0);
+ }
+}

Tests/SimpleTestCases/ObservableCollectionGetEnumerator.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.ObjectModel;
+
+public static class Program {
+ public static void Main () {
+ var list1 = new ObservableCollection<string> {
+ "a", "b", "c"
+ };
+ var list2 = new ObservableCollection<string>(list1);
+ list2.Add("d");
+
+ foreach (var s in list2)
+ Console.WriteLine(s);
+ }
+}

Tests/SimpleTestCases/ObservableCollectionICollection.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+public static class Program
+{
+
+
+ public static void Main(string[] args)
+ {
+
+
+ var slist = new ObservableCollection<string> { "zero", "one", "two", "three" };
+
+
+ for (int i = 0; i < slist.Count; i++)
+ {
+ Console.WriteLine(slist[i]);
+ }
+
+
+ var collection = (ICollection<string>)slist;
+ Console.WriteLine(collection.Count);
+ PrintBool(collection.Contains("two"));
+ PrintBool(collection.Contains("two-shouldNotExits"));
+
+ // The following line passes even if IsReadonly is undefined in JSIL.Bootsrap.js, because !undefined seems to be true in JavaScript
+ // I can not write better unit test because of https:/kevingadd/JSIL/issues/91
+ // Manual tests (through JavaScript debugger) shows, that the property correctly returns false
+ PrintBool(collection.IsReadOnly);
+
+ Console.WriteLine("ICollection<T>.Add('four)");
+ collection.Add("four");
+
+ for (int i = 0; i < slist.Count; i++)
+ {
+ Console.WriteLine(slist[i]);
+ }
+
+ Console.WriteLine("ICollection<T>.Remove('one')");
+ collection.Remove("one");
+
+ for (int i = 0; i < slist.Count; i++)
+ {
+ Console.WriteLine(slist[i]);
+ }
+
+ Console.WriteLine("ICollection<T>.CopyTo");
+
+ string[] array = new string[collection.Count];
+ collection.CopyTo(array, 0);
+
+ for (int i = 0; i < array.Length; i++)
+ {
+ Console.WriteLine(array[i]);
+ }
+
+ Console.WriteLine("ICollection<T>.Clear");
+
+ Console.WriteLine(collection.Count);
+ PrintBool(collection.Count == slist.Count);
+
+ collection.Clear();
+
+ Console.WriteLine(collection.Count);
+ PrintBool(collection.Count == slist.Count);
+
+
+ }
+
+ static void PrintBool(bool b)
+ {
+ Console.WriteLine(b ? 1 : 0);
+ }
+}

Tests/SimpleTestCases/ObservableCollectionIList.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+public static class Program
+{
+
+
+ public static void Main(string[] args)
+ {
+
+
+ var slist = new ObservableCollection<string> { "zero", "one", "two", "three" };
+
+
+
+ // collection test are already implemented in ListiCollection.cs
+
+ // NOTE: JSIL is quite forgiving when implementing the interface - it does not take into account the returning parameter type
+ // so "object get_Item(i)" can also implement "T get_Item(int)". The listExternals implementation as a little bit
+ // loosey goosey. To be strict, different types of collection (ArrayList, List<T> should really have slightly
+ // different method signatures for get_item, set_Item and others - this is currenlty only partially covverred in JSIL.Bootsrap.js)
+ Console.WriteLine("----- interface ----");
+
+ var list = (IList<string>) slist;
+
+ Console.WriteLine(list.Count);
+ Console.WriteLine(list[0]);
+ Console.WriteLine(list[1]);
+ Console.WriteLine(list[2]);
+ Console.WriteLine(list[3]);
+
+ Console.WriteLine(list.IndexOf("two"));
+
+ list.Insert(1,"inserted");
+ Console.WriteLine(list.Count);
+ Console.WriteLine(list[4]);
+
+ list.RemoveAt(2);
+ Console.WriteLine(list.Count);
+ Console.WriteLine(list[3]);
+
+
+ list[2] = "modified";
+ Console.WriteLine(list[2]);
+
+ // also check item acecssor throw class (not the interface)
+ slist = new ObservableCollection<string> { "zero", "one", "two", "three" };
+
+ Console.WriteLine("----- class ----");
+
+ Console.WriteLine(slist.Count);
+ Console.WriteLine(slist[0]);
+ Console.WriteLine(slist[1]);
+ Console.WriteLine(slist[2]);
+ Console.WriteLine(slist[3]);
+
+ Console.WriteLine(slist.IndexOf("two"));
+
+ slist.Insert(1,"inserted");
+ Console.WriteLine(slist.Count);
+ Console.WriteLine(slist[4]);
+
+ slist.RemoveAt(2);
+ Console.WriteLine(slist.Count);
+ Console.WriteLine(slist[3]);
+
+
+ slist[2] = "modified";
+ Console.WriteLine(slist[2]);
+
+ }
+
+
+}

Tests/SimpleTestCases/ObservableCollectionIndexOf.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.ObjectModel;
+
+public static class Program {
+ public static void Main (string[] args) {
+
+ var list = new ObservableCollection<string> { "zero", "one", "two", "three" };
+
+ Console.WriteLine(list.IndexOf("two"));
+ Console.WriteLine(list.IndexOf("zero"));
+ Console.WriteLine(list.IndexOf("two-shouldNotExits"));
+ Console.WriteLine(list.IndexOf("three"));
+
+ // Other overloads not implemented yet
+ }
+
+}

Tests/SimpleTestCases/ObservableCollectionIndexOfEnum.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.ObjectModel;
+
+public enum Enum1 {
+ Value0 = 0,
+ Value1 = 1,
+}
+
+public static class Program {
+ public static void Main (string[] args) {
+ var list = new ObservableCollection<Enum1> { Enum1.Value0, Enum1.Value1, Enum1.Value0, (Enum1)3 };
+
+ Console.WriteLine(list.IndexOf(Enum1.Value0));
+ Console.WriteLine(list.IndexOf(Enum1.Value1));
+ Console.WriteLine(list.IndexOf((Enum1)2));
+
+ // Other overloads not implemented yet
+ }
+
+}

Tests/SimpleTestCases/ObservableCollectionInsert.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.ObjectModel;
+
+public static class Program {
+ public static void Main (string[] args) {
+
+
+ var list = new ObservableCollection<string> { "zero", "one", "two", "three" };
+
+ Console.WriteLine(list.IndexOf("two"));
+ Console.WriteLine(list.IndexOf("zero"));
+ Console.WriteLine(list.IndexOf("three"));
+
+ list.Insert(0, "newOne");
+ Console.WriteLine(list.IndexOf("three"));
+ Console.WriteLine(list.IndexOf("newOne"));
+
+ list.Insert(3, "anotherNewOne");
+ Console.WriteLine(list.IndexOf("three"));
+ Console.WriteLine(list.IndexOf("anotherNewOne")); 
+ Console.WriteLine(list.IndexOf("one"));
+
+
+ }
+
+}