public void read_incorrectly_formatted_step_value_increments_syntax_error()
        {
            Step step = new Step().With("DistanceFromOffice:abc");
            var context = new TestContext();

            match.ReadExpected(context, step, new SetRow());

            context.Counts.ShouldEqual(0, 0, 0, 1);
        }

        public void SetUp()
        {
            grammar = CheckPropertyGrammar.For<CheckPropertyTarget>(x => x.Age);
            theStep = new Step("grammar");
            context = new TestContext();

            beforeEach();

            then();
        }

        public void SetUp()
        {
            var context = new TestContext(x => { x.AddFixture<FixtureWithHiddenGrammarsFixture>(); });

            var observer = MockRepository.GenerateMock<IFixtureObserver>();
            var builder = new LibraryBuilder(observer, new CompositeFilter<Type>());
            builder.Build(context);

            library = builder.Library;
        }

        public void SetUp()
        {
            grammar1 = new ConfigureObjectGrammar<ConfiguredObject, int>("age", (o, age) => o.Age = age);
            grammar2 = new ConfigureObjectGrammar<ConfiguredObject, string>("name", (o, name) => o.Name = name);
            grammar2.DefaultValue = "Han Solo";

            context = new TestContext();
            target = new ConfiguredObject();

            context.CurrentObject = target;
        }

        public void read_step_successfully_if_it_exists_and_is_formatted_correctly()
        {
            Step step = new Step().With("City:Dallas,Distance:189");
            var row = new SetRow();

            var context = new TestContext();

            _matchCity.As<ISetColumn>().ReadExpected(context, step, row);
            _matchDistance.As<ISetColumn>().ReadExpected(context, step, row);

            row.Values["City"].ShouldEqual("Dallas");
            row.Values["Distance"].ShouldEqual(189);
        }

        public void SetUp()
        {
            var container = new Container();
            var registry = new FixtureRegistry();
            registry.AddFixture<FixtureWithHiddenGrammarsFixture>();
            registry.AddFixturesToContainer(container);
            var context = new TestContext(container);

            var observer = MockRepository.GenerateMock<IFixtureObserver>();
            var builder = new LibraryBuilder(observer, new CompositeFilter<Type>(), new ObjectConverter());

            builder.Build(context);

            library = builder.Library;
        }

        public void SetUp()
        {
            grammar =
                Fixture.VerifyStringList(() => { throw new NotImplementedException(); }).Titled(
                    "The list of strings should be").LeafNameIs("row").Grammar();

            step = new Step("anything").WithChildren("row", new Step(), new Step(), new Step());

            var context = new TestContext();

            grammar.Execute(step, context);
            counts = context.Counts;

            rowResults = context.ResultsFor(step).GetResult<IList<SetRow>>(grammar.LeafName);
            stepResults = context.ResultsFor(step);
        }

        public void FixtureSetup()
        {
            var lifecycle = BrowserForTesting.Use<ChromeBrowser>();

            var context = new TestContext();

            var applicationUnderTest = new StubbedApplicationUnderTest
            {
                Browser = lifecycle
            };

            applicationUnderTest.Driver.Manage().Timeouts().SetScriptTimeout(TimeSpan.FromMilliseconds(1000));

            context.Store<IApplicationUnderTest>(applicationUnderTest);

            SetUp(context);
        }

        public void run_with_a_test_context_func()
        {
            var context = new TestContext();
            var service = new ServiceInContext(){
                Count = 2
            };
            context.Store(service);

            var fact = new FactGrammar(c => c.Retrieve<ServiceInContext>().Count == 2, "the count should be 2");

            fact.Execute(new Step(), context);
            context.Counts.ShouldEqual(1, 0, 0, 0);

            service.Count = 3;
            context.Counts.Reset();

            fact.Execute(new Step(), context);
            context.Counts.ShouldEqual(0, 1, 0, 0);
        }

        public void the_test_is_available_in_the_test_context()
        {
            var test = new Test("some test");
            var context = new TestContext(new Container(), test, new ConsoleListener());

            context.Retrieve<Test>().ShouldBeTheSameAs(test);
        }

 public void throw_argument_not_null_exception_when_the_log_action_is_null()
 {
     var fixture = MockRepository.GenerateMock<IFixture>();
     var context = new TestContext();
     context.LoadFixture(fixture, null);
 }

        public void store_and_retrieve()
        {
            var context = new TestContext();
            var data = new SomeContext();

            context.Store(data);

            context.Retrieve<SomeContext>().ShouldBeTheSameAs(data);
        }

        public void store_and_retrieve_backs_up_by_the_system()
        {
            var returnValue = new SomethingThatDoesNotExist();

            var context = new TestContext()
            {
                BackupResolver = t =>
                {
                    if (t == typeof(ISomethingThatDoesNotExist)) return returnValue;

                    throw new ApplicationException("Unexpected Type:  " + t.FullName);
                }
            };

            context.Retrieve(typeof (ISomethingThatDoesNotExist)).ShouldBeTheSameAs(returnValue);
            context.Retrieve<ISomethingThatDoesNotExist>().ShouldBeTheSameAs(returnValue);
        }

        public void get_startup_type_for_a_name()
        {
            var container = new Container(x =>
            {
                x.For<IStartupAction>().Add<SetUserAction>().Named("SetUser");
                x.For<IStartupAction>().Add<StartWebAppAction>().Named("StartWebApp");
            });

            var context = new TestContext(container);

            context.GetStartupType("SetUser").ShouldEqual(typeof (SetUserAction));
            context.GetStartupType("StartWebApp").ShouldEqual(typeof (StartWebAppAction));
        }

        public void increment_syntax_errors()
        {
            var test = new Test("some test");
            var context = new TestContext(new Container(), test, new ConsoleListener());

            context.IncrementSyntaxErrors();

            context.Counts.ShouldEqual(0, 0, 0, 1);
        }

        public void running_a_step_logs_the_start_and_end_of_the_grammar()
        {
            var step = new Step("the step");

            var listener = MockRepository.GenerateMock<ITestObserver>();
            listener.Expect(x => x.CanContinue(null)).Return(true).IgnoreArguments().Repeat.Any();

            var context = new TestContext(new Container(), new Test("Fake"), listener);
            IGrammar grammar = context.SetupMockGrammar(step.GrammarKey);

            context.RunStep(step);

            listener.AssertWasCalled(x => x.StartStep(step));
            listener.AssertWasCalled(x => x.FinishStep(step));
        }

 public void get_string_for_DbNull()
 {
     var context = new TestContext();
     context.GetDisplay(DBNull.Value).ShouldEqual(Step.NULL);
 }

        public void log_exception_from_section_setup()
        {
            var fixture = MockRepository.GenerateMock<IFixture>();
            var context = new TestContext();

            var exception = new NotImplementedException();
            fixture.Expect(x => x.SetUp(context)).Throw(exception);

            var step = new Step();
            context.LoadFixture(fixture, step);

            context.Counts.Exceptions.ShouldEqual(1);
            context.ResultsFor(step).ExceptionText.ShouldContain(exception.ToString());
        }

 public void get_string_for_empty_string()
 {
     var context = new TestContext();
     context.GetDisplay(string.Empty).ShouldEqual(Step.BLANK);
 }

        public void load_fixture_directly_and_find_object_off_of_it()
        {
            var context = new TestContext();

            context.LoadFixture(new SomethingElseFixture(), new StubTestPart());

            context.FindGrammar("Go").ShouldBeOfType<ValueCheckMethod>();
        }