smarkdatatest.cs

smark.data是基于C#开发的轻量级数据访问组件。 提供以下功能封： 1）提供了跨数据库类型操作能力 2）基于程线存储的数据访问上下文对象

using System;
using System.Text;
using System.Collections.Generic;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Smark.Data;
namespace Smark.Data.TestCase
{
    /// <summary>
    /// SmarkDataTest 的摘要说明
    /// </summary>
    [TestClass]
    public class SmarkDataTest
    {
        public SmarkDataTest()
        {
            //
            //TODO: 在此处添加构造函数逻辑
            //
            DBContext.DB="Provider=Microsoft.Jet.OleDb.4.0;Data Source=C:\\Northwind.mdb";
            
        }

        private TestContext testContextInstance;

        /// <summary>
        ///获取或设置测试上下文，该上下文提供
        ///有关当前测试运行及其功能的信息。
        ///</summary>
        public TestContext TestContext 
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        #region 附加测试属性
        //
        // 编写测试时，还可使用以下附加属性:
        //
        // 在运行类中的第一个测试之前使用 ClassInitialize 运行代码
        // [ClassInitialize()]
        // public static void MyClassInitialize(TestContext testContext) { }
        //
        // 在类中的所有测试都已运行之后使用 ClassCleanup 运行代码
        // [ClassCleanup()]
        // public static void MyClassCleanup() { }
        //
        // 在运行每个测试之前，使用 TestInitialize 来运行代码
        // [TestInitialize()]
        // public void MyTestInitialize() { }
        //
        // 在每个测试运行完之后，使用 TestCleanup 来运行代码
        // [TestCleanup()]
        // public void MyTestCleanup() { }
        //
        #endregion

       
        [TestMethod]
        public void Null()
        {
            IList<Order> items = Order.List(null);
            WriteOrder(items);
        }
        [TestMethod]
        public void Eq()
        {
            Expression exp = Order.employeeID.Eq(4);
            WriteExpression(exp);
            IList<Order> items = Order.List( exp);
            WriteOrder(items);
        }
        [TestMethod]
        public void Lt()
        {
            Expression exp = Order.employeeID.Lt(3);
            WriteExpression(exp);
            IList<Order> items = Order.List(exp);
            WriteOrder(items);
        }
        [TestMethod]
        public void LtEq()
        {
            Expression exp = Order.employeeID.LtEq(3);
            WriteExpression(exp);
            IList<Order> items =Order.List(exp);
            WriteOrder(items);
        }
        [TestMethod]
        public void Gt()
        {
            Expression exp = Order.employeeID.Gt(4);
            WriteExpression(exp);
            IList<Order> items = Order.List(exp);
            WriteOrder(items);
        }
        [TestMethod]
        public void GtEq()
        {
            Expression exp = Order.employeeID.GtEq(4);
            WriteExpression(exp);
            IList<Order> items = Order.List(exp);
            WriteOrder(items);
        }
        [TestMethod]
        public void NotRt()
        {
            Expression exp = Order.employeeID.NotEq(4);
            WriteExpression(exp);
            IList<Order> items = Order.List(exp);
            WriteOrder(items);
        }
        [TestMethod]
        public void In()
        {
            Expression exp = Order.employeeID.In(new int[] {1,3,5 });
            WriteExpression(exp);
            IList<Order> items = Order.List(exp);
            WriteOrder(items);
        }
        [TestMethod]
        public void InTable()
        {
            Expression exp = Order.employeeID.In(Employee.employeeID, Employee.country.Eq("usa"));
            WriteExpression(exp);
            IList<Order> items = Order.List(exp);
            WriteOrder(items);
        }
        [TestMethod]
        public void NotIn()
        {
            Expression exp = Order.employeeID.NotIn(new int[] { 1, 3, 5 });
            WriteExpression(exp);
            IList<Order> items = Order.List(exp);
            WriteOrder(items);
        }
        [TestMethod]
        public void NoTInTable()
        {
            Expression exp = Order.employeeID.NotIn(Employee.employeeID, Employee.country.Eq("usa"));
            WriteExpression(exp);
            IList<Order> items = Order.List(exp);
            WriteOrder(items);
        }
        [TestMethod]
        public void Between()
        {
            Expression exp = Order.orderDate.Between("1995-1-1", "1995-12-31");
            WriteExpression(exp);
            IList<Order> items = Order.List(exp);
            WriteOrder(items);
        }
        [TestMethod]
        public void NotBetween()
        {
            Expression exp = Order.orderDate.NotBetween("1995-1-1", "1995-12-31");
            WriteExpression(exp);
            IList<Order> items = Order.List(exp);
            WriteOrder(items);
        }
        [TestMethod]
        public void Insert()
        {
            Employee emp = new Employee();
            emp.FirstName = "Fan";
            emp.LastName = "henry";
            emp.Save();
            TestContext.WriteLine("EmployeeID:" + emp.EmployeeID);
        }
        [TestMethod]
        public void Update()
        {
            Employee emp = Employee.Load(3);
            emp.Country = "china";
            emp.Save();
            emp = Employee.Load(3);
            TestContext.WriteLine(emp.Country);
        }
        [TestMethod]
        public void Count()
        {

            Expression exp=null;
            TestContext.WriteLine("Orders:" + Order.Count(exp));
            exp = Order.orderDate.Between("1995-1-1", "1995-1-31");
            WriteExpression(exp);
            TestContext.WriteLine("Orders:" + Order.Count(exp));
        }
        [TestMethod]
        public void Sum()
        {
            Expression exp = Detail.orderID.In(Order.orderID, Order.orderDate.Between("1995-1-1", "1995-1-31"));
            WriteExpression(exp);
            TestContext.WriteLine(
                "Order ExtendedPrice:" + Detail.SUM(string.Format("{0}*{1}",Detail.unitPrice,Detail.quantity), exp));
            WriteSplit();
            exp = Detail.orderID.In(Order.orderID, Order.employeeID.In(Employee.employeeID, Employee.country.Eq("usa")));
            WriteExpression(exp);
            TestContext.WriteLine(
                "Order ExtendedPrice:" + Detail.SUM(string.Format("{0}*{1}", Detail.unitPrice, Detail.quantity), exp));
            exp = Detail.orderID.In(Order.orderID, Order.employeeID.Eq(5));
            WriteExpression(exp);
            TestContext.WriteLine(
                "Order ExtendedPrice:" + Detail.SUM(string.Format("{0}*{1}", Detail.unitPrice, Detail.quantity), exp));
        }
        [TestMethod]
        public void Max()
        {
            Expression exp = Detail.orderID.In(Order.orderID, Order.orderDate.Between("1995-1-1", "1995-1-31"));
            WriteExpression(exp);
            TestContext.WriteLine(
                "Order ExtendedPrice:" + Detail.MAX(string.Format("{0}*{1}", Detail.unitPrice, Detail.quantity), exp));
            WriteSplit();
            exp = Detail.orderID.In(Order.orderID, Order.employeeID.In(Employee.employeeID, Employee.country.Eq("usa")));
            WriteExpression(exp);
            TestContext.WriteLine(
                "Order ExtendedPrice:" + Detail.MAX(string.Format("{0}*{1}", Detail.unitPrice, Detail.quantity), exp));
            exp = Detail.orderID.In(Order.orderID, Order.employeeID.Eq(5));
            WriteExpression(exp);
            TestContext.WriteLine(
                "Order ExtendedPrice:" + Detail.MAX(string.Format("{0}*{1}", Detail.unitPrice, Detail.quantity), exp));
        }
        [TestMethod]
        public void Min()
        {
            Expression exp = Detail.orderID.In(Order.orderID, Order.orderDate.Between("1995-1-1", "1995-1-31"));
            WriteExpression(exp);
            TestContext.WriteLine(
                "Order ExtendedPrice:" + Detail.MIN(string.Format("{0}*{1}", Detail.unitPrice, Detail.quantity), exp));
            WriteSplit();
            exp = Detail.orderID.In(Order.orderID, Order.employeeID.In(Employee.employeeID, Employee.country.Eq("usa")));
            WriteExpression(exp);
            TestContext.WriteLine(
                "Order ExtendedPrice:" + Detail.MIN(string.Format("{0}*{1}", Detail.unitPrice, Detail.quantity), exp));
            exp = Detail.orderID.In(Order.orderID, Order.employeeID.Eq(5));
            WriteExpression(exp);
            TestContext.WriteLine(
                "Order ExtendedPrice:" + Detail.MIN(string.Format("{0}*{1}", Detail.unitPrice, Detail.quantity), exp));
        }
        [TestMethod]
        public void Avg()
        {
            Expression exp = Detail.orderID.In(Order.orderID, Order.orderDate.Between("1995-1-1", "1995-1-31"));
            WriteExpression(exp);
            TestContext.WriteLine(
                "Order ExtendedPrice:" + Detail.AVG(string.Format("{0}*{1}", Detail.unitPrice, Detail.quantity), exp));
            WriteSplit();
            exp = Detail.orderID.In(Order.orderID, Order.employeeID.In(Employee.employeeID, Employee.country.Eq("usa")));
            WriteExpression(exp);
            TestContext.WriteLine(
                "Order ExtendedPrice:" + Detail.AVG(string.Format("{0}*{1}", Detail.unitPrice, Detail.quantity), exp));
            exp = Detail.orderID.In(Order.orderID, Order.employeeID.Eq(5));
            WriteExpression(exp);
            TestContext.WriteLine(
                "Order ExtendedPrice:" + Detail.AVG(string.Format("{0}*{1}", Detail.unitPrice, Detail.quantity), exp));