public void TestGetOneToManyListWithInverseGuidId()
        {
            var conn = Utils.CreateConnection();
            conn.DropTable<O2MClassG>();
            conn.DropTable<O2MClassH>();
            conn.CreateTable<O2MClassG>();
            conn.CreateTable<O2MClassH>();

            // Use standard SQLite-Net API to create the objects
            var objectsD = new List<O2MClassH>
            {
                new O2MClassH {
                    Guid = Guid.NewGuid(),
                    Foo = string.Format("1- Foo String {0}", new Random().Next(100))
                },
                new O2MClassH {
                    Guid = Guid.NewGuid(),
                    Foo = string.Format("2- Foo String {0}", new Random().Next(100))
                },
                new O2MClassH {
                    Guid = Guid.NewGuid(),
                    Foo = string.Format("3- Foo String {0}", new Random().Next(100))
                },
                new O2MClassH {
                    Guid = Guid.NewGuid(),
                    Foo = string.Format("4- Foo String {0}", new Random().Next(100))
                }
            };
            conn.InsertAll(objectsD);

            var objectC = new O2MClassG { Guid = Guid.NewGuid() };
            conn.Insert(objectC);

            Assert.Null(objectC.HObjects);

            // Fetch (yet empty) the relationship
            conn.GetChildren(objectC);
            Assert.NotNull(objectC.HObjects);
            Assert.AreEqual(0, objectC.HObjects.Count);

            // Set the relationship using IDs
            foreach (var objectD in objectsD)
            {
                objectD.ClassGKey = objectC.Guid;
                conn.Update(objectD);
            }

            Assert.NotNull(objectC.HObjects);
            Assert.AreEqual(0, objectC.HObjects.Count);

            // Fetch the relationship
            conn.GetChildren(objectC);

            Assert.NotNull(objectC.HObjects);
            Assert.AreEqual(objectsD.Count, objectC.HObjects.Count);
            var foos = objectsD.Select(objectB => objectB.Foo).ToList();
            foreach (var objectD in objectC.HObjects)
            {
                Assert.IsTrue(foos.Contains(objectD.Foo));
                Assert.AreEqual(objectC.Guid, objectD.ObjectG.Guid);
                Assert.AreEqual(objectC.Bar, objectD.ObjectG.Bar);
                Assert.AreSame(objectC, objectD.ObjectG); // Not only equal, they are the same!
            }
        }
        public void TestUpdateUnsetOneToManyNullList()
        {
            var conn = Utils.CreateConnection();
            conn.DropTable<O2MClassA>();
            conn.DropTable<O2MClassB>();
            conn.CreateTable<O2MClassA>();
            conn.CreateTable<O2MClassB>();

            // Use standard SQLite-Net API to create the objects
            var objectsB = new List<O2MClassB>
            {
                new O2MClassB {
                    Foo = string.Format("1- Foo String {0}", new Random().Next(100))
                },
                new O2MClassB {
                    Foo = string.Format("2- Foo String {0}", new Random().Next(100))
                },
                new O2MClassB {
                    Foo = string.Format("3- Foo String {0}", new Random().Next(100))
                },
                new O2MClassB {
                    Foo = string.Format("4- Foo String {0}", new Random().Next(100))
                }
            };
            conn.InsertAll(objectsB);

            var objectA = new O2MClassA();
            conn.Insert(objectA);

            Assert.Null(objectA.BObjects);

            objectA.BObjects = objectsB;

            foreach (var objectB in objectsB)
            {
                Assert.AreEqual(0, objectB.ClassAKey, "Foreign keys shouldn't have been updated yet");
            }

            conn.UpdateWithChildren(objectA);

            foreach (var objectB in objectA.BObjects)
            {
                Assert.AreEqual(objectA.Id, objectB.ClassAKey, "Foreign keys haven't been updated yet");

                // Check database values
                var newObjectB = conn.Get<O2MClassB>(objectB.Id);
                Assert.AreEqual(objectA.Id, newObjectB.ClassAKey, "Database stored value is not correct");
            }

            // At this point the test is exactly the same as TestUpdateSetOneToManyList
            objectA.BObjects = null; // Reset the relationship

            conn.UpdateWithChildren(objectA);

            foreach (var objectB in objectsB)
            {
                // Check database values
                var newObjectB = conn.Get<O2MClassB>(objectB.Id);
                Assert.AreEqual(0, newObjectB.ClassAKey, "Database stored value is not correct");
            }

        }