public void BindOther()
        {
            var foo = new Foo("123");
            var bar = new Bar(foo);

            AssertChange(foo, bar, x => x.FooDependentValue, () => foo.Value = "arbitrary");
        }

        public void FooTest()
        {
            var sqlConnectionFoo = new Foo<SqlConnection>();
            var oleDbConnectionFoo = new Foo<OleDbConnection>(new OleDbConnection());

            IDbConnection connection = new SqlConnection();
        }

        public void AreSetEventEnabled_disables_events()
        {
            // arrange
            var prevField1 = default(string);
            var prevField2 = default(DateTime);
            var field1 = "test";
            var field2 = DateTime.UtcNow;
            storage[0] = new Dictionary<string, object>{
                {"Field1", prevField1},
                {"Field2", prevField2}
            };
            var foo = new Foo(0, dBCollectionMock.Object);

            // act
            foo.AreSetEventsEnabled = false;
            foo.Field1 = field1;
            foo.Field2 = field2;
            foo.Commit();

            // assert
            storage[0]["Field1"].Should().Be(prevField1);
            storage[0]["Field2"].Should().Be(prevField2);
            foo.Field1.Should().Be(field1);
            foo.Field2.Should().Be(field2);
        }

 public void ProperContentType()
 {
     var content = new Foo();
     var message = new FakeConsumedMessage(content, FakeBasicDeliverEventArgs());
     var actual = message.As<Foo>();
     Assert.Equal(content, actual.Content);
 }

        public void TestPushPop()
        {
            var p0 = new Pool<Foo>();
            var p1 = new Pool<Foo>(1);

            var f = new Foo();
            var g = new Foo();

            p0.Push(f);
            Assert.AreEqual(1, p0.Count);
            p0.Push(g);
            Assert.AreEqual(2, p0.Count);

            p1.Push(f);
            Assert.AreEqual(1, p1.Count);
            // capacity overflow
            p1.Push(g);
            Assert.AreEqual(1, p1.Count);

            Foo g1 = p0.Pop();
            Assert.AreSame(g, g1);
            Foo f1 = p0.Pop();
            Assert.AreSame(f, f1);

            Foo f2 = p1.Pop();
            Assert.AreSame(f, f2);
            // pop underflow
            Foo g2 = p1.Pop();
            Assert.AreSame(null, g2);
        }

        public void EqualsShouldBeTheSameAsEq()
        {
            // Create two equal but distinct strings
            string a = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
            string b = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });

            Assert.IsTrue(a == b);
            Assert.IsTrue(a.Equals(b));

            object c = a;
            object d = b;

            Assert.IsFalse(c == d);
            Assert.IsTrue(c.Equals(d));

            if(new Foo())
            {

            }
            else
            {
                Assert.Fail("should fail");
            }

            Foo foo = new Foo();
        }

            public void ShouldSerializeWithCircularReferences()
            {
                var foo = new Foo();
                foo.Parent = foo;

                Assert.DoesNotThrow(() => _serializer.Serialize(foo));
            }

 public void ArrayToDelimitedString()
 {
     Foo[] arr = new Foo[] {new Foo("Foo"), new Foo("Bar")};
     Assert.AreEqual(
         ":Foo,:Bar", StringUtils.CollectionToCommaDelimitedString(arr));
     Assert.AreEqual("null", StringUtils.CollectionToCommaDelimitedString<object>(null));
 }

        public void ShouldReturnDefaultIfNoneStored()
        {
            var foo = new Foo();
            var value = NotifiableProperty.Get(foo, x => x.Age);

            Assert.AreEqual(0, value);
        }

        public void TestSave()
        {
            var server = Configuration.TestServer;
            var database = Configuration.TestDatabase;
            var collection = Configuration.GetTestCollection<Foo>();

            var conventions = new ConventionPack();
            conventions.Add(new NamedIdMemberConvention(new[] { "FooId" }));
            ConventionRegistry.Register("test", conventions, t => t == typeof(Foo));

            var classMap = new BsonClassMap<Foo>(cm => cm.AutoMap());

            collection.RemoveAll();
            for (int i = 0; i < 10; i++)
            {
                var foo = new Foo
                {
                    FooId = ObjectId.Empty,
                    Name = string.Format("Foo-{0}", i),
                    Summary = string.Format("Summary for Foo-{0}", i)
                };
                collection.Save(foo);
                var count = collection.Count();
                Assert.AreEqual(i + 1, count);
            }
        }

        public void SetPropertyValue_Sets_String_Property()
        {
            var foo = new Foo();
            foo.SetPropertyValue("StringProperty", "Hello Mvc!");

            Assert.IsNotNull(foo.StringProperty);
        }

        public void SetPropertyValue_Sets_Nullable_Property()
        {
            var foo = new Foo() { NullableInt32Property = 32 };
            foo.SetPropertyValue("NullableInt32Property", null);

            Assert.IsNull(foo.NullableInt32Property);
        }

        public void SetPropertyValue_Sets_Boolean_Property()
        {
            var foo = new Foo();
            foo.SetPropertyValue("BooleanProperty", true);

            Assert.IsTrue(foo.BooleanProperty);
        }

        public void SetPropertyValue_Converts_String_To_Boolean_And_Sets_Value()
        {
            var foo = new Foo();
            foo.SetPropertyValue("BooleanProperty", "true");

            Assert.IsTrue(foo.BooleanProperty);
        }

        public void HeaderMapping()
        {
            var content = new Foo();
            const String messageId = "one-id";
            const Int64 timestamp = 123456789L;
            const String replyExchangeType = "direct";
            const String replyExchangeName = "exchange-name";
            const String replyRoutingKey = "routing-key";
            const String correlationId = "one-correlation-id";
            var replyTo = $"{replyExchangeType}://{replyExchangeName}/{replyRoutingKey}";

            var args = new BasicDeliverEventArgs
                           {
                               BasicProperties = new BasicProperties
                                                     {
                                                         MessageId = messageId,
                                                         Timestamp = new AmqpTimestamp(timestamp),
                                                         CorrelationId = correlationId,
                                                         ReplyTo = replyTo
                                                     }
                           };
            var message = new FakeConsumedMessage(content, args);
            var actual = message.To<Foo>();
            Assert.Equal(messageId, actual.Headers.MessageId);
            Assert.Equal(timestamp, actual.Headers.Timestamp);
            Assert.Equal(correlationId, actual.Headers.CorrelationId);
            Assert.Equal(replyTo, actual.Headers.ReplyConfiguration.ToString());
        }

        public void DependencyOrderingWorksWithSubclassesAsWellAsPrimitives()
        {
            var rootObject = new Foo();
            var filler = new Filler();

            var generator = MockRepository.GenerateStub<IGenerateDummyData>();
            generator.Stub(g => g.Generate(Arg<GenerationContext>.Is.Anything)).Return("Chris");

            var dependentGenerator = MockRepository.GenerateStub<IGenerateDummyData>();
            dependentGenerator.Stub(g => g.Generate(Arg<GenerationContext>.Is.Anything))
                .Do(new GeneratorDelegate(context => string.Format("Hello {0}", context.RootAs<Foo>().Bar.Name)));

            filler.Configure<Goo>(config => config.For(goo => goo.Name).Use(dependentGenerator));
            filler.Configure<Bar>(config => config.For(goo => goo.Name).Use(generator));

            filler.Configure<Foo>(config =>
            {
                config.For(f => f.Goo).Order(2);
                config.For(f => f.Bar).Order(1);
            });

            filler.Fill(rootObject);

            Assert.That(rootObject.Goo.Name, Is.EqualTo("Hello Chris"));
        }

        public void TestSerializeRespected()
        {
            var obj = new Foo { X = "abc", Z = "def" }; // don't touch Y...

            string json = JsonSerializer.SerializeToString(obj);
            Assert.That(json, Is.StringMatching("{\"X\":\"abc\",\"Z\":\"def\"}"));   
        }

        public void If_no_exception_occurred_then_changes_are_saved()
        {
            var testDocument = new Foo { Id = "foos/123", Title = "foo" };

            var store = new TestableStore();

            var controller = new TestableController(store);

            StartActionExecuting(controller);

            using (var session = controller.Session)
            {
                session.Store(testDocument);
                session.SaveChanges();

                var doc = session.Load<Foo>(testDocument.Id);
                doc.Title = "bar";

                FinishActionExecuted(controller);
            }

            using (var session = store.OpenSession())
            {
                var doc = session.Load<Foo>(testDocument.Id);
                Assert.Equal("bar", doc.Title);
            }
        }

		public void Export_And_Import_Retains_HiLoState()
		{
			using (var session = documentStore.OpenSession()) {
				var foo = new Foo() { Something = "something2" };
				Assert.Null(foo.Id);
				session.Store(foo);
				Assert.NotNull(foo.Id);
				session.SaveChanges();
			}

			if (File.Exists("hilo-export.dump"))
				File.Delete("hilo-export.dump");
			Smuggler.Smuggler.ExportData(new Smuggler.Smuggler.ExportSpec("http://localhost:8079/", "hilo-export.dump", false, false));
			Assert.True(File.Exists("hilo-export.dump"));

			using (var session = documentStore.OpenSession()) {
				var hilo = session.Load<HiLoKey>("Raven/Hilo/foos");
				Assert.NotNull(hilo);
				Assert.Equal(32, hilo.Max);
			}

			server.Dispose();
			CreateServer();

			Smuggler.Smuggler.ImportData("http://localhost:8079/", "hilo-export.dump");

			using (var session = documentStore.OpenSession()) {
				var hilo = session.Load<HiLoKey>("Raven/Hilo/foos");
				Assert.NotNull(hilo);
				Assert.Equal(32, hilo.Max);
			}
		}

			public void WhenSavingSettings_ThenCanReadThem()
			{
                var manager = new SettingsManager(Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider);

				var foo = new Foo
				{
					StringProperty = "World",
					IntProperty = -1,
					DefaultValueIntProperty = -20,
					DefaultValueAsStringIntProperty = 25,
					EnumProperty = UriFormat.SafeUnescaped,
					DefaultValueEnumProperty = UriFormat.Unescaped,
					ComplexTypeWithConverter = new Bar("BarValue"),
					PingInterval = TimeSpan.FromMinutes(2),
				};

				manager.Save(foo);

				var saved = new Foo();
				manager.Read(saved);

				Assert.Equal("World", saved.StringProperty);
				Assert.Equal("Hello", saved.DefaultValueStringProperty);
				Assert.Equal(-1, saved.IntProperty);
				Assert.Equal(-20, saved.DefaultValueIntProperty);
				Assert.Equal(25, saved.DefaultValueAsStringIntProperty);
				Assert.Equal(UriFormat.SafeUnescaped, saved.EnumProperty);
				Assert.Equal(UriFormat.Unescaped, saved.DefaultValueEnumProperty);
				Assert.NotNull(saved.ComplexTypeWithConverter);
				Assert.Equal("BarValue", saved.ComplexTypeWithConverter.Value);
				Assert.Equal(TimeSpan.FromMinutes(2), saved.PingInterval);
			}