public void CreateBloggingContext()
        {
            using (var db = new BloggingContext(new NpgsqlConnection(ConnectionStringEF)))
            {
                if (!(db.Database.Connection is NpgsqlConnection))
                {
                    Assert.Fail(
                        "Connection type is \"" + db.Database.Connection.GetType().FullName + "\" should be \"" + typeof(NpgsqlConnection).FullName + "\"." + Environment.NewLine +
                        "Most likely wrong configuration in App.config file of Tests project.");
                }
                db.Database.Delete();
                var blog = new Blog {
                    Name = "blogNameTest1"
                };
                db.Blogs.Add(blog);
                db.SaveChanges();

                var query = from b in db.Blogs
                            where b.Name == "blogNameTest1"
                            select b;
                Assert.AreEqual(1, query.Count());

                db.Database.Connection.Open();
                using (var command = db.Database.Connection.CreateCommand())
                {
                    command.CommandText = "select column_name, data_type, is_nullable, column_default from information_schema.columns where table_name = 'Blogs';";
                    List <string> expectedColumns = new List <string>(new string[] { "Name", "BlogId" });
                    using (var reader = command.ExecuteReader())
                    {
                        while (reader.Read())
                        {
                            Console.WriteLine((string)reader[0] + " " + (string)reader[1] + " " + (string)reader[2] + " " + (reader[3] ?? "").ToString());
                            switch ((string)reader[0])
                            {
                            case "Name":
                                expectedColumns.Remove((string)reader[0]);
                                Assert.AreEqual("text", (string)reader[1]);
                                Assert.AreEqual("YES", (string)reader[2]);
                                Assert.IsNullOrEmpty(reader[3] as string);
                                break;

                            case "BlogId":
                                expectedColumns.Remove((string)reader[0]);
                                Assert.AreEqual("integer", (string)reader[1]);
                                Assert.AreEqual("NO", (string)reader[2]);
                                Assert.AreEqual("nextval('dbo.\"Blogs_BlogId_seq\"'::regclass)", reader[3] as string);
                                break;

                            default:
                                Assert.Fail("Unknown column '" + (string)reader[0] + "' in Blogs table.");
                                break;
                            }
                        }
                    }
                    foreach (var columnName in expectedColumns)
                    {
                        Assert.Fail("Column '" + columnName + "' was not created in Blogs table.");
                    }
                }

                using (var command = db.Database.Connection.CreateCommand())
                {
                    command.CommandText = "select column_name, data_type, is_nullable, column_default from information_schema.columns where table_name = 'Posts';";
                    List <string> expectedColumns = new List <string>(new string[] { "PostId", "Title", "Content", "BlogId" });
                    using (var reader = command.ExecuteReader())
                    {
                        while (reader.Read())
                        {
                            Console.WriteLine((string)reader[0] + " " + (string)reader[1] + " " + (string)reader[2] + " " + (reader[3] ?? "").ToString());
                            switch ((string)reader[0])
                            {
                            case "PostId":
                                expectedColumns.Remove((string)reader[0]);
                                Assert.AreEqual("integer", (string)reader[1]);
                                Assert.AreEqual("NO", (string)reader[2]);
                                Assert.AreEqual("nextval('dbo.\"Posts_PostId_seq\"'::regclass)", (string)reader[3]);
                                break;

                            case "Title":
                                expectedColumns.Remove((string)reader[0]);
                                Assert.AreEqual("text", (string)reader[1]);
                                Assert.AreEqual("YES", (string)reader[2]);
                                Assert.IsNullOrEmpty(reader[3] as string);
                                break;

                            case "Content":
                                expectedColumns.Remove((string)reader[0]);
                                Assert.AreEqual("text", (string)reader[1]);
                                Assert.AreEqual("YES", (string)reader[2]);
                                Assert.IsNullOrEmpty(reader[3] as string);
                                break;

                            case "BlogId":
                                expectedColumns.Remove((string)reader[0]);
                                Assert.AreEqual("integer", (string)reader[1]);
                                Assert.AreEqual("NO", (string)reader[2]);
                                Assert.AreEqual("0", (string)reader[3]);
                                break;

                            case "UniqueId":
                                expectedColumns.Remove((string)reader[0]);
                                Assert.AreEqual("uuid", (string)reader[1]);
                                Assert.AreEqual("NO", (string)reader[2]);
                                Assert.AreEqual("'00000000-0000-0000-0000-000000000000'::uuid", reader[3] as string);
                                //Assert.AreEqual("uuid_generate_v4()", reader[3] as string);
                                break;

                            case "Rating":
                                expectedColumns.Remove((string)reader[0]);
                                Assert.AreEqual("smallint", (string)reader[1]);
                                Assert.AreEqual("YES", (string)reader[2]);
                                Assert.IsNullOrEmpty(reader[3] as string);
                                break;

                            default:
                                Assert.Fail("Unknown column '" + (string)reader[0] + "' in Post table.");
                                break;
                            }
                        }
                    }
                    foreach (var columnName in expectedColumns)
                    {
                        Assert.Fail("Column '" + columnName + "' was not created in Posts table.");
                    }
                }
            }
        }
        public void DataTypes()
        {
            using (var context = new BloggingContext(ConnectionString))
            {
                context.Database.Log = Console.Out.WriteLine;

                IQueryable <int> oneRow = context.Posts.Where(p => false).Select(p => 1).Concat(new int[] { 1 });

                Assert.AreEqual((byte)1, oneRow.Select(p => (byte)1).First());
                Assert.AreEqual((short)1, oneRow.Select(p => (short)1).First());
                Assert.AreEqual((long)1, oneRow.Select(p => (long)1).First());
                Assert.AreEqual(1.25M, oneRow.Select(p => 1.25M).First());
                Assert.AreEqual(double.NaN, oneRow.Select(p => double.NaN).First());
                Assert.AreEqual(double.PositiveInfinity, oneRow.Select(p => double.PositiveInfinity).First());
                Assert.AreEqual(double.NegativeInfinity, oneRow.Select(p => double.NegativeInfinity).First());
                Assert.AreEqual(1.12e+12, oneRow.Select(p => 1.12e+12).First());
                Assert.AreEqual(1.12e-12, oneRow.Select(p => 1.12e-12).First());
                Assert.AreEqual(float.NaN, oneRow.Select(p => float.NaN).First());
                Assert.AreEqual(float.PositiveInfinity, oneRow.Select(p => float.PositiveInfinity).First());
                Assert.AreEqual(float.NegativeInfinity, oneRow.Select(p => float.NegativeInfinity).First());
                Assert.AreEqual(1.12e+12f, oneRow.Select(p => 1.12e+12f).First());
                Assert.AreEqual(1.12e-12f, oneRow.Select(p => 1.12e-12f).First());
                Assert.AreEqual((short)-32768, oneRow.Select(p => (short)-32768).First());
                Assert.IsTrue(new byte[] { 1, 2 }.SequenceEqual(oneRow.Select(p => new byte[] { 1, 2 }).First()));

                byte    byteVal    = 1;
                short   shortVal   = -32768;
                long    longVal    = 1L << 33;
                decimal decimalVal = 1.25M;
                double  doubleVal  = 1.12;
                float   floatVal   = 1.22f;
                byte[]  byteArrVal = new byte[] { 1, 2 };

                Assert.AreEqual(byteVal, oneRow.Select(p => byteVal).First());
                Assert.AreEqual(shortVal, oneRow.Select(p => shortVal).First());
                Assert.AreEqual(longVal, oneRow.Select(p => longVal).First());
                Assert.AreEqual(decimalVal, oneRow.Select(p => decimalVal).First());
                Assert.AreEqual(doubleVal, oneRow.Select(p => doubleVal).First());
                Assert.AreEqual(floatVal, oneRow.Select(p => floatVal).First());
                Assert.IsTrue(byteArrVal.SequenceEqual(oneRow.Select(p => byteArrVal).First()));

                // A literal TimeSpan is written as an interval
                Assert.AreEqual(new TimeSpan(1, 2, 3, 4), oneRow.Select(p => new TimeSpan(1, 2, 3, 4)).First());
                var val1 = new TimeSpan(1, 2, 3, 4);
                Assert.AreEqual(val1, oneRow.Select(p => new TimeSpan(1, 2, 3, 4)).First());
                Assert.AreEqual(val1, oneRow.Select(p => val1).First());

                // DateTimeOffset -> timestamptz
                Assert.AreEqual(new DateTimeOffset(2014, 2, 3, 4, 5, 6, 0, TimeSpan.Zero), oneRow.Select(p => new DateTimeOffset(2014, 2, 3, 4, 5, 6, 0, TimeSpan.Zero)).First());
                var val2 = new DateTimeOffset(2014, 2, 3, 4, 5, 6, 0, TimeSpan.Zero);
                Assert.AreEqual(val2, oneRow.Select(p => new DateTimeOffset(2014, 2, 3, 4, 5, 6, 0, TimeSpan.Zero)).First());
                Assert.AreEqual(val2, oneRow.Select(p => val2).First());

                // DateTime -> timestamp
                Assert.AreEqual(new DateTime(2014, 2, 3, 4, 5, 6, 0), oneRow.Select(p => new DateTime(2014, 2, 3, 4, 5, 6, 0)).First());
                var val3 = new DateTime(2014, 2, 3, 4, 5, 6, 0);
                Assert.AreEqual(val3, oneRow.Select(p => new DateTime(2014, 2, 3, 4, 5, 6, 0)).First());
                Assert.AreEqual(val3, oneRow.Select(p => val3).First());

                var val4 = new Guid("1234567890abcdef1122334455667788");
                Assert.AreEqual(val4, oneRow.Select(p => new Guid("1234567890abcdef1122334455667788")).First());
                Assert.AreEqual(val4, oneRow.Select(p => val4).First());

                // String
                Assert.AreEqual(@"a'b\c", oneRow.Select(p => @"a'b\c").First());
            }
        }