public TestModel EndTest(ITestEvaluator evaluator)
 {
      _currentTest.Assessments.Add(evaluator.Name, evaluator.Assess(_currentTest));
      TestModel test = _currentTest;
      _currentTest = null;
      return test;
 }

        public void ValueHelpersWithErrorsGetValueFromModelState()
        {
            // Arrange
            var model = new TestModel()
            {
                StringProperty = "ModelStringPropertyValue",
                ObjectProperty = "ModelObjectPropertyValue",
            };
            var helper = DefaultTemplatesUtilities.GetHtmlHelper<TestModel>(model);
            var viewData = helper.ViewData;
            viewData["StringProperty"] = "ViewDataValue";
            viewData.TemplateInfo.HtmlFieldPrefix = "FieldPrefix";

            var modelState = new ModelState();
            modelState.Value = new ValueProviderResult(
                rawValue: new string[] { "StringPropertyRawValue" },
                attemptedValue: "StringPropertyAttemptedValue",
                culture: CultureInfo.InvariantCulture);
            viewData.ModelState["FieldPrefix.StringProperty"] = modelState;

            modelState = new ModelState();
            modelState.Value = new ValueProviderResult(
                rawValue: new string[] { "ModelRawValue" },
                attemptedValue: "ModelAttemptedValue",
                culture: CultureInfo.InvariantCulture);
            viewData.ModelState["FieldPrefix"] = modelState;

            // Act & Assert
            Assert.Equal("StringPropertyRawValue", helper.Value("StringProperty"));
            Assert.Equal("StringPropertyRawValue", helper.ValueFor(m => m.StringProperty));
            Assert.Equal("ModelRawValue", helper.ValueForModel());
        }

        public void GetNameChainOverload1TestCase2()
        {
            var model = new TestModel();
            var actual = model.GetNameChain( () => model.SubModel.Foo );

            Assert.AreEqual( "SubModel.Foo", actual );
        }

		public void DocumentStoreWorksWhenAddingItemThenDeletingItAndThenGrabbingNonExistingItemAndStoringNewOne()
		{
			using (var documentStore = new EmbeddableDocumentStore { RunInMemory = true }.Initialize())
			{
				documentStore.Conventions.AllowQueriesOnId = true;
				using (var session = documentStore.OpenSession())
				{
					var deletedModel = new TestModel { Id = 1 };
					session.Store(deletedModel);
					session.SaveChanges();

					session.Delete(deletedModel);
					session.SaveChanges();

					TestModel testModelItem = session.Query<TestModel>().SingleOrDefault(t => t.Id == 2) ??
												  new TestModel { Id = 2 };
					Assert.NotNull(testModelItem);
					session.Store(testModelItem);
					session.SaveChanges();

					var list = session.Query<TestModel>()
						.Customize(x => x.WaitForNonStaleResults())
						.ToList();
					Assert.Equal(1, list.Count());
				}
			}
		}

        public void GetNameOverloadTest1()
        {
            var model = new TestModel();
            var actual = model.Name.GetName( () => model.Name );

            Assert.AreEqual( "Name", actual );
        }

        public void OneContextTwoNodes()
        {
            Gtk.Application.Init ();

            string context = "Context1";
            TestModel model = new TestModel();
            /*INode nodeA = */model.CreateAddNode(10, context, new Size(80, 50));
            /*INode nodeB = */model.CreateAddNode(20, context, new Size(100, 40));
            TimelineLayoutManager layout = new TimelineLayoutManager(model);
            layout.Update();

            TestRenderer renderer = new TestRenderer();
            TimelineView view = new TimelineView(model, renderer);

            Gtk.Widget[] children = view.Children;

            Assert.That(children.Length, Is.EqualTo(2));

            Assert.That(children[0].Visible, Is.True);
            Assert.That(children[1].Visible, Is.True);

            int ax = (int) view.ChildGetProperty(children[0], "x").Val;
            int ay = (int) view.ChildGetProperty(children[0], "y").Val;
            int bx = (int) view.ChildGetProperty(children[1], "x").Val;
            int by = (int) view.ChildGetProperty(children[1], "y").Val;

            Assert.That(ay, Is.GreaterThan(0));
            Assert.That(ay, Is.EqualTo(by));

            Assert.That(ax, Is.GreaterThan(0));
            Assert.That(bx, Is.GreaterThan(0));
            Assert.That(ax, Is.Not.EqualTo(bx));
        }

		public void PersistNewObject()
		{
			// Arrange
			Bootstrapper.Start();
			const string Key = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

			var repository = Bootstrapper.AmbientContainer.GetInstance<Repository<TestModel>>();
			var unitOfWorkFactory = Bootstrapper.AmbientContainer.GetInstance<IUnitOfWorkFactory>();
			var unitOfWork = unitOfWorkFactory.CreateUnitOfWork();

			var testModel = new TestModel(Key);

			// Act
			using (unitOfWork.Start())
			{
				repository.Create(testModel);

				unitOfWork.Commit();
			}

			// Assert
			using (unitOfWork.Start())
			{
				var foundModel = repository.Find.OneMatchingExpression(x => x.Key.Equals(Key));

				Assert.That(foundModel != null);
			}
		}

            public void ReturnsRightOwnerWhenUsingAdditionalParentWithIntProperty()
            {
                var testModel = new TestModel();
                var owner = ExpressionHelper.GetOwner(() => testModel.IntProperty);

                Assert.IsTrue(ReferenceEquals(testModel, owner));
            }

        public void GetNameOverloadTest2()
        {
            var model = new TestModel();
            var actual = PropertyChanged.GetName( () => PropertyChanged );

            Assert.AreEqual( "PropertyChanged", actual );
        }

        public void ReturnResultsAsDynamicList()
        {
            // Arrange
            Bootstrapper.Start();

            var unitOfWorkFactory = Bootstrapper.AmbientContainer.GetInstance<IUnitOfWorkFactory>();

            var unitOfWork = unitOfWorkFactory.CreateUnitOfWork();

            var repository = Bootstrapper.AmbientContainer.GetInstance<Repository<TestModel>>();

            const string Key = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

            var testModel = new TestModel(Key);

            IList<dynamic> results;

            // Act
            using (unitOfWork.Start())
            {
                repository.Create(testModel);

                unitOfWork.Commit();

                results = unitOfWork.CurrentSession().CreateSQLQuery("SELECT Key FROM TestModel").AsDynamicList();
            }

            // Assert
            Assert.That(results[0].Key.Equals(Key));
        }

 public void ObjectCache()
 {
     var model = new TestModel() { Id = 101, Name = "TestName" };
     this.helper.Set("TestObject",model);
     TestModel result = this.helper.Get<TestModel>("TestObject");
     Assert.AreEqual(model, result);
 }

		public void ReturnAllMatchingObjects()
		{
			// Arrange
			Bootstrapper.Start();

            var repository = Bootstrapper.AmbientContainer.GetInstance<Repository<TestModel>>();
            var unitOfWorkFactory = Bootstrapper.AmbientContainer.GetInstance<IUnitOfWorkFactory>();
		    var dataCommandProvider = Bootstrapper.AmbientContainer.GetInstance<IDataCommandProvider>();
			var unitOfWork = unitOfWorkFactory.CreateUnitOfWork();

            var testModel01 = new TestModel("ABCDEF");
            var testModel02 = new TestModel("HIJKLM");
            var testModel03 = new TestModel("ABCZZZ");

            // Act
            using (unitOfWork.Start())
            {
                repository.Create(testModel01);
                repository.Create(testModel02);
                repository.Create(testModel03);

                unitOfWork.Commit();
            }

			// Assert
			using (unitOfWork.Start())
			{
				var foundModel = repository.Find.AllMatchingQuery(new TestModelsWithTestPropertiesThatStartWithABC(dataCommandProvider));

				Assert.That(foundModel.Count().Equals(2));
			}
		}

        public void GetNameTest()
        {
            var model = new TestModel();
            var actual = model.GetName( x => x.Age );

            Assert.AreEqual( "Age", actual );
        }

        public void GetNameChainOverload1TestCase1()
        {
            var model = new TestModel();
            var actual = model.GetNameChain( x => model.Age );

            Assert.AreEqual( "Age", actual );
        }

        public void ReturnAllMatchingObjectsGivenAndSpecification()
        {
            // Arrange
            Bootstrapper.Start();

            var repository = Bootstrapper.AmbientContainer.GetInstance<Repository<TestModel>>();
            var unitOfWorkFactory = Bootstrapper.AmbientContainer.GetInstance<IUnitOfWorkFactory>();
            var unitOfWork = unitOfWorkFactory.CreateUnitOfWork();

            var testModel01 = new TestModel("ABCDEF");
            var testModel02 = new TestModel("HIJKLM");
            var testModel03 = new TestModel("ABCXYZ");

            // Act
            using (unitOfWork.Start())
            {
                repository.Create(testModel01);
                repository.Create(testModel02);
                repository.Create(testModel03);

                unitOfWork.Commit();
            }

            // Assert
            using (unitOfWork.Start())
            {
                var foundModel = repository.Find.AllMatchingSpecification(TestModelSpecifications.TestPropertyStartsWithABCAndEndsWithXYZ()).ToList();

                Assert.That(foundModel.Count.Equals(1));
            }
        }

        public void ValidateValidObjectReturnsEmptyListValidationResult()
        {
            var sut = new TestModel() { Name = "Name", SubModel = new SubModel { Property1 = "1" } };

            var validationResults = sut.Validate();

            Assert.Empty(validationResults);
        }

        public void GetNameChainOverload1TestCase4()
        {
            var model = new TestModel();
            Expression<Func<Object>> expression1 = () => model.SubModel.Foo;
            var actual = model.GetNameChain( expression1 );

            Assert.AreEqual( "SubModel.Foo", actual );
        }

 public void BuilderModelLoadAndChangeState()
 {
     // Создадим и изменим.
       TestModel model = new TestModel();
       ((TestProduct)model.MainItem).Id = "777";
       Assert.AreEqual(ModelState.New, model.State);
       Assert.IsNull(model.LoadedFileName);
 }

 public void SetUp()
 {
     _model = new TestModel();
     _router = new StubRouter<TestModel>(_model);
     _stringSubject = new StubSubject<string>();
     _intSubject = new StubSubject<int>();
     _decimalSubject = new StubSubject<decimal>();
 }

        public ActionResult TestUiDateTimeModelAsParameter()
        {
            var model = new TestModel {
                ModelOne = new UiDateTimeModel("US Eastern Standard Time"),
                ModelTwo = new UiDateTimeModel("Pacific Standard Time")
            };

            return View(model);
        }