public void simple_valid_case_of_configure_object_working()
        {
            Step step = new Step().With("age", 45);
            grammar1.Execute(step, context);

            target.Age.ShouldEqual(45);
        }

        public void using_a_default_value()
        {
            var step = new Step();
            grammar2.Execute(step, context);

            target.Name.ShouldEqual(grammar2.DefaultValue);
        }

        public void execute_with_exceptions()
        {
            grammar = new ReadGrammar<int>("var", x => { throw new NotImplementedException(); });

            Step step = new Step("some grammar").With("var", "1");
            grammar.Execute(step).ShouldEqual(0, 0, 1, 0);
        }

        public void negative_case_for_select()
        {
            var grammar = grammarForId("select1");
            var step = new Step().With("data", "different");

            grammar.Execute(step).Counts.ShouldEqual(0, 1, 0, 0);
        }

 public void step_count_of_a_step_with_child_leaves_and_grand_children()
 {
     Step step = new Step().WithChildren("a", new Step(), new Step(),
                                         new Step().WithChildren("b", new Step()).WithChildren("c", new Step(),
                                                                                               new Step()));
     step.StepCount().ShouldEqual(7);
 }

        public void execute_happy_path()
        {
            Step step = new Step("some grammar").With("var", "13");
            grammar.Execute(step).ShouldEqual(0, 0, 0, 0);

            whatWasRead.ShouldEqual(13);
        }

        public static Step AddStep(this IPartHolder holder, string grammarKey)
        {
            var step = new Step(grammarKey);
            holder.Parts.Add(step);

            return step;
        }

        public void negative_case_with_syntax_error()
        {
            var grammar = grammarForId("div1");
            var step = new Step();

            grammar.Execute(step).Counts.ShouldEqual(0, 0, 0, 1);
        }

        public void positive_case_for_select_verifying_by_display()
        {
            var grammar = grammarForId("select1");
            var step = new Step().With("data", "b");

            grammar.Execute(step).Counts.ShouldEqual(1, 0, 0, 0);
        }

        public void negative_case_against_div()
        {
            var grammar = grammarForId("div1");
            var step = new Step().With("data", "different text");

            grammar.Execute(step).Counts.ShouldEqual(0, 1, 0, 0);
        }

        public void positive_case_against_div()
        {
            var grammar = grammarForId("div1");
            var step = new Step().With("data", "the div text");

            grammar.Execute(step).Counts.ShouldEqual(1, 0, 0, 0);
        }

 public void step_childstepsfor_is_wired_up()
 {
     var step = new Step();
     var child = new Step();
     step.LeafFor("record").Add(child);
     step.LeafFor("record").AllSteps().ShouldContain(child);
     step.LeafFor("something else").AllSteps().ShouldNotContain(child);
 }

        public void happy_path_creates_the_object_and_puts_it_on_the_TestContext()
        {
            Step step = new Step().With("name", "Josh");
            grammar.Execute(step, context);

            context.CurrentObject.ShouldBeOfType<CreateObjectGrammarTarget>()
                .Name.ShouldEqual("Josh");
        }

        public void SetUp()
        {
            _theAddress = null;

            grammar = new ParagraphGrammar();
            expression = new ObjectConstructionExpression<Address>(grammar);

            theStep = new Step();
        }

        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 read_correctly_formatted_step_value()
        {
            Step step = new Step().With("DistanceFromOffice:112.5");
            var row = new SetRow();

            match.ReadExpected(new TestContext(), step, row);

            row.Values["DistanceFromOffice"].ShouldEqual(112.5);
        }

        public void has_checks_the_cache()
        {
            var step = new Step("a");
            step.Has("b").ShouldBeFalse();

            step.Set("b", 123);

            step.Has("b").ShouldBeTrue();
        }

        public void happy_path_does_not_increment_the_counts()
        {
            Step step = new Step().With("name", "Josh");
            grammar.Execute(step, context);

            context.Counts.ShouldEqual(0, 0, 0, 0);
            context.CurrentObject.ShouldBeOfType<CreateObjectGrammarTarget>()
                .Name.ShouldEqual("Josh");
        }

        public void accept_a_visitor()
        {
            var visitor = MockRepository.GenerateMock<ITestVisitor>();

            var step = new Step("a");

            step.AcceptVisitor(visitor);

            visitor.AssertWasCalled(x => x.RunStep(step));
        }

        public void write_preview_when_the_cell_value_is_missing_in_the_step()
        {
            var cell = Cell.For<string>("name");
            var step = new Step();

            var tag = new CellTag(cell, step);
            tag.WritePreview(new TestContext());

            tag.Text().ShouldEqual("MISSING");
        }