Unit Testing of a Xml Parser class

The parsing of the Xml and the displaying of error messages are separate concerns, so your parser should not have any knowledge about how the error messages are displayed.

Depending on your needs, there are a few options:

Exceptions

I often live by the rule: "If a method can't do it's job, throw an exception". If you need to stop at the first error, exceptions are the way to go.

From a unit test perspective, if you pass in illegal data, verify that the code throws an exception using the [ExpectedException] attribute.

[TestMethod, ExpectedException(typeof(ParserValidationException))]
public void IllegalDataShouldThrowValidationErrors()
{
    var parser = new MyParser();
    parser.Parse( dataThatContainsErrors );
}

However, if your need to ignore illegal data and report errors, you might want a different approach.

Specialized Return Type

If you need to collect all the errors, it's best to keep the parsed result and the errors together as an object.

public class ParsedResult<T>
{
    public T Result;
    public List<string> Warnings;
}

From a unit test perspective, you should verify that the list of warnings isn't empty if you pass in illegal data.

[TestMethod]
public void ParsedResultsForIllegalDataShouldContainWarnings()
{
    var parsedResult = new MyParser.Parse<Foo>( dataThatContainsErrors );

    Assert.IsNotNull(parsedResult);
    Assert.IsNotNull(parsedResult.Result);
    Assert.AreEqual(1, parsedResult.Warnings.Count);
}

Error Reporter

Pass in a collaborator into the object and have it report it's findings.

public ObjectToReturn Parse(string xml, IProgressReporter progress)
{
     // create xml reader
     // read values from xml
     // if a value is invalid, log it
     progress.AddMessage( "property x was invalid. ")
}

The progress reporter can be a wrapper around your MessageBox, or it could be a Console output, Logger, etc. From a unit test perspective, you can either create a Test Double that captures the messages, or you can use a mock framework and verify that it was called a certain amount of times. Here's an example that uses Moq.

var mockReporter = new Mock<IProgressReporter>();
IProgressReporter reporter = mockReporter.Object;

var parser = new MyParser();
var illegalData = // your illegal data;

var result = parser.Parse( illegalData, parser);

Assert.IsNotNull(result, "The value was not parsed correctly.");
mockReporter.Verify( r => r.AddMessage( It.IsAny<string>() ), Times.AtLeast(1));