public void TestDocumentChange()
        {
            var exp1 = new WaitAssert();
            var exp2 = new WaitAssert();

            Db.AddDocumentChangeListener("doc1", (sender, args) =>
            {
                WriteLine("Reached document changed callback");
                exp2.RunAssert(() =>
                {
                    WriteLine("Waiting for exp1 in document changed callback");
                    exp1.WaitForResult(TimeSpan.FromSeconds(20)); // Test deadlock
                });
            });

            WriteLine("Triggering async save");
            var ignore = exp1.RunAssertAsync(() =>
            {
                WriteLine("Running async save");
                Db.Save(new MutableDocument("doc1"));
                WriteLine("Async save completed");
            });

            WriteLine("Waiting for exp1 in test method");
            exp1.WaitForResult(TimeSpan.FromSeconds(10));
        }
        public void TestConcurrentDelete()
        {
            const int nDocs = 1000;
            var       docs  = CreateDocs(nDocs, "Create").ToList();

            docs.Count.Should().Be(nDocs);

            var delete1 = new WaitAssert();
            var ignore  = delete1.RunAssertAsync(() =>
            {
                foreach (var doc in docs)
                {
                    Db.Delete(doc);
                }
            });

            var delete2 = new WaitAssert();

            ignore = delete2.RunAssertAsync(() =>
            {
                foreach (var doc in docs)
                {
                    Db.Delete(doc);
                }
            });

            WaitAssert.WaitFor(TimeSpan.FromSeconds(60), delete1, delete2);
            Db.Count.Should().Be(0, "because all documents were deleted");
        }
        public void TestConcurrentCreateNCreateIndexDB()
        {
            const int nDocs = 1000;

            var exp1   = new WaitAssert();
            var ignore = exp1.RunAssertAsync(() =>
            {
                CreateDocs(nDocs, "Create").ToList();
            });

            Db.CreateIndex("sentence", IndexBuilder.FullTextIndex(FullTextIndexItem.Property("sentence")));
            exp1.WaitForResult(TimeSpan.FromSeconds(60));
        }
        public void TestConcurrentCreateNCompactDB()
        {
            const int nDocs = 1000;

            var exp1   = new WaitAssert();
            var ignore = exp1.RunAssertAsync(() =>
            {
                CreateDocs(nDocs, "Create").ToList();
            });

            Db.Compact();
            exp1.WaitForResult(TimeSpan.FromSeconds(60));
        }
        public void TestConcurrentCreateAndDeleteDB()
        {
            const int nDocs = 1000;

            var exp1   = new WaitAssert();
            var ignore = exp1.RunAssertAsync(() =>
            {
                Action a = () => CreateDocs(nDocs, "Create").ToList();
                a.Should().Throw <InvalidOperationException>();
            });

            Db.Delete();
            exp1.WaitForResult(TimeSpan.FromSeconds(60));
        }
        public void TestDatabaseChange()
        {
            var exp1 = new WaitAssert();
            var exp2 = new WaitAssert();

            Db.AddChangeListener(null, (sender, args) =>
            {
                exp2.RunAssert(() =>
                {
                    exp1.WaitForResult(TimeSpan.FromSeconds(20)); // Test deadlock
                });
            });

            var ignore = exp1.RunAssertAsync(() =>
            {
                Db.Save(new MutableDocument("doc1"));
            });

            exp1.WaitForResult(TimeSpan.FromSeconds(10));
        }