public void TestMethodDefinition(String methodDefinitionString, SosMethodDefinition expectedMethodDefinition)
{
Console.WriteLine("Testing '{0}'", methodDefinitionString);
SosMethodDefinition methodDefinition = SosTypes.ParseMethodDefinition(methodDefinitionString, 0);
String diff = expectedMethodDefinition.Diff(methodDefinition);
if (diff != null)
{
Assert.Fail("Expected diff to be null but was '{0}'", diff);
}
if (!expectedMethodDefinition.Equals(methodDefinition))
{
Assert.Fail(String.Format("Diff was null but Equals failed Expected '{0}' Actual '{1}'",
expectedMethodDefinition.Definition(), methodDefinition.Definition()));
}
}
// returns false if interactive mode should stop
Boolean ProcessInteractiveCommand(String command)
{
if (command.Equals("help", StringComparison.CurrentCultureIgnoreCase))
{
//
// Request methods from server
//
Console.WriteLine("Format: <Interface> <Method> [<Parameters>...]");
List <RemoteNpcObject> objects = client.GetServerInterface(false);
for (int objectIndex = 0; objectIndex < objects.Count; objectIndex++)
{
RemoteNpcObject npcObject = objects[objectIndex];
Console.WriteLine(interfaceMapping.NpcToUserInterface(npcObject.name));
for (int interfaceIndex = 0; interfaceIndex < npcObject.interfaces.Length; interfaceIndex++)
{
RemoteNpcInterface npcInterface = npcObject.interfaces[interfaceIndex];
for (int i = 0; i < npcInterface.methods.Length; i++)
{
SosMethodDefinition method = npcInterface.methods[i];
Console.Write(" {0}", method.methodName);
if (method.parameters != null)
{
foreach (SosMethodDefinition.Parameter parameter in method.parameters)
{
Console.Write(" {0}", parameter.name);
}
}
Console.WriteLine();
}
}
}
}
else if (command.Equals("exit", StringComparison.CurrentCultureIgnoreCase) ||
command.Equals("q", StringComparison.CurrentCultureIgnoreCase) ||
command.Equals("quit", StringComparison.CurrentCultureIgnoreCase))
{
return(false);
}
else
{
Console.WriteLine("Error: Unknown interface/command '{0}'", command);
}
return(true);
}
/*
* public void VerifyObjectsAndInterfaceMethods(Boolean forceInterfaceUpdateFromServer, ICollection<RemoteNpcObject> expectedObjects, ICollection<RemoteNpcInterface> expectedInterfaces)
* {
* GetServerInterface(forceInterfaceUpdateFromServer);
* String interfaceDiff = ServerInterfaceMethodsDiff(cachedServerInterfaces.Values, expectedInterfaces);
* if (interfaceDiff != null) throw new InvalidOperationException(interfaceDiff);
*
* foreach (RemoteNpcObject expectedObject in expectedObjects)
* {
* Boolean foundObject = false;
* for (int serverObjectIndex = 0; serverObjectIndex < cachedServerObjects.Count; serverObjectIndex++)
* {
* RemoteNpcObject serverObject = cachedServerObjects[serverObjectIndex];
*
* if (expectedObject.name.Equals(serverObject.name))
* {
* foundObject = true;
*
* // Check that the interfaces are the same
* for (int expectedInterfaceIndex = 0; expectedInterfaceIndex < expectedObject.interfaces.Length; expectedInterfaceIndex++)
* {
* RemoteNpcInterface expectedInterface = expectedObject.interfaces[expectedInterfaceIndex];
* Boolean foundInterface = false;
*
* for(int serverInterfaceIndex = 0; serverInterfaceIndex < serverObject.interfaces.Length; serverInterfaceIndex++)
* {
* RemoteNpcInterface serverInterface = serverObject.interfaces[serverInterfaceIndex];
*
* if(expectedInterface.name.Equals(serverInterface.name))
* {
* foundInterface = true;
* // Note: the interface definition does not need to be checked because it was already checked
* break;
* }
*
* }
*
* if(!foundInterface) throw new InvalidOperationException(String.Format("Server object '{0}' is missing the '{1}' interface", serverObject.name, expectedInterface.name));
* }
*
* break;
* }
* }
* if(!foundObject) throw new InvalidOperationException(String.Format("Server missing '{0}' object", expectedObject.name));
* }
* }
*/
/*
* public void VerifyInterfaceMethods(Boolean forceInterfaceUpdateFromServer, ICollection<RemoteNpcInterface> expectedInterfaces)
* {
* GetServerInterface(forceInterfaceUpdateFromServer);
* String interfaceDiff = ServerInterfaceMethodsDiff(cachedServerInterfaces.Values, expectedInterfaces);
* if (interfaceDiff != null) throw new InvalidOperationException(interfaceDiff);
* }
*/
// Returns null if the client interfaces are contained in the server interfaces, otherwise,
// returns a message indicating what client interface is missing or out of sync.
public static String ServerInterfaceMethodsDiff(IDictionary <String, RemoteNpcInterface> serverInterfaces, ICollection <RemoteNpcInterface> expectedInterfaces)
{
if (expectedInterfaces.Count > serverInterfaces.Count)
{
return(String.Format("Expected server to have at least {0} interfaces but server only has {1}", expectedInterfaces.Count, serverInterfaces.Count));
}
foreach (RemoteNpcInterface expectedInterface in expectedInterfaces)
{
RemoteNpcInterface serverInterface;
if (!serverInterfaces.TryGetValue(expectedInterface.name, out serverInterface))
{
return(String.Format("Server does not have the '{0}' interface", expectedInterface.name));
}
if (serverInterface.methods.Length != expectedInterface.methods.Length)
{
return(String.Format("Expected server interface '{0}' to have {1} methods but it has {2}",
serverInterface.name, expectedInterface.methods.Length, serverInterface.methods.Length));
}
//
// Check that the interfaces are the same
//
for (int clientMethodIndex = 0; clientMethodIndex < expectedInterface.methods.Length; clientMethodIndex++)
{
SosMethodDefinition clientMethodDefinition = expectedInterface.methods[clientMethodIndex];
Boolean foundMethod = false;
for (int serverMethodIndex = 0; serverMethodIndex < serverInterface.methods.Length; serverMethodIndex++)
{
SosMethodDefinition serverMethodDefinition = serverInterface.methods[serverMethodIndex];
if (clientMethodDefinition.Equals(serverMethodDefinition))
{
foundMethod = true;
break;
}
}
if (!foundMethod)
{
return(String.Format("Server Interface '{0}' does not have method '{1}'",
serverInterface.name, clientMethodDefinition.Definition()));
}
}
}
return(null); // The server has all the expected interfaces
}
public static List <RemoteNpcObject> GetServerInterface(SocketLineReader socketLineReader,
out Dictionary <String, RemoteNpcInterface> serverInterfaces)
{
socketLineReader.socket.Send(Encoding.ASCII.GetBytes(":interface\n"));
serverInterfaces = new Dictionary <String, RemoteNpcInterface>();
List <SosMethodDefinition> methodDefinitionList = new List <SosMethodDefinition>();
while (true)
{
String interfaceName = socketLineReader.ReadLine();
if (interfaceName == null)
{
throw UnexpectedClose(socketLineReader);
}
if (interfaceName.Length <= 0)
{
break;
}
// Get parent interfaces
String[] parentInterfaceNames = null;
Int32 spaceIndex = interfaceName.IndexOf(' ');
if (spaceIndex >= 0)
{
parentInterfaceNames = interfaceName.Substring(spaceIndex + 1).Split(' ');
interfaceName = interfaceName.Remove(spaceIndex);
}
while (true)
{
String methodDefinitionLine = socketLineReader.ReadLine();
if (methodDefinitionLine == null)
{
throw UnexpectedClose(socketLineReader);
}
if (methodDefinitionLine.Length <= 0)
{
break;
}
SosMethodDefinition methodDefinition = SosTypes.ParseMethodDefinition(methodDefinitionLine, 0);
methodDefinitionList.Add(methodDefinition);
}
serverInterfaces.Add(interfaceName, new RemoteNpcInterface(interfaceName, parentInterfaceNames, methodDefinitionList.ToArray()));
methodDefinitionList.Clear();
}
List <RemoteNpcObject> serverObjects = new List <RemoteNpcObject>();
while (true)
{
String objectLine = socketLineReader.ReadLine();
if (objectLine == null)
{
throw UnexpectedClose(socketLineReader);
}
if (objectLine.Length <= 0)
{
break;
}
String objectName = objectLine.Peel(out objectLine);
String[] interfaceNames = objectLine.Split(RemoteNpcObject.SplitChars, StringSplitOptions.RemoveEmptyEntries);
RemoteNpcInterface[] interfaces = new RemoteNpcInterface[interfaceNames.Length];
for (int i = 0; i < interfaceNames.Length; i++)
{
String interfaceName = interfaceNames[i];
RemoteNpcInterface npcInterface;
if (!serverInterfaces.TryGetValue(interfaceName, out npcInterface))
{
throw new FormatException(String.Format("The NPC server returned interface '{0}' in the :objects command but not in the :interfaces command",
interfaceName));
}
interfaces[i] = npcInterface;
}
serverObjects.Add(new RemoteNpcObject(objectName, interfaces));
}
return(serverObjects);
}
