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);
}
