public void W039_ChangeDocumentType()
{
using (var stream = GetStream(TestFiles.Document, true))
using (var package = Package.Open(stream, FileMode.Open, FileAccess.ReadWrite))
using (var doc = WordprocessingDocument.Open(package))
{
doc.ChangeDocumentType(WordprocessingDocumentType.Template);
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
Assert.Equal(2, v.Validate(doc).Count());
}
}
public void W052_CreateElementFromOuterXml()
{
using (var stream = GetStream(TestFiles.UnknownElement))
using (var doc = WordprocessingDocument.Open(stream, false))
{
var mdp = doc.MainDocumentPart;
var cnt = mdp.Document.Descendants().Count();
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
var errs = v.Validate(doc);
Assert.Single(errs);
}
}
public void W021_OuterXml()
{
using (var stream = GetStream(TestFiles.Document))
using (var doc = WordprocessingDocument.Open(stream, false))
{
var mdp = doc.MainDocumentPart;
var firstPara = mdp.Document.Body.FirstChild;
var s = firstPara.OuterXml;
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
Assert.Equal(2, v.Validate(doc).Count());
}
}
public void W041_AddAlternativeFormatImportPart()
{
using (var stream = GetStream(TestFiles.Hyperlink, true))
using (var doc = WordprocessingDocument.Open(stream, true))
{
doc.MainDocumentPart.AddAlternativeFormatImportPart(AlternativeFormatImportPartType.Html);
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
var errs = v.Validate(doc);
Assert.Empty(errs);
}
}
public void P003_PptxCreation_Stream()
{
using (var ms = new MemoryStream())
using (var doc = PresentationDocument.Create(ms, PresentationDocumentType.Presentation))
{
CreatePresentation(doc);
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
var errs = v.Validate(doc);
Assert.Empty(errs);
}
}
private void Bug663834(OpenXmlValidator validator)
{
DocumentFormat.OpenXml.Wordprocessing.StatusText st = new StatusText();
st.Val = "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
var errors = validator.Validate(st);
Assert.Equal(1, errors.Count());
Assert.Equal(ValidationErrorType.Schema, errors.First().ErrorType);
Assert.Equal("Sch_AttributeValueDataTypeDetailed", errors.First().Id);
AssertValidationErrorCategory("Sch_MaxLengthConstraintFailed", errors.First());
Assert.True(errors.First().Description.EndsWith("The length must be smaller than or equal to 140."));
}
private void Bug423988(OpenXmlValidator validator)
{
var shape = new DocumentFormat.OpenXml.Drawing.Spreadsheet.Shape();
shape.TextBody = new DocumentFormat.OpenXml.Drawing.Spreadsheet.TextBody();
var errors = validator.Validate(shape);
Assert.Equal(1, errors.Count());
Assert.Same(shape, errors.First().Node);
Assert.Same(shape.TextBody, errors.First().RelatedNode);
Assert.Equal(ValidationErrorType.Schema, errors.First().ErrorType);
Assert.Equal("Sch_UnexpectedElementContentExpectingComplex", errors.First().Id);
}
private void Bug669663(OpenXmlValidator validator)
{
var framePr = new FrameProperties();
framePr.Height = 32767;
var errors = validator.Validate(framePr);
Assert.Equal(1, errors.Count());
Assert.Equal(ValidationErrorType.Schema, errors.First().ErrorType);
Assert.Equal("Sch_AttributeValueDataTypeDetailed", errors.First().Id);
AssertValidationErrorCategory("Sch_MaxInclusiveConstraintFailed", errors.First());
}
public void W023_NamespaceDeclarations()
{
using (var stream = GetStream(TestFiles.Document))
using (var doc = WordprocessingDocument.Open(stream, false))
{
var mdp = doc.MainDocumentPart;
var firstPara = mdp.Document.Body.FirstChild;
var ns = firstPara.NamespaceDeclarations;
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
Assert.Single(v.Validate(doc));
}
}
public void SemanticErrorValue()
{
var validator = new OpenXmlValidator();
var element = new TestElement
{
Condition = ExpectedConditionValue,
};
var error = Assert.Single(validator.Validate(element));
Assert.Equal("Sem_AttributeRequiredConditionToValue", error.Id);
Assert.Equal(ValidationErrorType.Semantic, error.ErrorType);
}
public void W024_LastChild_LookupPrefix()
{
using (var stream = GetStream(TestFiles.Document))
using (var doc = WordprocessingDocument.Open(stream, false))
{
var mdp = doc.MainDocumentPart;
var firstPara = mdp.Document.Body.LastChild;
var p = firstPara.LookupPrefix("http://schemas.openxmlformats.org/wordprocessingml/2006/main");
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
Assert.Equal(2, v.Validate(doc).Count());
}
}
public void W051_AddNewPart_ToOpenXmlPackage()
{
using (var stream = GetStream(TestFiles.Hyperlink, true))
using (var doc = WordprocessingDocument.Open(stream, true))
{
var pkg = (OpenXmlPackage)doc;
var wpcp = pkg.AddNewPart <RibbonExtensibilityPart>("application/xml", "rid1232131");
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
var errs = v.Validate(doc);
Assert.Empty(errs);
}
}
/// <summary>
/// Validates the file and prints result to console
/// </summary>
/// <param name="file">Path to the file</param>
private static bool ValidateFile(string file)
{
ConsoleColor color = Console.ForegroundColor;
bool isValid = false;
try
{
Console.WriteLine("File name: {0}", file);
OpenXmlValidator validator = new OpenXmlValidator();
using (var doc = GetOpenXmlPackage(file))
{
var errors = validator.Validate(doc);
if (errors.Any())
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Found {0} validation errors: ", errors.Count());
int count = 0;
foreach (ValidationErrorInfo error in errors)
{
count++;
Console.WriteLine("Error " + count);
Console.WriteLine("Part: " + error.Part.Uri);
Console.WriteLine("Description: " + error.Description);
Console.WriteLine("Path: " + error.Path.XPath);
}
}
else
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Document valid");
isValid = true;
}
Console.WriteLine();
}
}
catch (Exception e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Exception occured while validating file: {0} - {1}", e.GetType().ToString(), e.Message);
}
finally
{
Console.ForegroundColor = color;
}
return(isValid);
}
public void PTagWithStyle()
{
using MemoryStream mem = new MemoryStream();
WordDocument doc = new WordDocument(mem);
doc.Process(new HtmlParser(TestUtility.GetHtmlFromFile("/Html/ptagwithstyle.htm")));
Assert.IsNotNull(doc.Document.Body);
Assert.AreEqual(1, doc.Document.Body.ChildElements.Count);
Paragraph para = doc.Document.Body.ChildElements[0] as Paragraph;
Assert.IsNotNull(para);
Assert.AreEqual(1, para.ChildElements.Count);
Run run = para.ChildElements[0] as Run;
Assert.IsNotNull(run);
Assert.AreEqual(2, run.ChildElements.Count);
RunProperties properties = run.ChildElements[0] as RunProperties;
Assert.IsNotNull(properties);
Assert.AreEqual(3, properties.ChildElements.Count);
RunFonts fonts = properties.ChildElements[0] as RunFonts;
Assert.IsNotNull(fonts);
Assert.AreEqual("Arial,Verdana", fonts.Ascii.Value);
Bold bold = properties.ChildElements[1] as Bold;
Assert.IsNotNull(bold);
FontSize fontSize = properties.ChildElements[2] as FontSize;
Assert.IsNotNull(fontSize);
Assert.AreEqual("24", fontSize.Val.Value);
Word.Text text = run.ChildElements[1] as Word.Text;
Assert.IsNotNull(text);
Assert.AreEqual(0, text.ChildElements.Count);
Assert.AreEqual("Test", text.InnerText.Trim());
OpenXmlValidator validator = new OpenXmlValidator();
var errors = validator.Validate(doc.WordprocessingDocument);
errors.PrintValidationErrors();
Assert.AreEqual(0, errors.Count());
}
public void TestRunBackgroundColor()
{
using (MemoryStream mem = new MemoryStream())
{
WordDocument doc = new WordDocument(mem);
doc.Process(new HtmlParser("<p><span style='background-color:#ccc;color:#000'>one</span><span>two</span></p>"));
Assert.IsNotNull(doc.Document.Body);
Assert.AreEqual(1, doc.Document.Body.ChildElements.Count);
Paragraph para = doc.Document.Body.ChildElements[0] as Paragraph;
Assert.IsNotNull(para);
Assert.AreEqual(2, para.ChildElements.Count);
Run run = para.ChildElements[0] as Run;
Assert.IsNotNull(run);
Assert.AreEqual(2, run.ChildElements.Count);
RunProperties properties = run.ChildElements[0] as RunProperties;
Assert.IsNotNull(properties);
Word.Color color = properties.ChildElements[0] as Word.Color;
Assert.IsNotNull(color);
Assert.AreEqual("000000", color.Val.Value);
Word.Shading shading = properties.ChildElements[1] as Word.Shading;
Assert.IsNotNull(shading);
Assert.AreEqual("cccccc", shading.Fill.Value);
Assert.AreEqual(Word.ShadingPatternValues.Clear, shading.Val.Value);
Word.Text text = run.ChildElements[1] as Word.Text;
Assert.IsNotNull(text);
Assert.AreEqual(0, text.ChildElements.Count);
Assert.AreEqual("one", text.InnerText);
run = para.ChildElements[1] as Run;
Assert.IsNotNull(run);
Assert.AreEqual(1, run.ChildElements.Count);
text = run.ChildElements[0] as Word.Text;
Assert.IsNotNull(text);
Assert.AreEqual(0, text.ChildElements.Count);
Assert.AreEqual("two", text.InnerText);
OpenXmlValidator validator = new OpenXmlValidator();
var errors = validator.Validate(doc.WordprocessingDocument);
errors.PrintValidationErrors();
Assert.AreEqual(0, errors.Count());
}
}
public void W007_GetPartById_DeleteParts()
{
using (var stream = GetStream(TestFiles.CommentsDocx, true))
using (var doc = WordprocessingDocument.Open(stream, true))
{
var partList = new[] { doc.MainDocumentPart.GetPartById("rId1") };
doc.MainDocumentPart.DeleteParts(partList);
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
var errs = v.Validate(doc);
Assert.Empty(errs);
}
}
public void W010_HyperlinkRelationships()
{
using (var stream = GetStream(TestFiles.Hyperlink))
using (var doc = WordprocessingDocument.Open(stream, false))
{
var mdp = doc.MainDocumentPart;
var extRels = mdp.HyperlinkRelationships;
var hyperlinkRel = extRels.First();
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
var errs = v.Validate(doc);
Assert.Empty(errs);
}
}
public void W018_RemoveAttributes()
{
using (var stream = GetStream(TestFiles.Document))
using (var doc = WordprocessingDocument.Open(stream, false))
{
var mdp = doc.MainDocumentPart;
var firstPara = mdp.Document.Body.FirstChild;
firstPara.RemoveAttribute("displacedByCustomXml", "http://schemas.openxmlformats.org/wordprocessingml/2006/main");
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
Assert.Equal(2, v.Validate(doc).Count());
}
}
public void W022_InnerXml_InnerText()
{
using (var stream = GetStream(TestFiles.Document))
using (var doc = WordprocessingDocument.Open(stream, false))
{
var mdp = doc.MainDocumentPart;
var firstPara = mdp.Document.Body.FirstChild;
var s = firstPara.InnerXml;
var s2 = firstPara.InnerText;
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
Assert.Single(v.Validate(doc));
}
}
public void TableAllProperties()
{
using (MemoryStream mem = new MemoryStream())
{
WordDocument doc = new WordDocument(mem);
doc.Process(new HtmlParser("<table border='1' style='width:500px' cellpadding='2'><tr><td>1</td><td>2</td></tr><tr><td colspan='2'>1</td></tr></table>"));
OpenXmlValidator validator = new OpenXmlValidator();
var errors = validator.Validate(doc.WordprocessingDocument);
errors.PrintValidationErrors();
Assert.AreEqual(0, errors.Count());
}
}
public void Bug669663(FileFormatVersions version)
{
var validator = new OpenXmlValidator(version);
var framePr = new FrameProperties();
framePr.Height = 32767;
var errors = validator.Validate(framePr);
Assert.Single(errors);
Assert.Equal(ValidationErrorType.Schema, errors.First().ErrorType);
Assert.Equal("Sch_AttributeValueDataTypeDetailed", errors.First().Id);
}
private static void ValidateOpenXml(OpenXmlElement element)
{
OpenXmlValidator validator = new OpenXmlValidator(FileFormatVersions.Office2010);
IEnumerable <ValidationErrorInfo> validationErrors = validator.Validate(element);
var filteredErrors = validationErrors.Where(y =>
y.Description != "The 'http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing:editId' attribute is not declared.");
foreach (var error in filteredErrors)
{
Console.WriteLine("{0} {1}", error.Path.XPath, error.Description);
}
Assert.AreEqual(0, filteredErrors.Count());
}
public void W038_DocxCreation_Package()
{
using (var stream = GetStream(TestFiles.Document, true))
using (var package = Package.Open(stream, FileMode.Open, FileAccess.ReadWrite))
using (var doc = WordprocessingDocument.Open(package))
{
var cnt = doc.MainDocumentPart.Document.Descendants().Count();
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
var errs = v.Validate(doc);
var errcnt = errs.Count();
Assert.True(errcnt == 416 || errcnt == 2); // v3.0 correctly reports fewer errors than v2.5.1
}
}
public void W006_RemoveCommentsPart()
{
using (var stream = GetStream(TestFiles.CommentsDocx, true))
using (var doc = WordprocessingDocument.Open(stream, true))
{
var commentsPart = doc.MainDocumentPart.WordprocessingCommentsPart;
doc.MainDocumentPart.DeletePart(commentsPart);
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
var errs = v.Validate(doc);
Assert.Equal(3, errs.Count());
}
}
public void Bug423998(FileFormatVersions version)
{
var validator = new OpenXmlValidator(version);
var element = new DocumentFormat.OpenXml.Drawing.Spreadsheet.Shape();
var errors = validator.Validate(element);
Assert.Single(errors);
Assert.Equal("The element has incomplete content.".Length, errors.First().Description.LastIndexOf(" List of possible elements expected:"));
element.AppendChild(new DocumentFormat.OpenXml.Drawing.Spreadsheet.TextBody());
var errors2 = validator.Validate(element);
Assert.Equal(2, errors2.Count());
var message1 = errors.First().Description;
var list1 = message1.Substring(message1.IndexOf("List of possible elements expected:"));
var message2 = errors.First().Description;
var list2 = message2.Substring(message2.IndexOf("List of possible elements expected:"));
Assert.Equal(list1, list2);
}
public void W030_DeleteReferenceRelationship2()
{
using (var stream = GetStream(TestFiles.Document, true))
using (var doc = WordprocessingDocument.Open(stream, true))
{
var mdp = doc.MainDocumentPart;
var r = mdp.GetReferenceRelationship("rId26");
mdp.DeleteReferenceRelationship("rId26");
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
Assert.Equal(3, v.Validate(doc).Count());
}
}
public void MaxNumberOfErrorsTest(int maxErrorCount, int expectedErrorCount)
{
using (var stream = GetStream(TestDataStorage.V2FxTestFiles.ForTestCase.Bug539654_529755))
using (var package = SpreadsheetDocument.Open(stream, false))
{
var validator = new OpenXmlValidator(FileFormatVersions.Office2007)
{
MaxNumberOfErrors = maxErrorCount,
};
var errors = validator.Validate(package);
Assert.Equal(expectedErrorCount, errors.Count());
}
}
public void W021_OuterXml()
{
using (var stream = GetStream(TestFiles.Document))
using (var doc = WordprocessingDocument.Open(stream, false))
{
var mdp = doc.MainDocumentPart;
var firstPara = mdp.Document.Body.FirstChild;
var s = firstPara.OuterXml;
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
var errs = v.Validate(doc);
var cnt = errs.Count();
Assert.True(cnt == 416 || cnt == 2); // v3.0 correctly reports fewer errors than v2.5.1
}
}
public void W025_ClearAllAttributes()
{
using (var stream = GetStream(TestFiles.Document))
using (var doc = WordprocessingDocument.Open(stream, false))
{
var mdp = doc.MainDocumentPart;
var firstPara = mdp.Document.Body.LastChild;
firstPara.ClearAllAttributes();
var v = new OpenXmlValidator(FileFormatVersions.Office2013);
Assert.Single(v.Validate(doc));
}
}
/// <summary>
/// Verify that OOXML SDK can properly validate an OOXML file
/// </summary>
/// <param name="filePath">filenae of the file under test</param>
private void VerifyValidator(string filePath)
{
// Get File Information object for the target test file
FileInfo fi = GetTestFileOne(filePath).GetCopy();
Log.VerifyNotNull(fi, "Test File is copied successfully.");
try
{
using (OpenXmlPackage package = OpenXmlDomTestExtension.OpenPackage(fi, true))
{
Log.VerifyNotNull(package, "File is opened successfully.");
OpenXmlValidator validator = new OpenXmlValidator(FileFormatVersions.Office2013);
// Verify the number of validation errrors
Log.VerifyValue(validator.Validate(package).Count(), 0, "Verifying the number of validation errors...Errors = {0}", validator.Validate(package).Count());
if (validator.Validate(package).Count() != 0)
{
foreach (ValidationErrorInfo error in validator.Validate(package))
{
// List error information
Log.Comment("*** Error: {0}", error.Description);
Log.Comment("Type = " + error.ErrorType);
Log.Comment("Node = " + error.Node);
Log.Comment("Parth = " + error.Path);
}
}
}
}
catch (Exception e)
{
Log.Fail("File = {0}, Message = {1}", filePath, e.Message);
}
}
static void Main(string[] args)
{
string newPresentation = "DeckFromImages.pptx";
string presentationTemplate = "PresentationTemplate.pptx";
string presentationFolder = @"C:\Temp\";
string imageFolder = @"C:\Temp";
string[] imageFileExtensions =
new[] { "*.jpg", "*.jpeg", "*.gif", "*.bmp", "*.png", "*.tif" };
// Make a copy of the template presentation. This will throw an
// exception if the template presentation does not exist.
File.Copy(presentationFolder + presentationTemplate,
presentationFolder + newPresentation, true);
// Get the image files in the image folder.
List<string> imageFileNames = GetImageFileNames(imageFolder,
imageFileExtensions);
// Create new slides for the images.
if (imageFileNames.Count() > 0)
CreateSlides(imageFileNames,
presentationFolder + newPresentation);
// Validate the new presentation.
OpenXmlValidator validator = new OpenXmlValidator();
var errors = validator.Validate(
presentationFolder + newPresentation);
if (errors.Count() > 0)
{
Console.WriteLine("The deck creation process completed but " +
"the created presentation failed to validate.");
Console.WriteLine("There are " + errors.Count() +
" errors:\r\n");
DisplayValidationErrors(errors);
}
else
Console.WriteLine("The deck creation process completed and " +
"the created presentation validated with 0 errors.");
}
