public void IListInsertWorks() { IList <string> l = new[] { "x", "y", "z" }; l.Insert(1, "a"); Assert.AreDeepEqual(new[] { "x", "a", "y", "z" }, l); }
public void IListRemoveAtWorks() { IList <string> l = new[] { "x", "y", "z" }; l.RemoveAt(1); Assert.AreDeepEqual(new[] { "x", "z" }, l); }
public static void TestUseCase() { var c1 = new Bridge722(); var asset1 = 1; asset1 = c1["path"] = 2; Assert.AreEqual(asset1, 2, "Bridge722 asset1"); Assert.AreEqual(M1(c1["path"] = 3), 3, "Bridge722 M1 3"); Assert.AreEqual(M1(asset1 = c1["path"] = 4), 4, "Bridge722 M1 4"); var c2 = new { }; var asset2 = c2["path"] = 5; Assert.AreEqual(asset2, 5, "Bridge722 asset2"); Assert.AreEqual(c2["path"], 5, "Bridge722 c2"); var c3 = new Dictionary <string, int>(); var asset3 = c3["path"] = 6; Assert.AreEqual(asset3, 6, "Bridge722 asset3"); Assert.AreEqual(c3["path"], 6, "Bridge722 c3"); decimal[] data4 = { 1m, 2m, 3m, 4m, 7m }; var c4 = new Dictionary <string, decimal>(); var asset4 = c4["path"] = data4.Select(x => x).Last(); Assert.AreDeepEqual(asset4, 7m, "Bridge722 asset4"); Assert.AreDeepEqual(c4["path"], 7m, "Bridge722 c4"); }
public void TaskFromPromiseWorksWhenPromiseFails() { var completeAsync = Assert.Async(); var promise = CreatePromise(); var task = Task.FromPromise(promise); Assert.AreEqual(TaskStatus.Running, task.Status, "Task should be running after being created"); bool continuationRun = false; var task1 = task.ContinueWith(t => { Assert.True(t == task, "ContinueWith parameter should be correct"); continuationRun = true; }); Assert.False(continuationRun, "Continuation should not be run too early."); Assert.AreEqual(TaskStatus.Running, task.Status, "Task should be running before promise is completed."); promise.Reject(42, "result 123", 101); task1.ContinueWith(x => { Assert.AreEqual(TaskStatus.Faulted, task.Status, "Task should have faulted after the promise was rejected."); Assert.True(continuationRun, "Continuation should have been run after promise was rejected."); Assert.True((object)task.Exception is AggregateException, "Exception should be an AggregateException"); Assert.AreEqual(1, task.Exception.InnerExceptions.Count, "Exception should have one inner exception"); Assert.True(task.Exception.InnerExceptions[0] is PromiseException, "Inner exception should be a PromiseException"); Assert.AreDeepEqual(new object[] { 42, "result 123", 101 }, ((PromiseException)task.Exception.InnerExceptions[0]).Arguments, "The PromiseException arguments should be correct"); completeAsync(); }); }
public void SomeNetSplitTests() { Assert.AreDeepEqual(new[] { "a", "bc", "de" }, "axybcxzde".Split(new[] { "xy", "xz" }, StringSplitOptions.None)); Assert.AreDeepEqual(new[] { "a", "bc", "de", "" }, "axybcxzdexz".Split(new[] { "xy", "xz" }, StringSplitOptions.None)); Assert.AreDeepEqual(new[] { "", "a", "bc", "de", "" }, "xzaxybcxzdexz".Split(new[] { "xy", "xz" }, StringSplitOptions.None)); Assert.AreDeepEqual(new[] { "", "a", "", "bc", "de", "" }, "xzaxyxzbcxzdexz".Split(new[] { "xy", "xz" }, StringSplitOptions.None)); Assert.AreDeepEqual(new[] { "", "a", "", "", "bc", "de", "" }, "xzaxyxzxybcxzdexz".Split(new[] { "xy", "xz" }, StringSplitOptions.None)); Assert.AreDeepEqual(new[] { "a", "bc", "de" }, "axybcxzde".Split(new[] { "xy", "xz" }, StringSplitOptions.RemoveEmptyEntries)); Assert.AreDeepEqual(new[] { "a", "bc", "de" }, "axybcxzdexz".Split(new[] { "xy", "xz" }, StringSplitOptions.RemoveEmptyEntries)); Assert.AreDeepEqual(new[] { "a", "bc", "de" }, "xzaxybcxzdexz".Split(new[] { "xy", "xz" }, StringSplitOptions.RemoveEmptyEntries)); Assert.AreDeepEqual(new[] { "a", "bc", "de" }, "xzaxyxzbcxzdexz".Split(new[] { "xy", "xz" }, StringSplitOptions.RemoveEmptyEntries)); Assert.AreDeepEqual(new[] { "a", "bc", "de" }, "xzaxyxzxybcxzdexz".Split(new[] { "xy", "xz" }, StringSplitOptions.RemoveEmptyEntries)); Assert.AreDeepEqual(new[] { "a", "bc", "de" }, "axybcxzde".Split(new[] { "xy", "xz" }, 100, StringSplitOptions.None)); Assert.AreDeepEqual(new[] { "a", "bc", "de", "" }, "axybcxzdexz".Split(new[] { "xy", "xz" }, 100, StringSplitOptions.None)); Assert.AreDeepEqual(new[] { "", "a", "bc", "de", "" }, "xzaxybcxzdexz".Split(new[] { "xy", "xz" }, 100, StringSplitOptions.None)); Assert.AreDeepEqual(new[] { "", "a", "", "bc", "de", "" }, "xzaxyxzbcxzdexz".Split(new[] { "xy", "xz" }, 100, StringSplitOptions.None)); Assert.AreDeepEqual(new[] { "", "a", "", "", "bc", "de", "" }, "xzaxyxzxybcxzdexz".Split(new[] { "xy", "xz" }, 100, StringSplitOptions.None)); Assert.AreDeepEqual(new[] { "a", "bcxzde" }, "axybcxzde".Split(new[] { "xy", "xz" }, 2, StringSplitOptions.None)); Assert.AreDeepEqual(new[] { "a", "bcxzdexz" }, "axybcxzdexz".Split(new[] { "xy", "xz" }, 2, StringSplitOptions.None)); Assert.AreDeepEqual(new[] { "a", "xzbcxzdexz" }, "axyxzbcxzdexz".Split(new[] { "xy", "xz" }, 2, StringSplitOptions.None)); Assert.AreDeepEqual(new[] { "", "axybcxzdexz" }, "xzaxybcxzdexz".Split(new[] { "xy", "xz" }, 2, StringSplitOptions.None)); Assert.AreDeepEqual(new[] { "a", "bcxzde" }, "axybcxzde".Split(new[] { "xy", "xz" }, 2, StringSplitOptions.RemoveEmptyEntries)); Assert.AreDeepEqual(new[] { "a", "bcxzdexz" }, "axybcxzdexz".Split(new[] { "xy", "xz" }, 2, StringSplitOptions.RemoveEmptyEntries)); Assert.AreDeepEqual(new[] { "a", "bcxzdexz" }, "axyxzbcxzdexz".Split(new[] { "xy", "xz" }, 2, StringSplitOptions.RemoveEmptyEntries)); Assert.AreDeepEqual(new[] { "a", "bcxzdexz" }, "xzaxyxzbcxzdexz".Split(new[] { "xy", "xz" }, 2, StringSplitOptions.RemoveEmptyEntries)); }
public void InvariantWorks() { var format = DateTimeFormatInfo.InvariantInfo; Assert.AreEqual("AM", format.AMDesignator); Assert.AreEqual("PM", format.PMDesignator); Assert.AreEqual("/", format.DateSeparator); Assert.AreEqual(":", format.TimeSeparator); Assert.AreEqual("dddd, dd MMMM yyyy HH:mm:ss", format.FullDateTimePattern); Assert.AreEqual("yyyy MMMM", format.YearMonthPattern); Assert.AreEqual("yyyy'-'MM'-'dd'T'HH':'mm':'ss", format.SortableDateTimePattern); Assert.AreEqual("dddd, dd MMMM yyyy", format.LongDatePattern); Assert.AreEqual("MM/dd/yyyy", format.ShortDatePattern); Assert.AreEqual("HH:mm:ss", format.LongTimePattern); Assert.AreEqual("HH:mm", format.ShortTimePattern); Assert.AreEqual(0, format.FirstDayOfWeek); Assert.AreDeepEqual(new[] { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" }, format.DayNames); Assert.AreDeepEqual(new[] { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December", "" }, format.MonthNames); }
public void ReverseWorks() { var arr = new[] { 1, 3, 4, 1, 3, 2 }; arr.Reverse(); Assert.AreDeepEqual(new[] { 2, 3, 1, 4, 3, 1 }, arr); }
public void PushWorks() { var l = GetStack(); l.Push("a"); Assert.AreDeepEqual(new[] { "a", "y", "x" }, l.ToArray()); }
public void ClassImplementingIListRemoveAtWorks() { MyList l = new MyList(new[] { "x", "y", "z" }); l.RemoveAt(1); Assert.AreDeepEqual(l.Items.ToArray(), new[] { "x", "z" }); }
public void ClassImplementingIListCastToIListRemoveAtWorks() { IList <string> l = new MyList(new[] { "x", "y", "z" }); l.RemoveAt(1); Assert.AreDeepEqual(((MyList)l).Items.ToArray(), new[] { "x", "z" }); }
public void ClassImplementingIListInsertWorks() { MyList l = new MyList(new[] { "x", "y" }); l.Insert(1, "z"); Assert.AreDeepEqual(l.Items.ToArray(), new[] { "x", "z", "y" }); }
public static void TestStaticConstructorsAndMethods() { // TEST // Check static fields initialization Assert.AreEqual(ClassA.StatitIntNotInitialized, 0, "#74 StatitInt not initialized"); Assert.AreEqual(ClassA.StatitStringNotInitialized, null, "#74 StatitString not initialized"); Assert.AreEqual(ClassA.CONST_CHAR, 81, "#74 CONST_CHAR Q"); Assert.AreEqual(ClassA.CONST_DECIMAL == 3.123456789324324324m, true, "#74 CONST_DECIMAL 3.123456789324324324m"); // TEST // Check static constructor Assert.AreEqual(ClassA.StaticInt, -340, "StatitInt initialized"); Assert.AreEqual(ClassA.StaticString, "Defined string", "StatitString initialized"); // TEST // Check static methods var a = ClassA.StaticMethod1(678, "ASD", double.NaN); Assert.AreEqual(ClassA.StatitIntNotInitialized, 678, "StatitIntNotInitialized 678"); Assert.AreEqual(ClassA.StatitStringNotInitialized, "ASD", "ClassA.StatitStringNotInitialized ASD"); Assert.AreDeepEqual(a.DoubleA, double.NaN, "DoubleA double.NaN"); a = ClassA.StaticMethod2((object)678, "QWE", 234); Assert.AreEqual(ClassA.StatitIntNotInitialized, 1678, "StatitIntNotInitialized 1678"); Assert.AreEqual(ClassA.StatitStringNotInitialized, "QWE", "ClassA.StatitStringNotInitialized QWE"); Assert.AreEqual(a.DoubleA, 234, "DoubleA 234"); Assert.Throws(TestSet1FailureHelper.StaticMethod2Failure, "Unable to cast type String to type Bridge.Int", "Cast exception should occur"); }
public void ICollectionClearWorks() { IList <string> l = new[] { "x", "y", "z" }; l.Clear(); Assert.AreDeepEqual(l, new string[0]); }
public void Sort1Works() { var arr = new[] { 1, 6, 6, 4, 2 }; Array.Sort(arr); Assert.AreDeepEqual(arr, new[] { 1, 2, 4, 6, 6 }); }
public void SortWithDefaultCompareWorks() { var arr = new[] { 1, 6, 6, 4, 2 }; arr.JsSort(); Assert.AreDeepEqual(new[] { 1, 2, 4, 6, 6 }, arr); }
public static void Test() { // TEST var words = new string[] { "ab2", "ac", "a", "ab12", "", "ab", "bac", "z" }; var sortedWords = (from word in words orderby word select word).ToArray(); Assert.AreDeepEqual(new[] { "", "a", "ab", "ab12", "ab2", "ac", "bac", "z" }, sortedWords, "Order by words"); // TEST var sortedWordsByLength = (from word in words orderby word.Length select word).ToArray(); Assert.AreDeepEqual(new[] { "", "a", "z", "ac", "ab", "ab2", "bac", "ab12" }, sortedWordsByLength, "Order by word length"); // TEST var sortedPersonsByName = (from p in Person.GetPersons() orderby p.Name select p.Name).ToArray(); Assert.AreDeepEqual(new[] { "Billy", "Dora", "Frank", "Ian", "John", "Mary", "Nemo", "Zeppa" }, sortedPersonsByName, "Order by person names"); // TODO test with System.StringComparison // TEST var doubles = new double[] { 1.0, -0.7, 2.1, 0.9, 1.4, 2.9 }; var sortedDoubles = (from d in doubles orderby d descending select d).ToArray(); Assert.AreDeepEqual(new[] { 2.9, 2.1, 1.4, 1.0, 0.9, -0.7 }, sortedDoubles, "Order by descending double"); // TEST var sortedPersonsByCountDesc = (from p in Person.GetPersons() orderby p.Count descending select p.Count).ToArray(); Assert.AreDeepEqual(new[] { 3000, 700, 700, 550, 500, 300, 100, 50 }, sortedPersonsByCountDesc, "Order by person count descending"); // TEST var sortedWordsByLengthAndLetters = (from word in words orderby word.Length, word select word).ToArray(); Assert.AreDeepEqual(new[] { "", "a", "z", "ab", "ac", "ab2", "bac", "ab12" }, sortedWordsByLengthAndLetters, "Order by word length then by letters"); // TEST var sortedWordsByLengthAndLettersLambda = words.OrderBy(x => x.Length).ThenByDescending(x => x).ToArray(); Assert.AreDeepEqual(new[] { "", "z", "a", "ac", "ab", "bac", "ab2", "ab12" }, sortedWordsByLengthAndLettersLambda, "Order by word length then by letters as lambda"); // TEST // var numbers = new[] { 2, 4, 6, 1, 5, 7, 9, 0, 8, 3}; var numbers = new[] { 2, 4, 6, 1, 5 }; var numbersReversed = numbers.Reverse <int>().ToArray(); Assert.AreDeepEqual(new[] { 5, 1, 6, 4, 2 }, numbersReversed, "Reverse() numbers"); }
public void Sort2Works() { var arr = new[] { 1, 6, 6, 4, 2 }; Array.Sort(arr, 2, 3); Assert.AreDeepEqual(new[] { 1, 6, 2, 4, 6 }, arr); }
public void PeekWorks() { var list = GetStack(); Assert.AreEqual("y", list.Peek()); Assert.AreDeepEqual(new[] { "y", "x" }, list.ToArray()); }
public void Sort3Works() { var arr = new[] { 1, 2, 6, 3, 6, 7 }; Array.Sort(arr, 2, 3, new TestReverseComparer()); Assert.AreDeepEqual(new[] { 1, 2, 6, 6, 3, 7 }, arr); }
public static void TypeWithFieldWorks() { var c = new ClassWithFields(); dynamic raw = null; //@ raw = Newtonsoft.Json.JsonConvert.SerializeObject(c, 0, {}, true); Assert.AreEqual(System.Convert.ToBase64String(c.byteArrayField), raw.byteArrayField, "#1"); Assert.AreEqual(c.guidField.ToString(), raw.guidField, "#2"); Assert.AreEqual(typeof(SerializationTests).FullName, raw.typeField, "#3"); Assert.AreEqual("a", raw.charField, "#4"); Assert.AreEqual(0, raw.longField, "#5"); Assert.AreEqual(0, raw.ulongField, "#6"); Assert.AreEqual(0, raw.decimalField, "#7"); Assert.NotNull(raw.dateField, "#8"); dynamic rawDateField = null; //@ rawDateField = System.DateTime.format(c.dateField, "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'FFFFFFFK"); Assert.AreEqual(rawDateField, raw.dateField, "#9 " + raw.dateField); Assert.AreEqual(0, raw.enumField, "#10"); Assert.AreEqual(new int[] { 1, 2, 3 }, raw.arrayField, "#11"); Assert.AreEqual(new int[] { 0, 1, 2 }, raw.listField, "#12"); Assert.AreDeepEqual(Script.ToPlainObject(new { i1 = 0, i2 = 1, i3 = 2 }), raw.dictField, "#13"); }
public void Sort4Works() { var arr = new[] { 1, 6, 6, 4, 2 }; Array.Sort(arr, new TestReverseComparer()); Assert.AreDeepEqual(new[] { 6, 6, 4, 2, 1 }, arr); }
public static void Test() { // TEST var numbers = (from n in Enumerable.Range(0, 6) select new { Number = n, IsOdd = n % 2 == 1 }).ToArray(); var numbersExpected = new object[] { new { Number = 0, IsOdd = false }, new { Number = 1, IsOdd = true }, new { Number = 2, IsOdd = false }, new { Number = 3, IsOdd = true }, new { Number = 4, IsOdd = false }, new { Number = 5, IsOdd = true }, }; Assert.AreDeepEqual(numbersExpected, numbers, "Range() 6 items from 0"); // TEST var repeatNumbers = Enumerable.Repeat(-3, 4).ToArray(); var repeatNumbersExpected = new[] { -3, -3, -3, -3 }; Assert.AreDeepEqual(repeatNumbersExpected, repeatNumbers, "Repeat() -3 four times"); }
public void ICollectionAddWorks() { IList <string> l = new[] { "x", "y", "z" }; l.Add("a"); Assert.AreDeepEqual(new[] { "x", "y", "z", "a" }, l); }
public void TaskFromPromiseWithoutResultFactoryWorksWhenPromiseCompletes() { var completeAsync = Assert.Async(); var promise = CreatePromise(); var task = Task.FromPromise(promise); Assert.AreEqual(TaskStatus.Running, task.Status, "Task should be running after being created"); bool continuationRun = false; var task1 = task.ContinueWith(t => { Assert.True(t == task, "ContinueWith parameter should be correct"); continuationRun = true; }); Assert.False(continuationRun, "Continuation should not be run too early."); Assert.AreEqual(TaskStatus.Running, task.Status, "Task should be running before promise is completed."); promise.Resolve(42, "result 123", 101); task1.ContinueWith(x => { Assert.AreEqual(TaskStatus.RanToCompletion, task.Status, "Task should be completed after promise"); Assert.True(continuationRun, "Continuation should have been run after promise was completed."); Assert.AreDeepEqual(new object[] { 42, "result 123", 101 }, task.Result, "The result should be correct"); completeAsync(); }); }
public void IssueSpecific() { IList <string> l = new[] { "x", "y", "z" }; l.RemoveAt(1); Assert.AreDeepEqual(new[] { "x", "z" }, l); }
public void ClassImplementingIListCastToIListInsertWorks() { IList <string> l = new MyList(new[] { "x", "y" }); l.Insert(1, "z"); Assert.AreDeepEqual(new[] { "x", "z", "y" }, ((MyList)l).Items.ToArray()); }
public void IListIndexingWorks() { IList <string> l = new[] { "x", "y", "z" }; Assert.AreEqual("y", l[1]); l[1] = "a"; Assert.AreDeepEqual(new[] { "x", "a", "z" }, l); }
public void ConcatWorks() { var arr = new[] { "a", "b" }; Assert.AreDeepEqual(new[] { "a", "b", "c" }, arr.Concat("c")); Assert.AreDeepEqual(new[] { "a", "b", "c", "d" }, arr.Concat("c", "d")); Assert.AreDeepEqual(new[] { "a", "b" }, arr); }
public void ICollectionRemoveWorks() { IList <string> l = new[] { "x", "y", "z" }; Assert.True(l.Remove("y")); Assert.False(l.Remove("a")); Assert.AreDeepEqual(new[] { "x", "z" }, l); }
public void CloneWorks() { var arr = new[] { "x", "y" }; var arr2 = arr.Clone(); Assert.False(arr == arr2); Assert.AreDeepEqual(arr2, arr); }