From 913d29274edec445b2b7373cbbc913fc8ebccb9f Mon Sep 17 00:00:00 2001
From: "grzegorz.russek" <grzegorz.russek@4fcca04b-e380-4062-a974-89054f7ae9f5>
Date: Thu, 20 Sep 2018 05:35:36 +0000
Subject: [PATCH]

---
 AmalgamationTool/DynamORM.Amalgamation.cs     |  90 +++++++-
 DynamORM.Tests/DynamORM.Tests.csproj          |  24 ++-
 DynamORM.Tests/Helpers/AttachToDebugger.cs    |  17 +-
 .../Helpers/Dynamic/DynamicParserTests.cs     |  32 +--
 DynamORM.Tests/Helpers/PoolingTests.cs        |  14 +-
 .../Validation/ObjectValidationTest.cs        |  80 +++++++
 .../Modify/DynamicModificationTests.cs        |  48 ++---
 .../DynamicNoSchemaModificationTests.cs       |   8 +-
 .../DynamicTypeSchemaModificationTests.cs     |   6 +-
 DynamORM.Tests/Modify/ParserTests.cs          |  24 +--
 .../Properties/Resources.Designer.cs          |   4 +-
 DynamORM.Tests/Select/DynamicAccessTests.cs   | 168 +++++++--------
 .../Select/DynamicNoSchemaAccessTests.cs      |   6 +-
 .../Select/DynamicTypeSchemaAccessTests.cs    |   4 +-
 DynamORM.Tests/Select/LegacyParserTests.cs    |  44 ++--
 DynamORM.Tests/Select/ParserTests.cs          | 128 +++++------
 DynamORM.Tests/Select/TypedAccessTests.cs     | 203 +++++++++---------
 DynamORM/Mapper/DynamicTypeMap.cs             |  41 +++-
 DynamORM/Validation/RequiredAttribute.cs      |  51 ++++-
 19 files changed, 607 insertions(+), 385 deletions(-)
 create mode 100644 DynamORM.Tests/Helpers/Validation/ObjectValidationTest.cs

diff --git a/AmalgamationTool/DynamORM.Amalgamation.cs b/AmalgamationTool/DynamORM.Amalgamation.cs
index 37db94a..dbf2055 100644
--- a/AmalgamationTool/DynamORM.Amalgamation.cs
+++ b/AmalgamationTool/DynamORM.Amalgamation.cs
@@ -13432,7 +13432,7 @@ namespace DynamORM
 
                     var v = prop.Get(val);
 
-                    foreach (var r in prop.Requirements)
+                    foreach (var r in prop.Requirements.Where(x => !x.ElementRequirement))
                     {
                         var valid = r.ValidateSimpleValue(prop, v);
 
@@ -13441,8 +13441,42 @@ namespace DynamORM
                             if (prop.Type.IsArray || prop.IsGnericEnumerable)
                             {
                                 var map = DynamicMapperCache.GetMapper(prop.ArrayType);
-                                foreach (var item in val as IEnumerable<object>)
-                                    result.AddRange(map.ValidateObject(item));
+
+                                var list = v as IEnumerable<object>;
+
+                                if (list == null)
+                                {
+                                    var enumerable = v as IEnumerable;
+                                    if (enumerable != null)
+                                        list = enumerable.Cast<object>();
+                                }
+
+                                if (list != null)
+                                    foreach (var item in list)
+                                    {
+                                        if (prop.Requirements.Any(x => x.ElementRequirement))
+                                        {
+                                            foreach (var re in prop.Requirements.Where(x => x.ElementRequirement))
+                                            {
+                                                var validelem = re.ValidateSimpleValue(prop.ArrayType, prop.ArrayType.IsGenericEnumerable(), item);
+
+                                                if (validelem == ValidateResult.NotSupported)
+                                                {
+                                                    result.AddRange(map.ValidateObject(item));
+                                                    break;
+                                                }
+                                                else if (validelem != ValidateResult.Valid)
+                                                    result.Add(new ValidationResult()
+                                                    {
+                                                        Property = prop,
+                                                        Requirement = r,
+                                                        Value = item,
+                                                    });
+                                            }
+                                        }
+                                        else
+                                            result.AddRange(map.ValidateObject(item));
+                                    }
                             }
 
                             continue;
@@ -13544,7 +13578,7 @@ namespace DynamORM
     namespace Validation
     {
         /// <summary>Required attribute can be used to validate fields in objects using mapper class.</summary>
-        [AttributeUsage(AttributeTargets.Property)]
+        [AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
         public class RequiredAttribute : Attribute
         {
             /// <summary>Gets or sets minimum value or length of field.</summary>
@@ -13559,6 +13593,9 @@ namespace DynamORM
             /// <summary>Gets or sets a value indicating whether property value is required or not.</summary>
             public bool Required { get; set; }
 
+            /// <summary>Gets or sets a value indicating whether this is an element requirement.</summary>
+            public bool ElementRequirement { get; set; }
+
             /// <summary>Initializes a new instance of the <see cref="RequiredAttribute" /> class.</summary>
             /// <param name="required">This field will be required.</param>
             public RequiredAttribute(bool required = true)
@@ -13605,10 +13642,20 @@ namespace DynamORM
 
             internal ValidateResult ValidateSimpleValue(DynamicPropertyInvoker dpi, object val)
             {
-                if (val == null && Required)
-                    return ValidateResult.ValueIsMissing;
+                return ValidateSimpleValue(dpi.Type, dpi.IsGnericEnumerable, val);
+            }
 
-                if (dpi.Type.IsValueType)
+            internal ValidateResult ValidateSimpleValue(Type type, bool isGnericEnumerable, object val)
+            {
+                if (val == null)
+                {
+                    if (Required)
+                        return ValidateResult.ValueIsMissing;
+                    else
+                        return ValidateResult.Valid;
+                }
+
+                if (type.IsValueType)
                 {
                     if (val is decimal || val is long || val is int || val is float || val is double || val is short || val is byte ||
                         val is decimal? || val is long? || val is int? || val is float? || val is double? || val is short? || val is byte?)
@@ -13639,9 +13686,19 @@ namespace DynamORM
                         return ValidateResult.Valid;
                     }
                 }
-                else if (dpi.Type.IsArray || dpi.IsGnericEnumerable)
+                else if (type.IsArray || isGnericEnumerable)
                 {
-                    var cnt = (val as IEnumerable<object>).Count();
+                    int? cnt = null;
+
+                    var list = (val as IEnumerable<object>);
+                    if (list != null)
+                        cnt = list.Count();
+                    else
+                    {
+                        var enumerable = (val as IEnumerable);
+                        if (enumerable != null)
+                            cnt = enumerable.Cast<object>().Count();
+                    }
 
                     if (Min.HasValue && Min.Value > cnt)
                         return ValidateResult.TooFewElementsInCollection;
@@ -13651,6 +13708,21 @@ namespace DynamORM
 
                     return ValidateResult.Valid;
                 }
+                else if (type == typeof(string))
+                {
+                    var str = (string)val;
+
+                    if (Min.HasValue && Min.Value > str.Length)
+                        return ValidateResult.ValueTooShort;
+
+                    if (Max.HasValue && Max.Value < str.Length)
+                        return ValidateResult.ValueTooLong;
+
+                    if (Pattern != null && !Pattern.IsMatch(str))
+                        return ValidateResult.ValueDontMatchPattern;
+
+                    return ValidateResult.Valid;
+                }
 
                 return ValidateResult.NotSupported;
             }
diff --git a/DynamORM.Tests/DynamORM.Tests.csproj b/DynamORM.Tests/DynamORM.Tests.csproj
index 7ebb425..6ee31c5 100644
--- a/DynamORM.Tests/DynamORM.Tests.csproj
+++ b/DynamORM.Tests/DynamORM.Tests.csproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@@ -10,7 +10,7 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>DynamORM.Tests</RootNamespace>
     <AssemblyName>DynamORM.Tests</AssemblyName>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <TargetFrameworkProfile />
     <AllowUnsafeBlocks>False</AllowUnsafeBlocks>
@@ -20,6 +20,8 @@
     <SignAssembly>False</SignAssembly>
     <DelaySign>False</DelaySign>
     <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugType>Full</DebugType>
@@ -63,14 +65,8 @@
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="Microsoft.CSharp" />
-    <Reference Include="nunit.framework">
-      <HintPath>C:\Program Files %28x86%29\NUnit 2.6.3\bin\framework\nunit.framework.dll</HintPath>
-    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
-    <Reference Include="System.Data.SQLite">
-      <HintPath>..\..\..\Libs\SQLite\Any\System.Data.SQLite.dll</HintPath>
-    </Reference>
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="System.Data" />
@@ -79,6 +75,7 @@
   <ItemGroup>
     <Compile Include="Helpers\Dynamic\DynamicParserTests.cs" />
     <Compile Include="Helpers\PoolingTests.cs" />
+    <Compile Include="Helpers\Validation\ObjectValidationTest.cs" />
     <Compile Include="Modify\DynamicModificationTests.cs" />
     <Compile Include="Modify\DynamicNoSchemaModificationTests.cs" />
     <Compile Include="Modify\DynamicTypeSchemaModificationTests.cs" />
@@ -113,6 +110,17 @@
       <Name>DynamORM</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="MSTest.TestAdapter">
+      <Version>1.2.1</Version>
+    </PackageReference>
+    <PackageReference Include="MSTest.TestFramework">
+      <Version>1.2.1</Version>
+    </PackageReference>
+    <PackageReference Include="System.Data.SQLite">
+      <Version>1.0.109.1</Version>
+    </PackageReference>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/DynamORM.Tests/Helpers/AttachToDebugger.cs b/DynamORM.Tests/Helpers/AttachToDebugger.cs
index 72992e1..16bb134 100644
--- a/DynamORM.Tests/Helpers/AttachToDebugger.cs
+++ b/DynamORM.Tests/Helpers/AttachToDebugger.cs
@@ -28,25 +28,16 @@
 
 using System.Collections.Generic;
 using System.Diagnostics;
-using NUnit.Framework;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace DynamORM.Tests.Helpers
 {
     /// <summary>Class responsible for users operations testing.</summary>
-    [TestFixture]
+    [TestClass]
     public class AttachToDebugger
     {
-        /// <summary>Attach to debugger.</summary>
-        [Test]
-        [Explicit("Test for attaching debugger to NUnit test framework")]
-        public void Attach()
-        {
-            if (!Debugger.IsAttached)
-                Debugger.Launch();
-        }
-
         /// <summary>Test anonymous type compatibility.</summary>
-        [Test]
+        [TestMethod]
         public void TestAnonType()
         {
             var a = new { x = 1, y = 2 };
@@ -56,7 +47,7 @@ namespace DynamORM.Tests.Helpers
         }
 
         /// <summary>Test anonymous type value.</summary>
-        [Test]
+        [TestMethod]
         public void TestAnonTypeValue()
         {
             var a = new { x = 1, y = "bla bla" };
diff --git a/DynamORM.Tests/Helpers/Dynamic/DynamicParserTests.cs b/DynamORM.Tests/Helpers/Dynamic/DynamicParserTests.cs
index 5d07f1f..8a2f232 100644
--- a/DynamORM.Tests/Helpers/Dynamic/DynamicParserTests.cs
+++ b/DynamORM.Tests/Helpers/Dynamic/DynamicParserTests.cs
@@ -28,39 +28,39 @@
 
 using System;
 using DynamORM.Helpers.Dynamics;
-using NUnit.Framework;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace DynamORM.Tests.Helpers.Dynamic
 {
     /// <summary><see cref="DynamicParser"/> tests.</summary>
-    [TestFixture]
+    [TestClass]
     public class DynamicParserTests
     {
         /// <summary>
         /// Tests the get member.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestGetMember()
         {
             Func<dynamic, object> f = x => x.SomePropery;
 
             var val = DynamicParser.Parse(f).Result as DynamicParser.Node.GetMember;
 
-            Assert.NotNull(val);
+            Assert.IsNotNull(val);
             Assert.AreEqual("SomePropery", val.Name);
         }
 
         /// <summary>
         /// Tests the set member.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSetMember()
         {
             Func<dynamic, object> f = x => x.SomePropery = "value";
 
             var val = DynamicParser.Parse(f).Result as DynamicParser.Node.SetMember;
 
-            Assert.NotNull(val);
+            Assert.IsNotNull(val);
             Assert.AreEqual("SomePropery", val.Name);
             Assert.AreEqual("value", val.Value);
         }
@@ -68,34 +68,34 @@ namespace DynamORM.Tests.Helpers.Dynamic
         /// <summary>
         /// Tests the index of the get.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestGetIndex()
         {
             Func<dynamic, object> f = x => x.SomePropery[0];
 
             var val = DynamicParser.Parse(f).Result as DynamicParser.Node.GetIndex;
 
-            Assert.NotNull(val);
+            Assert.IsNotNull(val);
         }
 
         /// <summary>
         /// Tests the index of the set.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSetIndex()
         {
             Func<dynamic, object> f = x => x.SomePropery[0] = "value";
 
             var val = DynamicParser.Parse(f).Result as DynamicParser.Node.SetIndex;
 
-            Assert.NotNull(val);
+            Assert.IsNotNull(val);
             Assert.AreEqual("value", val.Value);
         }
 
         /// <summary>
         /// Tests something.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSomething()
         {
             Func<dynamic, object> f = x => x.SomePropery == "value" || x.OtherProperty == -1;
@@ -103,16 +103,16 @@ namespace DynamORM.Tests.Helpers.Dynamic
             var p = DynamicParser.Parse(f);
             var val = p.Result as DynamicParser.Node.Binary;
 
-            Assert.NotNull(val);
+            Assert.IsNotNull(val);
 
             var left = val.Host as DynamicParser.Node.Binary;
             var right = val.Right as DynamicParser.Node.Binary;
 
-            Assert.NotNull(left);
-            Assert.NotNull(right);
+            Assert.IsNotNull(left);
+            Assert.IsNotNull(right);
 
-            Assert.IsInstanceOf<DynamicParser.Node.GetMember>(left.Host);
-            Assert.IsInstanceOf<DynamicParser.Node.GetMember>(right.Host);
+            Assert.IsInstanceOfType(left.Host, typeof(DynamicParser.Node.GetMember));
+            Assert.IsInstanceOfType(right.Host, typeof(DynamicParser.Node.GetMember));
 
             Assert.AreEqual("value", left.Right);
             Assert.AreEqual(-1, right.Right);
diff --git a/DynamORM.Tests/Helpers/PoolingTests.cs b/DynamORM.Tests/Helpers/PoolingTests.cs
index cd8409e..dc34e53 100644
--- a/DynamORM.Tests/Helpers/PoolingTests.cs
+++ b/DynamORM.Tests/Helpers/PoolingTests.cs
@@ -26,23 +26,23 @@
  * THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-using NUnit.Framework;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace DynamORM.Tests.Helpers
 {
     /// <summary>Pooling tests.</summary>
-    [TestFixture]
+    [TestClass]
     public class PoolingTests : TestsBase
     {
         /// <summary>Setup test parameters.</summary>
-        [TestFixtureSetUp]
+        [TestInitialize]
         public virtual void SetUp()
         {
             CreateTestDatabase();
         }
 
         /// <summary>Tear down test objects.</summary>
-        [TestFixtureTearDown]
+        [TestCleanup]
         public virtual void TearDown()
         {
             DestroyDynamicDatabase();
@@ -50,7 +50,7 @@ namespace DynamORM.Tests.Helpers
         }
 
         /// <summary>Test single mode command disposing.</summary>
-        [Test]
+        [TestMethod]
         public void TestSingleModeCommand()
         {
             CreateDynamicDatabase();
@@ -62,11 +62,11 @@ namespace DynamORM.Tests.Helpers
             Database.Dispose();
             Database = null;
 
-            Assert.Throws<DynamicQueryException>(() => cmd.ExecuteScalar());
+            Assert.ThrowsException<DynamicQueryException>(() => cmd.ExecuteScalar());
         }
 
         /// <summary>Test single mode transaction disposing.</summary>
-        [Test]
+        [TestMethod]
         public void TestSingleModeTransaction()
         {
             try
diff --git a/DynamORM.Tests/Helpers/Validation/ObjectValidationTest.cs b/DynamORM.Tests/Helpers/Validation/ObjectValidationTest.cs
new file mode 100644
index 0000000..103d4ab
--- /dev/null
+++ b/DynamORM.Tests/Helpers/Validation/ObjectValidationTest.cs
@@ -0,0 +1,80 @@
+/*
+ * DynamORM - Dynamic Object-Relational Mapping library.
+ * Copyright (c) 2012-2015, Grzegorz Russek (grzegorz.russek@gmail.com)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+using DynamORM.Mapper;
+using DynamORM.Validation;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace DynamORM.Tests.Helpers.Validation
+{
+    [TestClass]
+    public class ObjectValidationTest
+    {
+        public class TestObject
+        {
+            [Required(1f, 10f)]
+            public int TestInt { get; set; }
+
+            [Required(7, false, false)]
+            public string CanBeNull { get; set; }
+
+            [Required(2, true)]
+            [Required(7, 18, ElementRequirement = true)]
+            public decimal[] ArrayTest { get; set; }
+        }
+
+        [TestMethod]
+        public void ValidateCorrectObject()
+        {
+            var result = DynamicMapperCache.GetMapper<TestObject>().ValidateObject(
+                new TestObject
+                {
+                    TestInt = 2,
+                    ArrayTest = new decimal[] { 7, 18 },
+                });
+
+            Assert.IsNotNull(result);
+            Assert.AreEqual(0, result.Count);
+        }
+
+        [TestMethod]
+        public void ValidateIncorrectObject()
+        {
+            var result = DynamicMapperCache.GetMapper<TestObject>().ValidateObject(
+                new TestObject
+                {
+                    TestInt = 0,
+                    CanBeNull = string.Empty,
+                    ArrayTest = new decimal[] { 0, 0 },
+                });
+
+            Assert.IsNotNull(result);
+            Assert.AreEqual(4, result.Count);
+        }
+    }
+}
\ No newline at end of file
diff --git a/DynamORM.Tests/Modify/DynamicModificationTests.cs b/DynamORM.Tests/Modify/DynamicModificationTests.cs
index f25b96e..53ed113 100644
--- a/DynamORM.Tests/Modify/DynamicModificationTests.cs
+++ b/DynamORM.Tests/Modify/DynamicModificationTests.cs
@@ -28,16 +28,16 @@
 
 using System;
 using DynamORM.Tests.Helpers;
-using NUnit.Framework;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace DynamORM.Tests.Modify
 {
     /// <summary>Test standard dynamic access ORM.</summary>
-    [TestFixture]
+    [TestClass]
     public class DynamicModificationTests : TestsBase
     {
         /// <summary>Setup test parameters.</summary>
-        [TestFixtureSetUp]
+        [TestInitialize]
         public virtual void SetUp()
         {
             CreateTestDatabase();
@@ -45,7 +45,7 @@ namespace DynamORM.Tests.Modify
         }
 
         /// <summary>Tear down test objects.</summary>
-        [TestFixtureTearDown]
+        [TestCleanup]
         public virtual void TearDown()
         {
             DestroyDynamicDatabase();
@@ -62,14 +62,14 @@ namespace DynamORM.Tests.Modify
         #region Insert
 
         /// <summary>Test row insertion by dynamic arguments.</summary>
-        [Test]
+        [TestMethod]
         public void TestInsertByArguments()
         {
             Assert.AreEqual(1, GetTestTable().Insert(code: "201", first: null, last: "Gagarin", email: "juri.gagarin@megacorp.com", quote: "bla, bla, bla"));
 
             // Verify
             var o = GetTestTable().Single(code: "201");
-            Assert.Less(200, o.id);
+            Assert.AreNotEqual(200, o.id);
             Assert.AreEqual("201", o.code.ToString());
             Assert.AreEqual(null, o.first);
             Assert.AreEqual("Gagarin", o.last);
@@ -79,14 +79,14 @@ namespace DynamORM.Tests.Modify
         }
 
         /// <summary>Test row insertion by dynamic object.</summary>
-        [Test]
+        [TestMethod]
         public void TestInsertByDynamicObjects()
         {
             Assert.AreEqual(1, GetTestTable().Insert(values: new { code = "202", first = DBNull.Value, last = "Gagarin", email = "juri.gagarin@megacorp.com", quote = "bla, bla, bla" }));
 
             // Verify
             var o = GetTestTable().Single(code: "202");
-            Assert.Less(200, o.id);
+            Assert.AreNotEqual(200, o.id);
             Assert.AreEqual("202", o.code.ToString());
             Assert.AreEqual(null, o.first);
             Assert.AreEqual("Gagarin", o.last);
@@ -96,7 +96,7 @@ namespace DynamORM.Tests.Modify
         }
 
         /// <summary>Test row insertion by mapped object.</summary>
-        [Test]
+        [TestMethod]
         public void TestInsertByMappedObject()
         {
             var u = GetTestTable();
@@ -113,7 +113,7 @@ namespace DynamORM.Tests.Modify
 
             // Verify
             var o = u.Single(code: "203");
-            Assert.Less(200, o.id);
+            Assert.AreNotEqual(200, o.id);
             Assert.AreEqual("203", o.code.ToString());
             Assert.AreEqual(null, o.first);
             Assert.AreEqual("Gagarin", o.last);
@@ -123,7 +123,7 @@ namespace DynamORM.Tests.Modify
         }
 
         /// <summary>Test row insertion by basic object.</summary>
-        [Test]
+        [TestMethod]
         public void TestInsertByBasicObject()
         {
             var u = GetTestTable();
@@ -140,7 +140,7 @@ namespace DynamORM.Tests.Modify
 
             // Verify
             var o = u.Single(code: "204");
-            Assert.Less(200, o.id);
+            Assert.AreNotEqual(200, o.id);
             Assert.AreEqual("204", o.code.ToString());
             Assert.AreEqual(null, o.first);
             Assert.AreEqual("Gagarin", o.last);
@@ -154,7 +154,7 @@ namespace DynamORM.Tests.Modify
         #region Update
 
         /// <summary>Test row updating by dynamic arguments.</summary>
-        [Test]
+        [TestMethod]
         public void TestUpdateByArguments()
         {
             Assert.AreEqual(1, GetTestTable().Update(id: 1, code: "201", first: null, last: "Gagarin", email: "juri.gagarin@megacorp.com", quote: "bla, bla, bla"));
@@ -171,7 +171,7 @@ namespace DynamORM.Tests.Modify
         }
 
         /// <summary>Test row updating by dynamic objects.</summary>
-        [Test]
+        [TestMethod]
         public void TestUpdateByDynamicObject()
         {
             Assert.AreEqual(1, GetTestTable().Update(update: new { id = 2, code = "202", first = DBNull.Value, last = "Gagarin", email = "juri.gagarin@megacorp.com", quote = "bla, bla, bla" }));
@@ -188,7 +188,7 @@ namespace DynamORM.Tests.Modify
         }
 
         /// <summary>Test row updating by mapped object.</summary>
-        [Test]
+        [TestMethod]
         public void TestUpdateByMappedObject()
         {
             var u = GetTestTable();
@@ -215,7 +215,7 @@ namespace DynamORM.Tests.Modify
         }
 
         /// <summary>Test row updating by basic object.</summary>
-        [Test]
+        [TestMethod]
         public void TestUpdateByBasicObject()
         {
             var u = GetTestTable();
@@ -242,7 +242,7 @@ namespace DynamORM.Tests.Modify
         }
 
         /// <summary>Test row updating by dynamic objects.</summary>
-        [Test]
+        [TestMethod]
         public void TestUpdateByDynamicObjects()
         {
             Assert.AreEqual(1, GetTestTable().Update(values: new { code = "205", first = DBNull.Value, last = "Gagarin", email = "juri.gagarin@megacorp.com", quote = "bla, bla, bla" }, where: new { id = 5 }));
@@ -259,7 +259,7 @@ namespace DynamORM.Tests.Modify
         }
 
         /// <summary>Test row updating by mapped objects.</summary>
-        [Test]
+        [TestMethod]
         public void TestUpdateByMappedObjects()
         {
             var u = GetTestTable();
@@ -286,7 +286,7 @@ namespace DynamORM.Tests.Modify
         }
 
         /// <summary>Test row updating by basic objects.</summary>
-        [Test]
+        [TestMethod]
         public void TestUpdateByBasicObjects()
         {
             var u = GetTestTable();
@@ -317,7 +317,7 @@ namespace DynamORM.Tests.Modify
         #region Delete
 
         /// <summary>Test row deleting by dynamic arguments.</summary>
-        [Test]
+        [TestMethod]
         public void TestDeleteByArguments()
         {
             Assert.AreEqual(1, GetTestTable().Delete(code: "10"));
@@ -327,7 +327,7 @@ namespace DynamORM.Tests.Modify
         }
 
         /// <summary>Test row deleting by dynamic objects (all except ID should be ignored).</summary>
-        [Test]
+        [TestMethod]
         public void TestDeleteyDynamicObject()
         {
             Assert.AreEqual(1, GetTestTable().Delete(delete: new { id = 11, code = 11, first = "Juri", last = "Gagarin", email = "juri.gagarin@megacorp.com", quote = "bla, bla, bla" }));
@@ -337,7 +337,7 @@ namespace DynamORM.Tests.Modify
         }
 
         /// <summary>Test row deleting by mapped object.</summary>
-        [Test]
+        [TestMethod]
         public void TestDeleteByMappedObject()
         {
             var u = GetTestTable();
@@ -357,7 +357,7 @@ namespace DynamORM.Tests.Modify
         }
 
         /// <summary>Test row deleting by basic object.</summary>
-        [Test]
+        [TestMethod]
         public void TestDeleteByBasicObject()
         {
             var u = GetTestTable();
@@ -377,7 +377,7 @@ namespace DynamORM.Tests.Modify
         }
 
         /// <summary>Test row deleting by dynamic objects (all except ID should be ignored).</summary>
-        [Test]
+        [TestMethod]
         public void TestDeleteyDynamicObjectWhere()
         {
             Assert.AreEqual(1, GetTestTable().Delete(where: new { id = 14, code = "14" }));
diff --git a/DynamORM.Tests/Modify/DynamicNoSchemaModificationTests.cs b/DynamORM.Tests/Modify/DynamicNoSchemaModificationTests.cs
index 7591500..5943acc 100644
--- a/DynamORM.Tests/Modify/DynamicNoSchemaModificationTests.cs
+++ b/DynamORM.Tests/Modify/DynamicNoSchemaModificationTests.cs
@@ -26,17 +26,17 @@
  * THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-using NUnit.Framework;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace DynamORM.Tests.Modify
 {
     /// <summary>Test standard dynamic access ORM. With out schema information from database.</summary>
-    [TestFixture]
+    [TestClass]
     public class DynamicNoSchemaModificationTests : DynamicModificationTests
     {
         /// <summary>Setup test parameters.</summary>
-        [TestFixtureSetUp]
-        public override void SetUp()
+        [TestInitialize]
+        public virtual void SetUp()
         {
             CreateTestDatabase();
             CreateDynamicDatabase(
diff --git a/DynamORM.Tests/Modify/DynamicTypeSchemaModificationTests.cs b/DynamORM.Tests/Modify/DynamicTypeSchemaModificationTests.cs
index a0e360a..546e355 100644
--- a/DynamORM.Tests/Modify/DynamicTypeSchemaModificationTests.cs
+++ b/DynamORM.Tests/Modify/DynamicTypeSchemaModificationTests.cs
@@ -28,12 +28,12 @@
 
 using System.Collections.Generic;
 using DynamORM.Tests.Helpers;
-using NUnit.Framework;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace DynamORM.Tests.Modify
 {
     /// <summary>Test standard dynamic access ORM. With out schema information from database.</summary>
-    [TestFixture]
+    [TestClass]
     public class DynamicTypeSchemaModificationTests : DynamicModificationTests
     {
         /// <summary>Create table using specified method.</summary>
@@ -46,7 +46,7 @@ namespace DynamORM.Tests.Modify
         /// <summary>
         /// Tests the bulk insert.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestBulkInsert()
         {
             Assert.AreEqual(2, Database.Insert<users>(new List<users>
diff --git a/DynamORM.Tests/Modify/ParserTests.cs b/DynamORM.Tests/Modify/ParserTests.cs
index df9f6c9..a3a57d5 100644
--- a/DynamORM.Tests/Modify/ParserTests.cs
+++ b/DynamORM.Tests/Modify/ParserTests.cs
@@ -29,18 +29,18 @@
 using System.Linq;
 using DynamORM.Builders;
 using DynamORM.Builders.Implementation;
-using NUnit.Framework;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using DynamORM.Tests.Helpers;
 using System.Collections.Generic;
 
 namespace DynamORM.Tests.Modify
 {
     /// <summary>New parser tests.</summary>
-    [TestFixture]
+    [TestClass]
     public class ParserTests : TestsBase
     {
         /// <summary>Setup test parameters.</summary>
-        [TestFixtureSetUp]
+        [TestInitialize]
         public virtual void SetUp()
         {
             CreateTestDatabase();
@@ -51,7 +51,7 @@ namespace DynamORM.Tests.Modify
         }
 
         /// <summary>Tear down test objects.</summary>
-        [TestFixtureTearDown]
+        [TestCleanup]
         public virtual void TearDown()
         {
             DestroyDynamicDatabase();
@@ -63,7 +63,7 @@ namespace DynamORM.Tests.Modify
         /// <summary>
         /// Tests the basic insert.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestInsertBasic()
         {
             IDynamicInsertQueryBuilder cmd = new DynamicInsertQueryBuilder(Database, "Users");
@@ -77,7 +77,7 @@ namespace DynamORM.Tests.Modify
         /// <summary>
         /// Tests the insert with sub query.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestInsertSubQuery()
         {
             IDynamicInsertQueryBuilder cmd = new DynamicInsertQueryBuilder(Database, "Users");
@@ -94,7 +94,7 @@ namespace DynamORM.Tests.Modify
         /// <summary>
         /// Tests the basic insert using object.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestInsertBasicObject()
         {
             IDynamicInsertQueryBuilder cmd = new DynamicInsertQueryBuilder(Database, "Users");
@@ -108,7 +108,7 @@ namespace DynamORM.Tests.Modify
         /// <summary>
         /// Tests the insert using object with sub query.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestInsertSubQueryObject()
         {
             IDynamicInsertQueryBuilder cmd = new DynamicInsertQueryBuilder(Database, "Users");
@@ -134,7 +134,7 @@ namespace DynamORM.Tests.Modify
         /// <summary>
         /// Tests the basic update.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestUpdateBasic()
         {
             IDynamicUpdateQueryBuilder cmd = new DynamicUpdateQueryBuilder(Database, "Users");
@@ -149,7 +149,7 @@ namespace DynamORM.Tests.Modify
         /// <summary>
         /// Tests the insert with sub query.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestUpdateSubQuery()
         {
             IDynamicUpdateQueryBuilder cmd = new DynamicUpdateQueryBuilder(Database, "Users");
@@ -167,7 +167,7 @@ namespace DynamORM.Tests.Modify
         /// <summary>
         /// Tests the basic insert using object.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestUpdateBasicObject()
         {
             IDynamicUpdateQueryBuilder cmd = new DynamicUpdateQueryBuilder(Database, "Users");
@@ -182,7 +182,7 @@ namespace DynamORM.Tests.Modify
         /// <summary>
         /// Tests the basic insert using object.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestUpdateSubQueryObject()
         {
             IDynamicUpdateQueryBuilder cmd = new DynamicUpdateQueryBuilder(Database, "Users");
diff --git a/DynamORM.Tests/Properties/Resources.Designer.cs b/DynamORM.Tests/Properties/Resources.Designer.cs
index 6c5a129..9357e59 100644
--- a/DynamORM.Tests/Properties/Resources.Designer.cs
+++ b/DynamORM.Tests/Properties/Resources.Designer.cs
@@ -1,7 +1,7 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
-//     Runtime Version:4.0.30319.269
+//     Runtime Version:4.0.30319.42000
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.
@@ -19,7 +19,7 @@ namespace DynamORM.Tests.Properties {
     // class via a tool like ResGen or Visual Studio.
     // To add or remove a member, edit your .ResX file then rerun ResGen
     // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
     internal class Resources {
diff --git a/DynamORM.Tests/Select/DynamicAccessTests.cs b/DynamORM.Tests/Select/DynamicAccessTests.cs
index 89734a4..4105b4c 100644
--- a/DynamORM.Tests/Select/DynamicAccessTests.cs
+++ b/DynamORM.Tests/Select/DynamicAccessTests.cs
@@ -30,16 +30,16 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using DynamORM.Builders;
-using NUnit.Framework;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace DynamORM.Tests.Select
 {
     /// <summary>Test standard dynamic access ORM.</summary>
-    [TestFixture]
+    [TestClass]
     public class DynamicAccessTests : TestsBase
     {
         /// <summary>Setup test parameters.</summary>
-        [TestFixtureSetUp]
+        [TestInitialize]
         public virtual void SetUp()
         {
             CreateTestDatabase();
@@ -47,7 +47,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Tear down test objects.</summary>
-        [TestFixtureTearDown]
+        [TestCleanup]
         public virtual void TearDown()
         {
             DestroyDynamicDatabase();
@@ -71,28 +71,28 @@ namespace DynamORM.Tests.Select
         #region Select
 
         /// <summary>Test unknown op.</summary>
-        [Test]
+        [TestMethod]
         public void TestUnknownOperation()
         {
-            Assert.Throws<InvalidOperationException>(() => GetTestTable().MakeMeASandwitch(with: "cheese"));
+            Assert.ThrowsException<InvalidOperationException>(() => GetTestTable().MakeMeASandwitch(with: "cheese"));
         }
 
         /// <summary>Test dynamic <c>Count</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestCount()
         {
             Assert.AreEqual(200, GetTestTable().Count(columns: "id"));
         }
 
         /// <summary>Test dynamic <c>Count</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestCount2()
         {
-            Assert.AreEqual(200, GetTestBuilder().Select(x => x.Count(x.id)).Scalar());
+            Assert.AreEqual(200L, GetTestBuilder().Select(x => x.Count(x.id)).Scalar());
         }
 
         /// <summary>Test count with in statement.</summary>
-        [Test]
+        [TestMethod]
         public void TestSelectInEnumerableCount()
         {
             Assert.AreEqual(4, GetTestTable().Count(last: new DynamicColumn
@@ -103,17 +103,17 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test count with in statement.</summary>
-        [Test]
+        [TestMethod]
         public void TestSelectInEnumerableCount2()
         {
-            Assert.AreEqual(4, GetTestBuilder()
+            Assert.AreEqual(4L, GetTestBuilder()
                 .Where(x => x.last.In(new object[] { "Hendricks", "Goodwin", "Freeman" }.Take(3)))
                 .Select(x => x.Count())
                 .Scalar());
         }
 
         /// <summary>Test count with in statement.</summary>
-        [Test]
+        [TestMethod]
         public void TestSelectInArrayCount()
         {
             Assert.AreEqual(4, GetTestTable().Count(last: new DynamicColumn
@@ -124,24 +124,24 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test count with in statement.</summary>
-        [Test]
+        [TestMethod]
         public void TestSelectInArrayCount2()
         {
-            Assert.AreEqual(4, GetTestBuilder()
+            Assert.AreEqual(4L, GetTestBuilder()
                 .Where(x => x.last.In(new object[] { "Hendricks", "Goodwin", "Freeman" }))
                 .Select(x => x.Count())
                 .Scalar());
         }
 
         /// <summary>Test dynamic <c>First</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestFirst()
         {
             Assert.AreEqual(1, GetTestTable().First(columns: "id").id);
         }
 
         /// <summary>Test dynamic <c>First</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestFirst2()
         {
             Assert.AreEqual(1, GetTestBuilder()
@@ -151,14 +151,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test dynamic <c>Last</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestLast()
         {
             Assert.AreEqual(200, GetTestTable().Last(columns: "id").id);
         }
 
         /// <summary>Test dynamic <c>Last</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestLast2()
         {
             Assert.AreEqual(200, GetTestBuilder()
@@ -168,63 +168,63 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test dynamic <c>Count</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestCountSpecificRecord()
         {
             Assert.AreEqual(1, GetTestTable().Count(first: "Ori"));
         }
 
         /// <summary>Test dynamic <c>Count</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestCountSpecificRecord2()
         {
-            Assert.AreEqual(1, GetTestBuilder()
+            Assert.AreEqual(1L, GetTestBuilder()
                 .Where(x => x.first == "Ori")
                 .Select(x => x.Count())
                 .Scalar());
         }
 
         /// <summary>Test dynamic <c>Min</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestMin()
         {
             Assert.AreEqual(1, GetTestTable().Min(columns: "id"));
         }
 
         /// <summary>Test dynamic <c>Min</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestMin2()
         {
-            Assert.AreEqual(1, GetTestBuilder()
+            Assert.AreEqual(1L, GetTestBuilder()
                 .Select(x => x.Min(x.id))
                 .Scalar());
         }
 
         /// <summary>Test dynamic <c>Min</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestMax()
         {
             Assert.AreEqual(200, GetTestTable().Max(columns: "id"));
         }
 
         /// <summary>Test dynamic <c>Min</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestMax2()
         {
-            Assert.AreEqual(200, GetTestBuilder()
+            Assert.AreEqual(200L, GetTestBuilder()
                 .Select(x => x.Max(x.id))
                 .Scalar());
         }
 
         /// <summary>Test dynamic <c>Min</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TesttAvg()
         {
             Assert.AreEqual(100.5, GetTestTable().Avg(columns: "id"));
         }
 
         /// <summary>Test dynamic <c>Min</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TesttAvg2()
         {
             Assert.AreEqual(100.5, GetTestBuilder()
@@ -233,37 +233,37 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test dynamic <c>Sum</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestSum()
         {
             Assert.AreEqual(20100, GetTestTable().Sum(columns: "id"));
         }
 
         /// <summary>Test dynamic <c>Sum</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestSum2()
         {
-            Assert.AreEqual(20100, GetTestBuilder()
+            Assert.AreEqual(20100L, GetTestBuilder()
                 .Select(x => x.Sum(x.id))
                 .Scalar());
         }
 
         /// <summary>Test dynamic <c>Scalar</c> method for invalid operation exception.</summary>
-        [Test]
+        [TestMethod]
         public void TestScalarException()
         {
-            Assert.Throws<InvalidOperationException>(() => GetTestTable().Scalar(id: 19));
+            Assert.ThrowsException<InvalidOperationException>(() => GetTestTable().Scalar(id: 19));
         }
 
         /// <summary>Test dynamic <c>Scalar</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestScalar()
         {
             Assert.AreEqual("Ori", GetTestTable().Scalar(columns: "first", id: 19));
         }
 
         /// <summary>Test dynamic <c>Scalar</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestScalar2()
         {
             Assert.AreEqual("Ori", GetTestBuilder()
@@ -273,7 +273,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test dynamic <c>Scalar</c> method with SQLite specific aggregate.</summary>
-        [Test]
+        [TestMethod]
         public void TestScalarGroupConcat()
         {
             // This test should produce something like this:
@@ -283,7 +283,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test dynamic <c>Scalar</c> method with SQLite specific aggregate.</summary>
-        [Test]
+        [TestMethod]
         public void TestScalarGroupConcat2()
         {
             // This test should produce something like this:
@@ -296,7 +296,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test dynamic <c>Scalar</c> method with SQLite specific aggregate not using aggregate field.</summary>
-        [Test]
+        [TestMethod]
         public void TestScalarGroupConcatNoAggregateField()
         {
             // This test should produce something like this:
@@ -306,7 +306,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test dynamic <c>Scalar</c> method with SQLite specific aggregate not using aggregate field.</summary>
-        [Test]
+        [TestMethod]
         public void TestScalarGroupConcatNoAggregateField2()
         {
             // This test should produce something like this:
@@ -319,7 +319,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test something fancy... like: <code>select "first", count("first") occurs from "users" group by "first" order by 2 desc;</code>.</summary>
-        [Test]
+        [TestMethod]
         public void TestFancyAggregateQuery()
         {
             var v = (GetTestTable().Query(columns: "first,first:occurs:count", group: "first", order: ":desc:2") as IEnumerable<dynamic>).ToList();
@@ -334,7 +334,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test something fancy... like: <code>select "first", count("first") occurs from "users" group by "first" order by 2 desc;</code>.</summary>
-        [Test]
+        [TestMethod]
         public void TestFancyAggregateQuery2()
         {
             var v = GetTestBuilder()
@@ -354,14 +354,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>This time also something fancy... aggregate in aggregate <code>select AVG(LENGTH("login")) len from "users";</code>.</summary>
-        [Test]
+        [TestMethod]
         public void TestAggregateInAggregate()
         {
             Assert.AreEqual(12.77, GetTestTable().Scalar(columns: @"length(""login""):len:avg"));
         }
 
         /// <summary>This time also something fancy... aggregate in aggregate <code>select AVG(LENGTH("login")) len from "users";</code>.</summary>
-        [Test]
+        [TestMethod]
         public void TestAggregateInAggregate2()
         {
             Assert.AreEqual(12.77, GetTestBuilder()
@@ -370,14 +370,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>This time also something fancy... aggregate in aggregate <code>select AVG(LENGTH("email")) len from "users";</code>.</summary>
-        [Test]
+        [TestMethod]
         public void TestAggregateInAggregateMark2()
         {
             Assert.AreEqual(27.7, GetTestTable().Avg(columns: @"length(""email""):len"));
         }
 
         /// <summary>This time also something fancy... aggregate in aggregate <code>select AVG(LENGTH("email")) len from "users";</code>.</summary>
-        [Test]
+        [TestMethod]
         public void TestAggregateInAggregateMark3()
         {
             Assert.AreEqual(27.7, GetTestBuilder()
@@ -409,7 +409,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test dynamic <c>Single</c> multi.</summary>
-        [Test]
+        [TestMethod]
         public void TestSingleObject()
         {
             var exp = new { id = 19, first = "Ori", last = "Ellis" };
@@ -421,7 +421,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test dynamic <c>Single</c> multi.</summary>
-        [Test]
+        [TestMethod]
         public void TestSingleObject2()
         {
             var exp = new { id = 19, first = "Ori", last = "Ellis" };
@@ -437,10 +437,10 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test dynamic duplicate column name occurrence.</summary>
-        [Test]
+        [TestMethod]
         public void TestDuplicateColumnNameException()
         {
-            Assert.Throws<ArgumentException>(() => GetTestBuilder()
+            Assert.ThrowsException<ArgumentException>(() => GetTestBuilder()
                 .Where(x => x.id == 19)
                 .Select(x => new
                 {
@@ -458,14 +458,14 @@ namespace DynamORM.Tests.Select
         #region Where
 
         /// <summary>Test dynamic where expression equal.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereEq()
         {
             Assert.AreEqual("hoyt.tran", GetTestTable().Single(where: new DynamicColumn("id").Eq(100)).login);
         }
 
         /// <summary>Test dynamic where expression equal.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereEq2()
         {
             Assert.AreEqual("hoyt.tran", GetTestBuilder()
@@ -473,31 +473,31 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test dynamic where expression not equal.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereNot()
         {
             Assert.AreEqual(199, GetTestTable().Count(where: new DynamicColumn("id").Not(100)));
         }
 
         /// <summary>Test dynamic where expression not equal.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereNot2()
         {
-            Assert.AreEqual(199, GetTestBuilder()
+            Assert.AreEqual(199L, GetTestBuilder()
                 .Where(x => x.id != 100)
                 .Select(x => x.Count())
                 .Scalar());
         }
 
         /// <summary>Test dynamic where expression like.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereLike()
         {
             Assert.AreEqual(100, GetTestTable().Single(where: new DynamicColumn("login").Like("Hoyt.%")).id);
         }
 
         /// <summary>Test dynamic where expression like.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereLike2()
         {
             Assert.AreEqual(100, GetTestBuilder()
@@ -505,146 +505,146 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test dynamic where expression not like.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereNotLike()
         {
             Assert.AreEqual(199, GetTestTable().Count(where: new DynamicColumn("login").NotLike("Hoyt.%")));
         }
 
         /// <summary>Test dynamic where expression not like.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereNotLike2()
         {
-            Assert.AreEqual(199, GetTestBuilder()
+            Assert.AreEqual(199L, GetTestBuilder()
                 .Where(x => x.login.NotLike("Hoyt.%"))
                 .Select(x => x.Count())
                 .Scalar());
         }
 
         /// <summary>Test dynamic where expression not like.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereNotLike3()
         {
-            Assert.AreEqual(199, GetTestBuilder()
+            Assert.AreEqual(199L, GetTestBuilder()
                 .Where(x => !x.login.Like("Hoyt.%"))
                 .Select(x => x.Count())
                 .Scalar());
         }
 
         /// <summary>Test dynamic where expression greater.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereGt()
         {
             Assert.AreEqual(100, GetTestTable().Count(where: new DynamicColumn("id").Greater(100)));
         }
 
         /// <summary>Test dynamic where expression greater.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereGt2()
         {
-            Assert.AreEqual(100, GetTestBuilder()
+            Assert.AreEqual(100L, GetTestBuilder()
                 .Where(x => x.id > 100)
                 .Select(x => x.Count())
                 .Scalar());
         }
 
         /// <summary>Test dynamic where expression greater or equal.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereGte()
         {
             Assert.AreEqual(101, GetTestTable().Count(where: new DynamicColumn("id").GreaterOrEqual(100)));
         }
 
         /// <summary>Test dynamic where expression greater or equal.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereGte2()
         {
-            Assert.AreEqual(101, GetTestBuilder()
+            Assert.AreEqual(101L, GetTestBuilder()
                .Where(x => x.id >= 100)
                .Select(x => x.Count())
                .Scalar());
         }
 
         /// <summary>Test dynamic where expression less.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereLt()
         {
             Assert.AreEqual(99, GetTestTable().Count(where: new DynamicColumn("id").Less(100)));
         }
 
         /// <summary>Test dynamic where expression less.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereLt2()
         {
-            Assert.AreEqual(99, GetTestBuilder()
+            Assert.AreEqual(99L, GetTestBuilder()
                 .Where(x => x.id < 100)
                 .Select(x => x.Count())
                 .Scalar());
         }
 
         /// <summary>Test dynamic where expression less or equal.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereLte()
         {
             Assert.AreEqual(100, GetTestTable().Count(where: new DynamicColumn("id").LessOrEqual(100)));
         }
 
         /// <summary>Test dynamic where expression less or equal.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereLte2()
         {
-            Assert.AreEqual(100, GetTestBuilder()
+            Assert.AreEqual(100L, GetTestBuilder()
                 .Where(x => x.id <= 100)
                 .Select(x => x.Count())
                 .Scalar());
         }
 
         /// <summary>Test dynamic where expression between.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereBetween()
         {
             Assert.AreEqual(26, GetTestTable().Count(where: new DynamicColumn("id").Between(75, 100)));
         }
 
         /// <summary>Test dynamic where expression between.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereBetween2()
         {
-            Assert.AreEqual(26, GetTestBuilder()
+            Assert.AreEqual(26L, GetTestBuilder()
                 .Where(x => x.id.Between(75, 100))
                 .Select(x => x.Count())
                 .Scalar());
         }
 
         /// <summary>Test dynamic where expression in parameters.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereIn1()
         {
             Assert.AreEqual(3, GetTestTable().Count(where: new DynamicColumn("id").In(75, 99, 100)));
         }
 
         /// <summary>Test dynamic where expression in array.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereIn2()
         {
             Assert.AreEqual(3, GetTestTable().Count(where: new DynamicColumn("id").In(new[] { 75, 99, 100 })));
         }
 
         /// <summary>Test dynamic where expression in parameters.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereIn3()
         {
-            Assert.AreEqual(3, GetTestBuilder()
+            Assert.AreEqual(3L, GetTestBuilder()
                 .Where(x => x.id.In(75, 99, 100))
                 .Select(x => x.Count())
                 .Scalar());
         }
 
         /// <summary>Test dynamic where expression in parameters.</summary>
-        [Test]
+        [TestMethod]
         public void TestWhereIn4()
         {
-            Assert.AreEqual(3, GetTestBuilder()
+            Assert.AreEqual(3L, GetTestBuilder()
                 .Where(x => x.id.In(new[] { 75, 99, 100 }))
                 .Select(x => x.Count())
                 .Scalar());
diff --git a/DynamORM.Tests/Select/DynamicNoSchemaAccessTests.cs b/DynamORM.Tests/Select/DynamicNoSchemaAccessTests.cs
index 3c551a0..267c776 100644
--- a/DynamORM.Tests/Select/DynamicNoSchemaAccessTests.cs
+++ b/DynamORM.Tests/Select/DynamicNoSchemaAccessTests.cs
@@ -26,16 +26,16 @@
  * THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-using NUnit.Framework;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace DynamORM.Tests.Select
 {
     /// <summary>Test standard dynamic access ORM. With out schema information from database.</summary>
-    [TestFixture]
+    [TestClass]
     public class DynamicNoSchemaAccessTests : DynamicAccessTests
     {
         /// <summary>Setup test parameters.</summary>
-        [TestFixtureSetUp]
+        [TestInitialize]
         public override void SetUp()
         {
             CreateTestDatabase();
diff --git a/DynamORM.Tests/Select/DynamicTypeSchemaAccessTests.cs b/DynamORM.Tests/Select/DynamicTypeSchemaAccessTests.cs
index 3e2e505..998c262 100644
--- a/DynamORM.Tests/Select/DynamicTypeSchemaAccessTests.cs
+++ b/DynamORM.Tests/Select/DynamicTypeSchemaAccessTests.cs
@@ -27,12 +27,12 @@
 */
 
 using DynamORM.Tests.Helpers;
-using NUnit.Framework;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace DynamORM.Tests.Select
 {
     /// <summary>Test standard dynamic access ORM. With out schema information from database.</summary>
-    [TestFixture]
+    [TestClass]
     public class DynamicTypeSchemaAccessTests : DynamicNoSchemaAccessTests
     {
         /// <summary>Create table using specified method.</summary>
diff --git a/DynamORM.Tests/Select/LegacyParserTests.cs b/DynamORM.Tests/Select/LegacyParserTests.cs
index fb34422..8053aa7 100644
--- a/DynamORM.Tests/Select/LegacyParserTests.cs
+++ b/DynamORM.Tests/Select/LegacyParserTests.cs
@@ -29,16 +29,16 @@
 using System.Linq;
 using DynamORM.Builders;
 using DynamORM.Builders.Implementation;
-using NUnit.Framework;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace DynamORM.Tests.Select
 {
     /// <summary>Tests of legacy parser methods.</summary>
-    [TestFixture]
+    [TestClass]
     public class LegacyParserTests : TestsBase
     {
         /// <summary>Setup test parameters.</summary>
-        [TestFixtureSetUp]
+        [TestInitialize]
         public virtual void SetUp()
         {
             CreateTestDatabase();
@@ -49,7 +49,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Tear down test objects.</summary>
-        [TestFixtureTearDown]
+        [TestCleanup]
         public virtual void TearDown()
         {
             DestroyDynamicDatabase();
@@ -59,7 +59,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the where expression equal.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereEq()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -73,7 +73,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the where expression equal with brackets.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereBracketsEq()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -88,7 +88,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the where expression equal with brackets and or condition.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereBracketsOrEq()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -103,7 +103,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the where expression equal with brackets.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereBracketsOrEq2()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -120,7 +120,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the where expression equal with brackets.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereBracketsOrEqForgotToEnd()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -139,7 +139,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the where expression not equal.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereNotEq()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -153,7 +153,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the where expression greater.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereGreater()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -167,7 +167,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the where expression greater or equal.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereGreaterOrEqual()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -181,7 +181,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the where expression less.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereLess()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -195,7 +195,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the where expression less or equal.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereLessOrEqual()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -209,7 +209,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the where expression like.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereLike()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -223,7 +223,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the where expression not like.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereNotLike()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -237,7 +237,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the where expression between.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereBetween()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -251,7 +251,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the where expression in.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereIn()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -265,7 +265,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the where expression using anonymous types.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereAnon()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -279,7 +279,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the order by column.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestOrderByCol()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -293,7 +293,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the order by column number.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestOrderByNum()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -307,7 +307,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests the group by column.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestGroupByCol()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
diff --git a/DynamORM.Tests/Select/ParserTests.cs b/DynamORM.Tests/Select/ParserTests.cs
index e353b2c..b99ef99 100644
--- a/DynamORM.Tests/Select/ParserTests.cs
+++ b/DynamORM.Tests/Select/ParserTests.cs
@@ -29,18 +29,18 @@
 using System.Linq;
 using DynamORM.Builders;
 using DynamORM.Builders.Implementation;
-using NUnit.Framework;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace DynamORM.Tests.Select
 {
     /// <summary>
     /// New parser tests.
     /// </summary>
-    [TestFixture]
+    [TestClass]
     public class ParserTests : TestsBase
     {
         /// <summary>Setup test parameters.</summary>
-        [TestFixtureSetUp]
+        [TestInitialize]
         public virtual void SetUp()
         {
             CreateTestDatabase();
@@ -51,7 +51,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Tear down test objects.</summary>
-        [TestFixtureTearDown]
+        [TestCleanup]
         public virtual void TearDown()
         {
             try
@@ -65,7 +65,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests from method.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestFromGet()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -77,7 +77,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests from method with multi tables.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestFromGetMultiKulti()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -89,7 +89,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests from method with as expression in text.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestFromGetAs1()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -101,7 +101,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests from method with as expression using lambda.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestFromGetAs2()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -113,7 +113,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests from method using text.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestFromText()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -125,7 +125,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests from method using text with decorators.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestFromDecoratedText()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -137,7 +137,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests from method using text with as.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestFromTextAs1()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -149,7 +149,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests from method using invoke with as.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestFromTextAs2()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -162,7 +162,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests from method using invoke with as.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestFromTextAs3()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -175,7 +175,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests from method using invoke with sub query.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestFromSubQuery1()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -188,7 +188,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests from method using invoke with sub query.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestFromSubQuery2()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -201,7 +201,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests from method using invoke with sub query.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestFromSubQuery3()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -214,7 +214,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests where method with alias.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereAlias()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -228,7 +228,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests where method with alias.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestHavingAlias()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -242,7 +242,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests complex where method with alias.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereAliasComplex()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -258,7 +258,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests where method with alias using in.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereAliasIn()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -278,7 +278,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests where method with alias using between.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereAliasBetween1()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -298,7 +298,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests where method with alias using between.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereAliasBetween2()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -318,7 +318,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests where method without alias.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereNoAlias()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -332,7 +332,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests where method with full column name.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestWhereNoAliasTableName()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -346,7 +346,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests simple join method.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestJoinClassic()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -360,7 +360,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests inner join method.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestInnerJoin()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -374,7 +374,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests inner join method with aliases mix.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestInnerJoin2()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -389,7 +389,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests from method using invoke with sub query.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestInnerJoin3()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -404,7 +404,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests from method using invoke with sub query.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestInnerJoin4()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -419,7 +419,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests left outer join method.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestLeftOuterJoin()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -433,7 +433,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests left join method.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestLeftJoin()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -447,7 +447,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests right outer join method.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestRightOuterJoin()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -461,7 +461,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests right join method.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestRightJoin()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -475,7 +475,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests complex join with parameters.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestJoinClassicWithParamAndWhere()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -491,7 +491,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select all.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectAll1()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -505,7 +505,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select all.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectAll2()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -519,7 +519,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select field.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectField1()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -533,7 +533,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select field.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectField2()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -547,7 +547,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select field with alias.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectFieldAlias1()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -561,7 +561,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select field with alias.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectFieldAlias2()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -575,7 +575,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select field with alias.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectFieldAlias3()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -589,7 +589,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select field with alias.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectFieldAlias4()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -603,7 +603,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select aggregate field with alias (Sum).
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectAggregateField1()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -617,7 +617,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select aggregate field with alias (Coalesce).
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectAggregateField2()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -632,7 +632,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select aggregate field with alias (Sum).
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectAggregateField3()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -646,7 +646,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select aggregate field with alias (Sum).
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectAggregateField4()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -660,7 +660,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select aggregate field with alias (Sum).
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectAggregateField5()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -674,7 +674,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select from anonymous type.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectAnon()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -692,7 +692,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select escaped case.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectCaseEscaped1()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -707,7 +707,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select escaped case.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectCaseEscaped2()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -722,7 +722,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select escaped case.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestCoalesceEscaped()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -737,7 +737,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select escaped case.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestCoalesce()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -752,7 +752,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select escaped case.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestCoalesceCalculatedArgs()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -771,7 +771,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select escaped case.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestCoalesceInWhere()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -787,7 +787,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests select escaped case with sub query.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSelectCaseEscapedAndSub()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -805,7 +805,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests group by.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestGroupBy()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -819,7 +819,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests order by.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestOrderBy()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -833,7 +833,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests order by using string with number.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestOrderByNumberedColumnStr()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -847,7 +847,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests order by using member with number.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestOrderByNumberedColFn()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -861,7 +861,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests order by using member with field.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestOrderByAlt()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -875,7 +875,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests sub query select.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSubQuerySelect()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -892,7 +892,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests sub query where.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSubQueryWhere()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -909,7 +909,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests sub query in.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSubQueryWhereIn()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
@@ -926,7 +926,7 @@ namespace DynamORM.Tests.Select
         /// <summary>
         /// Tests sub query join.
         /// </summary>
-        [Test]
+        [TestMethod]
         public void TestSubQueryJoin()
         {
             IDynamicSelectQueryBuilder cmd = new DynamicSelectQueryBuilder(Database);
diff --git a/DynamORM.Tests/Select/TypedAccessTests.cs b/DynamORM.Tests/Select/TypedAccessTests.cs
index 1c8e0ed..485a6e0 100644
--- a/DynamORM.Tests/Select/TypedAccessTests.cs
+++ b/DynamORM.Tests/Select/TypedAccessTests.cs
@@ -31,28 +31,25 @@ using System.Collections.Generic;
 using System.Linq;
 using DynamORM.Builders;
 using DynamORM.Tests.Helpers;
-using NUnit.Framework;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace DynamORM.Tests.Select
 {
     /// <summary>Test typed ORM.</summary>
     /// <typeparam name="T">Type to test.</typeparam>
-    [TestFixture(typeof(users))]
+    [TestClass]
     public class TypedAccessTests<T> : TestsBase where T : class
     {
         /// <summary>Setup test parameters.</summary>
-        [TestFixtureSetUp]
+        [TestInitialize]
         public virtual void SetUp()
         {
             CreateTestDatabase();
             CreateDynamicDatabase();
-
-            // Cache table (profiler freaks out)
-            GetTestTable();
         }
 
         /// <summary>Tear down test objects.</summary>
-        [TestFixtureTearDown]
+        [TestCleanup]
         public virtual void TearDown()
         {
             DestroyDynamicDatabase();
@@ -76,7 +73,7 @@ namespace DynamORM.Tests.Select
         #region Select typed
 
         /// <summary>Test load all rows into mapped list alternate way.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedGetAll()
         {
             var list = (GetTestTable().Query(type: typeof(T)) as IEnumerable<object>).Cast<T>().ToList();
@@ -85,7 +82,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test load all rows into mapped list alternate way.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedGetAll2()
         {
             var list = GetTestBuilder()
@@ -98,7 +95,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test load all rows into mapped list alternate way.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedGetAll3()
         {
             var list = GetTestBuilder()
@@ -110,21 +107,21 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test unknown op.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedUnknownOperation()
         {
-            Assert.Throws<InvalidOperationException>(() => GetTestTable().MakeMeASandwitch(type: typeof(T), with: "cheese"));
+            Assert.ThrowsException<InvalidOperationException>(() => GetTestTable().MakeMeASandwitch(type: typeof(T), with: "cheese"));
         }
 
         /// <summary>Test typed <c>Count</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedCount()
         {
             Assert.AreEqual(200, GetTestTable().Count(type: typeof(T), columns: "id"));
         }
 
         /// <summary>Test typed <c>Count</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedCount2()
         {
             Assert.AreEqual(200, GetTestBuilder()
@@ -134,7 +131,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test count with in statement.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedSelectInEnumerableCount()
         {
             Assert.AreEqual(4, GetTestTable().Count(type: typeof(T), last: new DynamicColumn
@@ -145,7 +142,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test count with in statement.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedSelectInEnumerableCount2()
         {
             Assert.AreEqual(4, GetTestBuilder()
@@ -156,7 +153,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test count with in statement.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedSelectInArrayCount()
         {
             Assert.AreEqual(4, GetTestTable().Count(type: typeof(T), last: new DynamicColumn
@@ -167,7 +164,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test count with in statement.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedSelectInArrayCount2()
         {
             Assert.AreEqual(4, GetTestBuilder()
@@ -178,14 +175,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed <c>First</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedFirst()
         {
             Assert.AreEqual(1, GetTestTable().First(type: typeof(T), columns: "id").id);
         }
 
         /// <summary>Test typed <c>First</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedFirst2()
         {
             Assert.AreEqual(1, GetTestBuilder()
@@ -196,14 +193,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed <c>Last</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedLast()
         {
             Assert.AreEqual(200, GetTestTable().Last(type: typeof(T), columns: "id").id);
         }
 
         /// <summary>Test typed <c>Last</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedLast2()
         {
             Assert.AreEqual(200, GetTestBuilder()
@@ -214,21 +211,21 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed <c>Count</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedCountSpecificRecord()
         {
             Assert.AreEqual(1, GetTestTable().Count(type: typeof(T), first: "Ori"));
         }
 
         /// <summary>Test typed <c>Min</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedMin()
         {
             Assert.AreEqual(1, GetTestTable().Min(type: typeof(T), columns: "id"));
         }
 
         /// <summary>Test typed <c>Min</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedMin2()
         {
             Assert.AreEqual(1, GetTestBuilder()
@@ -238,14 +235,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed <c>Min</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedMax()
         {
             Assert.AreEqual(200, GetTestTable().Max(type: typeof(T), columns: "id"));
         }
 
         /// <summary>Test typed <c>Min</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedMax2()
         {
             Assert.AreEqual(200, GetTestBuilder()
@@ -255,14 +252,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed <c>Min</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedtAvg()
         {
             Assert.AreEqual(100.5, GetTestTable().Avg(type: typeof(T), columns: "id"));
         }
 
         /// <summary>Test typed <c>Min</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedtAvg2()
         {
             Assert.AreEqual(100.5, GetTestBuilder()
@@ -272,14 +269,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed <c>Sum</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedSum()
         {
             Assert.AreEqual(20100, GetTestTable().Sum(type: typeof(T), columns: "id"));
         }
 
         /// <summary>Test typed <c>Sum</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedSum2()
         {
             Assert.AreEqual(20100, GetTestBuilder()
@@ -289,21 +286,21 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed <c>Scalar</c> method for invalid operation exception.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedScalarException()
         {
-            Assert.Throws<InvalidOperationException>(() => GetTestTable().Scalar(type: typeof(T), id: 19));
+            Assert.ThrowsException<InvalidOperationException>(() => GetTestTable().Scalar(type: typeof(T), id: 19));
         }
 
         /// <summary>Test typed <c>Scalar</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedScalar()
         {
             Assert.AreEqual("Ori", GetTestTable().Scalar(type: typeof(T), columns: "first", id: 19));
         }
 
         /// <summary>Test typed <c>Scalar</c> method.</summary>
-        [Test]
+        [TestMethod]
         public void TestTypedScalar2()
         {
             Assert.AreEqual("Ori", GetTestBuilder()
@@ -314,7 +311,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed <c>Scalar</c> method with SQLite specific aggregate.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedScalarGroupConcat()
         {
             // This test should produce something like this:
@@ -324,7 +321,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed <c>Scalar</c> method with SQLite specific aggregate.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedScalarGroupConcat2()
         {
             // This test should produce something like this:
@@ -338,7 +335,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed <c>Scalar</c> method with SQLite specific aggregate not using aggregate field.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedScalarGroupConcatNoAggregateField()
         {
             // This test should produce something like this:
@@ -348,7 +345,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed <c>Scalar</c> method with SQLite specific aggregate not using aggregate field.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedScalarGroupConcatNoAggregateField2()
         {
             // This test should produce something like this:
@@ -362,7 +359,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test something fancy... like: <code>select "first", count("first") aggregatefield from "users" group by "first" order by 2 desc;</code>.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedFancyAggregateQuery()
         {
             var v = (GetTestTable().Query(type: typeof(T), columns: "first,first:aggregatefield:count", group: "first", order: ":desc:2") as IEnumerable<dynamic>).ToList();
@@ -377,7 +374,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test something fancy... like: <code>select "first", count("first") aggregatefield from "users" group by "first" order by 2 desc;</code>.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedFancyAggregateQuery2()
         {
             var v = GetTestBuilder()
@@ -398,14 +395,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>This time also something fancy... aggregate in aggregate <code>select AVG(LENGTH("login")) len from "users";</code>.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedAggregateInAggregate()
         {
             Assert.AreEqual(12.77, GetTestTable().Scalar(type: typeof(T), columns: @"length(""login""):len:avg"));
         }
 
         /// <summary>This time also something fancy... aggregate in aggregate <code>select AVG(LENGTH("login")) len from "users";</code>.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedAggregateInAggregate2()
         {
             Assert.AreEqual(12.77, GetTestBuilder()
@@ -415,14 +412,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>This time also something fancy... aggregate in aggregate <code>select AVG(LENGTH("email")) len from "users";</code>.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedAggregateInAggregateMark2()
         {
             Assert.AreEqual(27.7, GetTestTable().Avg(type: typeof(T), columns: @"length(""email""):len"));
         }
 
         /// <summary>This time also something fancy... aggregate in aggregate <code>select AVG(LENGTH("email")) len from "users";</code>.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedAggregateInAggregateMark3()
         {
             Assert.AreEqual(27.7, GetTestBuilder()
@@ -456,7 +453,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed <c>Single</c> multi.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedSingleObject()
         {
             var exp = new { id = 19, first = "Ori", last = "Ellis" };
@@ -468,7 +465,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed <c>Single</c> multi.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedSingleObject2()
         {
             var exp = new { id = 19, first = "Ori", last = "Ellis" };
@@ -489,14 +486,14 @@ namespace DynamORM.Tests.Select
         #region Where typed
 
         /// <summary>Test typed where expression equal.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereEq()
         {
             Assert.AreEqual("hoyt.tran", GetTestTable().Single(type: typeof(T), where: new DynamicColumn("id").Eq(100)).login);
         }
 
         /// <summary>Test typed where expression equal.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereEq2()
         {
             Assert.AreEqual("hoyt.tran", GetTestBuilder()
@@ -505,14 +502,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed where expression not equal.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereNot()
         {
             Assert.AreEqual(199, GetTestTable().Count(type: typeof(T), where: new DynamicColumn("id").Not(100)));
         }
 
         /// <summary>Test typed where expression not equal.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereNot2()
         {
             Assert.AreEqual(199, GetTestBuilder()
@@ -523,14 +520,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed where expression like.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereLike()
         {
             Assert.AreEqual(100, GetTestTable().Single(type: typeof(T), where: new DynamicColumn("login").Like("Hoyt.%")).id);
         }
 
         /// <summary>Test typed where expression like.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereLike2()
         {
             Assert.AreEqual(100, GetTestBuilder()
@@ -539,14 +536,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed where expression not like.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereNotLike()
         {
             Assert.AreEqual(199, GetTestTable().Count(type: typeof(T), where: new DynamicColumn("login").NotLike("Hoyt.%")));
         }
 
         /// <summary>Test typed where expression not like.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereNotLike2()
         {
             Assert.AreEqual(199, GetTestBuilder()
@@ -557,7 +554,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed where expression not like.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereNotLike3()
         {
             Assert.AreEqual(199, GetTestBuilder()
@@ -568,14 +565,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed where expression greater.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereGt()
         {
             Assert.AreEqual(100, GetTestTable().Count(type: typeof(T), where: new DynamicColumn("id").Greater(100)));
         }
 
         /// <summary>Test typed where expression greater.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereGt2()
         {
             Assert.AreEqual(100, GetTestBuilder()
@@ -586,14 +583,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed where expression greater or equal.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereGte()
         {
             Assert.AreEqual(101, GetTestTable().Count(type: typeof(T), where: new DynamicColumn("id").GreaterOrEqual(100)));
         }
 
         /// <summary>Test typed where expression greater or equal.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereGte2()
         {
             Assert.AreEqual(101, GetTestBuilder()
@@ -604,14 +601,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed where expression less.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereLt()
         {
             Assert.AreEqual(99, GetTestTable().Count(type: typeof(T), where: new DynamicColumn("id").Less(100)));
         }
 
         /// <summary>Test typed where expression less.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereLt2()
         {
             Assert.AreEqual(99, GetTestBuilder()
@@ -622,14 +619,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed where expression less or equal.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereLte()
         {
             Assert.AreEqual(100, GetTestTable().Count(type: typeof(T), where: new DynamicColumn("id").LessOrEqual(100)));
         }
 
         /// <summary>Test typed where expression less or equal.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereLte2()
         {
             Assert.AreEqual(100, GetTestBuilder()
@@ -640,14 +637,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed where expression between.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereBetween()
         {
             Assert.AreEqual(26, GetTestTable().Count(type: typeof(T), where: new DynamicColumn("id").Between(75, 100)));
         }
 
         /// <summary>Test typed where expression between.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereBetween2()
         {
             Assert.AreEqual(26, GetTestBuilder()
@@ -658,21 +655,21 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed where expression in parameters.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereIn1()
         {
             Assert.AreEqual(3, GetTestTable().Count(type: typeof(T), where: new DynamicColumn("id").In(75, 99, 100)));
         }
 
         /// <summary>Test typed where expression in array.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereIn2()
         {
             Assert.AreEqual(3, GetTestTable().Count(type: typeof(T), where: new DynamicColumn("id").In(new[] { 75, 99, 100 })));
         }
 
         /// <summary>Test typed where expression in parameters.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereIn3()
         {
             Assert.AreEqual(3, GetTestBuilder()
@@ -683,7 +680,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test typed where expression in array.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestTypedWhereIn4()
         {
             Assert.AreEqual(3, GetTestBuilder()
@@ -698,7 +695,7 @@ namespace DynamORM.Tests.Select
         #region Select generic
 
         /// <summary>Test load all rows into mapped list alternate way.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericGetAll()
         {
             var list = (GetTestTable().Query<T>() as IEnumerable<object>).Cast<T>().ToList();
@@ -707,21 +704,21 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test unknown op.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericUnknownOperation()
         {
-            Assert.Throws<InvalidOperationException>(() => GetTestTable().MakeMeASandwitch<T>(with: "cheese"));
+            Assert.ThrowsException<InvalidOperationException>(() => GetTestTable().MakeMeASandwitch<T>(with: "cheese"));
         }
 
         /// <summary>Test generic <c>Count</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericCount()
         {
             Assert.AreEqual(200, GetTestTable().Count<T>(columns: "id"));
         }
 
         /// <summary>Test count with in statement.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericSelectInEnumerableCount()
         {
             Assert.AreEqual(4, GetTestTable().Count<T>(last: new DynamicColumn
@@ -732,7 +729,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test count with in statement.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericSelectInArrayCount()
         {
             Assert.AreEqual(4, GetTestTable().Count<T>(last: new DynamicColumn
@@ -743,70 +740,70 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test generic <c>First</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericFirst()
         {
             Assert.AreEqual(1, GetTestTable().First<T>(columns: "id").id);
         }
 
         /// <summary>Test generic <c>Last</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericLast()
         {
             Assert.AreEqual(200, GetTestTable().Last<T>(columns: "id").id);
         }
 
         /// <summary>Test generic <c>Count</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericCountSpecificRecord()
         {
             Assert.AreEqual(1, GetTestTable().Count<T>(first: "Ori"));
         }
 
         /// <summary>Test generic <c>Min</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericMin()
         {
             Assert.AreEqual(1, GetTestTable().Min<T>(columns: "id"));
         }
 
         /// <summary>Test generic <c>Min</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericMax()
         {
             Assert.AreEqual(200, GetTestTable().Max<T>(columns: "id"));
         }
 
         /// <summary>Test generic <c>Min</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenerictAvg()
         {
             Assert.AreEqual(100.5, GetTestTable().Avg<T>(columns: "id"));
         }
 
         /// <summary>Test generic <c>Sum</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericSum()
         {
             Assert.AreEqual(20100, GetTestTable().Sum<T>(columns: "id"));
         }
 
         /// <summary>Test generic <c>Scalar</c> method for invalid operation exception.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericScalarException()
         {
-            Assert.Throws<InvalidOperationException>(() => GetTestTable().Scalar<T>(id: 19));
+            Assert.ThrowsException<InvalidOperationException>(() => GetTestTable().Scalar<T>(id: 19));
         }
 
         /// <summary>Test generic <c>Scalar</c> method.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericScalar()
         {
             Assert.AreEqual("Ori", GetTestTable().Scalar<T>(columns: "first", id: 19));
         }
 
         /// <summary>Test generic <c>Scalar</c> method with SQLite specific aggregate.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericScalarGroupConcat()
         {
             // This test should produce something like this:
@@ -816,7 +813,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test generic <c>Scalar</c> method with SQLite specific aggregate not using aggregate field.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericScalarGroupConcatNoAggregateField()
         {
             // This test should produce something like this:
@@ -826,7 +823,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test something fancy... like: <code>select "first", count("first") aggregatefield from "users" group by "first" order by 2 desc;</code>.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericFancyAggregateQuery()
         {
             var v = (GetTestTable().Query<T>(columns: "first,first:aggregatefield:count", group: "first", order: ":desc:2") as IEnumerable<dynamic>).ToList();
@@ -841,14 +838,14 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>This time also something fancy... aggregate in aggregate <code>select AVG(LENGTH("login")) len from "users";</code>.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericAggregateInAggregate()
         {
             Assert.AreEqual(12.77, GetTestTable().Scalar<T>(columns: @"length(""login""):len:avg"));
         }
 
         /// <summary>This time also something fancy... aggregate in aggregate <code>select AVG(LENGTH("email")) len from "users";</code>.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericAggregateInAggregateMark2()
         {
             Assert.AreEqual(27.7, GetTestTable().Avg<T>(columns: @"length(""email""):len"));
@@ -869,7 +866,7 @@ namespace DynamORM.Tests.Select
         }
 
         /// <summary>Test generic <c>Single</c> multi.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericSingleObject()
         {
             var exp = new { id = 19, first = "Ori", last = "Ellis" };
@@ -885,77 +882,77 @@ namespace DynamORM.Tests.Select
         #region Where generic
 
         /// <summary>Test generic where expression equal.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericWhereEq()
         {
             Assert.AreEqual("hoyt.tran", GetTestTable().Single<T>(where: new DynamicColumn("id").Eq(100)).login);
         }
 
         /// <summary>Test generic where expression not equal.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericWhereNot()
         {
             Assert.AreEqual(199, GetTestTable().Count<T>(where: new DynamicColumn("id").Not(100)));
         }
 
         /// <summary>Test generic where expression like.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericWhereLike()
         {
             Assert.AreEqual(100, GetTestTable().Single<T>(where: new DynamicColumn("login").Like("Hoyt.%")).id);
         }
 
         /// <summary>Test generic where expression not like.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericWhereNotLike()
         {
             Assert.AreEqual(199, GetTestTable().Count<T>(where: new DynamicColumn("login").NotLike("Hoyt.%")));
         }
 
         /// <summary>Test generic where expression greater.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericWhereGt()
         {
             Assert.AreEqual(100, GetTestTable().Count<T>(where: new DynamicColumn("id").Greater(100)));
         }
 
         /// <summary>Test generic where expression greater or equal.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericWhereGte()
         {
             Assert.AreEqual(101, GetTestTable().Count<T>(where: new DynamicColumn("id").GreaterOrEqual(100)));
         }
 
         /// <summary>Test generic where expression less.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericWhereLt()
         {
             Assert.AreEqual(99, GetTestTable().Count<T>(where: new DynamicColumn("id").Less(100)));
         }
 
         /// <summary>Test generic where expression less or equal.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericWhereLte()
         {
             Assert.AreEqual(100, GetTestTable().Count<T>(where: new DynamicColumn("id").LessOrEqual(100)));
         }
 
         /// <summary>Test generic where expression between.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericWhereBetween()
         {
             Assert.AreEqual(26, GetTestTable().Count<T>(where: new DynamicColumn("id").Between(75, 100)));
         }
 
         /// <summary>Test generic where expression in parameters.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericWhereIn1()
         {
             Assert.AreEqual(3, GetTestTable().Count<T>(where: new DynamicColumn("id").In(75, 99, 100)));
         }
 
         /// <summary>Test generic where expression in array.</summary>
-        [Test]
+        [TestMethod]
         public virtual void TestGenericWhereIn2()
         {
             Assert.AreEqual(3, GetTestTable().Count<T>(where: new DynamicColumn("id").In(new[] { 75, 99, 100 })));
diff --git a/DynamORM/Mapper/DynamicTypeMap.cs b/DynamORM/Mapper/DynamicTypeMap.cs
index 29576bc..751de68 100644
--- a/DynamORM/Mapper/DynamicTypeMap.cs
+++ b/DynamORM/Mapper/DynamicTypeMap.cs
@@ -27,6 +27,7 @@
 */
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
@@ -156,7 +157,7 @@ namespace DynamORM.Mapper
 
                 var v = prop.Get(val);
 
-                foreach (var r in prop.Requirements)
+                foreach (var r in prop.Requirements.Where(x => !x.ElementRequirement))
                 {
                     var valid = r.ValidateSimpleValue(prop, v);
 
@@ -165,8 +166,42 @@ namespace DynamORM.Mapper
                         if (prop.Type.IsArray || prop.IsGnericEnumerable)
                         {
                             var map = DynamicMapperCache.GetMapper(prop.ArrayType);
-                            foreach (var item in val as IEnumerable<object>)
-                                result.AddRange(map.ValidateObject(item));
+
+                            var list = v as IEnumerable<object>;
+
+                            if (list == null)
+                            {
+                                var enumerable = v as IEnumerable;
+                                if (enumerable != null)
+                                    list = enumerable.Cast<object>();
+                            }
+
+                            if (list != null)
+                                foreach (var item in list)
+                                {
+                                    if (prop.Requirements.Any(x => x.ElementRequirement))
+                                    {
+                                        foreach (var re in prop.Requirements.Where(x => x.ElementRequirement))
+                                        {
+                                            var validelem = re.ValidateSimpleValue(prop.ArrayType, prop.ArrayType.IsGenericEnumerable(), item);
+
+                                            if (validelem == ValidateResult.NotSupported)
+                                            {
+                                                result.AddRange(map.ValidateObject(item));
+                                                break;
+                                            }
+                                            else if (validelem != ValidateResult.Valid)
+                                                result.Add(new ValidationResult()
+                                                {
+                                                    Property = prop,
+                                                    Requirement = r,
+                                                    Value = item,
+                                                });
+                                        }
+                                    }
+                                    else
+                                        result.AddRange(map.ValidateObject(item));
+                                }
                         }
 
                         continue;
diff --git a/DynamORM/Validation/RequiredAttribute.cs b/DynamORM/Validation/RequiredAttribute.cs
index 2ab2ce0..fae84f1 100644
--- a/DynamORM/Validation/RequiredAttribute.cs
+++ b/DynamORM/Validation/RequiredAttribute.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
@@ -7,7 +8,7 @@ using DynamORM.Mapper;
 namespace DynamORM.Validation
 {
     /// <summary>Required attribute can be used to validate fields in objects using mapper class.</summary>
-    [AttributeUsage(AttributeTargets.Property)]
+    [AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
     public class RequiredAttribute : Attribute
     {
         /// <summary>Gets or sets minimum value or length of field.</summary>
@@ -22,6 +23,9 @@ namespace DynamORM.Validation
         /// <summary>Gets or sets a value indicating whether property value is required or not.</summary>
         public bool Required { get; set; }
 
+        /// <summary>Gets or sets a value indicating whether this is an element requirement.</summary>
+        public bool ElementRequirement { get; set; }
+
         /// <summary>Initializes a new instance of the <see cref="RequiredAttribute" /> class.</summary>
         /// <param name="required">This field will be required.</param>
         public RequiredAttribute(bool required = true)
@@ -68,10 +72,20 @@ namespace DynamORM.Validation
 
         internal ValidateResult ValidateSimpleValue(DynamicPropertyInvoker dpi, object val)
         {
-            if (val == null && Required)
-                return ValidateResult.ValueIsMissing;
+            return ValidateSimpleValue(dpi.Type, dpi.IsGnericEnumerable, val);
+        }
 
-            if (dpi.Type.IsValueType)
+        internal ValidateResult ValidateSimpleValue(Type type, bool isGnericEnumerable, object val)
+        {
+            if (val == null)
+            {
+                if (Required)
+                    return ValidateResult.ValueIsMissing;
+                else
+                    return ValidateResult.Valid;
+            }
+
+            if (type.IsValueType)
             {
                 if (val is decimal || val is long || val is int || val is float || val is double || val is short || val is byte ||
                     val is decimal? || val is long? || val is int? || val is float? || val is double? || val is short? || val is byte?)
@@ -102,9 +116,19 @@ namespace DynamORM.Validation
                     return ValidateResult.Valid;
                 }
             }
-            else if (dpi.Type.IsArray || dpi.IsGnericEnumerable)
+            else if (type.IsArray || isGnericEnumerable)
             {
-                var cnt = (val as IEnumerable<object>).Count();
+                int? cnt = null;
+
+                var list = (val as IEnumerable<object>);
+                if (list != null)
+                    cnt = list.Count();
+                else
+                {
+                    var enumerable = (val as IEnumerable);
+                    if (enumerable != null)
+                        cnt = enumerable.Cast<object>().Count();
+                }
 
                 if (Min.HasValue && Min.Value > cnt)
                     return ValidateResult.TooFewElementsInCollection;
@@ -114,6 +138,21 @@ namespace DynamORM.Validation
 
                 return ValidateResult.Valid;
             }
+            else if (type == typeof(string))
+            {
+                var str = (string)val;
+
+                if (Min.HasValue && Min.Value > str.Length)
+                    return ValidateResult.ValueTooShort;
+
+                if (Max.HasValue && Max.Value < str.Length)
+                    return ValidateResult.ValueTooLong;
+
+                if (Pattern != null && !Pattern.IsMatch(str))
+                    return ValidateResult.ValueDontMatchPattern;
+
+                return ValidateResult.Valid;
+            }
 
             return ValidateResult.NotSupported;
         }