public void ChildCanBeParagraph()
        {
            var paragraph = new ParagraphProxy();

            this.testee.Add(paragraph);

            this.testee.Children.Should().Contain(paragraph);
        }
        public void HasChildrenInAddedOrder()
        {
            var firstChild = new ParagraphProxy();
            var secondChild = new ParagraphProxy();

            this.testee.Add(firstChild);
            this.testee.Add(secondChild);

            this.testee.Children.Should().ContainInOrder(firstChild, secondChild);
        }
 public override void VisitParagraphStart(ParagraphProxy paragraph)
 {
     if (this.displayOptions.IncludeFormatting)
     {
         this.builder
             .AppendFormat(
                 "<Paragraph {0}>",
                 FormatAttributes(
                     new NamedValue("StyleIdentifier", paragraph.Format.StyleIdentifier),
                     new NamedValue("StyleName", paragraph.Format.StyleName)))
             .AppendLine();
     }
     else
     {
         this.builder.AppendLine("<Paragraph>");
     }
 }
 public override void VisitParagraphEnd(ParagraphProxy paragraph)
 {
     this.builder.AppendLine("</Paragraph>");
 }
        public void AddsBookmarkEndsToParagraph_WhenStartVisitingFromParagraph()
        {
            const string FirstBookmarkName = "Bookmark 1";
            const string SecondBookmarkName = "Bookmark 2";
            var builder = new DocumentBuilder();
            builder.StartBookmark(FirstBookmarkName);
            builder.EndBookmark(FirstBookmarkName);
            builder.StartBookmark(SecondBookmarkName);
            builder.EndBookmark(SecondBookmarkName);
            Paragraph paragraph = builder.Document.FirstSection.Body.FirstParagraph;

            var paragraphProxy = new ParagraphProxy();
            var firstBookmarkEndProxy = A.Fake<BookmarkEndProxy>();
            var secondBookmarkEndProxy = A.Fake<BookmarkEndProxy>();

            A.CallTo(() => this.proxyFactory.CreateParagraph()).Returns(paragraphProxy);
            A.CallTo(() => this.proxyFactory.CreateBookmarkEnd(FirstBookmarkName)).Returns(firstBookmarkEndProxy);
            A.CallTo(() => this.proxyFactory.CreateBookmarkEnd(SecondBookmarkName)).Returns(secondBookmarkEndProxy);

            paragraph.Accept(this.testee);

            paragraphProxy.Children.Should().ContainInOrder(firstBookmarkEndProxy, secondBookmarkEndProxy);
        }
        public void AddsRunsToParagraph_WhenStartVisitingFromParagraph()
        {
            var builder = new DocumentBuilder();
            builder.Write("FirstRun");
            builder.Write("SecondRun");
            Paragraph paragraph = builder.Document.FirstSection.Body.FirstParagraph;

            var paragraphProxy = new ParagraphProxy();
            var firstRunProxy = A.Fake<RunProxy>();
            var secondRunProxy = A.Fake<RunProxy>();

            A.CallTo(() => this.proxyFactory.CreateParagraph()).Returns(paragraphProxy);
            A.CallTo(() => this.proxyFactory.CreateRun(A<string>._)).ReturnsNextFromSequence(firstRunProxy, secondRunProxy);

            paragraph.Accept(this.testee);

            paragraphProxy.Children.Should().HaveCount(2)
                .And.ContainInOrder(firstRunProxy, secondRunProxy);
        }
        public void AddsRunsToParagraph_WhenStartVisitingFromCell()
        {
            Cell cell = CreateDocumentWithTables(1, 1, 1).FirstSection.Body.Tables[0].FirstRow.FirstCell;
            var firstRun = new Run(cell.Document);
            var secondRun = new Run(cell.Document);
            cell.FirstParagraph.AppendChild(firstRun);
            cell.FirstParagraph.AppendChild(secondRun);

            var paragraphProxy = new ParagraphProxy();
            var firstRunProxy = A.Fake<RunProxy>();
            var secondRunProxy = A.Fake<RunProxy>();

            A.CallTo(() => this.proxyFactory.CreateParagraph()).Returns(paragraphProxy);
            A.CallTo(() => this.proxyFactory.CreateRun(A<string>._)).ReturnsNextFromSequence(firstRunProxy, secondRunProxy);

            cell.Accept(this.testee);

            paragraphProxy.Children.Should().HaveCount(2)
                .And.ContainInOrder(firstRunProxy, secondRunProxy);
        }
        public void AddsParagraphsToCell_WhenStartVisitingFromRow()
        {
            Row row = CreateDocumentWithTables(1, 1, 1).FirstSection.Body.Tables[0].FirstRow;
            var secondParagraph = new Paragraph(row.Document);
            row.FirstCell.AppendChild(secondParagraph);

            var cellProxy = new CellProxy();
            var firstParagraphProxy = new ParagraphProxy();
            var secondParagraphProxy = new ParagraphProxy();

            A.CallTo(() => this.proxyFactory.CreateCell()).Returns(cellProxy);
            A.CallTo(() => this.proxyFactory.CreateParagraph()).ReturnsNextFromSequence(firstParagraphProxy, secondParagraphProxy);

            row.Accept(this.testee);

            cellProxy.Children.Should().HaveCount(2)
                .And.ContainInOrder(firstParagraphProxy, secondParagraphProxy);
        }
        public void AddsFieldStartToParagraph_WhenStartVisitingFromParagraph()
        {
            var builder = new DocumentBuilder();
            builder.InsertField("PAGE");

            Paragraph paragraph = builder.Document.FirstSection.Body.LastParagraph;

            var paragraphProxy = new ParagraphProxy();
            var fieldStartProxy = A.Fake<FieldStartProxy>();

            A.CallTo(() => this.proxyFactory.CreateParagraph()).Returns(paragraphProxy);
            A.CallTo(() => this.proxyFactory.CreateFieldStart()).Returns(fieldStartProxy);

            paragraph.Accept(this.testee);

            paragraphProxy.Children.Should().Contain(fieldStartProxy);
        }
 public ParagraphProxyFacts()
 {
     this.testee = new ParagraphProxy();
 }