Exemple #1
0
 public void CanDoFileBasedCloneSpreadsheet()
 {
     using (var tempFile = TemporaryFile.Create())
         using (var stream = GetStream(TestFiles.Spreadsheet))
             using (var source = SpreadsheetDocument.Open(stream, false))
                 using (source.Clone(tempFile.Path, false))
                     using (var dest = SpreadsheetDocument.Open(tempFile.Path, false))
                     {
                         PackageAssert.Equal(source, dest);
                     }
 }
Exemple #2
0
 public void CanDoFileBasedClonePresentation()
 {
     using (var tempFile = TemporaryFile.Create())
         using (var stream = GetStream(TestFiles.Presentation))
             using (var source = PresentationDocument.Open(stream, false))
                 using (source.Clone(tempFile.Path, false))
                     using (var dest = PresentationDocument.Open(tempFile.Path, false))
                     {
                         PackageAssert.Equal(source, dest);
                     }
 }
        public void CanCreateFlatOpcPresentationDocuments3()
        {
            using (var inputStream = GetStream(TestFiles.Presentation))
                using (var source = PresentationDocument.Open(inputStream, false))
                {
                    var flatOpcDoc = source.ToFlatOpcDocument();

                    using (var tempFile = TemporaryFile.Create())
                        using (PresentationDocument.FromFlatOpcDocument(flatOpcDoc, tempFile.Path, false))
                            using (var dest = PresentationDocument.Open(tempFile.Path, false))
                            {
                                PackageAssert.Equal(source, dest);
                            }
                }
        }
        public void CanCreateFlatOpcWordprocessingDocuments7()
        {
            using (var inputStream = GetStream(TestFiles.Document))
                using (var source = WordprocessingDocument.Open(inputStream, false))
                {
                    var flatOpcString = source.ToFlatOpcString();

                    using (var tempFile = TemporaryFile.Create())
                        using (WordprocessingDocument.FromFlatOpcString(flatOpcString, tempFile.Path, false))
                            using (var dest = WordprocessingDocument.Open(tempFile.Path, false))
                            {
                                PackageAssert.Equal(source, dest);
                            }
                }
        }
        public void CanCreateFlatOpcDocuments7()
        {
            using (var inputStream = GetStream(Path))
                using (var source = Open(inputStream, false))
                {
                    var flatOpcString = source.ToFlatOpcString();

                    using (var tempFile = TemporaryFile.Create())
                        using (FromFlatOpcString(flatOpcString, tempFile.Path, false))
                            using (var dest = Open(tempFile.Path, false))
                            {
                                PackageAssert.Equal(source, dest);
                            }
                }
        }
Exemple #6
0
        public void CanSaveAsPowerpoint()
        {
            using (var stream = GetStream(TestFiles.Presentation))
                using (var source = PresentationDocument.Open(stream, false))
                    using (var tempFile = TemporaryFile.Create())
                    {
                        using (source.SaveAs(tempFile.Path))
                        {
                        }

                        using (var dest = PresentationDocument.Open(tempFile.Path, false))
                        {
                            PackageAssert.Equal(source, dest);
                        }
                    }
        }
Exemple #7
0
        public void CanSaveAsExcel()
        {
            using (var tempFile = TemporaryFile.Create())
                using (var stream = GetStream(TestFiles.Spreadsheet))
                    using (var source = SpreadsheetDocument.Open(stream, false))
                    {
                        using (source.SaveAs(tempFile.Path))
                        {
                        }

                        using (var dest = SpreadsheetDocument.Open(tempFile.Path, false))
                        {
                            PackageAssert.Equal(source, dest);
                        }
                    }
        }
Exemple #8
0
        public void CanSaveAsWord()
        {
            using (var tempFile = TemporaryFile.Create())
                using (var stream = GetStream(TestFiles.Document))
                    using (var source = WordprocessingDocument.Open(stream, false))
                    {
                        using (source.SaveAs(tempFile.Path))
                        {
                        }

                        using (var dest = WordprocessingDocument.Open(tempFile.Path, false))
                        {
                            PackageAssert.Equal(source, dest);
                        }
                    }
        }
Exemple #9
0
        public void CanWildlyCloneAndFlush()
        {
            using (var input = GetStream(TestFiles.Document, true))
                using (var wordDoc = WordprocessingDocument.Open(input, true))
                {
                    Parallel.For(0, 10, index =>
                    {
                        using (var clone = (WordprocessingDocument)wordDoc.Clone())
                        {
                            var secondClone = (WordprocessingDocument)clone.Clone();
                            secondClone.MainDocumentPart.Document.Body
                            .GetFirstChild <Paragraph>()
                            .InsertBeforeSelf(new Paragraph(new Run(new Text("Changes."))));
                            secondClone.Package.Flush();

                            // Change the main document part.
                            clone.MainDocumentPart.Document.Body
                            .GetFirstChild <Paragraph>()
                            .InsertBeforeSelf(new Paragraph(new Run(new Text("Changes."))));

                            // Create a new Custom XML part.
                            var part = clone.MainDocumentPart.AddCustomXmlPart(CustomXmlPartType.CustomXml);

                            using (var stream = part.GetStream())
                                using (var xw = XmlWriter.Create(stream))
                                    using (var docProperties = GetStream(TestFiles.DocPropertiesPath))
                                    {
                                        XElement.Load(docProperties).WriteTo(xw);
                                    }

                            // Flush the clone (the removal of which fixed the original error).
                            clone.Package.Flush();

                            var thirdClone = (WordprocessingDocument)clone.Clone();
                            thirdClone.MainDocumentPart.Document.Body
                            .GetFirstChild <Paragraph>()
                            .InsertBeforeSelf(new Paragraph(new Run(new Text("Changes."))));
                            thirdClone.Package.Flush();

                            using (var tempFile = TemporaryFile.Create())
                            {
                                clone.SaveAs(tempFile.Path).Close();
                            }
                        }
                    });
                }
        }
Exemple #10
0
        public void CanCloneDocument()
        {
            using (var file = TemporaryFile.Create())
            {
                using (var stream = GetStream(TestFiles.Document))
                    using (var source = WordprocessingDocument.Open(stream, false))
                        using (var clone = (WordprocessingDocument)source.Clone())
                        {
                            var body = clone.MainDocumentPart.Document.Body;
                            body.InsertBefore(new Paragraph(new Run(new Text("Hello World"))), body.FirstChild);
                            clone.SaveAs(file.Path).Close();

                            using (var dest = WordprocessingDocument.Open(file.Path, false))
                            {
                                PackageAssert.NotEqual(source, dest);
                            }
                        }
            }
        }
Exemple #11
0
        public void CanCloneDocument()
        {
            using (var file = TemporaryFile.Create())
            {
                using (var stream = GetStream(TestFiles.Document))
                    using (var source = WordprocessingDocument.Open(stream, false))
                        using (var clone = (WordprocessingDocument)source.Clone())
                        {
                            var body = clone.MainDocumentPart.Document.Body;
                            body.InsertBefore(new Paragraph(new Run(new Text("Hello World"))), body.FirstChild);
                            clone.SaveAs(file.Path).Close();

                            using (var dest = WordprocessingDocument.Open(file.Path, false))
                            {
                                // We want the documents to be different.
                                Assert.Throws <Xunit.Sdk.EqualException>(() => PackageAssert.Equal(source, dest));
                            }
                        }
            }
        }
Exemple #12
0
        public void CanDoMultithreadedMultipleCloning()
        {
            using (var stream = GetStream(TestFiles.Document, true))
                using (var source = WordprocessingDocument.Open(stream, true))
                {
                    Parallel.For(0, 10, index =>
                    {
                        using (var clone1 = (WordprocessingDocument)source.Clone())
                        {
                            var body1 = clone1.MainDocumentPart.Document.Body;
                            body1.GetFirstChild <Paragraph>()
                            .InsertBeforeSelf(new Paragraph(new Run(new Text("Clone 1"))));

                            using (var tempFile = TemporaryFile.Create())
                                using (var clone2 = (WordprocessingDocument)clone1.SaveAs(tempFile.Path))
                                {
                                    var body2 = clone2.MainDocumentPart.Document.Body;
                                    body2.GetFirstChild <Paragraph>()
                                    .InsertBeforeSelf(new Paragraph(new Run(new Text("Clone 2"))));
                                }

                            // Clone clone1 again.
                            var clone3 = (WordprocessingDocument)clone1.Clone();
                            var body3  = clone3.MainDocumentPart.Document.Body;
                            body3.GetFirstChild <Paragraph>()
                            .InsertBeforeSelf(new Paragraph(new Run(new Text("Clone 3"))));
                            clone3.Close();

                            // Clone source again.
                            var clone4 = (WordprocessingDocument)source.Clone();
                            var body4  = clone4.MainDocumentPart.Document.Body;
                            body4.GetFirstChild <Paragraph>()
                            .InsertBeforeSelf(new Paragraph(new Run(new Text("Clone 4"))));
                            clone4.Close();
                        }
                    });
                }
        }