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 void testAs2()
{
var x = new MyEnumerable();
AssertNotNull(AsIEnumerable(x));
AssertNull(AsICollection(x));
AssertNull(AsIList(x));
}
public void testIs2()
{
var x = new MyEnumerable();
AssertTrue(IsIEnumerable(x));
AssertFalse(IsICollection(x));
AssertFalse(IsIList(x));
}
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);
}
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) { }
}
