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(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 TestStatic(Assert assert) { assert.Expect(16); assert.Equal(Static.Foo(1), "Foo(int x)", "Static Foo(int x)"); assert.Equal(Static.Foo("string"), "Foo(string s)", "Static Foo(string s)"); assert.Equal(Static.Foo(1.1), "Foo(double d)", "Static Foo(double d)"); assert.Equal(Static.Foo(1, 2), "Foo(int x, int y)", "Static Foo(int x, int y)"); assert.Equal(Static.Foo(1, 1.1), "Foo(int x, double y)", "Static Foo(int x, double y)"); assert.Equal(Static.Foo(1.1, 1), "Foo(double x, int y)", "Static Foo(double x, int y)"); assert.Equal(Static.FooReturnType(1), 'C', "Static char FooReturnType(int y)"); assert.Equal(Static.FooReturnType(1.1), "string FooReturnType(double d)", "Static string FooReturnType(double d)"); assert.Equal(Static.FooOptionalParameters(1), "FooOptionalParameters(int x)", "Static FooOptionalParameters(int x)"); assert.Equal(Static.FooOptionalParameters(1, 2), "FooOptionalParameters(int x, int y = 5)", "Static FooOptionalParameters(int x, int y = 5)"); assert.Equal(Static.FooMultipleOptionalParameters(1, 2), "FooMultipleOptionalParameters(int x, int y = 5)", "Static FooMultipleOptionalParameters(int x, int y = 5)"); assert.Equal(Static.FooMultipleOptionalParameters(1, z: 2), "FooMultipleOptionalParameters(int x, int y = 5, int z = 10)", "Static FooMultipleOptionalParameters(int x, int y = 5, int z = 10)"); assert.Equal(Static.FooMultipleOptionalParameters(1, 2, 3), "FooMultipleOptionalParameters(int x, int y = 5, int z = 10)", "Static FooMultipleOptionalParameters(int x, int y = 5, int z = 10)"); assert.Equal(Static.FooMultipleOptionalParameters(1, z: 2, y: 3), "FooMultipleOptionalParameters(int x, int y = 5, int z = 10)", "Static FooMultipleOptionalParameters(int x, int y = 5, int z = 10)"); assert.Equal(Static.FooNamedArgument(x: 1), "FooNamedArgument(int x)", "Static FooNamedArgument(int x)"); assert.Equal(Static.FooNamedArgument(d: 1), "FooNamedArgument(double d)", "Static FooNamedArgument(double d)"); }
public static void ThrownExceptions(Assert assert) { assert.Expect(12); // #230 assert.Throws(TryCatchWithNotCaughtTypedException, "catch me", "A.Typed exception is not Caught"); assert.Ok(IsATry, "A. exception not caught - try section called"); assert.Ok(!IsACatch, "A. exception not caught - catch section not called"); // #229 assert.Throws(TryCatchWithNotCaughtTypedExceptionAndArgument, "catch me", "[#229] B. Typed exception is not Caught; and argument"); assert.Ok(IsBTry, "[#229] B. exception not caught - try section called"); assert.Ok(!IsBCatch, "B. exception not caught - catch section not called"); // #231 assert.Throws(TryCatchWithRethrow, "catch me", "[#231] C. Rethrow"); assert.Ok(IsCTry, "C. exception caught and re-thrown - try section called"); assert.Ok(IsCCatch, "C. exception caught and re-thrown - catch section called"); assert.Throws(TryCatchWithRethrowEx, new Func<object, bool>((error) => { return error.ToString() == "catch me"; }), "D. Rethrow with parameter"); assert.Ok(IsDTry, "D. exception caught and re-thrown - try section called"); assert.Ok(IsDCatch, "D. exception caught and re-thrown - catch section called"); }
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 TestUseCase(Assert assert) { assert.Expect(12); Func<object> item11 = () => 11; assert.Equal(item11.IsNullOrUndefined(), false, "Bridge655 IsNullOrUndefined11"); assert.Equal(item11(), 11, "Bridge655 item11"); Func<int, int> item12 = (i) => i; assert.Equal(item12.IsNullOrUndefined(), false, "Bridge655 IsNullOrUndefined12"); assert.Equal(item12(12), 12, "Bridge655 item12"); Func<object> item21 = () => 21; assert.Equal(item21.IsNullOrUndefined(21), false, "Bridge655 IsNullOrUndefined21 false"); assert.Equal(item21.IsNullOrUndefined(0), true, "Bridge655 IsNullOrUndefined21 true"); assert.Equal(item21(), 21, "Bridge655 item21"); Func<int, string, int> item22 = (i, s) => i + s.Length; assert.Equal(item22.IsNullOrUndefined("22"), "false", "Bridge655 IsNullOrUndefined22 false"); assert.Equal(item22.IsNullOrUndefined(string.Empty), "true", "Bridge655 IsNullOrUndefined22 true"); assert.Equal(item22(19, "two"), 22, "Bridge655 item22"); Action<int, string> item32 = (i, s) => { var b = i == s.Length; }; assert.Equal(item32.IsNullOrUndefined("32"), "false", "Bridge655 IsNullOrUndefined32 false"); assert.Equal(item32.IsNullOrUndefined(string.Empty), "true", "Bridge655 IsNullOrUndefined32 true"); }
public static void TestUseCase(Assert assert) { assert.Expect(6); var s1 = string.Join(",", new[] { "a", "b" }); assert.Equal(s1, "a,b", "Join1"); var animals = new List<Animal>(); animals.Add(new Animal("Squirrel", "Rodent")); animals.Add(new Animal("Gray Wolf", "Carnivora")); animals.Add(new Animal("Capybara", "Rodent")); string s2 = String.Join(" ", animals); assert.Equal(s2, "Squirrel Gray Wolf Capybara", "Join2"); object[] values = { null, "Cobb", 4189, 11434, .366 }; string s31 = String.Join("|", values); assert.Equal(s31, "|Cobb|4189|11434|0.366", "Join31"); values[0] = String.Empty; string s32 = String.Join("|", values); assert.Equal(s32, "|Cobb|4189|11434|0.366", "Join32"); string[] sArr = new string[10]; for (int i = 0; i < 10; i++) sArr[i] = String.Format("{0,-3}", i * 5); string s4 = String.Join(":", sArr); assert.Equal(s4, "0 :5 :10 :15 :20 :25 :30 :35 :40 :45 ", "Join4"); var val = new string[] { "apple", "orange", "grape", "pear" }; var s5 = string.Join(", ", val, 1, 2); assert.Equal(s5, "orange, grape", "Join5"); }
public static void TestUseCase(Assert assert) { assert.Expect(1); var ted = new Bridge566B(); assert.Equal(ted.Data, "Ted", "#566 Ted"); }
public static void TestUseCase(Assert assert) { assert.Expect(1); object o = Script.Undefined; assert.Throws(() => { var s = (string)o; }, "Unable to cast type 'null' to type String"); }
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(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 TesForeach(Assert assert) { assert.Expect(2); string[] keys = new[] { "1", "2", "3" }; Action[] handlers = new Action[3]; int i = 0; string result = ""; foreach (var itm in keys) handlers[i++] = () => result += itm; foreach (var handler in handlers) { handler(); } assert.Equal(result, "123", "Bridge563 No block foreach loop"); i = 0; result = ""; foreach (var itm in keys) { handlers[i++] = () => result += itm; } foreach (var handler in handlers) { handler(); } assert.Equal(result, "123", "Bridge563 block foreach loop"); }
public static void TestUseCase(Assert assert) { assert.Expect(1); int[] numbers = { 1, 2, 3 }; int sum = 0; foreach (int a in numbers) { sum = sum + a; } foreach (int a in numbers) { sum = sum + a; } foreach (int a in numbers) { sum = sum + a; } foreach (int a in numbers) { sum = sum + a; } assert.Equal(sum, 24, "Bridge502 sum"); }
public static void TestCloneCompare(Assert assert) { assert.Expect(13); var v1 = new Version(1, 2, 3, (4 << 16) + 5); var o = v1.Clone(); assert.Ok(o != null, "v1 Cloned"); var v2 = o as Version; assert.Ok(v2 != null, "v1 Cloned as Version"); assert.Equal(v2.Major, 1, "v2.Major 1"); assert.Equal(v2.Minor, 2, "v2.Minor 2"); assert.Equal(v2.Build, 3, "v2.Build 3"); assert.Equal(v2.Revision, 262149, "v2.Revision (4 << 16) + 5 = 262149"); assert.Equal(v2.MajorRevision, 4, "v2.MajorRevision 4"); assert.Equal(v2.MinorRevision, 5, "v2.MinorRevision 5"); var v3 = new Version(1, 2, 2, (4 << 16) + 5); assert.Equal(v1.CompareTo(v3), 1, "v1.CompareTo(v3)"); var v4 = new Version(1, 3, 3, (4 << 16) + 5); assert.Equal(v1.CompareTo(v4), -1, "v1.CompareTo(v4)"); assert.Equal(v1.CompareTo(o), 0, "v1.CompareTo(o)"); assert.Equal(v1.CompareTo(v2), 0, "v1.CompareTo(v2)"); assert.NotEqual(v1.CompareTo(null), 0, "v1.CompareTo(null)"); }
public static void TestUseCase(Assert assert) { assert.Expect(6); SByte i8_1 = -2; SByte i8_2 = (SByte)(i8_1 >> 4); Byte u8_1 = 0xFE; Byte u8_2 = (Byte)(u8_1 >> 4); Int16 i16_1 = -2; Int16 i16_2 = (Int16)(i16_1 >> 8); UInt16 u16_1 = 0xFFFE; UInt16 u16_2 = (UInt16)(u16_1 >> 8); Int32 i32_1 = -2; Int32 i32_2 = i32_1 >> 16; UInt32 u32_1 = 0xFFFFFFFE; UInt32 u32_2 = u32_1 >> 16; assert.Equal(i8_2, -1, "Bridge592 i8_2"); assert.Equal(u8_2, 0xF, "Bridge592 u8_2"); assert.Equal(i16_2, -1, "Bridge592 i16_2"); assert.Equal(u16_2, 0xFF, "Bridge592 u16_2"); assert.Equal(i32_2, -1, "Bridge592 i32_2"); assert.Equal(u32_2, 0xFFFF, "Bridge592 u32_2"); }
public static void TestUseCase(Assert assert) { assert.Expect(1); var o = JSON.Parse<bool>("true"); assert.Equal(o, true, "Bridge544 bool"); }
public static void TestUseCase(Assert assert) { assert.Expect(7); var t1 = new Type(); assert.Ok(t1 != null, "#565 t1"); var t2 = new ValueType(); assert.Ok(t2 != null, "#565 t2"); var t3 = new IntPtr(); assert.Ok(t3.GetType() == typeof(IntPtr) , "#565 t3"); var t4 = new UIntPtr(); assert.Ok(t4.GetType() == typeof(UIntPtr), "#565 t4"); var t5 = new ParamArrayAttribute(); assert.Ok(t5 != null, "#565 t5"); var t6 = new RuntimeTypeHandle(); assert.Ok(t6.GetType() == typeof(RuntimeTypeHandle), "#565 t6"); var t7 = new RuntimeFieldHandle(); assert.Ok(t7.GetType() == typeof(RuntimeFieldHandle), "#565 t7"); }
public static void TestUseCase(Assert assert) { assert.Expect(10); var array1 = new Int8Array(1); Bridge550.TestMethod(array1, "Int8Array", assert); var array2 = new Uint8Array(1); Bridge550.TestMethod(array2, "Uint8Array", assert); var array3 = new Uint8ClampedArray(1); Bridge550.TestMethod(array3, "Uint8ClampedArray", assert); var array4 = new Int16Array(1); Bridge550.TestMethod(array4, "Int16Array", assert); var array5 = new Uint16Array(1); Bridge550.TestMethod(array5, "Uint16Array", assert); var array6 = new Int32Array(1); Bridge550.TestMethod(array6, "Int32Array", assert); var array7 = new Uint32Array(1); Bridge550.TestMethod(array7, "Uint32Array", assert); var array8 = new Float32Array(1); Bridge550.TestMethod(array8, "Float32Array", assert); var array9 = new Float64Array(1); Bridge550.TestMethod(array9, "Float64Array", assert); var array10 = new DataView(array9.Buffer); Bridge550.TestMethod(array10, "DataView", assert); }
public static void TestInstance(Assert assert) { assert.Expect(17); var i = new Instance(); assert.Ok(i != null, "i created"); assert.Equal(i.Foo(1), "Foo(int x)", "Instance Foo(int x)"); assert.Equal(i.Foo("string"), "Foo(string s)", "Instance Foo(string s)"); assert.Equal(i.Foo(1.1), "Foo(double d)", "Instance Foo(double d)"); assert.Equal(i.Foo(1, 2), "Foo(int x, int y)", "Instance Foo(int x, int y)"); assert.Equal(i.Foo(1, 1.1), "Foo(int x, double y)", "Instance Foo(int x, double y)"); assert.Equal(i.Foo(1.1, 1), "Foo(double x, int y)", "Instance Foo(double x, int y)"); assert.Equal(i.FooReturnType(1), 'C', "Instance char FooReturnType(int y)"); assert.Equal(i.FooReturnType(1.1), "string FooReturnType(double d)", "Instance string FooReturnType(double d)"); assert.Equal(i.FooOptionalParameters(1), "FooOptionalParameters(int x)", "Instance FooOptionalParameters(int x)"); assert.Equal(i.FooOptionalParameters(1, 2), "FooOptionalParameters(int x, int y = 5)", "Instance FooOptionalParameters(int x, int y = 5)"); assert.Equal(i.FooMultipleOptionalParameters(1, 2), "FooMultipleOptionalParameters(int x, int y = 5)", "Instance FooMultipleOptionalParameters(int x, int y = 5)"); assert.Equal(i.FooMultipleOptionalParameters(1, z: 2), "FooMultipleOptionalParameters(int x, int y = 5, int z = 10)", "Instance FooMultipleOptionalParameters(int x, int y = 5, int z = 10)"); assert.Equal(i.FooMultipleOptionalParameters(1, 2, 3), "FooMultipleOptionalParameters(int x, int y = 5, int z = 10)", "Instance FooMultipleOptionalParameters(int x, int y = 5, int z = 10)"); assert.Equal(i.FooMultipleOptionalParameters(1, z: 2, y: 3), "FooMultipleOptionalParameters(int x, int y = 5, int z = 10)", "Instance FooMultipleOptionalParameters(int x, int y = 5, int z = 10)"); assert.Equal(i.FooNamedArgument(x: 1), "FooNamedArgument(int x)", "Static FooNamedArgument(int x)"); assert.Equal(i.FooNamedArgument(d: 1), "FooNamedArgument(double d)", "Static FooNamedArgument(double d)"); }
public static void TestConstructors(Assert assert) { assert.Expect(42); var v1 = new Version(); assert.Ok(v1 != null, "v1 created"); assert.Equal(v1.Major, 0, "v1.Major 0"); assert.Equal(v1.Minor, 0, "v1.Minor 0"); assert.Equal(v1.Build, -1, "v1.Build -1"); assert.Equal(v1.Revision, -1, "v1.Revision -1"); assert.Equal(v1.MajorRevision, -1, "v1.MajorRevision -1"); assert.Equal(v1.MinorRevision, -1, "v1.MinorRevision -1"); var v2 = new Version("2.4.1128.2"); assert.Ok(v2 != null, "v2 created"); assert.Equal(v2.Major, 2, "v2.Major 2"); assert.Equal(v2.Minor, 4, "v2.Minor 4"); assert.Equal(v2.Build, 1128, "v2.Build 1128"); assert.Equal(v2.Revision, 2, "v2.Revision 2"); assert.Equal(v2.MajorRevision, 0, "v2.MajorRevision 0"); assert.Equal(v2.MinorRevision, 2, "v2.MinorRevision 2"); var v3 = new Version("2.4.1128.65537"); assert.Ok(v3 != null, "v3 created"); assert.Equal(v3.Major, 2, "v3.Major 2"); assert.Equal(v3.Minor, 4, "v3.Minor 4"); assert.Equal(v3.Build, 1128, "v3.Build 1128"); assert.Equal(v3.Revision, 65537, "v3.Revision 65537"); assert.Equal(v3.MajorRevision, 1, "v3.MajorRevision 1"); assert.Equal(v3.MinorRevision, 1, "v3.MinorRevision 1"); var v4 = new Version(20, 10); assert.Ok(v4 != null, "v4 created"); assert.Equal(v4.Major, 20, "v4.Major 20"); assert.Equal(v4.Minor, 10, "v4.Minor 10"); assert.Equal(v4.Build, -1, "v4.Build -1"); assert.Equal(v4.Revision, -1, "v4.Revision -1"); assert.Equal(v4.MajorRevision, -1, "v4.MajorRevision -1"); assert.Equal(v4.MinorRevision, -1, "v4.MinorRevision -1"); var v5 = new Version(200, 100, 300); assert.Ok(v5 != null, "v5 created"); assert.Equal(v5.Major, 200, "v5.Major 200"); assert.Equal(v5.Minor, 100, "v5.Minor 100"); assert.Equal(v5.Build, 300, "v5.Build 300"); assert.Equal(v5.Revision, -1, "v5.Revision -1"); assert.Equal(v5.MajorRevision, -1, "v5.MajorRevision -1"); assert.Equal(v5.MinorRevision, -1, "v5.MinorRevision -1"); var v6 = new Version(2000, 1000, 3000, (345 << 16) + 4000); assert.Ok(v6 != null, "v6 created"); assert.Equal(v6.Major, 2000, "v6.Major 2000"); assert.Equal(v6.Minor, 1000, "v6.Minor 1000"); assert.Equal(v6.Build, 3000, "v6.Build 3000"); assert.Equal(v6.Revision, 22613920, "v6.Revision (345 << 16) + 4000 = 22613920"); assert.Equal(v6.MajorRevision, 345, "v6.MajorRevision 345"); assert.Equal(v6.MinorRevision, 4000, "v6.MinorRevision 4"); }
public static void TestUseCase(Assert assert) { assert.Expect(2); var inst = new Bridge597A(); assert.Equal(inst.Get(), "0:a", "Bridge597 Without instance member access"); assert.Equal(inst.GetWithMember(), "HI!:0:a", "Bridge597 With instance member access"); }
public static void Bridge315(Assert assert) { assert.Expect(1); var q = "a,b,c,a".ToUpperCase().Split(",").Aggregate("", (workingSentence, next) => next + " " + workingSentence); assert.Equal(q, "A C B A ", "Enumerable.Aggregate"); }
public static void TestUseCase(Assert assert) { assert.Expect(2); assert.Equal(Bridge537B.TestB1(), 2, "Bridge537 TestB1"); assert.Equal(Bridge537B.TestB2(), 1, "Bridge537 TestB2"); }
// [#84] Does not compile public static void SimpleTryCatch(Assert assert) { assert.Expect(1); var result = TryCatch("Good"); assert.Equal(result, "Good", "TryCatch() executes"); }
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"); }
public static void TestExplicitInterfaceMethodAndProperty(Assert assert) { assert.Expect(3); ISimple b = new B(); assert.Ok(b != null, "Instance of B created through ISimple interface explicitly"); assert.Equal(b.GetString(), "explicit B.ISimple", "b.GetString() = explicit B.ISimple"); assert.Equal(b.Data, 2, "a.Data = 2"); }
public static void TestUseCase(Assert assert) { assert.Expect(2); var s = new Bridge608A("test"); object o = "test"; assert.Ok(s.Equals(o), "Bridge608 Object"); assert.Ok(s.Equals("test"), "Bridge608 String"); }
public static void Test(Assert assert) { assert.Expect(3); assert.Equal(TestMethodParametersClass.MethodDefault(), 5, "Default parameter - 5"); assert.Equal(TestMethodParametersClass.MethodDefault(10), 10, "Default parameter - 10"); assert.Equal(TestMethodParametersClass.MethodParams(new[] { 1, 2, 3 }), 6, "params int[]"); }
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"); }
public static void SimpleTryCatchFinally(Assert assert) { assert.Expect(1); var data = new Data(); TryCatchFinally(data); assert.Equal(data.Count, 2, "TryCatchFinally() executes"); }