public void CreateDatabaseScript()
 {
     using (testEntities ctx = new testEntities())
     {
         string s = ctx.CreateDatabaseScript();
     }
 }

        public void AverageWithGrouping()
        {
            MySqlDataAdapter da = new MySqlDataAdapter(
              "SELECT AVG(Freight) FROM Orders GROUP BY ShopId", conn);
              DataTable dt = new DataTable();
              da.Fill(dt);

              using (testEntities context = new testEntities())
              {
            string eSql = "SELECT AVG(o.Freight) FROM Orders AS o GROUP BY o.Shop.Id";
            ObjectQuery<DbDataRecord> q = context.CreateQuery<DbDataRecord>(eSql);

            string sql = q.ToTraceString();
            CheckSql(sql, SQLSyntax.AverageWithGrouping);

            foreach (object x in q)
            {
              string s = x.GetType().ToString();
            }
            int i = 0;
            foreach (var freight in q)
            {
              //   Assert.AreEqual(Convert.ToInt32(dt.Rows[i++][0]), Convert.ToInt32(freight));
            }
              }
        }

        public void DoubleValuesNonEnglish()
        {
            CultureInfo curCulture = Thread.CurrentThread.CurrentCulture;
              CultureInfo curUICulture = Thread.CurrentThread.CurrentUICulture;
              CultureInfo newCulture = new CultureInfo("da-DK");
              Thread.CurrentThread.CurrentCulture = newCulture;
              Thread.CurrentThread.CurrentUICulture = newCulture;

              try
              {
            using (testEntities context = new testEntities())
            {
              Child c = new Child();
              c.Id = 20;
              c.EmployeeID = 1;
              c.FirstName = "Bam bam";
              c.LastName = "Rubble";
              c.BirthWeight = 8.65;
              c.Modified = DateTime.Now;
              context.AddToChildren(c);
              context.SaveChanges();
            }
              }
              finally
              {
            Thread.CurrentThread.CurrentCulture = curCulture;
            Thread.CurrentThread.CurrentUICulture = curUICulture;
              }
        }

    public void SimpleJoinWithPredicate()
    {
      MySqlDataAdapter da = new MySqlDataAdapter(
          @"SELECT b.id,b.name,a.name as author_name from books b JOIN
                    authors a ON b.author_id=a.id WHERE b.pages > 300", conn);
      DataTable dt = new DataTable();
      da.Fill(dt);

      using (testEntities context = new testEntities())
      {
        var q = from b in context.Books
                join a in context.Authors
                on b.Author.Id equals a.Id
                where b.Pages > 300
                select new
                {
                  bookId = b.Id,
                  bookName = b.Name,
                  authorName = a.Name
                };

        string sql = q.ToTraceString();
        CheckSql(sql, SQLSyntax.SimpleJoinWithPredicate);

        int i = 0;
        foreach (var o in q)
          Assert.AreEqual(dt.Rows[i++][0], o.bookId);
        Assert.AreEqual(dt.Rows.Count, i);
      }
    }

 public void ConversionToLike()
 {
     // Generates queries for each LIKE + wildcards case and checks SQL generated.
       using (testEntities ctx = new testEntities())
       {
     // Like 'pattern%'
     var q = from c in ctx.Employees where c.FirstName.StartsWith( "B" )
         orderby c.FirstName select c;
     string query = q.ToTraceString();
     CheckSql(query, SQLSyntax.StartsWithTranslatedToLike);
     Assert.AreEqual(2, q.Count());
     Assert.AreEqual("Barney", q.First().FirstName);
     Assert.AreEqual("Betty", q.Skip(1).First().FirstName);
     // Like '%pattern%'
     q = from c in ctx.Employees where c.FirstName.Contains("r")
     orderby c.FirstName select c;
     query = q.ToTraceString();
     CheckSql(query, SQLSyntax.ContainsTranslatedToLike);
     Assert.AreEqual(2, q.Count());
     Assert.AreEqual("Barney", q.First().FirstName);
     Assert.AreEqual("Fred", q.Skip(1).First().FirstName);
     // Like '%pattern'
     q = from c in ctx.Employees
         where c.FirstName.EndsWith("y")
         orderby c.FirstName
         select c;
     query = q.ToTraceString();
     CheckSql(query, SQLSyntax.EndsWithTranslatedToLike);
     Assert.AreEqual(3, q.Count());
     Assert.AreEqual("Barney", q.First().FirstName);
     Assert.AreEqual("Betty", q.Skip(1).First().FirstName);
     Assert.AreEqual("Scooby", q.Skip(2).First().FirstName);
       }
 }

        public void CanGroupByMultipleColumns()
        {
            MySqlDataAdapter adapter = new MySqlDataAdapter(
              "SELECT Name, COUNT(Id) as Count FROM Companies GROUP BY Name, NumEmployees, DateBegan", conn);
              DataTable table = new DataTable();
              adapter.Fill(table);

              using (testEntities context = new testEntities())
              {
            var companies = from c in context.Companies
                        group c by new { c.Name, c.NumEmployees, c.DateBegan } into cgroup
                        select new
                        {
                          Name = cgroup.Key.Name,
                          Count = cgroup.Count()
                        };

            string sql = companies.ToTraceString();
            CheckSql(sql, SQLSyntax.CanGroupByMultipleColumns);

            int i = 0;
            foreach (var company in companies)
            {
              Assert.AreEqual(table.Rows[i][0], company.Name);
              Assert.AreEqual(table.Rows[i][1], company.Count);
              i++;
            }
              }
        }

        public void SimpleJoin()
        {
            MySqlDataAdapter da = new MySqlDataAdapter(
                @"SELECT b.id,b.name,a.name as author_name from books b JOIN
                    authors a ON b.author_id=a.id", conn);
            DataTable dt = new DataTable();
            da.Fill(dt);

            using (testEntities context = new testEntities())
            {
                var q = from b in context.Books
                        join a in context.Authors
                        on b.Author.Id equals a.Id
                        select new
                        {
                            bookId = b.Id,
                            bookName = b.Name,
                            authorName = a.Name
                        };

                int i = 0;
                foreach (var o in q)
                    Assert.AreEqual(dt.Rows[i++][0], o.bookId);
                Assert.AreEqual(dt.Rows.Count, i);
            }
        }

        public void JoinOfNestedUnionsWithLimit()
        {
            using (testEntities context = new testEntities())
              {
            var q = context.Books.Include("Author");
            q = q.Include("Publisher");
            q = q.Include("Publisher.Books");
            string sql = q.ToTraceString();

            var  i = 0;
            foreach (var o in q.Where(p => p.Id > 0).OrderBy(p => p.Name).ThenByDescending(p => p.Id).Skip(0).Take(32).ToList())
            {
               switch (i)
              {
             case 0:
               Assert.AreEqual(5, o.Id);
               Assert.AreEqual("Debt of Honor", o.Name);
             break;
             case 1:
               Assert.AreEqual(1, o.Id);
               Assert.AreEqual("Debt of Honor", o.Name);
             break;
             case 4:
               Assert.AreEqual(3, o.Id);
               Assert.AreEqual("Rainmaker", o.Name);
             break;
              }
               i++;
            }
              }
        }

 public void UnsignedValues()
 {
     using (testEntities context = new testEntities())
     {
         var row = context.Children.First();
         context.Detach(row);
         context.Attach(row);
     }
 }

        public void FirstSimple()
        {
            MySqlCommand cmd = new MySqlCommand("SELECT id FROM orders", conn);
            int id = (int)cmd.ExecuteScalar();

            using (testEntities context = new testEntities())
            {
                var q = from o in context.Orders 
                            select o;
                Order order = q.First() as Order;
                Assert.AreEqual(id, order.Id);
            }
        }

    public void FirstPredicate()
    {
      MySqlCommand cmd = new MySqlCommand("SELECT id FROM orders WHERE freight > 100", conn);
      int id = (int)cmd.ExecuteScalar();

      using (testEntities context = new testEntities())
      {
        var q = from o in context.Orders
                where o.Freight > 100
                select o;
        Order order = q.First() as Order;
        Assert.AreEqual(id, order.Id);
      }
    }

        public void BigCountSimple()
        {
            MySqlCommand trueCmd = new MySqlCommand("SELECT COUNT(*) FROM Toys", conn);
            object trueCount = trueCmd.ExecuteScalar();

            using (testEntities context = new testEntities())
            {
                string sql = "SELECT VALUE BigCount(t.Id) FROM Toys AS t";
                ObjectQuery<Int32> q = context.CreateQuery<Int32>(sql);

                foreach (int count in q)
                    Assert.AreEqual(trueCount, count);
            }
        }

        public void CanInsertRowWithDefaultTimeStamp()
        {
            using (testEntities context = new testEntities())
              {
            // The default timestamp is in the CreatedDate column.
            Product product = new Product();
            product.Name = "Coca Cola";

            context.AddToProducts(product);
            context.SaveChanges();

            Assert.AreEqual(DateTime.Today.Day, product.CreatedDate.Day);
              }
        }

 public void YearMonthDay()
 {
     using (testEntities context = new testEntities())
     {
         ObjectQuery<DbDataRecord> q = context.CreateQuery<DbDataRecord>(
             @"SELECT c.DateBegan, Year(c.DateBegan), Month(c.DateBegan), Day(c.DateBegan)
                 FROM Companies AS c WHERE c.Id=1");
         foreach (DbDataRecord record in q)
         {
             Assert.AreEqual(1996, record[1]);
             Assert.AreEqual(11, record[2]);
             Assert.AreEqual(15, record[3]);
         }
     }
 }

 public void Bitwise()
 {
   using (testEntities context = new testEntities())
   {
     ObjectQuery<Int32> q = context.CreateQuery<Int32>("BitwiseAnd(255,15)");
     foreach (int i in q)
       Assert.AreEqual(15, i);
     q = context.CreateQuery<Int32>("BitwiseOr(240,31)");
     foreach (int i in q)
       Assert.AreEqual(255, i);
     q = context.CreateQuery<Int32>("BitwiseXor(255,15)");
     foreach (int i in q)
       Assert.AreEqual(240, i);
   }
 }

        public void SimpleSelectWithFilter()
        {
            MySqlDataAdapter da = new MySqlDataAdapter("SELECT * FROM Toys WHERE minage=4", conn);
            DataTable toys = new DataTable();
            da.Fill(toys);
            int i = 0;

            using (testEntities context = new testEntities())
            {
                var query = context.CreateQuery<Toy>("SELECT VALUE t FROM Toys AS t WHERE t.MinAge=4");
                foreach (Toy t in query)
                {
                    Assert.AreEqual(toys.Rows[i++]["name"], t.Name);
                }
            }
        }

        public void Distinct()
        {
            using (testEntities context = new testEntities())
              {
            MySqlDataAdapter da = new MySqlDataAdapter("SELECT * FROM Companies LIMIT 2", conn);
            DataTable dt = new DataTable();
            da.Fill(dt);

            int i = 0;
            var query = context.Companies.Top("2");
            foreach (Company c in query)
            {
              Assert.AreEqual(dt.Rows[i++]["id"], c.Id);
            }
              }
        }

        public void SimpleDeleteAllRows()
        {
            using (testEntities context = new testEntities())
            {
                foreach (Toy t in context.Toys)
                    context.DeleteObject(t);
                context.SaveChanges();

                EntityConnection ec = context.Connection as EntityConnection;
                MySqlDataAdapter da = new MySqlDataAdapter("SELECT * FROM toys",
                    (MySqlConnection)ec.StoreConnection);
                DataTable dt = new DataTable();
                da.Fill(dt);
                Assert.AreEqual(0, dt.Rows.Count);
            }
        }

    public void UpdateAllRows()
    {
      MySqlCommand cmd = new MySqlCommand("SELECT COUNT(*) FROM toys", conn);
      object count = cmd.ExecuteScalar();

      using (testEntities context = new testEntities())
      {
        foreach (Toy t in context.Toys)
          t.Name = "Top";
        context.SaveChanges();
      }

      cmd.CommandText = "SELECT COUNT(*) FROM Toys WHERE name='Top'";
      object newCount = cmd.ExecuteScalar();
      Assert.AreEqual(count, newCount);
    }

    public void CurrentDateTime()
    {
      DateTime current = DateTime.Now;

      using (testEntities context = new testEntities())
      {
        ObjectQuery<DateTime> q = context.CreateQuery<DateTime>("CurrentDateTime()");
        foreach (DateTime dt in q)
        {
          Assert.AreEqual(current.Year, dt.Year);
          Assert.AreEqual(current.Month, dt.Month);
          Assert.AreEqual(current.Day, dt.Day);
          // we don't check time as that will be always be different
        }
      }
    }