public void TestOfType()
 {
     dynamic test = new SimpleResultSet(new dynamic[] { "Hello", 1 });
     IEnumerable<int> ints = test.OfType<int>();
     Assert.AreEqual(1, ints.Count());
     Assert.AreEqual(1, ints.Single());
 }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            if (_data.ContainsKey(binder.Name))
            {
                result = _data[binder.Name];
                var converted = ConvertResult(result);
                if (!ReferenceEquals(result, converted))
                    _data[binder.Name] = result = converted;
                
                return true;
            }

            if (_tableName == null)
            {
                result = null;
                return false;
            }
            var relatedAdapter = _database.Adapter as IAdapterWithRelation;
            if (relatedAdapter != null && relatedAdapter.IsValidRelation(_tableName, binder.Name))
            {
                var relatedRows = relatedAdapter.FindRelated(_tableName, _data, binder.Name);
                if (relatedRows.Count() == 1 && !binder.Name.IsPlural())
                {
                    result = new SimpleRecord(relatedRows.Single(), binder.Name, _database);
                }
                else
                {
                    result = new SimpleResultSet(relatedRows.Select(dict => new SimpleRecord(dict, binder.Name, _database)));
                }
                return true;
            }
            return base.TryGetMember(binder, out result);
        }

 public void TestCastWithClass()
 {
     var dict = new Dictionary<string, object> {{"Name", "Bob"}};
     dynamic test = new SimpleResultSet(new[] {new SimpleRecord(dict)});
     IEnumerable<Foo> foos = test.Cast<Foo>();
     Assert.AreEqual(1, foos.Count());
 }

 public void TestCastWithForeach()
 {
     var dict = new Dictionary<string, object> { { "Name", "Bob" } };
     dynamic test = new SimpleResultSet(new[] { new SimpleRecord(dict) });
     foreach (Foo foo in test)
     {
         Assert.AreEqual("Bob", foo.Name);
     }
 }

 public void TestCastWithForeach()
 {
     var dict = new Dictionary<string, object>(HomogenizedEqualityComparer.DefaultInstance) { { "Name", "Bob" } };
     dynamic test = new SimpleResultSet(new[] { new SimpleRecord(dict) });
     foreach (Foo foo in test)
     {
         Assert.AreEqual("Bob", foo.Name);
     }
 }

 public void LastOrDefaultReturnsLastElement()
 {
     var list = new SimpleResultSet(Records(10));
     Assert.AreEqual("9", list.LastOrDefault().Data);
 }

 public void FirstOrDefaultWithFailingCriteriaReturnsNull()
 {
     var list = new SimpleResultSet(Records(20));
     Assert.IsNull(list.FirstOrDefault<TestType>(t => t.Data.EndsWith("A")));
 }

 public void FirstWithFailingCriteriaThrows()
 {
     var list = new SimpleResultSet(Records(20));
     Assert.Throws<InvalidOperationException>(() => list.First<TestType>(t => t.Data.EndsWith("A")));
 }

        public void ToGenericListCreatesTypedList()
        {
            dynamic list = new SimpleResultSet(Records(1));
            List<TestType> converted = list.ToList<TestType>();

            Assert.IsNotNull(converted);
            Assert.AreEqual(1, converted.Count);
            Assert.AreEqual("0", converted[0].Data);
        }

        public void ToGenericArrayCreatesTypedArray()
        {
            dynamic list = new SimpleResultSet(Records(1));
            TestType[] array = list.ToArray<TestType>();

            Assert.IsNotNull(array);
            Assert.AreEqual(1, array.Length);
            Assert.AreEqual("0", array[0].Data);
        }

 public void ConvertsToHashSet()
 {
     dynamic list = new SimpleResultSet(Records(1));
     HashSet<dynamic> generic = list;
     Assert.IsNotNull(generic);
     Assert.AreEqual("0", generic.Single().Data);
 } 

 public void FirstReturnsFirstElement()
 {
     var list = new SimpleResultSet(Records(10));
     Assert.AreEqual("0", list.First().Data);
 }

 public void SingleWithCriteriaMatchingOneRecordReturnsMatch()
 {
     var list = new SimpleResultSet(Records(10));
     Assert.AreEqual("8", list.Single<TestType>(t => t.Data.EndsWith("8")).Data);
 }

 public void SingleThrowsOnListWithMoreThanOneElement()
 {
     var list = new SimpleResultSet(Records(2));
     Assert.Throws<InvalidOperationException>(() => list.Single());
 }

 public void SingleReturnsSingleElement()
 {
     var list = new SimpleResultSet(Records(1));
     Assert.AreEqual("0", list.Single().Data);
 }

 public void ConvertsToGenericList()
 {
     dynamic list = new SimpleResultSet(Records(1));
     List<dynamic> generic = list;
     Assert.IsNotNull(generic);
     Assert.AreEqual("0", generic[0].Data);
 }

 public void ConvertsToNonGenericList()
 {
     dynamic list = new SimpleResultSet(Records(1));
     ArrayList generic = list;
     Assert.IsNotNull(generic);
     Assert.AreEqual("0", ((dynamic)generic[0]).Data);
 }

 public void SingleOrDefaultWithCriteriaMatchingMultipleRecordsThrows()
 {
     var list = new SimpleResultSet(Records(20));
     Assert.Throws<InvalidOperationException>(() => list.SingleOrDefault<TestType>(t => t.Data.EndsWith("8")));
 }

        public void ToArrayCreatesArray()
        {
            dynamic list = new SimpleResultSet(Records(1));
            dynamic[] array = list.ToArray();

            Assert.IsNotNull(array);
            Assert.AreEqual(1, array.Length);
            Assert.AreEqual("0", array[0].Data);
        }

 public void GenericFirstOrDefaultReturnsFirstElement()
 {
     var list = new SimpleResultSet(Records(10));
     Assert.AreEqual("0", list.FirstOrDefault<TestType>().Data);
 }