public void WhereWhenEmpty() { var numbers = new List <Int32>(); var allNumbers = MyEnumerable.Where(numbers, (n, i) => i >= 0); Assert.That(allNumbers, Is.Empty); }
public void testAs2() { var x = new MyEnumerable(); AssertNotNull(AsIEnumerable(x)); AssertNull(AsICollection(x)); AssertNull(AsIList(x)); }
public void WhereWhenEmpty() { var numbers = new List <Int32>(); var numbersGreaterThanFive = MyEnumerable.Where(numbers, n => n > 5); Assert.That(numbersGreaterThanFive, Is.Empty); }
public void testIs2() { var x = new MyEnumerable(); AssertTrue(IsIEnumerable(x)); AssertFalse(IsICollection(x)); AssertFalse(IsIList(x)); }
public void WhereWhenNotEmpty() { var numbers = new[] { 1, 2, 3 }; var numbersGreaterThanOne = MyEnumerable.Where(numbers, (n, i) => i > 0); Assert.That(numbersGreaterThanOne, Is.EquivalentTo(new[] { 2, 3 })); }
public ObjectWithMyEnumerable() { Stuff = "stuff"; MyEnumerable = new MyEnumerable() { Property = "foo" }; }
public void Reverse() { var actual = MyEnumerable .Range(0, 5) .Reverse(); Assert.Equal(new[] { 4, 3, 2, 1, 0 }, actual); }
public void Select() { var actual = MyEnumerable .Range(0, 3) .Select(i => i * 2); Assert.Equal(new[] { 0, 2, 4 }, actual); }
public void Where() { var actual = MyEnumerable .Range(0, 5) .Where(i => i % 2 == 0); Assert.Equal(new[] { 0, 2, 4 }, actual); }
public void Take() { var actual = MyEnumerable .Range(0, 5) .Take(3); Assert.Equal(new[] { 0, 1, 2 }, actual); }
static void Main12(string[] args) { MyEnumerable enu = new MyEnumerable(); foreach (Person p in enu) { Console.WriteLine(p.Name + " " + p.Age + " 岁"); } }
public static void Main(string[] args) { MyEnumerable myEnumerable = new MyEnumerable(); foreach (Person person in myEnumerable) { Console.WriteLine(person.Name); } }
public static void Main(string[] args) { MyEnumerable myEnumerable = new MyEnumerable(); foreach (Person person in myEnumerable) { Console.WriteLine (person.Name); } }
public void ParallelForEachWithConsumingEnumerableTest() { // All the MoveNext calls should be made on the same thread var enumerable = new MyEnumerable(20); AsyncPatterns.ForEachWithEnumerationOnMainThread <int>(enumerable, (i) => { Debug.WriteLine("Loop: {0}", i); }); }
public static void Main() { MyEnumerable <int> en = new MyEnumerable <int>(); IEnumerable ee = en; // Duas versões de GetEnumerator diferem apenas no tipo de retorno. // Implementação explícita da interface IEnumerable evita a ambiguidade. en.GetEnumerator(); ee.GetEnumerator(); }
private static void UseMyEnumerable() { var e = new MyEnumerable(); var q2 = e.Where(x => x % 2 == 0); var q3 = q2.Select(x => x * x); foreach (var val in q3) { Console.WriteLine($"{val}"); } }
static void Main(string[] args) { var myEnumerable = new MyEnumerable(); foreach (var item in myEnumerable) { Console.WriteLine(item); } Console.ReadKey(); }
static void Main(string[] args) { IEnumerable <Person> enumerable = new MyEnumerable <Person>(); IEnumerator <Person> enumerator = enumerable.GetEnumerator(); while (enumerator.MoveNext()) { Console.WriteLine(enumerator.Current.Name); } Console.ReadKey(); }
static void Main(string[] args) { //var db = new filedbEntities(); //IEnumerable<SerializedFile> enumfiles = db.SerializedFiles; //IEnumerable<SerializedFile> fileList = enumfiles.Where(x => x.Id > 2); //foreach (var item in fileList) //{ // Console.WriteLine(item.FileContent); //} //IQueryable<SerializedFile> queryfiles = db.SerializedFiles; //IEnumerable<SerializedFile> fileList1 = queryfiles.Where(x => x.Id > 2).OrderBy(x => x.Id).Skip(1).Take(1).ToList(); //bool isInDb = queryfiles.Where(x => x.Id > 2).Any(x => x.FileContent.Contains("wirtek1")); //IEnumerable<bool> fileList3 = queryfiles.Where(x => x.Id > 2).Select(x => x.FileContent.Contains("wirtek1")).ToList(); //IEnumerable<bool> fileList4 = queryfiles.Where(x => x.Id > 2).Select(x => x.FileContent.Contains("wirtek1")).ToList(); //SerializedFile first = queryfiles.First(x => x.Id > 2); //SerializedFile single = queryfiles.Single(x => x.Id > 2 && x.FileContent.Contains("wirtek1")); //foreach (var item in fileList1) //{ // Console.WriteLine(item.FileContent); //} //Console.WriteLine(isInDb); //Console.WriteLine(first.Name); //Console.WriteLine(single.Name); using (var db = new filedbEntities()) { IEnumerable <string> myParamEnumerable = db.SerializedFiles.Select(serializedFile => serializedFile.FileContent); MyEnumerable <string> myEnumerable = new MyEnumerable <string>(myParamEnumerable); Console.WriteLine(myEnumerable); IEnumerable <int> myNbParamEnumerable = db.SerializedFiles.Select(serializedFile => serializedFile.Id); MyEnumerable <int> myNbEnumerable = new MyEnumerable <int>(myNbParamEnumerable); Console.WriteLine(myNbEnumerable); } }
public void ClassImplementingIEnumerableCanBeEnumerated() { MyEnumerable enm = new MyEnumerable(); var e = enm.GetEnumerator(); Assert.IsTrue(e.MoveNext()); Assert.AreEqual(e.Current, "x"); Assert.IsTrue(e.MoveNext()); Assert.AreEqual(e.Current, "y"); Assert.IsTrue(e.MoveNext()); Assert.AreEqual(e.Current, "z"); Assert.IsFalse(e.MoveNext()); }
public void JoinWorks() { Assert.AreEqual("a, ab, abc, abcd", string.Join(", ", new[] { "a", "ab", "abc", "abcd" })); Assert.AreEqual("ab, abc", string.Join(", ", new[] { "a", "ab", "abc", "abcd" }, 1, 2)); IEnumerable <int> intValues = new MyEnumerable <int>(new[] { 1, 5, 6 }); Assert.AreEqual("1, 5, 6", String.Join(", ", intValues)); IEnumerable <string> stringValues = new MyEnumerable <string>(new[] { "a", "ab", "abc", "abcd" }); Assert.AreEqual("a, ab, abc, abcd", String.Join(", ", stringValues)); Assert.AreEqual("a, 1, abc, False", String.Join(", ", new Object[] { "a", 1, "abc", false })); }
public void ClassImplementingIEnumerableCastToIEnumerableCanBeEnumerated() { IEnumerable <string> enm = new MyEnumerable(); var e = enm.GetEnumerator(); Assert.True(e.MoveNext()); Assert.AreEqual("x", e.Current); Assert.True(e.MoveNext()); Assert.AreEqual("y", e.Current); Assert.True(e.MoveNext()); Assert.AreEqual("z", e.Current); Assert.False(e.MoveNext()); }
public void SelectMany() { var numbers = MyEnumerable.Range(1, 2); var letters = new[] { 'A', 'B' }; var actual = numbers.SelectMany(num => letters, Tuple.Create); Assert.Equal(new[] { Tuple.Create(1, 'A'), Tuple.Create(1, 'B'), Tuple.Create(2, 'A'), Tuple.Create(2, 'B') }, actual); }
public void JoinWorks() { Assert.AreEqual(string.Join(", ", new[] { "a", "ab", "abc", "abcd" }), "a, ab, abc, abcd"); Assert.AreEqual(string.Join(", ", new[] { "a", "ab", "abc", "abcd" }, 1, 2), "ab, abc"); IEnumerable <int> intValues = new MyEnumerable <int>(new[] { 1, 5, 6 }); Assert.AreEqual(String.Join(", ", intValues), "1, 5, 6"); IEnumerable <string> stringValues = new MyEnumerable <string>(new[] { "a", "ab", "abc", "abcd" }); Assert.AreEqual(String.Join(", ", stringValues), "a, ab, abc, abcd"); // TODO: c# makes it False but js false Assert.AreEqual(String.Join(", ", new Object[] { "a", 1, "abc", false }), "a, 1, abc, false");// False"); }
public void IEnumerable_GetEnumerator() { // Arrange var sequence = new MyEnumerable(); // Act var enumerator = sequence.GetEnumerator(); // Assert var list = new List <char>(); while (enumerator.MoveNext()) { list.Add((char)enumerator.Current); } Assert.Equal("hello world", list.Aggregate(string.Empty, (c, i) => c + i)); }
public bool PosTest3() { bool retVal = true; const string c_TEST_DESC = "PosTest3: Useing customer class which implemented the GetEnumerator method in IEnumerable<T>... "; const string c_TEST_ID = "P003"; int[] pArray = new int[2]; pArray[0] = TestLibrary.Generator.GetInt32(-55); pArray[1] = TestLibrary.Generator.GetInt32(-55); MyEnumerable <int> myEnumerable = new MyEnumerable <int>(pArray); MyEnumerator <int> myEnumerator = new MyEnumerator <int>(pArray); ((IEnumerator <int>)myEnumerator).MoveNext(); TestLibrary.TestFramework.BeginScenario(c_TEST_DESC); try { IEnumerator <int> enumerator = ((IEnumerable <int>)myEnumerable).GetEnumerator(); enumerator.MoveNext(); if (enumerator.Current != ((IEnumerator <int>)myEnumerator).Current) { string errorDesc = "Value is not " + myEnumerator.Current + " as expected: Actual(" + enumerator.Current + ")"; TestLibrary.TestFramework.LogError("007" + " TestId-" + c_TEST_ID, errorDesc); retVal = false; } enumerator.MoveNext(); ((IEnumerator <int>)myEnumerator).MoveNext(); if (enumerator.Current != ((IEnumerator <int>)myEnumerator).Current) { string errorDesc = "Value is not " + myEnumerator.Current + " as expected: Actual(" + enumerator.Current + ")"; TestLibrary.TestFramework.LogError("008" + " TestId-" + c_TEST_ID, errorDesc); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError("009", "Unecpected exception occurs :" + e); retVal = false; } return(retVal); }
static void Main(string[] args) { Console.WriteLine("Hello World!"); IEnumerable <string> obj = new MyEnumerable(); foreach (var item in obj) { Console.WriteLine(item); } foreach (var item in obj) { Console.WriteLine("2: " + item); } Console.ReadKey(); }
public void testCast2() { var x = new MyEnumerable(); try { var e = CastToIEnumerable(x); AssertNull(e.GetEnumerator()); } catch (InvalidCastException) { Fail("valid cast expected"); } try { CastToICollection(x); Fail("invalid cast expected"); } catch (InvalidCastException) { } try { CastToIList(x); Fail("invalid cast expected"); } catch (InvalidCastException) { } }
public void SelectManyCartesianProduct() { var numbers = MyEnumerable.Range(1, 3); var letters = new[] { 'x', 'y', 'z' }; var actual = numbers.SelectMany( number => letters, Tuple.Create ); CollectionAssert.AreEqual( new[] { Tuple.Create(1, 'x'), Tuple.Create(1, 'y'), Tuple.Create(1, 'z'), Tuple.Create(2, 'x'), Tuple.Create(2, 'y'), Tuple.Create(2, 'z'), Tuple.Create(3, 'x'), Tuple.Create(3, 'y'), Tuple.Create(3, 'z') }, actual); }
static void Main(string[] args) { int n = int.Parse(Console.ReadLine()); var nodes = MyEnumerable.Repeat(i => new Node(i), n).ToList(); for (int i = 0; i < n; i++) { var input = Console.ReadLine().Split(' ').Select(int.Parse); int left = input.ElementAt(1); int right = input.ElementAt(2); nodes[i].Id = i; nodes[i].Left = left; nodes[i].Right = right; if (left != -1) { nodes[left].Parent = i; } if (right != -1) { nodes[right].Parent = i; } } var rootNode = nodes.Where(node => node.Parent == -1).First(); Console.WriteLine("Preorder"); Console.WriteLine(string.Join(" ", PreParse(rootNode, nodes))); Console.WriteLine(""); Console.WriteLine("Inorder"); Console.WriteLine(string.Join(" ", InorderParse(rootNode, nodes))); Console.WriteLine(""); Console.WriteLine("Postorder"); Console.WriteLine(string.Join(" ", PostorderParse(rootNode, nodes))); Console.WriteLine(""); Console.ReadLine(); }
public void DataBindingCustomElement () { DataGridPoker p = new DataGridPoker (); p.DataKeyField = "CustomName"; PagedDataSource source = new PagedDataSource (); MyEnumerable myenum = new MyEnumerable (); myenum.Item = new Custom (); source.DataSource = myenum; ArrayList columns = p.CreateColumns (source, true); Assert.AreEqual (1, columns.Count, "A1"); Assert.AreEqual ("CustomName", ((DataGridColumn) columns [0]).HeaderText, "A2"); Assert.AreEqual (0, p.DataKeys.Count, "A3"); }
public void ReverseTest() { var actual = MyEnumerable.Range(1, 5).Reverse(); CollectionAssert.AreEqual(new[] { 5, 4, 3, 2, 1 }, actual); }