1 files changed, 207 insertions, 0 deletions
diff --git a/test/Validator.cpp b/test/Validator.cpp
new file mode 100644
index 0000000..16d2e79
--- /dev/null
+++ b/test/Validator.cpp
@@ -0,0 +1,207 @@
+// Validator.cpp : XMLRPC server based on the compliancy test at validator.xmlrpc.com.
+//
+#include "XmlRpc.h"
+using namespace XmlRpc;
+
+#include <iostream>
+
+
+XmlRpcServer s;
+
+
+// One argument is passed, an array of structs, each with a member named curly with 
+// an integer value. Return the sum of those values.
+
+class ArrayOfStructsTest : public XmlRpcServerMethod
+{
+public:
+  ArrayOfStructsTest(XmlRpcServer* s) : XmlRpcServerMethod("validator1.arrayOfStructsTest", s) {}
+
+  void execute(XmlRpcValue& params, XmlRpcValue& result)
+  {
+    std::cerr << "ArrayOfStructsTest\n";
+    XmlRpcValue& arg1 = params[0];
+    int n = arg1.size(), sum = 0;
+    for (int i=0; i<n; ++i) 
+      sum += int(arg1[i]["curly"]);
+
+    result = sum;
+  }
+} arrayOfStructsTest(&s);
+
+
+// This handler takes a single parameter, a string, that contains any number of predefined 
+// entities, namely <, >, &, ' and ".
+// The handler must return a struct that contains five fields, all numbers: ctLeftAngleBrackets, 
+// ctRightAngleBrackets, ctAmpersands, ctApostrophes, ctQuotes. 
+// To validate, the numbers must be correct.
+
+class CountTheEntities : public XmlRpcServerMethod
+{
+public:
+  CountTheEntities(XmlRpcServer* s) : XmlRpcServerMethod("validator1.countTheEntities", s) {}
+
+  void execute(XmlRpcValue& params, XmlRpcValue& result)
+  {
+    std::cerr << "CountTheEntities\n";
+    std::string& arg = params[0];
+    int ctLeftAngleBrackets = 0;
+    int ctRightAngleBrackets = 0;
+    int ctAmpersands = 0;
+    int ctApostrophes = 0;
+    int ctQuotes = 0;
+
+    int n = int(arg.length());
+    for (int i=0; i<n; ++i)
+      switch (arg[i])
+      {
+        case '<': ++ctLeftAngleBrackets; break;
+        case '>': ++ctRightAngleBrackets; break;
+        case '&': ++ctAmpersands; break;
+        case '\'': ++ctApostrophes; break;
+        case '\"': ++ctQuotes; break;
+      }
+
+    result["ctLeftAngleBrackets"] = ctLeftAngleBrackets;
+    result["ctRightAngleBrackets"] = ctRightAngleBrackets;
+    result["ctAmpersands"] = ctAmpersands;
+    result["ctApostrophes"] = ctApostrophes;
+    result["ctQuotes"] = ctQuotes;
+  }
+} countTheEntities(&s);
+
+
+
+// This handler takes a single parameter, a struct, containing at least three elements 
+// named moe, larry and curly, all <i4>s. Your handler must add the three numbers and 
+// return the result.
+
+class EasyStructTest : public XmlRpcServerMethod
+{
+public:
+  EasyStructTest(XmlRpcServer* s) : XmlRpcServerMethod("validator1.easyStructTest", s) {}
+
+  void execute(XmlRpcValue& params, XmlRpcValue& result)
+  {
+    std::cerr << "EasyStructTest\n";
+    XmlRpcValue& arg1 = params[0];
+    int sum = int(arg1["moe"]) + int(arg1["larry"]) + int(arg1["curly"]);
+    result = sum;
+  }
+} easyStructTest(&s);
+
+
+// This handler takes a single parameter, a struct. Your handler must return the struct.
+
+class EchoStructTest : public XmlRpcServerMethod
+{
+public:
+  EchoStructTest(XmlRpcServer* s) : XmlRpcServerMethod("validator1.echoStructTest", s) {}
+
+  void execute(XmlRpcValue& params, XmlRpcValue& result)
+  {
+    std::cerr << "EchoStructTest\n";
+    result = params[0];
+  }
+} echoStructTest(&s);
+
+
+
+// This handler takes six parameters, and returns an array containing all the parameters.
+
+class ManyTypesTest : public XmlRpcServerMethod
+{
+public:
+  ManyTypesTest(XmlRpcServer* s) : XmlRpcServerMethod("validator1.manyTypesTest", s) {}
+
+  void execute(XmlRpcValue& params, XmlRpcValue& result)
+  {
+    std::cerr << "ManyTypesTest\n";
+    result = params;
+  }
+} manyTypesTest(&s);
+
+
+
+// This handler takes a single parameter, which is an array containing between 100 and 
+// 200 elements. Each of the items is a string, your handler must return a string 
+// containing the concatenated text of the first and last elements.
+
+
+class ModerateSizeArrayCheck : public XmlRpcServerMethod
+{
+public:
+  ModerateSizeArrayCheck(XmlRpcServer* s) : XmlRpcServerMethod("validator1.moderateSizeArrayCheck", s) {}
+
+  void execute(XmlRpcValue& params, XmlRpcValue& result)
+  {
+    std::cerr << "ModerateSizeArrayCheck\n";
+    std::string s = params[0][0];
+    s += params[0][params[0].size()-1];
+    result = s;
+  }
+} moderateSizeArrayCheck(&s);
+
+
+// This handler takes a single parameter, a struct, that models a daily calendar.
+// At the top level, there is one struct for each year. Each year is broken down
+// into months, and months into days. Most of the days are empty in the struct
+// you receive, but the entry for April 1, 2000 contains a least three elements
+// named moe, larry and curly, all <i4>s. Your handler must add the three numbers
+// and return the result.
+
+class NestedStructTest : public XmlRpcServerMethod
+{
+public:
+  NestedStructTest(XmlRpcServer* s) : XmlRpcServerMethod("validator1.nestedStructTest", s) {}
+
+  void execute(XmlRpcValue& params, XmlRpcValue& result)
+  {
+    std::cerr << "NestedStructTest\n";
+    XmlRpcValue& dayStruct = params[0]["2000"]["04"]["01"];
+    int sum = int(dayStruct["moe"]) + int(dayStruct["larry"]) + int(dayStruct["curly"]);
+    result = sum;
+  }
+} nestedStructTest(&s);
+
+
+
+// This handler takes one parameter, and returns a struct containing three elements, 
+// times10, times100 and times1000, the result of multiplying the number by 10, 100 and 1000.
+
+class SimpleStructReturnTest : public XmlRpcServerMethod
+{
+public:
+  SimpleStructReturnTest(XmlRpcServer* s) : XmlRpcServerMethod("validator1.simpleStructReturnTest", s) {}
+
+  void execute(XmlRpcValue& params, XmlRpcValue& result)
+  {
+    std::cerr << "SimpleStructReturnTest\n";
+    int n = params[0];
+    result["times10"] = n * 10;
+    result["times100"] = n * 100;
+    result["times1000"] = n * 1000;
+  }
+} simpleStructReturnTest(&s);
+
+
+
+int main(int argc, char* argv[])
+{
+  if (argc != 2) {
+    std::cerr << "Usage: Validator port\n";
+    return -1;
+  }
+  int port = atoi(argv[1]);
+
+  XmlRpc::setVerbosity(5);
+
+  // Create the server socket on the specified port
+  s.bindAndListen(port);
+
+  // Wait for requests indefinitely
+  s.work(-1.0);
+
+  return 0;
+}
+