public static void Test(Assert assert) { assert.Expect(4); // TEST int[] numbersA = { 4, 1, 3 }; int[] numbersB = { 2, 3, 5 }; var concatNumbers = numbersA.Concat(numbersB); assert.DeepEqual(concatNumbers, new[] { 4, 1, 3, 2, 3, 5 }, "Concat() numbers"); // TEST var names = from p in Person.GetPersons() select p.Name; var cities = from p in Person.GetPersons() select p.City; var concatNames = names.Concat(cities).ToArray(); assert.DeepEqual(concatNames, new[] { "Frank", "Zeppa", "John", "Billy", "Dora", "Ian", "Mary", "Nemo", "Edmonton", "Tokyo", "Lisbon", "Paris", "Budapest", "Rome", "Dortmund", "Ocean"}, "Concat() two sequences"); // TEST var a = new[] { "a", "b", "z" }; var b = new[] { "a", "b", "z" }; assert.Ok(a.SequenceEqual(b), "SequenceEqual() for equal sequences"); // TEST var c = new[] { "a", "b", "z" }; var d = new[] { "a", "z", "b" }; assert.Ok(!c.SequenceEqual(d), "SequenceEqual() for not equal sequences"); }
public static void Test(Assert assert) { assert.Expect(2); // 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.DeepEqual(numbers, numbersExpected, "Range() 6 items from 0"); // TEST var repeatNumbers = Enumerable.Repeat(-3, 4).ToArray(); var repeatNumbersExpected = new[] { -3, -3, -3, -3 }; assert.DeepEqual(repeatNumbers, repeatNumbersExpected, "Repeat() -3 four times"); }
public static void Test(Assert assert) { assert.Expect(5); // TEST var numbers = new[] { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 }; var filteredNumbers = (from n in numbers where n <= 6 select n).ToArray(); assert.DeepEqual(filteredNumbers, new[] { 5, 4, 1, 3, 6, 2, 0 }, "Where elements in integer array are below or equal 6"); // TEST var filteredCounts = (from p in Person.GetPersons() where p.Count < 501 select p.Count).ToArray(); assert.DeepEqual(filteredCounts, new[] {300, 100, 500, 50 }, "Where elements in Person array have Count below 501"); // TEST filteredCounts = (from p in Person.GetPersons() where p.Count < 501 && p.Group == "A" select p.Count).ToArray(); assert.DeepEqual(filteredCounts, new[] { 300 }, "Where elements in Person array have Count below 501 ang in group 'A'"); // TEST var persons = Person.GetPersons(); var filteredPersonByCounts = (from p in Person.GetPersons() where p.Count < 501 select p).ToArray(); assert.DeepEqual(filteredPersonByCounts, new[] { persons[0], persons[1], persons[3], persons[4] }, "Where elements in Person array have Count below 501. Returns Person instances"); // TEST var filteredPersonByCountAndIndex = persons.Where((p, index) => p.Count < index * 100).ToArray(); assert.DeepEqual(filteredPersonByCountAndIndex, new[] { persons[4] }, "Where elements in Person array have Count meet condition (p.Count < index * 100). Returns Person instances"); }
public static void Test(Assert assert) { assert.Expect(6); // TEST int[] numbers = new int[] { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 }; int i = 0; var aQuery = from n in numbers select ++i; assert.Equal(i, 0, "Query is not executed until you enumerate over them"); // TEST aQuery.ToList(); assert.Equal(i, 10, "Query is executed after you enumerate over them"); i = 0; // TEST var bQuery = (from n in numbers select ++i).Max(); assert.Equal(i, 10, "Max() executes immediately"); // TEST var smallNumbers = from n in numbers where n <= 3 select n; var smallerEvenNumbers = from n in smallNumbers where n % 2 == 0 select n; assert.DeepEqual(smallerEvenNumbers.ToArray(), new[] { 2, 0 }, "Query in a query"); // TEST numbers.ForEach((x, index) => numbers[index] = -numbers[index]); assert.DeepEqual(numbers.ToArray(), new int[] { -5, -4, -1, -3, -9, -8, -6, -7, -2, 0 }, "ForEach()"); // TEST assert.DeepEqual(smallerEvenNumbers.ToArray(), new[] { -4, -8, -6, -2, 0 }, "Second query run on a modified source"); }
public static void TestUseCase(Assert assert) { assert.Expect(3); var list = new List<int>(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }); assert.DeepEqual(list.GetRange(0, 2).ToArray(), new[] { 1, 2 }, "Bridge532 (0, 2)"); assert.DeepEqual(list.GetRange(1, 2).ToArray(), new[] { 2, 3 }, "Bridge532 (1, 2)"); assert.DeepEqual(list.GetRange(6, 3).ToArray(), new[] { 7, 8, 9 }, "Bridge532 (6, 3)"); }
public static void Test(Assert assert) { assert.Expect(4); // TEST string[] words = { "count", "tree", "mount", "five", "doubt" }; bool anyOu = words.Any(w => w.Contains("ou")); assert.Ok(anyOu, "Any() to return words containing 'ou'"); // TEST int[] oddNumbers = { 3, 7, 9, 5, 247, 1000001 }; bool onlyOdd = oddNumbers.All(n => n % 2 == 1); assert.Ok(onlyOdd, "All() is odd"); // TEST int[] someNumbers = { 2, 3, 7, 9, 5, 247, 1000001 }; bool notOnlyOdd = !someNumbers.All(n => n % 2 == 1); assert.Ok(notOnlyOdd, "All() is not only odd"); // TEST var productGroups = (from p in Person.GetPersons() group p by p.Group into pGroup where pGroup.Any(p => p.Count >= 500) select new { Group = pGroup.Key, Names = pGroup.Select(x => x.Name).ToArray() }).ToArray(); object[] productGroupsExpected = { new {Group = "C", Names = new[]{"Zeppa", "Billy"}}, new {Group = "B", Names = new[]{"John", "Dora", "Ian", "Mary"}}, new {Group = (string)null, Names = new[]{"Nemo"}} }; assert.DeepEqual(productGroups, productGroupsExpected, "Any() to return a grouped array of names only for groups having any item with Count > 500"); }
public static void Test(Assert assert) { // TEST int[] a = { 1, 2 }; int[] b = { 1, 2 }; var result = a.Intersect(b).ToArray(); assert.Expect(8); // TEST int[] numbers = { 1, 2, 3, 3, 1, 5, 4, 2, 3 }; var uniqueNumbers = numbers.Distinct().ToArray(); assert.DeepEqual(uniqueNumbers, new[] { 1, 2, 3, 5, 4 }, "Distinct() to remove duplicate elements"); // TEST var distinctPersonGroups = (from p in Person.GetPersons() select p.Group).Distinct().ToArray(); assert.DeepEqual(distinctPersonGroups, new[] { "A", "C", "B", null }, "Distinct() to remove duplicate Group elements"); // TEST int[] numbersA = { 0, 2, 4, 5, 6, 8, 9 }; int[] numbersB = { 1, 3, 5, 7, 8 }; var uniqueNumbersAB = numbersA.Union(numbersB).ToArray(); assert.DeepEqual(uniqueNumbersAB, new[] { 0, 2, 4, 5, 6, 8, 9, 1, 3, 7 }, "Union() to get unique number sequence"); // TEST var nameChars = from p in Person.GetPersons() select p.Name[0]; var cityChars = from p in Person.GetPersons() select p.City[0]; var uniqueFirstChars = nameChars.Union(cityChars).ToArray(); assert.DeepEqual(uniqueFirstChars, new[] { (int)'F', (int)'Z', (int)'J', (int)'B', (int)'D', (int)'I', (int)'M', (int)'N', (int)'E', (int)'T', (int)'L', (int)'P', (int)'R', (int)'O' }, "Union to get unique first letters of Name and City"); // TEST var commonNumbersCD = numbersA.Intersect(numbersB).ToArray(); assert.DeepEqual(commonNumbersCD, new[] { 5, 8 }, "Intersect() to get common number sequence"); // TEST nameChars = from p in Person.GetPersons() select p.Name[0]; cityChars = from p in Person.GetPersons() select p.City[0]; var commonFirstChars = nameChars.Intersect(cityChars).ToArray(); assert.DeepEqual(commonFirstChars, new[] { (int)'B', (int)'D' }, "Intersect() to get common first letters of Name and City"); // TEST var exceptNumbersCD = numbersA.Except(numbersB).ToArray(); assert.DeepEqual(exceptNumbersCD, new[] { 0, 2, 4, 6, 9 }, "Except() to get numbers from first sequence and does not contain the second sequence numbers"); // TEST var exceptFirstChars = nameChars.Except(cityChars).ToArray(); assert.DeepEqual(exceptFirstChars, new[] { (int)'F', (int)'Z', (int)'J', (int)'I', (int)'M', (int)'N' }, "Except() to get letters from Name sequence and does not contain City letters"); }
private static void TestCreateLabel(Assert assert) { assert.Expect(6); var view = Test.GetView(); var label = view.CreateLabelElement("someLabel", "Title", "10px", true, HTMLColor.Blue); assert.Ok(label != null, "label created"); view.Root.AppendChild(label); var foundLabel = Document.GetElementById<LabelElement>("someLabel"); assert.Ok(foundLabel != null, "foundLabel"); assert.DeepEqual(foundLabel.InnerHTML, "Title", "foundLabel.innerHtml = 'Title'"); assert.DeepEqual(foundLabel.Style.Color, HTMLColor.Blue, "foundLabel.Style.Color = Blue"); assert.DeepEqual(foundLabel.Style.Margin, "10px", "foundLabel.Style.Margin = '10px'"); assert.DeepEqual(foundLabel.Style.FontWeight, "bold", "foundLabel.Style.FontWeight = 'bold'"); }
public static void Test(Assert assert) { assert.Expect(8); // TEST var words = new string[] { "ab2", "ac", "a", "ab12", "", "ab", "bac", "z" }; var sortedWords = (from word in words orderby word select word).ToArray(); assert.DeepEqual(sortedWords, new[] { "", "a", "ab", "ab12", "ab2", "ac", "bac", "z" }, "Order by words"); // TEST var sortedWordsByLength = (from word in words orderby word.Length select word).ToArray(); assert.DeepEqual(sortedWordsByLength, new[] { "", "a", "z", "ac", "ab", "ab2", "bac", "ab12" }, "Order by word length"); // TEST var sortedPersonsByName = (from p in Person.GetPersons() orderby p.Name select p.Name).ToArray(); assert.DeepEqual(sortedPersonsByName, new[] { "Billy", "Dora", "Frank", "Ian", "John", "Mary", "Nemo", "Zeppa" }, "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.DeepEqual(sortedDoubles, new[] { 2.9, 2.1, 1.4, 1.0, 0.9, -0.7 }, "Order by descending double"); // TEST var sortedPersonsByCountDesc = (from p in Person.GetPersons() orderby p.Count descending select p.Count).ToArray(); assert.DeepEqual(sortedPersonsByCountDesc, new[] { 3000, 700, 700, 550, 500, 300, 100, 50 }, "Order by person count descending"); // TEST var sortedWordsByLengthAndLetters = (from word in words orderby word.Length, word select word).ToArray(); assert.DeepEqual(sortedWordsByLengthAndLetters, new[] { "", "a", "z", "ab", "ac", "ab2", "bac", "ab12" }, "Order by word length then by letters"); // TEST var sortedWordsByLengthAndLettersLambda = words.OrderBy(x => x.Length).ThenByDescending(x => x).ToArray(); assert.DeepEqual(sortedWordsByLengthAndLettersLambda, new[] { "", "z", "a", "ac", "ab", "bac", "ab2", "ab12" }, "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.DeepEqual(numbersReversed, new[] { 5, 1, 6, 4, 2 }, "Reverse() numbers"); }
public static void TestUseCase(Assert assert) { assert.Expect(1); var s = "ab|abc&ab&abc|de&ef&"; var r = s.Split('|', '&'); var expected = new[] { "ab", "abc", "ab", "abc", "de", "ef", "" }; assert.DeepEqual(r, expected, "#578 Split(params char[] separator)"); }
private static void TestCreatePersonUIElements(Assert assert) { assert.Expect(2); var application = Test.GetApplication(); application.RenderPerson(); var lblPersonName = Document.GetElementById<LabelElement>("lblPersonName"); assert.Ok(lblPersonName != null, "lblPersonName created"); assert.DeepEqual(lblPersonName.InnerHTML, "Frank", "lblPersonName = 'Frank'"); }
public static void CaughtExceptions(Assert assert) { assert.Expect(3); TryCatchWithCaughtException(); assert.Ok(true, "Exception catch"); TryCatchWithCaughtTypedException(); assert.Ok(true, "Typed exception catch"); var exceptionMessage = TryCatchWithCaughtArgumentException(); assert.DeepEqual(exceptionMessage, "catch me", "Typed exception catch with exception message"); }
public static void Bridge329(Assert assert) { assert.Expect(5); DateTime d1; var b1 = DateTime.TryParse("2001-01-01", out d1, true); assert.Ok(b1, "TryParse parsed '2001 - 01 - 01'"); assert.Equal(d1.GetUtcFullYear(), 2001, "TryParse works Year"); assert.Equal(d1.GetUtcMonth(), 1, "TryParse works Month"); assert.Equal(d1.GetUtcDay(), 1, "TryParse works Day"); var d2 = DateTime.Parse("2001-01-01", true); assert.DeepEqual(d2.ToString(), d1.ToString(), "TryParse And Parse give the same result"); }
// DateTime functions public static void DateTimes(Assert assert) { assert.Expect(2); // TEST // [#83] by C# var str = "2015-03-24T10:48:09.1500225+03:00"; var bridgeDate = DateTime.Parse(str); var bridgeDate1 = new DateTime(str); assert.DeepEqual(bridgeDate, bridgeDate1, "[#83] C# bridgeDate = bridgeDate1"); // TEST // [#83] by JavaScript code. This is to check the same issue as above and just to check another way of calling QUnit from JavaScript Script.Write<dynamic>(@"var str = ""2015-03-24T10:48:09.1500225+03:00"", bridgeDate = Bridge.Date.parse(str), jsDate = new Date(Date.parse(str)), format = ""yyyy-MM-dd hh:mm:ss""; assert.deepEqual(Bridge.Date.format(bridgeDate, format), Bridge.Date.format(jsDate, format), ""[#83] js"")"); }
public static void Test(Assert assert) { assert.Expect(8); // TEST var numbers = new[] { 1, 3, 5, 7, 9 }; var firstTwo = numbers.Take(2).ToArray(); assert.DeepEqual(firstTwo, new[] { 1, 3 }, "Take() the first two array elements"); // TEST var lastThree = numbers.TakeFromLast(3).ToArray(); assert.DeepEqual(lastThree, new[] { 5, 7, 9 }, "TakeFromLast() the last three array elements"); // TEST var exceptTwoLast = numbers.TakeExceptLast(2).ToArray(); assert.DeepEqual(exceptTwoLast, new[] { 1, 3, 5 }, "TakeExceptLast() the first array elements except the last two"); // TEST var takeWhileLessTwo = numbers.TakeWhile((number) => number < 2).ToArray(); assert.DeepEqual(takeWhileLessTwo, new[] { 1 }, "TakeWhile() less two"); // TEST var takeWhileSome = numbers.TakeWhile((number, index) => number - index <= 4).ToArray(); assert.DeepEqual(takeWhileSome, new[] { 1, 3, 5, 7 }, "TakeWhile() by value and index"); // TEST var skipThree = numbers.Skip(3).ToArray(); assert.DeepEqual(skipThree, new[] { 7, 9 }, "Skip() the first three"); // TEST var skipWhileLessNine = numbers.SkipWhile(number => number < 9).ToArray(); assert.DeepEqual(skipWhileLessNine, new[] { 9 }, "SkipWhile() less then 9"); // TEST var skipWhileSome = numbers.SkipWhile((number, index) => number <= 3 && index < 2).ToArray(); assert.DeepEqual(skipWhileSome, new[] { 5, 7, 9 }, "SkipWhile() by value and index"); }
public static void Test(Assert assert) { assert.Expect(20); int[] numbers = { 2, 2, 3, 5, 5, -1, 2, -1 }; string[] words = { "one", "two", "three" }; double[] doubles = { 1.7, 2.3, 1.9, 4.1, 2.9 }; // TEST int uniqueNumbers = numbers.Distinct().Count(); assert.DeepEqual(uniqueNumbers, 4, "Count() distinct numbers"); // TEST int oddNumbers = numbers.Count(n => n % 2 == 1); assert.DeepEqual(oddNumbers, 3, "Count() odd numbers"); // TEST var groupJoin = (from g in Group.GetGroups() join p in Person.GetPersons() on g.Name equals p.Group into pg select new { Group = g.Name, PersonCount = pg.Count() }) .ToArray(); var groupJoinExpected = new object[] { new { Group = "A", PersonCount = 1 }, new { Group = "B", PersonCount = 4 }, new { Group = "C", PersonCount = 2 }, new { Group = "D", PersonCount = 0 } }; assert.DeepEqual(groupJoin, groupJoinExpected, "Count() within joint collections"); // TEST var grouped = (from p in Person.GetPersons() group p by p.Group into g select new { Group = g.Key, PersonCount = g.Count() }) .ToArray(); var groupedExpected = new object[] { new { Group = "A", PersonCount = 1 }, new { Group = "C", PersonCount = 2 }, new { Group = "B", PersonCount = 4 }, new { Group = (string)null, PersonCount = 1 } }; assert.DeepEqual(grouped, groupedExpected, "Count() within group"); // TEST double numSum = numbers.Sum(); assert.DeepEqual(numSum, 17, "Sum() numbers"); // TEST double totalChars = words.Sum(w => w.Length); assert.DeepEqual(totalChars, 11, "Sum() total chars"); // TEST var groupedSum = (from p in Person.GetPersons() group p by p.Group into g select new { Group = g.Key, Sum = g.Sum(x => x.Count) }) .ToArray(); var groupedSumExpected = new object[] { new { Group = "A", Sum = 300 }, new { Group = "C", Sum = 600 }, new { Group = "B", Sum = 2000 }, new { Group = (string)null, Sum = 3000 } }; assert.DeepEqual(groupedSum, groupedSumExpected, "Sum() within group"); // TEST int minNum = numbers.Min(); assert.DeepEqual(minNum, -1, "Min() number"); // TEST int shortestWordLength = words.Min(w => w.Length); assert.DeepEqual(shortestWordLength, 3, "Min() for shortest word"); // TEST var groupedMin = (from p in Person.GetPersons() group p by p.Group into g select new { Group = g.Key, Min = g.Min(x => x.Count) }) .ToArray(); var groupedMinExpected = new object[] { new { Group = "A", Min = 300 }, new { Group = "C", Min = 100 }, new { Group = "B", Min = 50 }, new { Group = (string)null, Min = 3000 } }; assert.DeepEqual(groupedMin, groupedMinExpected, "Min() within group"); // TEST var groupedMinWithLet = (from p in Person.GetPersons() group p by p.Group into g let minCount = g.Min(x => x.Count) select new { Group = g.Key, Name = g.Where(x => x.Count == minCount).Select(x => x.Name).ToArray() }) .ToArray(); var groupedMinWithLetExpected = new object[] { new { Group = "A", Name = new[]{ "Frank"} }, new { Group = "C", Name = new[]{ "Zeppa"} }, new { Group = "B", Name = new[]{ "Dora"} }, new { Group = (string)null, Name = new[]{ "Nemo"} } }; assert.DeepEqual(groupedMinWithLet, groupedMinWithLetExpected, "Min() within group with let"); // TEST int maxNum = numbers.Max(); assert.DeepEqual(maxNum, 5, "Max() number"); // TEST int longestWordLength = words.Max(w => w.Length); assert.DeepEqual(longestWordLength, 5, "Max() for longest word"); // TEST var groupedMax = (from p in Person.GetPersons() group p by p.Group into g select new { Group = g.Key, Max = g.Max(x => x.Count) }) .ToArray(); var groupedMaxExpected = new object[] { new { Group = "A", Max = 300 }, new { Group = "C", Max = 500 }, new { Group = "B", Max = 700 }, new { Group = (string)null, Max = 3000 } }; assert.DeepEqual(groupedMax, groupedMaxExpected, "Max() within group"); // TEST var groupedMaxWithLet = (from p in Person.GetPersons() group p by p.Group into g let maxCount = g.Max(x => x.Count) select new { Group = g.Key, Name = g.Where(x => x.Count == maxCount).Select(x => x.Name).ToArray() }) .ToArray(); var groupedMaxWithLetExpected = new object[] { new { Group = "A", Name = new[]{ "Frank"} }, new { Group = "C", Name = new[]{ "Billy"} }, new { Group = "B", Name = new[]{ "John", "Mary"} }, new { Group = (string)null, Name = new[]{ "Nemo"} } }; assert.DeepEqual(groupedMaxWithLet, groupedMaxWithLetExpected, "Max() within group with let"); // TEST double averageNum = numbers.Average(); assert.DeepEqual(averageNum, 2.125, "Average() number"); // TEST var averageWordLengths = new[] { "1", "22", "333", "4444", "55555" }; double averageWordLength = averageWordLengths.Average(w => w.Length); assert.DeepEqual(averageWordLength, 3, "Average() for word lengths"); // TEST var groupedAverage = (from p in Person.GetPersons() group p by p.Group into g select new { Group = g.Key, Average = g.Average(x => x.Count) }) .ToArray(); var groupedAverageExpected = new object[] { new { Group = "A", Average = 300 }, new { Group = "C", Average = 300 }, new { Group = "B", Average = 500 }, new { Group = (string)null, Average = 3000 } }; assert.DeepEqual(groupedAverage, groupedAverageExpected, "Average() within group"); // TEST var doublesForAggregate = new[] { 1.0, 2.0, 3.0, 4.0, 5.0 }; double product = doublesForAggregate.Aggregate((runningProduct, nextFactor) => runningProduct * nextFactor); assert.DeepEqual(product, 120, "Aggregate() within doubles"); // TEST var startBalance = 100.0; var attemptedWithdrawals = new[] { 20, 10, 40, 50, 10, 70, 30 }; var endBalance = attemptedWithdrawals.Aggregate(startBalance, (balance, nextWithdrawal) => ((nextWithdrawal <= balance) ? (balance - nextWithdrawal) : balance)); assert.DeepEqual(endBalance, 20, "Aggregate() balance"); }
// String functions public static void Strings(Assert assert) { //In PhantomJS some correct tests failed. We will skip them in this environment. var isPhantomJs = Utilities.BrowserHelper.IsPhantomJs(); var expectedCount = isPhantomJs ? 28 : 48; assert.Expect(expectedCount); // TEST ToLower, ToLowerCase, ToLocaleLowerCase var s = "HELLO".ToLower(); assert.DeepEqual(s, "hello", "'HELLO'.ToLower()"); s = "HELLO".ToLowerCase(); assert.DeepEqual(s, "hello", "'HELLO'.ToLowerCase()"); s = "HELLO".ToLocaleLowerCase(); assert.DeepEqual(s, "hello", "'HELLO'.ToLocaleLowerCase()"); // TEST ToUpper, ToUpperCase, ToLocaleUpperCase s = "hello".ToUpper(); assert.DeepEqual(s, "HELLO", "'hello'.ToUpper()"); s = "hello".ToUpperCase(); assert.DeepEqual(s, "HELLO", "'hello'.ToUpperCase()"); s = "HELLO".ToLocaleUpperCase(); assert.DeepEqual(s, "HELLO", "'hello'.ToLocaleUpperCase()"); s = "Hello Bridge.NET"; // TEST String(string) constructor assert.DeepEqual(new String(s), s, "new String('" + s + "')"); // TEST String(char, count) constructor assert.DeepEqual(new String('-', 4), "----", "new String('-',4)"); // TEST IndexOfAny char[] anyOf = new char[] { 'x', 'b', 'i' }; string sAnyOf = "['x','b','i']"; assert.DeepEqual(s.IndexOfAny(anyOf), 8, "'" + s + "'.IndexOfAny(" + sAnyOf + ")"); assert.Throws(() => s.IndexOfAny(anyOf, 18, 8), "'" + s + "'.IndexOfAny(" + sAnyOf + ")"); assert.Throws(() => s.IndexOfAny(null), "'" + s + "'.IndexOfAny(null)"); s = string.Empty; assert.DeepEqual(s.IndexOfAny(anyOf), -1, "String.Empty.IndexOfAny(" + sAnyOf + ")"); s = null; assert.DeepEqual(s.IndexOfAny(anyOf), -1, "null.IndexOfAny(" + sAnyOf + ")"); // TEST IndexOf s = "Hello Bridge.NET"; assert.DeepEqual(s.IndexOf('e'), 1, "'" + s + "'.IndexOf('e')"); assert.DeepEqual(s.IndexOf("e."), 11, "'" + s + "'.IndexOf('e.')"); assert.DeepEqual(s.IndexOf('e', 6, 8), 11, "'" + s + "'.IndexOf('e', 6, 8)"); assert.Throws(() => s.IndexOf(null), "'" + s + "'.IndexOf(null)"); if (!isPhantomJs) { assert.DeepEqual(s.IndexOf("E", 6, 8, StringComparison.CurrentCultureIgnoreCase), 11, "'" + s + "'.IndexOf('E', 6, 8, StringComparison.CurrentCultureIgnoreCase)"); } s = string.Empty; assert.DeepEqual(s.IndexOf('e'), -1, "String.Empty.IndexOf('e')"); s = null; assert.DeepEqual(s.IndexOf('e'), -1, "null.IndexOf('e')"); // TEST Compare string s1 = "Animal"; string s2 = "animal"; assert.DeepEqual(string.Compare(s1, s2, true), 0, "String.Compare('" + s1 + "', '" + s2 + "', true)"); if (!isPhantomJs) { assert.DeepEqual(string.Compare(s1, s2, false), 1, "String.Compare('" + s1 + "', '" + s2 + "', false)"); } if (!isPhantomJs) { string[] threeIs = new string[3]; threeIs[0] = "\u0069"; threeIs[1] = "\u0131"; threeIs[2] = "\u0049"; StringComparison[] scValues = { StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, StringComparison.InvariantCulture, StringComparison.InvariantCultureIgnoreCase, StringComparison.Ordinal, StringComparison.OrdinalIgnoreCase }; int[] expected = { -1, -1, 1, -1, 0, 1, -1, -1, 1, -1, 0, 1, -1, 1, 1, 0, 0, 0 }; int expectedIndex = 0; foreach (StringComparison sc in scValues) { Test(0, 1, sc, threeIs, expected, expectedIndex++, assert); Test(0, 2, sc, threeIs, expected, expectedIndex++, assert); Test(1, 2, sc, threeIs, expected, expectedIndex++, assert); } } // TEST Contains s = "Hello Bridge.NET"; assert.DeepEqual(s.Contains("Bridge"), true, "'" + s + "'.Contains('Bridge')"); assert.DeepEqual(s.Contains(String.Empty), true, "'" + s + "'.Contains(String.Empty)"); assert.DeepEqual(String.Empty.Contains("Bridge"), false, "String.Empty.Contains('Bridge')"); assert.Throws(() => s.Contains(null), "null.Contains('Bridge')"); // TEST Concat s = string.Concat(s, "2", "3", "4"); assert.DeepEqual(s, "Hello Bridge.NET234", "string.Concat()"); s = string.Concat(null,true,3,false); assert.DeepEqual(s, "true3false", "string.Concat()"); s = string.Concat(new string[] { "1", "2", "3", "4", "5" }); assert.DeepEqual(s, "12345", "string.Concat()"); s = string.Concat(new object[] { 1, null, 2, null, 3 }); assert.DeepEqual(s, "123", "string.Concat()"); }
protected static void Test(int x, int y, StringComparison comparison, string[] testI, int[] expected, int expectedIndex, Assert assert) { int cmpValue = 0; cmpValue = String.Compare(testI[x], testI[y], comparison); assert.DeepEqual(cmpValue, expected[expectedIndex], "String.Compare('" + testI[x] + "', '" + testI[y] + "'," + comparison + ")"); }
// StringBuilder functions public static void StringBuilders(Assert assert) { assert.Expect(21); // TEST constructors StringBuilder sb = new StringBuilder(); var sb1 = new StringBuilder(128); assert.DeepEqual(sb.ToString(), string.Empty, "StringBuilder() .ctor"); assert.DeepEqual(sb.ToString(), sb1.ToString(), "StringBuilder(capacity) .ctor"); sb = new StringBuilder("foo"); sb1 = new StringBuilder("foo", 2); assert.DeepEqual(sb.ToString(), "foo", "StringBuilder(string) .ctor"); assert.DeepEqual(sb.ToString(), sb1.ToString(), "StringBuilder(string, capacity) .ctor"); sb = new StringBuilder("foo bar", 4, 3); assert.DeepEqual(sb.ToString(), "bar", "StringBuilder(string) .ctor"); // TEST properties // Capacity sb = new StringBuilder(128); assert.DeepEqual(sb.Capacity, 128, ".Capacity"); sb = new StringBuilder("foo", 2); assert.DeepEqual(sb.Capacity, 16, ".Capacity"); sb.Capacity = 10; assert.DeepEqual(sb.Capacity, 10, ".Capacity"); // Length assert.DeepEqual(sb.Length, "foo".Length, ".Length"); // TEST methods // Clear sb.Clear(); assert.DeepEqual(sb.Length, 0, ".Clear()"); assert.DeepEqual(sb.ToString(), string.Empty, ".Clear()"); // Append sb.Append("foo"); sb.Append("foo bar", 3, 4); sb.Append(true); sb.Append('='); sb.Append(123); assert.DeepEqual(sb.ToString(), "foo bartrue=123", ".Append()"); // AppendLine sb.AppendLine(); assert.DeepEqual(sb.ToString(), "foo bartrue=123\r\n", ".AppendLine()"); sb.AppendLine("foo bar"); assert.DeepEqual(sb.ToString(), "foo bartrue=123\r\nfoo bar\r\n", ".AppendLine(string)"); // AppendFormat sb.AppendFormat("({0}, {1})", "foo", false); assert.DeepEqual(sb.ToString(), "foo bartrue=123\r\nfoo bar\r\n(foo, false)", ".AppendFormat(format, args)"); // Insert sb.Insert(0, 56.7); assert.DeepEqual(sb.ToString(), "56.7foo bartrue=123\r\nfoo bar\r\n(foo, false)", ".Insert()"); // Remove sb.Remove(4, 7); assert.DeepEqual(sb.ToString(), "56.7true=123\r\nfoo bar\r\n(foo, false)", ".Remove(start, length)"); // Replace sb.Replace("foo bar", "bar foo"); assert.DeepEqual(sb.ToString(), "56.7true=123\r\nbar foo\r\n(foo, false)", ".Replace(string, string)"); sb.Replace('\r', '\n'); assert.DeepEqual(sb.ToString(), "56.7true=123\n\nbar foo\n\n(foo, false)", ".Replace(char, char)"); sb.Replace('f', 'F', 23, 6); assert.DeepEqual(sb.ToString(), "56.7true=123\n\nbar foo\n\n(Foo, false)", ".Replace(char, char, start, length)"); sb.Replace("Foo", "foo", 23, 6); assert.DeepEqual(sb.ToString(), "56.7true=123\n\nbar foo\n\n(foo, false)", ".Replace(string, string, start, length)"); }
//public class A //{ // public string Name { get; set; } //} public static void Test(Assert assert) { assert.Expect(8); // TEST var numbers = new[] { 1, 3, 5, 7 }; var numberPlusOne = (from n in numbers select n + 1).ToArray(); assert.DeepEqual(numberPlusOne, new[] { 2, 4, 6, 8 }, "A sequence of ints one higher than the numbers[]"); // TEST var persons = Person.GetPersons(); var names = (from p in persons select p.Name).ToArray(); assert.DeepEqual(names, new[] { "Frank", "Zeppa", "John", "Billy", "Dora", "Ian", "Mary", "Nemo" }, "Selects names as instance field"); // TEST string[] strings = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" }; var textNumbers = (from n in numbers select strings[n]).ToArray(); assert.DeepEqual(textNumbers, new[] { "one", "three", "five", "seven" }, "Selects names as items of another array"); // TEST var anonimNames = (from p in persons select new { Name = p.Name }).ToArray(); object[] anonimNamesToCompare = { new { Name = "Frank" }, new { Name = "Zeppa" }, new { Name = "John" }, new { Name = "Billy" }, new { Name = "Dora" }, new { Name = "Ian" }, new { Name = "Mary" }, new { Name = "Nemo" } }; assert.DeepEqual(anonimNames, anonimNamesToCompare, "Selects names as an anonymous type"); // TEST numbers = new[] { 0, 1, 3, 3 }; var numberssInPlace = numbers .Select((n, index) => new { Number = n, IsIndex = n == index }) .ToArray(); object[] anonimNumbersToCompare = { new { Number = 0, IsIndex = true }, new { Number = 1, IsIndex = true }, new { Number = 3, IsIndex = false }, new { Number = 3, IsIndex = true } }; assert.DeepEqual(numberssInPlace, anonimNumbersToCompare, "Selects numbers as an anonymous type"); // TEST var numbersA = new[] { 1, 5, 2 }; var numbersB = new[] { 3, 4, 2 }; var simplePairs = (from a in numbersA from b in numbersB where a < b select new { A = a, B = b } ).ToArray(); object[] expectedSimplePairs = { new { A = 1, B = 3 }, new { A = 1, B = 4 }, new { A = 1, B = 2 }, new { A = 2, B = 3 }, new { A = 2, B = 4 } }; assert.DeepEqual(simplePairs, expectedSimplePairs, "Join two numeric arrays with one where clause"); // TEST numbersA = new[] { 1, 5, 2, 4, 3 }; numbersB = new[] { 3, 4, 2, 5, 1 }; var pairs = (from a in numbersA where a > 1 from b in numbersB where b < 4 && a > b select new { Sum = a + b } ).ToArray(); object[] expectedPairs = { new { Sum = 8}, new { Sum = 7}, new { Sum = 6}, new { Sum = 3}, new { Sum = 7}, new { Sum = 6}, new { Sum = 5}, new { Sum = 5}, new { Sum = 4},}; assert.DeepEqual(pairs, expectedPairs, "Join two numeric arrays with two where clauses"); // TEST numbersA = new[] { 1, 5, 2, 4, 3 }; numbersB = new[] { 3, 4, 2, 5, 1 }; var manyNumbers = numbersA .SelectMany((a, aIndex) => numbersB.Where(b => a == b && b > aIndex).Select(b => new { A = a, B = b, I = aIndex })) .ToArray(); object[] expectedManyNumbers = { new { A = 1, B = 1, I = 0 }, new { A = 5, B = 5, I = 1 }, new { A = 4, B = 4, I = 3 }}; assert.DeepEqual(manyNumbers, expectedManyNumbers, "SelectMany() two number arrays"); }
// Check instance methods and constructors public static void TestInstanceConstructorsAndMethods(Assert assert) { assert.Expect(18); // Check parameterless constructor var a = new Point(); assert.DeepEqual(a.x, 0, "x 0"); assert.DeepEqual(a.y, 0, "y 0"); var r = new Rectangle(); assert.DeepEqual(r.l.x, 0, "r.l.x 0"); assert.DeepEqual(r.l.y, 0, "r.l.y 0"); assert.DeepEqual(r.t.x, 0, "r.t.x 0"); assert.DeepEqual(r.t.y, 0, "r.t.y 0"); r = new Rectangle(10, 20); assert.DeepEqual(r.l.x, 10, "r.l.x 10"); assert.DeepEqual(r.l.y, 20, "r.l.y 20"); assert.DeepEqual(r.t.x, 0, "r.t.x 0"); assert.DeepEqual(r.t.y, 0, "r.t.y 0"); r = new Rectangle(30, 40, 50, 60); assert.DeepEqual(r.l.x, 30, "r.l.x 30"); assert.DeepEqual(r.l.y, 40, "r.l.y 40"); assert.DeepEqual(r.t.x, 50, "r.t.x 50"); assert.DeepEqual(r.t.y, 60, "r.t.y 60"); var i = a.Test1(); assert.DeepEqual(i, 500, "i 500"); a.x = 300; i = a.Test1(); assert.DeepEqual(i, 800, "i 800"); a.y = 400; var b = new Point() { x = 5, y = 7 }; var c = b.Test2(a); assert.DeepEqual(c.x, 305, "c.x 305"); assert.DeepEqual(c.y, 407, "c.y 407"); }
//Check default parameters, method parameters, default values public static void TestMethodParameters(Assert assert) { assert.Expect(16); //Check default parameters var ra = new ClassA(); int r = ra.Method5(5); assert.DeepEqual(r, 5, "r 5"); r = ra.Method5(i: 15); assert.DeepEqual(r, 15, "r 15"); r = ra.Method5(5, 6); assert.DeepEqual(r, 11, "r 11"); r = ra.Method5(k: 6); assert.DeepEqual(r, -44, "r -44"); //Check referencing did not change data var a = new ClassA(); var b = a.Method1(); var c = b.Related; a.Method2(b); assert.Ok(b != null, "b not null"); assert.DeepEqual(b.Number, 2, "b Number 2"); assert.Ok(b.Related != null, "b.Related not null"); assert.DeepEqual(b.Related.Number, 2, "b.Related Number 2"); assert.Ok(c != null, "c not null"); assert.DeepEqual(c.Number, 1, "c Number 1"); assert.Ok(c.Related == null, "c.Related null"); //Check value local parameter var input = 1; var result = a.Method4(input, 4); assert.DeepEqual(input, 1, "input 1"); assert.DeepEqual(result, 5, "result 5"); // TEST //[#86] var di = ClassA.GetDefaultInt(); assert.DeepEqual(di, 0, "di 0"); // TEST //Check "out parameter" //[#85] int i; var tryResult = ClassA.TryParse("", out i); assert.Ok(tryResult, "tryResult"); assert.DeepEqual(i, 3, "i 3"); }
//Check instance methods and constructors public static void TestInstanceConstructorsAndMethods(Assert assert) { assert.Expect(26); //Check parameterless constructor var a = new ClassA(); // TEST assert.DeepEqual(a.NumberA, 10, "NumberA 10"); assert.DeepEqual(a.StringA, "Str", "StringA Str"); assert.DeepEqual(a.BoolA, true, "BoolA true"); assert.Ok(a.DoubleA == Double.PositiveInfinity, "DoubleA Double.PositiveInfinity"); assert.DeepEqual(a.DecimalA, -1, "DecimalA Decimal.MinusOne"); assert.Ok(a.Data != null, "Data not null"); assert.DeepEqual(a.Data.Number, 700, "Data.Number 700"); // TEST //Check constructor with parameter assert.Throws(TestSet1FailureHelper.TestConstructor1Failure, "Related should not be null", "Related should not be null"); // TEST //Check constructor with parameter assert.Throws(TestSet1FailureHelper.TestConstructor2Failure, "Should pass six parameters", "Should pass six parameters"); a = new ClassA(150, "151", true, 1.53d, 1.54m, new ClassA.Aux1() { Number = 155 }); assert.DeepEqual(a.NumberA, 150, "NumberA 150"); assert.DeepEqual(a.StringA, "151", "StringA 151"); assert.DeepEqual(a.BoolA, true, "BoolA true"); assert.DeepEqual(a.DoubleA, 1.53, "DoubleA Double.PositiveInfinity"); assert.DeepEqual(a.DecimalA, 1.54, "DecimalA 154"); assert.Ok(a.Data != null, "Data not null"); assert.DeepEqual(a.Data.Number, 155, "Data.Number 155"); // TEST //Check instance methods var b = a.Method1(); assert.Ok(b != null, "b not null"); assert.DeepEqual(b.Number, 2, "b Number 2"); assert.Ok(b.Related != null, "b.Related not null"); assert.DeepEqual(b.Related.Number, 1, "b.Related Number 1"); a.Data = b; assert.DeepEqual(a.Method3(), "2 Has related 1", "Method3 2 Has related 1"); a.Data = null; assert.DeepEqual(a.Method3(), "no data", "Method3 no data"); // TEST //Check [#68] var c68 = new Class68(); assert.DeepEqual(c68.x, 0, "c68.x 0"); assert.DeepEqual(c68.y, 1, "c68.y 1"); // TEST //Check local vars do not get overridden by fields c68.Test(); assert.DeepEqual(c68.x, 0, "c68.x 0"); assert.DeepEqual(c68.y, 1, "c68.y 1"); }
// Check static methods and constructor public static void TestStaticConstructorsAndMethods(Assert assert) { assert.Expect(7); assert.DeepEqual(Point.StaticInt, 500, "Point.StaticInt 500"); assert.DeepEqual(Point.StaticString, "Initialized", "Point.StaticString Initialized"); assert.DeepEqual(Point.StatitIntNotInitialized, 0, "Point.StatitIntNotInitialized 0"); assert.DeepEqual(Point.StatitStringNotInitialized, null, "Point.StatitStringNotInitialized null"); assert.DeepEqual(Point.CONST_CHAR, (int)'W', "Point.CONST_CHAR W"); Point.StatitIntNotInitialized = -1; assert.DeepEqual(Point.StatitIntNotInitialized, -1, "Point.StatitIntNotInitialized -1"); var i = Point.Test3(); assert.DeepEqual(i, 499, "i 499"); }
// Bridge[#273] public static void N273(Assert assert) { assert.Expect(4); // TEST var items = new List<int>() { 0, 1, 2, 3, 4 }; var r = items.Slice(-1).ToArray(); assert.DeepEqual(r, new[] { 4 }, "Slices start = -1"); r = items.Slice(1).ToArray(); assert.DeepEqual(r, new[] { 1, 2, 3, 4 }, "Slices start = 1"); r = items.Slice(-3, 4).ToArray(); assert.DeepEqual(r, new[] { 2, 3 }, "Slices start = -3, end = 3"); r = items.Slice(1, 3).ToArray(); assert.DeepEqual(r, new[] { 1, 2 }, "Slices start = 1, end = 2"); }
// Bridge[#169] public static void N169(Assert assert) { assert.Expect(2); // TEST Bridge169.M1(); assert.DeepEqual(Bridge169.Number, 1, "M1()"); // TEST Bridge169.M2(); assert.DeepEqual(Bridge169.Number, 2, "M2()"); }
public static void Test(Assert assert) { assert.Expect(5); // TEST var persons = (from p in Person.GetPersons() join g in Group.GetGroups() on p.Group equals g.Name select new { Name = p.Name, Limit = g.Limit }).ToArray(); var personsExpected = new object[] { new { Name = "Frank", Limit = 1000}, new { Name = "Zeppa", Limit = 800}, new { Name = "John", Limit = 400}, new { Name = "Billy", Limit = 800}, new { Name = "Dora", Limit = 400}, new { Name = "Ian", Limit = 400}, new { Name = "Mary", Limit = 400} }; assert.DeepEqual(persons, personsExpected, "Join Persons and Groups"); // TEST var personsByLambda = Person.GetPersons() .Join(Group.GetGroups(), p => p.Group, g => g.Name, (p, g) => new { Name = p.Name, Limit = g.Limit }) .ToArray(); var personsByLambdaExpected = new object[] { new { Name = "Frank", Limit = 1000}, new { Name = "Zeppa", Limit = 800}, new { Name = "John", Limit = 400}, new { Name = "Billy", Limit = 800}, new { Name = "Dora", Limit = 400}, new { Name = "Ian", Limit = 400}, new { Name = "Mary", Limit = 400} }; assert.DeepEqual(personsByLambda, personsByLambdaExpected, "Join Persons and Groups by lambda"); // TEST var groupJoin = (from g in Group.GetGroups() join p in Person.GetPersons() on g.Name equals p.Group into pg select new { Group = g.Name, Persons = pg.Select(x => x.Name).ToArray() }) .ToArray(); var groupJoinExpected = new object[] { new { Group = "A", Persons = new [] {"Frank"} }, new { Group = "B", Persons = new [] {"John", "Dora", "Ian", "Mary"} }, new { Group = "C", Persons = new [] {"Zeppa", "Billy"} }, new { Group = "D", Persons = new string [] {} } }; assert.DeepEqual(groupJoin, groupJoinExpected, "Grouped join Persons and Groups"); // TEST var groupJoinWithDefault = (from g in Group.GetGroups() join p in Person.GetPersons() on g.Name equals p.Group into pg from ep in pg.DefaultIfEmpty() // DefaultIfEmpty preserves left-hand elements that have no matches on the right side select new { GroupName = g.Name, PersonName = ep != null ? ep.Name : string.Empty, } ).ToArray(); var groupJoinWithDefaultExpected = new object[] { new { GroupName = "A", PersonName = "Frank" }, new { GroupName = "B", PersonName = "John" }, new { GroupName = "B", PersonName = "Dora" }, new { GroupName = "B", PersonName = "Ian" }, new { GroupName = "B", PersonName = "Mary" }, new { GroupName = "C", PersonName = "Zeppa" }, new { GroupName = "C", PersonName = "Billy" }, new { GroupName = "D", PersonName = string.Empty } }; assert.DeepEqual(groupJoinWithDefault, groupJoinWithDefaultExpected, "Grouped join Persons and Groups with DefaultIfEmpty"); // TEST var groupJoinWithDefaultAndComplexEquals = (from g in Group.GetGroups() join p in Person.GetPersons() on new { Name = g.Name, Digit = 1 } equals new { Name = p.Group, Digit = 1 } into pg from ep in pg.DefaultIfEmpty() // DefaultIfEmpty preserves left-hand elements that have no matches on the right side orderby ep != null ? ep.Name : null descending select new { GroupName = g != null ? g.Name : null, PersonName = ep != null ? ep.Name : null, } ).ToArray(); var groupJoinWithDefaultAndComplexEqualsExpected = new object[] { new { GroupName = "C", PersonName = "Zeppa" }, new { GroupName = "B", PersonName = "Mary" }, new { GroupName = "B", PersonName = "John" }, new { GroupName = "B", PersonName = "Ian" }, new { GroupName = "A", PersonName = "Frank" }, new { GroupName = "B", PersonName = "Dora" }, new { GroupName = "C", PersonName = "Billy" }, new { GroupName = "D", PersonName = (string)null } }; assert.DeepEqual(groupJoinWithDefaultAndComplexEquals, groupJoinWithDefaultAndComplexEqualsExpected, "Issue #209. Grouped join Persons and Groups with DefaultIfEmpty, complex equals and ordering"); }
//Check static methods and constructor public static void TestStaticConstructorsAndMethods(Assert assert) { assert.Expect(13); // TEST //Check static fields initialization assert.DeepEqual(ClassA.StatitIntNotInitialized, 0, "#74 StatitInt not initialized"); assert.DeepEqual(ClassA.StatitStringNotInitialized, null, "#74 StatitString not initialized"); assert.DeepEqual(ClassA.CONST_CHAR, 81, "#74 CONST_CHAR Q"); assert.DeepEqual(ClassA.CONST_DECIMAL, 3.123456789324324324, "#74 CONST_DECIMAL 3.123456789324324324m"); // TEST //Check static constructor assert.DeepEqual(ClassA.StaticInt, -340, "StatitInt initialized"); assert.DeepEqual(ClassA.StaticString, "Defined string", "StatitString initialized"); // TEST //Check static methods var a = ClassA.StaticMethod1(678, "ASD", double.NaN); assert.DeepEqual(ClassA.StatitIntNotInitialized, 678, "StatitIntNotInitialized 678"); assert.DeepEqual(ClassA.StatitStringNotInitialized, "ASD", "ClassA.StatitStringNotInitialized ASD"); assert.DeepEqual(a.DoubleA, double.NaN, "DoubleA double.NaN"); a = ClassA.StaticMethod2((object)678, "QWE", 234); assert.DeepEqual(ClassA.StatitIntNotInitialized, 1678, "StatitIntNotInitialized 1678"); assert.DeepEqual(ClassA.StatitStringNotInitialized, "QWE", "ClassA.StatitStringNotInitialized QWE"); assert.DeepEqual(a.DoubleA, 234, "DoubleA 234"); assert.Throws(TestSet1FailureHelper.StaticMethod2Failure, "Unable to cast type String to type Bridge.Int", "Cast exception should occur"); }
// Bridge[#272] public static void N272(Assert assert) { assert.Expect(3); // TEST assert.DeepEqual(Bridge272.Test(1), Bridge272.MyEnum.Abc, "Casted MyEnum.Abc"); assert.DeepEqual(Bridge272.Test(3), Bridge272.MyEnum.Ghi, "Casted MyEnum.Ghi"); assert.DeepEqual(Bridge272.Test(4), 4, "Casted MyEnum.Abc"); }
public static void Test(Assert assert) { assert.Expect(26); // TEST var persons = Person.GetPersons(); var person3 = (from p in Person.GetPersons() where p.ID == 3 select p).First(); assert.DeepEqual(person3, Person.GetPersons()[2], "First() with ID = 3"); assert.DeepEqual(persons.First(x => x.ID == 3), Person.GetPersons()[2], "First() with ID = 3 by lambda"); assert.DeepEqual(persons.Where(x => x.ID == 3).First(), Person.GetPersons()[2], "First() with Where() with ID = 3 by lambda"); assert.DeepEqual(persons.First(x => x.Group == "C"), Person.GetPersons()[1], "First() with Group = 'C' by lambda"); assert.Throws(TestLinqElementOperators.ThrowExceptionOnFirst1, "First() should throw exception if no element found"); assert.Throws(TestLinqElementOperators.ThrowExceptionOnFirst2, "First() should throw exception on empty collection"); // TEST assert.DeepEqual(persons.FirstOrDefault(x => x.ID == -1), null, "FirstOrDefault() unexisting element by lambda"); assert.DeepEqual(persons.Where(x => x.ID == -1).FirstOrDefault(), null, "FirstOrDefault() with Where() unexisting element by lambda"); assert.DeepEqual(persons.FirstOrDefault(x => x.Name == "Nemo"), persons[7], "FirstOrDefault() with Name = 'Nemo' by lambda"); assert.DeepEqual(persons.Where(x => x.Name == "Nemo").FirstOrDefault(), persons[7], "FirstOrDefault() with Where() with Name = 'Nemo' by lambda"); assert.DeepEqual((new object [] { }).FirstOrDefault(), null, "FirstOrDefault() within zero-length array by lambda"); // TEST var lastPerson = (from p in Person.GetPersons() select p).Last(); assert.DeepEqual(lastPerson, Person.GetPersons()[7], "Last() person"); assert.DeepEqual(persons.Last(x => x.ID == 4), Person.GetPersons()[3], "Last() with ID = 4 by lambda"); assert.DeepEqual(persons.Last(x => x.Group == "B"), Person.GetPersons()[6], "Last() with Group = 'B' by lambda"); assert.Throws(TestLinqElementOperators.ThrowExceptionOnLast1, "Last() should throw exception if no element found"); assert.Throws(TestLinqElementOperators.ThrowExceptionOnLast2, "Last() should throw exception on empty collection"); // TEST assert.DeepEqual(persons.LastOrDefault(x => x.ID == -1), null, "LastOrDefault() unexisting element by lambda"); assert.DeepEqual(persons.Where(x => x.ID == -1).LastOrDefault(), null, "LastOrDefault() with Where() unexisting element by lambda"); assert.DeepEqual(persons.LastOrDefault(x => x.Name == "Nemo"), persons[7], "LastOrDefault() with Name = 'Nemo' by lambda"); assert.DeepEqual((new object[] { }).LastOrDefault(), null, "LastOrDefault() within zero-length array by lambda"); // TEST int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 }; int elementAt1 = (from n in numbers where n > 5 select n).ElementAt(1); assert.DeepEqual(elementAt1, 8, "ElementAt() should return 8"); assert.Throws(TestLinqElementOperators.ThrowExceptionOnElementAt1, "ElementAt() should throw exception if no element found"); assert.Throws(TestLinqElementOperators.ThrowExceptionOnElementAt2, "ElementAt() should throw exception on empty collection"); // TEST int elementAt1OrDefault = numbers.ElementAtOrDefault(1); assert.DeepEqual(elementAt1OrDefault, 4, "ElementAtOrDefault() should return 4"); // TEST int elementAt2OrDefault = (from n in numbers where n > 5 select n).ElementAtOrDefault(2); assert.DeepEqual(elementAt2OrDefault, 6, "ElementAtOrDefault() should return 6"); // TEST int elementAt100OrDefault = (from n in numbers where n > 5 select n).ElementAtOrDefault(100); assert.DeepEqual(elementAt100OrDefault, 0, "ElementAtOrDefault() should return 0"); }