public void CommandsForWithUnknownType() { var collection = new LocalCommandCollection(); var id = CommandId.Create(typeof(int).GetMethod("CompareTo", new[] { typeof(object) })); Assert.Throws <UnknownCommandException>(() => collection.CommandToInvoke(id)); }
public void InvokeWithOnlyInterfaceMethodParameters() { var id = CommandId.Create(typeof(int).GetMethod("CompareTo", new[] { typeof(object) })); Func <int, double, string> func = (i, d) => (i + d).ToString(CultureInfo.InvariantCulture); var parameters = new[] { new CommandParameterDefinition(typeof(int), "i", CommandParameterOrigin.FromCommand), new CommandParameterDefinition(typeof(double), "d", CommandParameterOrigin.FromCommand), }; Delegate commandToExecute = func; var definition = new CommandDefinition(id, parameters, true, commandToExecute); var parameterValues = new[] { new CommandParameterValueMap( parameters[0], 10), new CommandParameterValueMap( parameters[1], 10.0), }; var result = definition.Invoke(new EndpointId("a"), new MessageId(), parameterValues); Assert.IsInstanceOf(typeof(string), result); Assert.AreEqual(20.0.ToString(CultureInfo.InvariantCulture), result); }
public void CompareToWithUnequalObjectTypes() { var first = CommandId.Create(typeof(double).GetMethod("CompareTo", new[] { typeof(object) })); var second = new object(); Assert.Throws <ArgumentException>(() => first.CompareTo(second)); }
public void SmallerThanOperatorWithSecondObjectNull() { var first = CommandId.Create(typeof(double).GetMethod("CompareTo", new[] { typeof(object) })); CommandId second = null; Assert.IsFalse(first < second); }
public void LargerThanOperatorWithFirstObjectNull() { CommandId first = null; var second = CommandId.Create(typeof(double).GetMethod("CompareTo", new[] { typeof(object) })); Assert.IsFalse(first > second); }
public void CompareToOperatorWithEqualObjects() { var first = CommandId.Create(typeof(double).GetMethod("CompareTo", new[] { typeof(object) })); object second = CommandId.Create(typeof(double).GetMethod("CompareTo", new[] { typeof(object) })); Assert.AreEqual(0, first.CompareTo(second)); }
public void CompareToWithSmallerFirstObject() { var first = CommandId.Create(typeof(double).GetMethod("CompareTo", new[] { typeof(object) })); object second = CommandId.Create(typeof(int).GetMethod("CompareTo", new[] { typeof(object) })); Assert.IsTrue(first.CompareTo(second) < 0); }
public void CompareToWithNullObject() { var first = CommandId.Create(typeof(double).GetMethod("CompareTo", new[] { typeof(object) })); object second = null; Assert.AreEqual(1, first.CompareTo(second)); }
public void Clone() { var first = CommandId.Create(typeof(double).GetMethod("CompareTo", new[] { typeof(object) })); var second = first.Clone(); Assert.AreEqual(first, second); }
public void SmallerThanOperatorWithFirstObjectSmaller() { var first = CommandId.Create(typeof(double).GetMethod("CompareTo", new[] { typeof(object) })); var second = CommandId.Create(typeof(int).GetMethod("CompareTo", new[] { typeof(object) })); Assert.IsTrue(first < second); }
public void InvokeWithInvalidOrigin() { var id = CommandId.Create(typeof(int).GetMethod("CompareTo", new[] { typeof(object) })); Func <int, double, string> func = (i, d) => (i + d).ToString(CultureInfo.InvariantCulture); var parameters = new[] { new CommandParameterDefinition(typeof(int), "i", CommandParameterOrigin.FromCommand), new CommandParameterDefinition(typeof(double), "d", CommandParameterOrigin.Unknown), }; Delegate commandToExecute = func; var definition = new CommandDefinition(id, parameters, true, commandToExecute); var parameterValues = new[] { new CommandParameterValueMap( parameters[0], 10), new CommandParameterValueMap( parameters[1], 10.0), }; Assert.Throws <InvalidCommandParameterOriginException>(() => definition.Invoke(new EndpointId("a"), new MessageId(), parameterValues)); }
public void LargerThanOperatorWithEqualObjects() { var first = CommandId.Create(typeof(double).GetMethod("CompareTo", new[] { typeof(object) })); var second = CommandId.Create(typeof(double).GetMethod("CompareTo", new[] { typeof(object) })); Assert.IsFalse(first > second); }
public void From() { var map = CreateCommandMap(); foreach (var method in typeof(ICommandInterface).GetMethods()) { var id = CommandId.Create(method); Assert.AreEqual(1, map.Definitions.Count(m => m.Id.Equals(id))); } }
private MethodMapper CreateMethodMapper(LambdaExpression methodCall) { var methodInfo = ExtractMethod(methodCall); var returnType = ExtractInstanceMethodReturnType(methodInfo); var parameters = ExtractInstanceMethodParameters(methodInfo); return(new MethodMapper( StoreDefinition, CommandId.Create(methodInfo), returnType, parameters)); }
public void Create() { var id = CommandId.Create(typeof(string).GetMethod("CompareTo", new[] { typeof(object) })); var parameters = new[] { new CommandParameterValueMap( new CommandParameterDefinition(typeof(string), "a", CommandParameterOrigin.FromCommand), "b"), }; var invocationData = new CommandInvokedData(id, parameters); Assert.AreSame(id, invocationData.Command); Assert.AreSame(parameters, invocationData.Parameters); }
/// <summary> /// Creates the command map for the given command interface. /// </summary> /// <returns>The command map.</returns> /// <exception cref="CommandMethodNotMappedException"> /// Thrown when one or more of the methods on the command interface are not mapped to instance methods. /// </exception> public CommandMap ToMap() { var type = typeof(TCommand); var methods = type.GetMethods(); foreach (var method in methods) { var id = CommandId.Create(method); if (!m_Definitions.ContainsKey(id)) { throw new CommandMethodNotMappedException(); } } return(new CommandMap(type, m_Definitions.Values.ToArray())); }
public void Create() { var id = CommandId.Create(typeof(int).GetMethod("CompareTo", new[] { typeof(object) })); Func <int, double, string> func = (i, d) => (i + d).ToString(CultureInfo.InvariantCulture); var parameters = new[] { new CommandParameterDefinition(typeof(int), "i", CommandParameterOrigin.FromCommand), new CommandParameterDefinition(typeof(double), "d", CommandParameterOrigin.FromCommand), }; Delegate commandToExecute = func; var definition = new CommandDefinition(id, parameters, true, commandToExecute); Assert.AreEqual(id, definition.Id); Assert.IsTrue(definition.HasReturnValue); }
public void Register() { var collection = new LocalCommandCollection(); var map = new[] { new CommandDefinition( CommandId.Create(typeof(int).GetMethod("CompareTo", new[] { typeof(object) })), new[] { new CommandParameterDefinition(typeof(int), "other", CommandParameterOrigin.FromCommand), }, false, (Action) delegate { }), }; collection.Register(map); Assert.IsTrue(collection.Any(id => id == map[0].Id)); }
public void InvokeWithMessageIdParameter() { var id = CommandId.Create(typeof(int).GetMethod("CompareTo", new[] { typeof(object) })); int storedValue = -1; MessageId storedMessage = null; var expectedResult = "20.0"; Func <int, MessageId, string> func = (i, m) => { storedValue = i; storedMessage = m; return(expectedResult); }; var parameters = new[] { new CommandParameterDefinition(typeof(int), "i", CommandParameterOrigin.FromCommand), new CommandParameterDefinition(typeof(MessageId), "m", CommandParameterOrigin.InvokingMessageId), }; Delegate commandToExecute = func; var definition = new CommandDefinition(id, parameters, true, commandToExecute); var parameterValues = new[] { new CommandParameterValueMap( parameters[0], 10), }; var endpoint = new EndpointId("a"); var msg = new MessageId(); var result = definition.Invoke(endpoint, msg, parameterValues); Assert.IsInstanceOf(typeof(string), result); Assert.AreEqual(expectedResult, result); Assert.AreEqual(expectedResult, result); Assert.AreEqual(parameterValues[0].Value, storedValue); Assert.AreEqual(msg, storedMessage); }
public void CommandsFor() { var collection = new LocalCommandCollection(); var map = new[] { new CommandDefinition( CommandId.Create(typeof(int).GetMethod("CompareTo", new[] { typeof(object) })), new[] { new CommandParameterDefinition(typeof(int), "other", CommandParameterOrigin.FromCommand), }, false, (Action) delegate { }), }; collection.Register(map); var commandSet = collection.CommandToInvoke(map[0].Id); Assert.AreSame(map[0], commandSet); }
public void RegisterWithExistingType() { var collection = new LocalCommandCollection(); var map = new[] { new CommandDefinition( CommandId.Create(typeof(int).GetMethod("CompareTo", new[] { typeof(object) })), new[] { new CommandParameterDefinition(typeof(int), "other", CommandParameterOrigin.FromCommand), }, false, (Action) delegate { }), }; collection.Register(map); Assert.AreEqual(1, collection.Count(id => id == map[0].Id)); Assert.Throws <CommandAlreadyRegisteredException>( () => collection.Register(map)); Assert.AreEqual(1, collection.Count(id => id == map[0].Id)); }