public void DeserializeObjectParamsStrings()
{
string xml =
@"<?xml version=""1.0""?>
<methodCall>
<methodName>Bar</methodName>
<params>
<param>
<value>
<string>one</string>
</value>
</param>
<param>
<value>
<string>two</string>
</value>
</param>
</params>
</methodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, this.GetType());
Assert.AreEqual(request.method, "Bar", "method is Foo");
Assert.AreEqual(request.args[0].GetType(), typeof(string[]),
"argument is string[]");
Assert.AreEqual((string[])request.args[0], new string[] { "one", "two" },
"argument is params array \"one\", \"two\"");
}
public void NullRequestStream()
{
var serializer = new XmlRpcSerializer();
Stream stm = null;
Assert.Throws <ArgumentNullException>(() => serializer.DeserializeRequest(stm, null));
}
public void DeserializeObjectParams1()
{
string xml =
@"<?xml version=""1.0""?>
<methodCall>
<methodName>Foo1</methodName>
<params>
<param>
<value>
<i4>5678</i4>
</value>
</param>
<param>
<value>
<i4>1</i4>
</value>
</param>
<param>
<value>
<string>one</string>
</value>
</param>
</params>
</methodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, this.GetType());
Assert.AreEqual(request.method, "Foo1", "method is Foo");
Assert.AreEqual((int)request.args[0], 5678, "first argument is int");
Assert.AreEqual(request.args[1].GetType(), typeof(object[]),
"argument is object[]");
Assert.AreEqual((object[])request.args[1], new object[] { 1, "one" },
"second argument is params array 1, \"one\"");
}
public void DeserializeObjectInvalidParams()
{
string xml =
@"<?xml version=""1.0""?>
<methodCall>
<methodName>Bar</methodName>
<params>
<param>
<value>
<string>string one</string>
</value>
</param>
<param>
<value>
<i4>2</i4>
</value>
</param>
</params>
</methodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
try
{
XmlRpcRequest request = serializer.DeserializeRequest(sr,
this.GetType());
Assert.Fail("Should detect invalid type of parameter #2");
}
catch (XmlRpcTypeMismatchException)
{
}
}
public void Base64MultiLine()
{
string xml = @"<?xml version=""1.0""?>
<methodCall>
<methodName>TestHex</methodName>
<params>
<param>
<value>
<base64>AQIDBAUGBwgJ
AQIDBAUGBwg=</base64>
</value>
</param>
</params>
</methodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, null);
Assert.AreEqual(request.args[0].GetType(), typeof(byte[]),
"argument is byte[]");
byte[] ret = (byte[])request.args[0];
Assert.AreEqual(17, ret.Length, "argument is byte[17]");
for (int i = 0; i < 9; i++)
Assert.AreEqual(i + 1, ret[i], "first 9 members are 1 to 9");
for (int i = 0; i < 8; i++)
Assert.AreEqual(i + 1, ret[i + 9], "last 8 members are 1 to 9");
}
public void MissingMethodCall()
{
string xml = @"<?xml version=""1.0"" ?> <elem/>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, null);
}
public void TooManyParameters()
{
string xml = @"<?xml version=""1.0""?>
<methodCall>
<methodName>blogger.getUsersBlogs</methodName>
<params>
<param>
<value>
<string>ffffffabffffffce6dffffff93ffffffac29ffffffc9fffffff826ffffffdefffff
fc9ff\
ffffe43c0b763036ffffffa0fffffff3ffffffa963377716</string>
</value>
</param>
<param>
<value>
<string>myusername</string>
</value>
</param>
<param>
<value>
<string>mypassword</string>
</value>
</param>
</params>
</methodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
Assert.That(() => serializer.DeserializeRequest(sr, GetType()), Throws.TypeOf<XmlRpcInvalidParametersException>());
}
public void MissingMethodCall()
{
string xml = @"<?xml version=""1.0"" ?> <elem/>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
Assert.That(() => serializer.DeserializeRequest(sr, null), Throws.TypeOf<XmlRpcInvalidXmlRpcException>());
}
public void DeserializeObjectParams()
{
var xml =
@"<?xml version=""1.0""?>
<methodCall>
<methodName>Foo</methodName>
<params>
<param>
<value>
<i4>1</i4>
</value>
</param>
<param>
<value>
<string>one</string>
</value>
</param>
</params>
</methodCall>";
var sr = new StringReader(xml);
var serializer = new XmlRpcSerializer();
var request = serializer.DeserializeRequest(sr, GetType());
Assert.AreEqual(request.method, "Foo", "method is Foo");
Assert.AreEqual(request.args[0].GetType(), typeof(object[]),
"argument is object[]");
Assert.AreEqual((object[])request.args[0], new object[] { 1, "one" },
"argument is params array 1, \"one\"");
}
public void Base64()
{
string xml = @"<?xml version=""1.0""?>
<methodCall>
<methodName>TestHex</methodName>
<params>
<param>
<value>
<base64>AQIDBAUGBwg=</base64>
</value>
</param>
</params>
</methodCall>";
var sr = new StringReader(xml);
var serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, null);
Assert.AreEqual(request.args[0].GetType(), typeof(byte[]),
"argument is byte[]");
var ret = (byte[])request.args[0];
Assert.AreEqual(8, ret.Length, "argument is byte[8]");
for (int i = 0; i < ret.Length; i++)
{
Assert.AreEqual(i + 1, ret[i], "members are 1 to 8");
}
}
public void Blakemore()
{
string xml = @"<?xml version=""1.0""?>
<methodCall><methodName>rtx.useArrayOfStruct</methodName>
<params>
<param><value><array>
<data><value>
<struct><member><name>detail</name><value><string>elephant</string></value></member><member><name>number</name><value><int>76</int></value></member></struct>
</value></data>
<data><value>
<struct><member><name>detail</name><value><string>rhino</string></value></member><member><name>number</name><value><int>33</int></value></member></struct>
</value></data>
<data><value>
<struct><member><name>detail</name><value><string>porcupine</string></value></member><member><name>number</name><value><int>106</int></value></member></struct>
</value></data>
</array></value></param>
</params></methodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, GetType());
Assert.AreEqual(request.args[0].GetType(), typeof(simple[]),
"argument is simple[]");
Assert.IsTrue((request.args[0] as simple[]).Length == 1,
"argument is simple[] of length 1");
}
public void EmptyRequestStream()
{
var sr = new StringReader("");
var serializer = new XmlRpcSerializer();
Assert.Throws <XmlRpcIllFormedXmlException>(() => serializer.DeserializeRequest(sr, null));
}
public void StructProperties()
{
string xml = @"<?xml version=""1.0""?>
<methodCall>
<methodName>Foo</methodName>
<params>
<param>
<value>
<struct>
<member>
<name>member1</name>
<value>
<i4>1</i4>
</value>
</member>
<member>
<name>member2</name>
<value>
<i4>2</i4>
</value>
</member>
<member>
<name>member-3</name>
<value>
<i4>3</i4>
</value>
</member>
<member>
<name>member-4</name>
<value>
<i4>4</i4>
</value>
</member>
</struct>
</value>
</param>
</params>
</methodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, null);
Assert.AreEqual(request.args[0].GetType(), typeof(XmlRpcStruct),
"argument is XmlRpcStruct");
XmlRpcStruct xrs = (XmlRpcStruct)request.args[0];
Assert.IsTrue(xrs.Count == 4, "XmlRpcStruct has 4 members");
Assert.IsTrue(xrs.ContainsKey("member1") && (int)xrs["member1"] == 1,
"member1");
Assert.IsTrue(xrs.ContainsKey("member2") && (int)xrs["member2"] == 2,
"member2");
Assert.IsTrue(xrs.ContainsKey("member-3") && (int)xrs["member-3"] == 3,
"member-3");
Assert.IsTrue(xrs.ContainsKey("member-4") && (int)xrs["member-4"] == 4,
"member-4");
}
public void InvalidXml()
{
string xml = @"<?xml version=""1.0"" ?>
<methodCall> </duffMmethodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, null);
}
public void InvalidXml()
{
string xml = @"<?xml version=""1.0"" ?>
<methodCall> </duffMmethodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
Assert.That(() => serializer.DeserializeRequest(sr, null), Throws.TypeOf<XmlRpcIllFormedXmlException>());
}
private static XmlRpcRequest DeserializeRequest(XmlRpcSerializer xmlRpcSerializer,
string serializedRequest, params Type[] parameterTypes)
{
using (MemoryStream memoryStream =
new MemoryStream(xmlRpcSerializer.Encoding.GetBytes(serializedRequest)))
{
return(xmlRpcSerializer.DeserializeRequest(memoryStream, parameterTypes));
} // using
}
public void MissingParams()
{
string xml = @"<?xml version=""1.0"" ?>
<methodCall>
<methodName>TestString</methodName>
</methodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, null);
}
public void NoParam1()
{
string xml = @"<?xml version=""1.0"" ?>
<methodCall>
<methodName>MethodNoArgs</methodName>
<params/>
</methodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, this.GetType());
}
public void DeserializeMassimo()
{
StringReader sr = new StringReader(massimoRequest);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, this.GetType());
Assert.AreEqual(request.method, "Send_Param", "method is Send_Param");
Assert.AreEqual(typeof(string), request.args[0].GetType(),
"argument is string");
Assert.AreEqual(typeof(object[]), request.args[1].GetType(),
"argument is object[]");
}
public void ISO_8859_1()
{
using (Stream stm = new FileStream("iso-8859-1_request.xml",
FileMode.Open, FileAccess.Read)) {
var serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(stm, null);
Assert.AreEqual(request.args[0].GetType(), typeof(string),
"argument is string");
Assert.AreEqual(request.args[0], "hæ hvað segirðu þá",
"argument is 'hæ hvað segirðu þá'");
}
}
public void DateTimeLocales()
{
CultureInfo oldci = Thread.CurrentThread.CurrentCulture;
try
{
foreach (string locale in Utils.GetLocales())
{
try
{
CultureInfo ci = new CultureInfo(locale);
Thread.CurrentThread.CurrentCulture = ci;
if (ci.LCID == 0x401 || // ar-SA (Arabic - Saudi Arabia)
ci.LCID == 0x465 || // div-MV (Dhivehi - Maldives)
ci.LCID == 0x41e) // th-TH (Thai - Thailand)
{
break;
}
DateTime dt = new DateTime(1900, 01, 02, 03, 04, 05);
while (dt < DateTime.Now)
{
Stream stm = new MemoryStream();
XmlRpcRequest req = new XmlRpcRequest();
req.args = new Object[] { dt };
req.method = "Foo";
XmlRpcSerializer ser = new XmlRpcSerializer();
ser.SerializeRequest(stm, req);
stm.Position = 0;
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(stm, null);
Assert.IsTrue(request.args[0] is DateTime,
"argument is DateTime");
DateTime dt0 = (DateTime)request.args[0];
Assert.AreEqual(dt0, dt, "DateTime argument 0");
dt += new TimeSpan(100, 1, 1, 1);
}
}
catch (Exception ex)
{
Assert.Fail(String.Format("unexpected exception {0}: {1}",
locale, ex.Message));
}
}
}
finally
{
Thread.CurrentThread.CurrentCulture = oldci;
}
}
public void DeserializeObjectParamsInsufficientParams()
{
string xml =
@"<?xml version=""1.0""?>
<methodCall>
<methodName>Foo1</methodName>
<params>
</params>
</methodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, this.GetType());
}
public void FlatXml()
{
string xml = @"<?xml version=""1.0"" ?><methodCall><methodName>TestString</methodName><params><param><value>test string</value></param></params></methodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, null);
Assert.AreEqual(request.method, "TestString", "method is TestString");
Assert.AreEqual(request.args[0].GetType(), typeof(string),
"argument is string");
Assert.AreEqual((string)request.args[0], "test string",
"argument is 'test string'");
}
public void EmptyRequestStream()
{
try
{
StringReader sr = new StringReader("");
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, null);
Assert.Fail("Should throw XmlRpcIllFormedXmlException");
}
catch (XmlRpcIllFormedXmlException)
{
}
}
public void EmptyParam1()
{
string xml = @"<?xml version=""1.0"" ?>
<methodCall>
<methodName>TestString</methodName>
<params>
<param/>
</params>
</methodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
Assert.That(() => serializer.DeserializeRequest(sr, null), Throws.TypeOf<XmlRpcInvalidXmlRpcException>());
}
public void ISO_8859_1()
{
var xmlPath = Path.Combine(Utils.AssemblyDirectory, "iso-8859-1_request.xml");
using (Stream stm = new FileStream(xmlPath, FileMode.Open, FileAccess.Read))
{
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(stm, null);
Assert.AreEqual(request.args[0].GetType(), typeof(string),
"argument is string");
Assert.AreEqual((string)request.args[0], "hæ hvað segirðu þá",
"argument is 'hæ hvað segirðu þá'");
}
}
public void NoParam2()
{
string xml = @"<?xml version=""1.0"" ?>
<methodCall>
<methodName>MethodNoArgs</methodName>
<params>
</params>
</methodCall>";
var sr = new StringReader(xml);
var serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, GetType());
//Console.WriteLine("");
}
public void NullRequestStream()
{
try
{
XmlRpcSerializer serializer = new XmlRpcSerializer();
Stream stm = null;
XmlRpcRequest request = serializer.DeserializeRequest(stm, null);
Assert.Fail("Should throw ArgumentNullException");
}
catch (ArgumentNullException)
{
}
}
public Stream Invoke(Stream requestStream)
{
try
{
XmlRpcSerializer serializer = new XmlRpcSerializer();
Type type = this.GetType();
XmlRpcServiceAttribute serviceAttr = (XmlRpcServiceAttribute)
Attribute.GetCustomAttribute(this.GetType(),
typeof(XmlRpcServiceAttribute));
if (serviceAttr != null)
{
if (serviceAttr.XmlEncoding != null)
{
serializer.XmlEncoding = Encoding.GetEncoding(serviceAttr.XmlEncoding);
}
serializer.UseIntTag = serviceAttr.UseIntTag;
serializer.UseStringTag = serviceAttr.UseStringTag;
serializer.UseIndentation = serviceAttr.UseIndentation;
serializer.Indentation = serviceAttr.Indentation;
}
XmlRpcRequest xmlRpcReq
= serializer.DeserializeRequest(requestStream, this.GetType());
XmlRpcResponse xmlRpcResp = Invoke(xmlRpcReq);
Stream responseStream = new MemoryStream();
serializer.SerializeResponse(responseStream, xmlRpcResp);
responseStream.Seek(0, SeekOrigin.Begin);
return(responseStream);
}
catch (Exception ex)
{
XmlRpcFaultException fex;
if (ex is XmlRpcException)
{
fex = new XmlRpcFaultException(0, ((XmlRpcException)ex).Message);
}
else if (ex is XmlRpcFaultException)
{
fex = (XmlRpcFaultException)ex;
}
else
{
fex = new XmlRpcFaultException(0, ex.Message);
}
XmlRpcSerializer serializer = new XmlRpcSerializer();
Stream responseStream = new MemoryStream();
serializer.SerializeFaultResponse(responseStream, fex);
responseStream.Seek(0, SeekOrigin.Begin);
return(responseStream);
}
}
public void DeserializeLinisgreEmptyParam()
{
string xml =
@"<?xml version=""1.0""?>
<methodCall>
<methodName>Linisgre</methodName>
<params>
<param/>
</params>
</methodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, this.GetType());
}
