public void HandleRequestThreeOptionalArgs()
{
const float arg0 = 3.14159f;
const int arg2 = 42;
var mock = new Mock <ITestService> (MockBehavior.Strict);
mock.Setup(x => x.ProcedureThreeOptionalArgsNoReturn(
It.IsAny <float> (),
It.IsAny <string> (),
It.IsAny <int> ()))
.Callback((float x,
string y,
int z) => {
Assert.AreEqual(arg0, x);
Assert.AreEqual("jeb", y);
Assert.AreEqual(arg2, z);
});
TestService.Service = mock.Object;
var request = Req("TestService", "ProcedureThreeOptionalArgsNoReturn",
Arg(2, ProtocolBuffers.WriteValue(arg2, arg2.GetType())),
Arg(0, ProtocolBuffers.WriteValue(arg0, arg0.GetType())));
Run(request);
mock.Verify(x => x.ProcedureThreeOptionalArgsNoReturn(
It.IsAny <float> (),
It.IsAny <string> (),
It.IsAny <int> ()), Times.Once());
}
public ParameterSignature(string fullProcedureName, ProcedureParameter parameter)
{
Name = parameter.Name;
Type = parameter.Type;
// Check the parameter type is valid
if (!TypeUtils.IsAValidType(Type))
{
throw new ServiceException(Type + " is not a valid Procedure parameter type, in " + fullProcedureName);
}
// Encode the default value as a ByteString
if (parameter.HasDefaultValue)
{
var value = parameter.DefaultValue;
if (TypeUtils.IsAClassType(Type))
{
DefaultArgument = ProtocolBuffers.WriteValue(ObjectStore.Instance.AddInstance(value), typeof(ulong));
}
else if (TypeUtils.IsAnEnumType(Type))
{
// TODO: Assumes it's underlying type is int
DefaultArgument = ProtocolBuffers.WriteValue((int)value, typeof(int));
}
else if (ProtocolBuffers.IsAMessageType(Type))
{
DefaultArgument = ProtocolBuffers.WriteMessage(value as IMessage);
}
else
{
DefaultArgument = ProtocolBuffers.WriteValue(value, Type);
}
}
}
public void HandleEchoDictionary()
{
var dictionary = new Dictionary();
dictionary.Entries.Add(new DictionaryEntry {
Key = ProtocolBuffers.WriteValue(0, typeof(int)),
Value = ProtocolBuffers.WriteValue("jeb", typeof(string))
});
dictionary.Entries.Add(new DictionaryEntry {
Key = ProtocolBuffers.WriteValue(1, typeof(int)),
Value = ProtocolBuffers.WriteValue("bob", typeof(string))
});
dictionary.Entries.Add(new DictionaryEntry {
Key = ProtocolBuffers.WriteValue(2, typeof(int)),
Value = ProtocolBuffers.WriteValue("bill", typeof(string))
});
var mock = new Mock <ITestService> (MockBehavior.Strict);
mock.Setup(x => x.EchoDictionary(It.IsAny <IDictionary <int, string> > ()))
.Returns((IDictionary <int, string> x) => x);
TestService.Service = mock.Object;
var response = Run(Req("TestService", "EchoDictionary",
Arg(0, ProtocolBuffers.WriteMessage(dictionary))));
response.Time = 0;
Assert.AreEqual("", response.Error);
Assert.AreEqual(ProtocolBuffers.WriteMessage(dictionary), response.ReturnValue);
mock.Verify(x => x.EchoDictionary(It.IsAny <IDictionary <int, string> > ()), Times.Once());
}
/// <summary>
/// Decode a serialized value
/// </summary>
object Decode(ProcedureSignature procedure, int i, Type type, ByteString value)
{
if (TypeUtils.IsAClassType(type))
{
return(ObjectStore.Instance.GetInstance((ulong)ProtocolBuffers.ReadValue(value, typeof(ulong))));
}
else if (TypeUtils.IsACollectionType(type))
{
return(DecodeCollection(procedure, i, type, value));
}
else if (ProtocolBuffers.IsAMessageType(type))
{
return(ProtocolBuffers.ParseFrom(type, value));
}
else if (TypeUtils.IsAnEnumType(type))
{
// TODO: Assumes it's underlying type is int
var enumValue = ProtocolBuffers.ReadValue(value, typeof(int));
if (!Enum.IsDefined(type, enumValue))
{
throw new RPCException(procedure, "Failed to convert value " + enumValue + " to enumeration type " + type);
}
return(Enum.ToObject(type, enumValue));
}
else
{
return(ProtocolBuffers.ReadValue(value, type));
}
}
public void HandleBlockingRequestArgsReturns()
{
const int num = 10;
const int expectedResult = 55;
var mock = new Mock <ITestService> (MockBehavior.Strict);
mock.Setup(x => x.BlockingProcedureReturns(It.IsAny <int> (), It.IsAny <int> ()))
.Returns((int n, int sum) => BlockingProcedureReturnsFn(n, sum));
TestService.Service = mock.Object;
var request = Req("TestService", "BlockingProcedureReturns",
Arg(0, ProtocolBuffers.WriteValue(num, typeof(int))));
BlockingProcedureReturnsFnCount = 0;
Response response = null;
Continuation <Response> continuation = new RequestContinuation(null, request);
while (response == null)
{
try {
response = continuation.Run();
} catch (YieldException e) {
continuation = (Continuation <Response>)e.Continuation;
}
}
response.Time = 0;
Assert.AreEqual("", response.Error);
Assert.AreEqual(expectedResult, ProtocolBuffers.ReadValue(response.ReturnValue, typeof(int)));
// Verify the KRPCProcedure is called once, but the handler function is called multiple times
mock.Verify(x => x.BlockingProcedureReturns(It.IsAny <int> (), It.IsAny <int> ()), Times.Once());
Assert.AreEqual(num + 1, BlockingProcedureReturnsFnCount);
}
public void GetMessageTypeName()
{
Assert.AreEqual("KRPC.Request", ProtocolBuffers.GetMessageTypeName(typeof(KRPC.Schema.KRPC.Request)));
Assert.AreEqual("KRPC.Response", ProtocolBuffers.GetMessageTypeName(typeof(KRPC.Schema.KRPC.Response)));
Assert.Throws <ArgumentException> (() => ProtocolBuffers.GetMessageTypeName(null));
Assert.Throws <ArgumentException> (() => ProtocolBuffers.GetMessageTypeName(typeof(string)));
Assert.Throws <ArgumentException> (() => ProtocolBuffers.GetMessageTypeName(typeof(ProtocolBuffersTest)));
}
public void IsAMessageType()
{
Assert.IsTrue(ProtocolBuffers.IsAMessageType(typeof(KRPC.Schema.KRPC.Request)));
Assert.IsTrue(ProtocolBuffers.IsAMessageType(typeof(KRPC.Schema.KRPC.Response)));
Assert.IsFalse(ProtocolBuffers.IsAMessageType(null));
Assert.IsFalse(ProtocolBuffers.IsAMessageType(typeof(string)));
Assert.IsFalse(ProtocolBuffers.IsAMessageType(typeof(ProtocolBuffersTest)));
}
public void HandleRequestForClassStaticMethod()
{
ByteString argBytes = ProtocolBuffers.WriteValue("bob", typeof(string));
var request = Req("TestService", "TestClass_StaticMethod", Arg(0, argBytes));
var response = Run(request);
response.Time = 42;
Assert.AreEqual("jebbob", ProtocolBuffers.ReadValue(response.ReturnValue, typeof(string)));
}
public void HandleRequestForPropertyGetter()
{
var mock = new Mock <ITestService> (MockBehavior.Strict);
mock.Setup(x => x.PropertyWithGet).Returns("foo");
TestService.Service = mock.Object;
Response response = Run(Req("TestService", "get_PropertyWithGet"));
Assert.AreEqual("foo", ProtocolBuffers.ReadValue(response.ReturnValue, typeof(string)));
mock.Verify(x => x.PropertyWithGet, Times.Once());
}
/// <summary>
/// Encode a collection
/// </summary>
ByteString EncodeCollection(Type type, object value)
{
if (TypeUtils.IsAListCollectionType(type))
{
var encodedList = new Schema.KRPC.List();
var list = (System.Collections.IList)value;
var valueType = type.GetGenericArguments().Single();
foreach (var item in list)
{
encodedList.Items.Add(Encode(valueType, item));
}
return(ProtocolBuffers.WriteMessage(encodedList));
}
else if (TypeUtils.IsADictionaryCollectionType(type))
{
var keyType = type.GetGenericArguments() [0];
var valueType = type.GetGenericArguments() [1];
var encodedDictionary = new Schema.KRPC.Dictionary();
foreach (System.Collections.DictionaryEntry entry in (System.Collections.IDictionary)value)
{
var encodedEntry = new Schema.KRPC.DictionaryEntry();
encodedEntry.Key = Encode(keyType, entry.Key);
encodedEntry.Value = Encode(valueType, entry.Value);
encodedDictionary.Entries.Add(encodedEntry);
}
return(ProtocolBuffers.WriteMessage(encodedDictionary));
}
else if (TypeUtils.IsASetCollectionType(type))
{
var encodedSet = new Schema.KRPC.Set();
var set = (System.Collections.IEnumerable)value;
var valueType = type.GetGenericArguments().Single();
foreach (var item in set)
{
encodedSet.Items.Add(Encode(valueType, item));
}
return(ProtocolBuffers.WriteMessage(encodedSet));
}
else // a tuple
// TODO: this is ugly
{
var encodedTuple = new Schema.KRPC.Tuple();
var valueTypes = type.GetGenericArguments().ToArray();
var genericType = Type.GetType("KRPC.Utils.Tuple`" + valueTypes.Length);
var tupleType = genericType.MakeGenericType(valueTypes);
for (int i = 0; i < valueTypes.Length; i++)
{
var property = tupleType.GetProperty("Item" + (i + 1));
var item = property.GetGetMethod().Invoke(value, null);
encodedTuple.Items.Add(Encode(valueTypes [i], item));
}
return(ProtocolBuffers.WriteMessage(encodedTuple));
}
}
public void HandleRequestForObjectMethod()
{
var instance = new TestService.TestClass("jeb");
var guid = ObjectStore.Instance.AddInstance(instance);
ByteString guidBytes = ProtocolBuffers.WriteValue(guid, typeof(ulong));
ByteString argBytes = ProtocolBuffers.WriteValue(3.14159f, typeof(float));
var request = Req("TestService", "TestClass_FloatToString", Arg(0, guidBytes), Arg(1, argBytes));
var response = Run(request);
response.Time = 42;
Assert.AreEqual("jeb3.14159", ProtocolBuffers.ReadValue(response.ReturnValue, typeof(string)));
}
public void HandleRequestSingleInvalidEnumArgNoReturn()
{
const int arg = 9999;
var mock = new Mock <ITestService> (MockBehavior.Strict);
mock.Setup(x => x.ProcedureEnumArg(It.IsAny <TestService.TestEnum> ()));
TestService.Service = mock.Object;
var request = Req("TestService", "ProcedureTestEnumArg",
Arg(0, ProtocolBuffers.WriteValue((int)arg, typeof(int))));
Assert.Throws <RPCException> (() => Run(request));
}
public void HandleRequestForPropertySetter()
{
var mock = new Mock <ITestService> (MockBehavior.Strict);
mock.SetupSet(x => x.PropertyWithSet = "foo");
TestService.Service = mock.Object;
var request = Req("TestService", "set_PropertyWithSet",
Arg(0, ProtocolBuffers.WriteValue("foo", typeof(string))));
Response response = Run(request);
Assert.AreEqual("", response.Error);
}
public void HandleRequestNoArgEnumReturn()
{
var mock = new Mock <ITestService> (MockBehavior.Strict);
mock.Setup(x => x.ProcedureEnumReturn()).Returns(TestService.TestEnum.z);
TestService.Service = mock.Object;
var response = Run(Req("TestService", "ProcedureEnumReturn"));
response.Time = 0;
Assert.AreEqual("", response.Error);
Assert.AreEqual(ProtocolBuffers.WriteValue((int)TestService.TestEnum.z, typeof(int)), response.ReturnValue);
mock.Verify(x => x.ProcedureEnumReturn(), Times.Once());
}
public void HandleRequestWithClassTypeReturnFromDifferentService()
{
var request = Req("TestService2", "ClassTypeFromOtherServiceAsReturn",
Arg(0, ProtocolBuffers.WriteValue("jeb", typeof(string))));
var response = Run(request);
response.Time = 0;
Assert.AreEqual("", response.Error);
var guid = (ulong)ProtocolBuffers.ReadValue(response.ReturnValue, typeof(ulong));
var obj = (TestService.TestClass)ObjectStore.Instance.GetInstance(guid);
Assert.AreEqual("jeb", obj.value);
}
public void HandleRequestWithObjectParameter()
{
var instance = new TestService.TestClass("foo");
var arg = ObjectStore.Instance.AddInstance(instance);
ByteString argBytes = ProtocolBuffers.WriteValue(arg, typeof(ulong));
var mock = new Mock <ITestService> (MockBehavior.Strict);
mock.Setup(x => x.DeleteTestObject(It.IsAny <TestService.TestClass> ()))
.Callback((TestService.TestClass x) => Assert.AreSame(instance, x));
TestService.Service = mock.Object;
Run(Req("TestService", "DeleteTestObject", Arg(0, argBytes)));
mock.Verify(x => x.DeleteTestObject(It.IsAny <TestService.TestClass> ()), Times.Once());
}
public void HandleRequestSingleEnumArgNoReturn()
{
var arg = TestService.TestEnum.y;
var mock = new Mock <ITestService> (MockBehavior.Strict);
mock.Setup(x => x.ProcedureEnumArg(It.IsAny <TestService.TestEnum> ()))
.Callback((TestService.TestEnum x) => Assert.AreEqual(TestService.TestEnum.y, x));
TestService.Service = mock.Object;
var request = Req("TestService", "ProcedureEnumArg",
Arg(0, ProtocolBuffers.WriteValue((int)arg, typeof(int))));
Run(request);
mock.Verify(x => x.ProcedureEnumArg(It.IsAny <TestService.TestEnum> ()), Times.Once());
}
public void HandleRequestForClassPropertyGetter()
{
var instance = new TestService.TestClass("jeb");
instance.IntProperty = 42;
var guid = ObjectStore.Instance.AddInstance(instance);
ByteString guidBytes = ProtocolBuffers.WriteValue(guid, typeof(ulong));
var request = Req("TestService", "TestClass_get_IntProperty", Arg(0, guidBytes));
var response = Run(request);
response.Time = 0;
Assert.AreEqual("", response.Error);
Assert.AreEqual(42, ProtocolBuffers.ReadValue(response.ReturnValue, typeof(int)));
}
public void HandleRequestForObjectMethodWithObjectParameter()
{
var instance = new TestService.TestClass("bill");
var argInstance = new TestService.TestClass("bob");
var guid = ObjectStore.Instance.AddInstance(instance);
var argGuid = ObjectStore.Instance.AddInstance(argInstance);
ByteString guidBytes = ProtocolBuffers.WriteValue(guid, typeof(ulong));
ByteString argBytes = ProtocolBuffers.WriteValue(argGuid, typeof(ulong));
var request = Req("TestService", "TestClass_ObjectToString", Arg(0, guidBytes), Arg(1, argBytes));
var response = Run(request);
response.Time = 42;
Assert.AreEqual("billbob", ProtocolBuffers.ReadValue(response.ReturnValue, typeof(string)));
}
public void ReadValue()
{
Assert.AreEqual(3.14159, ProtocolBuffers.ReadValue(FromHex("6E861BF0F9210940"), typeof(double)));
Assert.AreEqual(3.14159f, ProtocolBuffers.ReadValue(FromHex("D00F4940"), typeof(float)));
Assert.AreEqual(-42, ProtocolBuffers.ReadValue(FromHex("D6FFFFFFFFFFFFFFFF01"), typeof(int)));
Assert.AreEqual(-42834463454L, ProtocolBuffers.ReadValue(FromHex("A2EAF7B6E0FEFFFFFF01"), typeof(long)));
Assert.AreEqual(42, ProtocolBuffers.ReadValue(FromHex("2A"), typeof(uint)));
Assert.AreEqual(42834463454UL, ProtocolBuffers.ReadValue(FromHex("DE9588C99F01"), typeof(ulong)));
Assert.AreEqual(true, ProtocolBuffers.ReadValue(FromHex("01"), typeof(bool)));
Assert.AreEqual(false, ProtocolBuffers.ReadValue(FromHex("00"), typeof(bool)));
Assert.AreEqual("jebediah", ProtocolBuffers.ReadValue(FromHex("086A65626564696168"), typeof(string)));
Assert.AreEqual(new byte[] { 0xBA, 0xDA, 0x55 }, ProtocolBuffers.ReadValue(FromHex("03BADA55"), typeof(byte[])));
Assert.Throws <ArgumentException> (() => ProtocolBuffers.ReadValue(FromHex(""), typeof(bool)));
}
public void HandleRequestWithClassTypeParameterFromDifferentService()
{
var instance = new TestService.TestClass("jeb");
instance.IntProperty = 42;
var guid = ObjectStore.Instance.AddInstance(instance);
ByteString guidBytes = ProtocolBuffers.WriteValue(guid, typeof(ulong));
var request = Req("TestService2", "ClassTypeFromOtherServiceAsParameter", Arg(0, guidBytes));
var response = Run(request);
response.Time = 0;
Assert.AreEqual("", response.Error);
Assert.AreEqual(42, ProtocolBuffers.ReadValue(response.ReturnValue, typeof(long)));
}
public void WriteValue()
{
Assert.AreEqual("6E861BF0F9210940", ToHex(ProtocolBuffers.WriteValue(3.14159, typeof(double))));
Assert.AreEqual("D00F4940", ToHex(ProtocolBuffers.WriteValue(3.14159f, typeof(float))));
Assert.AreEqual("D6FFFFFFFFFFFFFFFF01", ToHex(ProtocolBuffers.WriteValue(-42, typeof(int))));
Assert.AreEqual("A2EAF7B6E0FEFFFFFF01", ToHex(ProtocolBuffers.WriteValue(-42834463454L, typeof(long))));
Assert.AreEqual("2A", ToHex(ProtocolBuffers.WriteValue(42U, typeof(uint))));
Assert.AreEqual("DE9588C99F01", ToHex(ProtocolBuffers.WriteValue(42834463454UL, typeof(ulong))));
Assert.AreEqual("01", ToHex(ProtocolBuffers.WriteValue(true, typeof(bool))));
Assert.AreEqual("00", ToHex(ProtocolBuffers.WriteValue(false, typeof(bool))));
Assert.AreEqual("086A65626564696168", ToHex(ProtocolBuffers.WriteValue("jebediah", typeof(string))));
Assert.AreEqual("03BADA55", ToHex(ProtocolBuffers.WriteValue(new byte[] { 0xBA, 0xDA, 0x55 }, typeof(byte[]))));
Assert.Throws <ArgumentException> (() => ProtocolBuffers.WriteValue("foo", typeof(ProtocolBuffersTest)));
}
public void HandleRequestWithNullObjectParameterAndReturn()
{
ByteString argBytes = ProtocolBuffers.WriteValue(0ul, typeof(ulong));
var mock = new Mock <ITestService> (MockBehavior.Strict);
mock.Setup(x => x.EchoTestObject(It.IsAny <TestService.TestClass> ()))
.Callback((TestService.TestClass x) => Assert.AreEqual(null, x))
.Returns((TestService.TestClass x) => x);
TestService.Service = mock.Object;
Response response = Run(Req("TestService", "EchoTestObject", Arg(0, argBytes)));
Assert.AreEqual("", response.Error);
response.Time = 42;
Assert.IsNotNull(response.ReturnValue);
Assert.AreEqual(0, ProtocolBuffers.ReadValue(response.ReturnValue, typeof(ulong)));
}
public void IsAValidType()
{
Assert.IsTrue(ProtocolBuffers.IsAValidType(typeof(KRPC.Schema.KRPC.Request)));
Assert.IsTrue(ProtocolBuffers.IsAValidType(typeof(KRPC.Schema.KRPC.Response)));
Assert.IsTrue(ProtocolBuffers.IsAValidType(typeof(double)));
Assert.IsTrue(ProtocolBuffers.IsAValidType(typeof(float)));
Assert.IsTrue(ProtocolBuffers.IsAValidType(typeof(int)));
Assert.IsTrue(ProtocolBuffers.IsAValidType(typeof(long)));
Assert.IsTrue(ProtocolBuffers.IsAValidType(typeof(uint)));
Assert.IsTrue(ProtocolBuffers.IsAValidType(typeof(ulong)));
Assert.IsTrue(ProtocolBuffers.IsAValidType(typeof(bool)));
Assert.IsTrue(ProtocolBuffers.IsAValidType(typeof(string)));
Assert.IsTrue(ProtocolBuffers.IsAValidType(typeof(byte[])));
Assert.IsFalse(ProtocolBuffers.IsAValidType(null));
Assert.IsFalse(ProtocolBuffers.IsAValidType(typeof(ProtocolBuffersTest)));
}
public void HandleRequestWithObjectReturn()
{
var instance = new TestService.TestClass("foo");
var guid = ObjectStore.Instance.AddInstance(instance);
var argBytes = ProtocolBuffers.WriteValue("foo", typeof(string));
var mock = new Mock <ITestService> (MockBehavior.Strict);
mock.Setup(x => x.CreateTestObject("foo")).Returns(instance);
TestService.Service = mock.Object;
Response response = Run(Req("TestService", "CreateTestObject", Arg(0, argBytes)));
Assert.AreEqual("", response.Error);
response.Time = 42;
Assert.IsNotNull(response.ReturnValue);
Assert.AreEqual(guid, ProtocolBuffers.ReadValue(response.ReturnValue, typeof(ulong)));
}
public void ReadWriteValues()
{
Assert.AreEqual(3.14159, ProtocolBuffers.ReadValue(ProtocolBuffers.WriteValue(3.14159, typeof(double)), typeof(double)));
Assert.AreEqual(3.14159f, ProtocolBuffers.ReadValue(ProtocolBuffers.WriteValue(3.14159f, typeof(float)), typeof(float)));
Assert.AreEqual(-42, ProtocolBuffers.ReadValue(ProtocolBuffers.WriteValue(-42, typeof(int)), typeof(int)));
Assert.AreEqual(-42834463454, ProtocolBuffers.ReadValue(ProtocolBuffers.WriteValue(-42834463454L, typeof(long)), typeof(long)));
Assert.AreEqual(42U, ProtocolBuffers.ReadValue(ProtocolBuffers.WriteValue(42U, typeof(uint)), typeof(uint)));
Assert.AreEqual(42834463454UL, ProtocolBuffers.ReadValue(ProtocolBuffers.WriteValue(42834463454UL, typeof(ulong)), typeof(ulong)));
Assert.AreEqual(true, ProtocolBuffers.ReadValue(ProtocolBuffers.WriteValue(true, typeof(bool)), typeof(bool)));
Assert.AreEqual(false, ProtocolBuffers.ReadValue(ProtocolBuffers.WriteValue(false, typeof(bool)), typeof(bool)));
Assert.AreEqual("jebediah", ProtocolBuffers.ReadValue(ProtocolBuffers.WriteValue("jebediah", typeof(string)), typeof(string)));
Assert.AreEqual(new byte[] { 0xBA, 0xDA, 0x55 }, ProtocolBuffers.ReadValue(ProtocolBuffers.WriteValue(new byte[] {
0xBA,
0xDA,
0x55
}, typeof(byte[])), typeof(byte[])));
}
public void HandleEchoTuple()
{
var tuple = new KRPC.Schema.KRPC.Tuple();
tuple.Items.Add(ProtocolBuffers.WriteValue(42, typeof(int)));
tuple.Items.Add(ProtocolBuffers.WriteValue(false, typeof(bool)));
var mock = new Mock <ITestService> (MockBehavior.Strict);
mock.Setup(x => x.EchoTuple(It.IsAny <KRPC.Utils.Tuple <int, bool> > ()))
.Returns((KRPC.Utils.Tuple <int, bool> x) => x);
TestService.Service = mock.Object;
var response = Run(Req("TestService", "EchoTuple",
Arg(0, ProtocolBuffers.WriteMessage(tuple))));
response.Time = 0;
Assert.AreEqual("", response.Error);
Assert.AreEqual(ProtocolBuffers.WriteMessage(tuple), response.ReturnValue);
mock.Verify(x => x.EchoTuple(It.IsAny <KRPC.Utils.Tuple <int, bool> > ()), Times.Once());
}
public void HandleEchoList()
{
var list = new KRPC.Schema.KRPC.List();
list.Items.Add(ProtocolBuffers.WriteValue("jeb", typeof(string)));
list.Items.Add(ProtocolBuffers.WriteValue("bob", typeof(string)));
list.Items.Add(ProtocolBuffers.WriteValue("bill", typeof(string)));
var mock = new Mock <ITestService> (MockBehavior.Strict);
mock.Setup(x => x.EchoList(It.IsAny <IList <string> > ()))
.Returns((IList <string> x) => x);
TestService.Service = mock.Object;
var response = Run(Req("TestService", "EchoList",
Arg(0, ProtocolBuffers.WriteMessage(list))));
response.Time = 0;
Assert.AreEqual("", response.Error);
Assert.AreEqual(ProtocolBuffers.WriteMessage(list), response.ReturnValue);
mock.Verify(x => x.EchoList(It.IsAny <IList <string> > ()), Times.Once());
}
public void HandleEchoSet()
{
var set = new Set();
set.Items.Add(ProtocolBuffers.WriteValue(345, typeof(int)));
set.Items.Add(ProtocolBuffers.WriteValue(723, typeof(int)));
set.Items.Add(ProtocolBuffers.WriteValue(112, typeof(int)));
var mock = new Mock <ITestService> (MockBehavior.Strict);
mock.Setup(x => x.EchoSet(It.IsAny <HashSet <int> > ()))
.Returns((HashSet <int> x) => x);
TestService.Service = mock.Object;
var response = Run(Req("TestService", "EchoSet",
Arg(0, ProtocolBuffers.WriteMessage(set))));
response.Time = 0;
Assert.AreEqual("", response.Error);
Assert.AreEqual(ProtocolBuffers.WriteMessage(set), response.ReturnValue);
mock.Verify(x => x.EchoSet(It.IsAny <HashSet <int> > ()), Times.Once());
}
/// <summary>
/// Return the name of the protocol buffer type for the given C# type
/// </summary>
public static string GetTypeName(Type type)
{
if (!IsAValidType(type))
{
throw new ArgumentException("Type is not valid");
}
else if (ProtocolBuffers.IsAValidType(type))
{
return(ProtocolBuffers.GetTypeName(type));
}
else if (IsAClassType(type))
{
return(ProtocolBuffers.GetTypeName(typeof(ulong))); // Class instance GUIDs are uint64
}
else if (IsAnEnumType(type))
{
return(ProtocolBuffers.GetTypeName(typeof(int))); // Enums are int32
}
else if (IsAListCollectionType(type))
{
return(ProtocolBuffers.GetMessageTypeName(typeof(Schema.KRPC.List)));
}
else if (IsADictionaryCollectionType(type))
{
return(ProtocolBuffers.GetMessageTypeName(typeof(Schema.KRPC.Dictionary)));
}
else if (IsASetCollectionType(type))
{
return(ProtocolBuffers.GetMessageTypeName(typeof(Schema.KRPC.Set)));
}
else if (IsATupleCollectionType(type))
{
return(ProtocolBuffers.GetMessageTypeName(typeof(Schema.KRPC.Tuple)));
}
else
{
throw new ArgumentException("Type is not valid");
}
}
