public void WriteXml(XmlWriter writer)
{
writer.WriteAttributeString("MethodName", MethodName);
writer.WriteAttributeString("MethodDeclaringTypeName", MethodDeclaringTypeName);
writer.WriteAttributeString("ReturnType", ReturnType);
if (!string.IsNullOrWhiteSpace(ThrownExceptionType))
{
writer.WriteAttributeString("ThrownExceptionType", ThrownExceptionType);
}
writer.WriteStartElement("ReturnValue");
Type returnType = Type.GetType(ReturnType);
if (returnType != typeof(void))
{
writer.WriteRaw(XmlSerialiser.Serialise(ReturnValue, returnType, false, true));
}
writer.WriteEndElement();
writer.WriteStartElement("Parameters");
if (Parameters != null)
{
foreach (var parameter in Parameters)
{
writer.WriteRaw(XmlSerialiser.Serialise(parameter, parameter.GetType(), false, true));
}
}
writer.WriteEndElement();
}
public void WhenCharacterSetIsDefaultItIsNotSerialised()
{
var message = new SmsMessage();
var serialiser = new XmlSerialiser();
var serialisedMessage = serialiser.Serialise(message);
Assert.That(serialisedMessage, Is.Not.StringContaining("characterset"));
}
public void WhenSmsMessageIsSerializedThenTheCharacterSetIsSerialisedAsExpected(CharacterSet characterSet, string expectedXml)
{
var message = new SmsMessage {CharacterSet = characterSet};
var serialiser = new XmlSerialiser();
var serialisedMessage = serialiser.Serialise(message);
Assert.That(serialisedMessage, Is.EqualTo(expectedXml));
}
public override string ToString()
{
return(String.Format("Method: '{0}'\nParams: {1}\nOutcome: {2}\nReturn Value: {3}",
Call.MethodName,
XmlSerialiser.Serialise(Call.Parameters),
Pass ? "Pass" : "Fail",
Pass ? SerialiseIfNotNull(Call.ReturnValue) : "Expected: " + ReturnValueOrException(Call.ReturnValue, Call.ThrownExceptionType)
+ "\nActual: " + ReturnValueOrException(ActualCall.ReturnValue, ActualCall.ThrownExceptionType)));
}
public bool Equals(object arg1, object arg2)
{
// TODO: requires serialisation to be unique
var ser1 = arg1 != null ? (string)XmlSerialiser.Serialise(arg1) : "";
var ser2 = arg2 != null ? (string)XmlSerialiser.Serialise(arg2) : "";
return(ser1 == ser2);
}
public void WhenCharacterSetIsSetShouldBeSerialised([Values(CharacterSet.Auto, CharacterSet.GSM, CharacterSet.Unicode)] CharacterSet characterSet)
{
var message = new SmsMessage();
message.CharacterSet = characterSet;
var serialiser = new XmlSerialiser();
var serialisedMessage = serialiser.Serialise(message);
Assert.That(serialiser.Deserialise<SmsMessage>(serialisedMessage).CharacterSet, Is.EqualTo(characterSet));
}
public void WhenSmsMessageIsSerializedThenTheCharacterSetIsSerialisedAsExpected(CharacterSet characterSet, string expectedXml)
{
var message = new SmsMessage {
CharacterSet = characterSet
};
var serialiser = new XmlSerialiser();
var serialisedMessage = serialiser.Serialise(message);
Assert.That(serialisedMessage, Is.EqualTo(expectedXml));
}
public void WriteXml(XmlWriter writer)
{
var type = Value != null?Value.GetType() : Type.GetType(ParameterActualType);
writer.WriteAttributeString("Name", Name);
writer.WriteAttributeString("ParameterActualType", type.AssemblyQualifiedName);
writer.WriteAttributeString("ParameterExpectedType", ParameterExpectedType);
writer.WriteStartElement("Value");
writer.WriteRaw(XmlSerialiser.Serialise(Value, type, false, true));
writer.WriteEndElement();
}
public void MessageCollection_WithoutBlankOriginator_ShouldNotSerialiseOriginator()
{
// Arrange
SmsMessageCollection message = new SmsMessageCollection()
{
Originator = string.Empty
};
XmlSerialiser serialiser = new XmlSerialiser();
// Act
string serialisedXml = serialiser.Serialise(message);
// Assert
var document = XDocument.Parse(serialisedXml);
var originator = document.Element(ns + "messages").Element(ns + "from");
Assert.IsNull(originator);
}
public void MessageCollection_WithoutBlankOriginator_ShouldNotSerialiseOriginator()
{
// Arrange
SmsMessageCollection message = new SmsMessageCollection()
{
Originator = string.Empty
};
XmlSerialiser serialiser = new XmlSerialiser();
// Act
string serialisedXml = serialiser.Serialise(message);
// Assert
var document = XDocument.Parse(serialisedXml);
var originator = document.Element(ns + "messages").Element(ns + "from");
Assert.IsNull(originator);
}
public void Message_WithoutBlankOriginator_ShouldNotSerialiseOriginator()
{
// Arrange
var message = new SmsMessage
{
Originator = string.Empty
};
var serialiser = new XmlSerialiser();
// Act
var serialisedXml = serialiser.Serialise(message);
// Assert
var document = XDocument.Parse(serialisedXml);
var originator = document.Element("message")
.Element("from");
Assert.IsNull(originator);
}
public void Message_WithOriginator_SerialisesOriginator()
{
// Arrange
SmsMessage message = new SmsMessage()
{
Originator = "07000000000"
};
XmlSerialiser serialiser = new XmlSerialiser();
// Act
string serialisedXml = serialiser.Serialise(message);
// Assert
var document = XDocument.Parse(serialisedXml);
var originator = document.Element("message").Element("from");
Assert.IsNotNull(originator);
Assert.AreEqual(message.Originator, originator.Value);
}
public void MessageCollection_WithOriginator_SerialisesOriginator()
{
// Arrange
SmsMessageCollection messages = new SmsMessageCollection()
{
Originator = "07000000000"
};
XmlSerialiser serialiser = new XmlSerialiser();
// Act
string serialisedXml = serialiser.Serialise(messages);
// Assert
var document = XDocument.Parse(serialisedXml);
var originator = document.Element(ns + "messages").Element(ns + "from");
Assert.IsNotNull(originator);
Assert.AreEqual(messages.Originator, originator.Value);
}
public void Message_WithoutBlankOriginator_ShouldNotSerialiseOriginator()
{
// Arrange
var message = new SmsMessage
{
Originator = string.Empty
};
var serialiser = new XmlSerialiser();
// Act
var serialisedXml = serialiser.Serialise(message);
// Assert
var document = XDocument.Parse(serialisedXml);
var originator = document.Element("message")
.Element("from");
Assert.IsNull(originator);
}
public void Message_WithOriginator_SerialisesOriginator()
{
// Arrange
var message = new SmsMessage
{
Originator = "07000000000"
};
var serialiser = new XmlSerialiser();
// Act
var serialisedXml = serialiser.Serialise(message);
// Assert
var document = XDocument.Parse(serialisedXml);
var originator = document.Element("message")
.Element("from");
Assert.IsNotNull(originator);
Assert.AreEqual(message.Originator, originator.Value);
}
public int GetHashCode(object arg1)
{
return((arg1 != null ? (string)XmlSerialiser.Serialise(arg1) : "").GetHashCode());
}
public void MessageCollection_WithOriginator_SerialisesOriginator()
{
// Arrange
var messages = new SmsMessageCollection
{
Originator = "07000000000"
};
var serialiser = new XmlSerialiser();
// Act
var serialisedXml = serialiser.Serialise(messages);
// Assert
var document = XDocument.Parse(serialisedXml);
var originator = document.Element(ns + "messages")
.Element(ns + "from");
Assert.IsNotNull(originator);
Assert.AreEqual(messages.Originator, originator.Value);
}
private string SerialiseIfNotNull(object returnValue)
{
return(returnValue != null?XmlSerialiser.Serialise(returnValue) : "null");
}
private static bool IsMatchingParams(Parameter[] invokedParams, Parameter[] historyParams)
{
foreach (var param in invokedParams)
{
var matchedName = historyParams.FirstOrDefault(x => x.Name == param.Name);
if (matchedName == null)
{
return(false);
}
if (matchedName.ParameterActualType != param.ParameterActualType)
{
return(false);
}
if (matchedName.ParameterExpectedType != param.ParameterExpectedType)
{
return(false);
}
bool matchValueIsNull = matchedName.Value == null;
bool parameterIsNull = param.Value == null;
if (matchValueIsNull ^ parameterIsNull)
{
return(false);
}
if (!(matchValueIsNull || parameterIsNull) &&
XmlSerialiser.Serialise(matchedName.Value) != XmlSerialiser.Serialise(param.Value))
{
return(false); // TODO: requires serialisation to be unique
}
}
foreach (var param in historyParams)
{
var matchedName = invokedParams.FirstOrDefault(x => x.Name == param.Name);
if (matchedName == null)
{
return(false);
}
if (matchedName.ParameterActualType != param.ParameterActualType)
{
return(false);
}
if (matchedName.ParameterExpectedType != param.ParameterExpectedType)
{
return(false);
}
bool matchValueIsNull = matchedName.Value == null;
bool parameterIsNull = param.Value == null;
if (matchValueIsNull ^ parameterIsNull)
{
return(false);
}
if (!(matchValueIsNull || parameterIsNull) &&
XmlSerialiser.Serialise(matchedName.Value) != XmlSerialiser.Serialise(param.Value))
{
return(false); // TODO: requires serialisation to be unique
}
}
return(true);
}
