public void SutEqualsIdenticalOther(XmlAtomContent sut)
{
var other = sut.WithItem(sut.Item);
var actual = sut.Equals(other);
Assert.True(actual);
}
public void WriteToXmlWriterWritesCorrectXml(
XmlContentSerializer serializer,
XmlAtomContent content,
AtomEntry entry,
XmlAttributedTestEventX tex)
{
// Fixture setup
var sb = new StringBuilder();
using (var w = XmlWriter.Create(sb))
{
var sut = content.WithItem(tex);
// Exercise system
sut.WriteTo(w, serializer);
// Verify outcome
w.Flush();
var expected = XDocument.Parse(
"<content type=\"application/xml\" xmlns=\"http://www.w3.org/2005/Atom\">" +
" <test-event-x xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"http://grean:rocks\">" +
" <number>" + tex.Number + "</number>" +
" <text>" + tex.Text + "</text>" +
" </test-event-x>" +
"</content>");
var actual = XDocument.Parse(sb.ToString());
Assert.Equal(expected, actual, new XNodeEqualityComparer());
// Teardown
}
}
public void ContentIsCorrect(
[Frozen] XmlAtomContent expected,
AtomEntry sut)
{
XmlAtomContent actual = sut.Content;
Assert.Equal(expected, actual);
}
public void GetHashCodeReturnsCorrectResult(XmlAtomContent sut)
{
var actual = sut.GetHashCode();
var expected = sut.Item.GetHashCode();
Assert.Equal(expected, actual);
}
public void SutDoesNotEqualDifferentOther(
XmlAtomContent sut,
XmlAtomContent other)
{
var actual = sut.Equals(other);
Assert.False(actual);
}
public void SutIsNotEqualToAnonymousObject(
XmlAtomContent sut,
object anonymous)
{
var actual = sut.Equals(anonymous);
Assert.False(actual);
}
public void ItemIsCorrect(
[Frozen] object expected,
XmlAtomContent sut)
{
var actual = sut.Item;
Assert.Equal(expected, actual);
}
public void WithContentReturnsCorrectResult(
AtomEntry sut,
XmlAtomContent newContent)
{
AtomEntry actual = sut.WithContent(newContent);
var expected = sut.AsSource().OfLikeness <AtomEntry>()
.With(x => x.Content).EqualsWhen(
(s, d) => object.Equals(newContent, d.Content));
expected.ShouldEqual(actual);
}
public void WithItemReturnsCorrectResult(
XmlAtomContent sut,
object newItem)
{
XmlAtomContent actual = sut.WithItem(newItem);
var expected = actual.AsSource().OfLikeness <XmlAtomContent>()
.With(x => x.Item).EqualsWhen(
(s, d) => object.Equals(newItem, s.Item));
expected.ShouldEqual(actual);
}
public void SutCanRoundTripToString(
XmlContentSerializer serializer,
XmlAtomContent seed,
XmlAttributedTestEventX tex)
{
var expected = seed.WithItem(tex);
var xml = expected.ToXmlString(serializer);
XmlAtomContent actual = XmlAtomContent.Parse(xml, serializer);
Assert.Equal(expected, actual);
}
public void ReadFromReturnsCorrectResult(
XmlContentSerializer serializer,
XmlAtomContent seed,
XmlAttributedTestEventX tex)
{
var expected = seed.WithItem(tex);
using (var sr = new StringReader(expected.ToXmlString(serializer)))
using (var r = XmlReader.Create(sr))
{
XmlAtomContent actual = XmlAtomContent.ReadFrom(r, serializer);
Assert.Equal(expected, actual);
}
}
public void ParseThrowsOnWrongContainingElement(
string startElement,
string endElement,
IContentSerializer dummySerializer)
{
var xml =
startElement +
" <test-event-x xmlns=\"urn:grean:atom-event-store:unit-tests\">" +
" <number>42</number>" +
" <text>Foo</text>" +
" </test-event-x>" +
endElement;
Assert.Throws <ArgumentException>(
() => XmlAtomContent.Parse(
xml,
dummySerializer));
}
public void SutIsXmlWritable(XmlAtomContent sut)
{
Assert.IsAssignableFrom <IXmlWritable>(sut);
}
