public void PostChatMessage(string message)
{
if (message.Length == 0)
return;
//Creates a teambit based on team
string teamBit = team.Substring (0, 1);
//Checks if the message begins "/all " and changes teambit to a if so
if (message.Length > 5) {
if (message.Substring (0, 5) == "/all ") {
teamBit = "a";
//Slices /all off the message
message = message.Remove (0, 5);
}
}
//Compiles message with teambit at start
var msg = new StringMessage (teamBit + username + ": " + message);
NetworkManager.singleton.client.Send (chatMsg, msg);
chatInput.text = "";
chatInput.Select ();
chatInput.ActivateInputField ();
}
public void UpdateScore(string team, string score)
{
//all this does is send a message across clients
//so that score can be viewed
var msg = new StringMessage (team+score);
NetworkManager.singleton.client.Send (chatMsg, msg);
}
internal void OnServerConnectInternal(NetworkMessage netMsg)
{
if (LogFilter.logDebug)
{
Debug.Log("NetworkManager:OnServerConnectInternal");
}
netMsg.conn.SetMaxDelay(m_MaxDelay);
if (m_MaxBufferedPackets != 512)
{
for (int i = 0; i < NetworkServer.numChannels; i++)
{
netMsg.conn.SetChannelOption(i, ChannelOption.MaxPendingBuffers, m_MaxBufferedPackets);
}
}
if (!m_AllowFragmentation)
{
for (int j = 0; j < NetworkServer.numChannels; j++)
{
netMsg.conn.SetChannelOption(j, ChannelOption.AllowFragmentation, 0);
}
}
if (networkSceneName != "" && networkSceneName != m_OfflineScene)
{
StringMessage msg = new StringMessage(networkSceneName);
netMsg.conn.Send(39, msg);
}
if (m_MigrationManager != null)
{
m_MigrationManager.SendPeerInfo();
}
OnServerConnect(netMsg.conn);
}
public void sendMessageToServer(string value)
{
var msg = new StringMessage(value);
networkManager.client.Send(stringCode, msg);
Log("Sending message to server: " + value);
}
public void ReceiveServerEndGame(NetworkMessage massage) //NOT SHOWING RESULT YET!!!
{
StringMessage msg = new StringMessage();
msg.value = massage.ReadMessage <StringMessage>().value;
string[] deltas = msg.value.Split('|');
//MAIN QUEST && SIDE QUEST
if (deltas[queue] == "Win")
{
PlayerPrefs.SetInt("EXP", PlayerPrefs.GetInt("EXP") + int.Parse(deltas[queue + 4]) + 1000);
}
else
{
PlayerPrefs.SetInt("EXP", PlayerPrefs.GetInt("EXP") + int.Parse(deltas[queue + 4]) + 100);
}
CalculateLevel();
if (deltas[queue] == "Win")
{
resSide[0].SetActive(true);
}
else
{
resSide[1].SetActive(true);
}
end.SetActive(true);
}
// Update is called once per frame
void Update()
{
if (client.isConnected)
{
if (!isQueue)
{
isQueue = true;
StringMessage msg = new StringMessage();
msg.value = vtpy.GetComponent <VirturePlayer>().playerName;
client.Send(796, msg);
}
else if (recon.activeSelf)
{
recon.SetActive(false);
}
}
else if (!client.isConnected && isQueue)
{
if (!isQueue)
{
Connect();
}
else
{
if (!recon.activeSelf)
{
recon.SetActive(true);
}
}
}
}
void ServerStringMessageReceiver(NetworkMessage NetMsg)
{
StringMessage msg = new StringMessage();
msg.value = NetMsg.ReadMessage <StringMessage>().value;
string[] deltas = msg.value.Split('|');
switch (deltas[0])
{
case "AnAx":
float Hor = Mathf.Round(float.Parse(deltas[1]) * 100f) / 100f, Ver = Mathf.Round(float.Parse(deltas[2]) * 100f) / 100f;
CurrentConnections[NetMsg.conn.connectionId].SetAnalogAxis(Hor, Ver);
break;
case "Butt":
CurrentConnections[NetMsg.conn.connectionId].PressedButton(deltas[1], deltas[2] == "Down");
break;
case "Gyro":
CurrentConnections[NetMsg.conn.connectionId].SetGyroscope(deltas[1][0], deltas[2][0], deltas[3][0], deltas[4][0]);
//DebugText.instance.Log("ricevuto gyro");
break;
case "GetUp":
CurrentConnections[NetMsg.conn.connectionId].Fallen(false);
break;
}
}
public void ServerSoundToControllerSender(int i, string ToSend)
{
StringMessage msg = new StringMessage();
msg.value = "Snd|" + ToSend;
NetworkServer.SendToClient(CurrentConnections.First(ConnId => ConnId.Value == PlayersInputManagers[i]).Key, 888, msg);
}
public void OnMessage(NetworkMessage netMsg)
{
StringMessage sm = netMsg.ReadMessage <StringMessage>();
Debug.Log("OnScoreMessage " + sm.value);
if (sm.value == "Achterkant")
{
Debug.Log("Achterkant disabled");
GameObject go1 = GameObject.Find("Voorkant1");
go1.active = false;
GameObject go2 = GameObject.Find("Achterkant1");
go2.active = true;
GameObject go3 = GameObject.Find("Voorkant2");
go3.active = false;
GameObject go4 = GameObject.Find("Achterkant2");
go4.active = true;
}
else if (sm.value == "Voorkant")
{
Debug.Log("Voorkant disabled");
GameObject go1 = GameObject.Find("Voorkant1");
go1.active = true;
GameObject go2 = GameObject.Find("Achterkant1");
go2.active = false;
GameObject go3 = GameObject.Find("Voorkant2");
go3.active = true;
GameObject go4 = GameObject.Find("Achterkant2");
go4.active = false;
}
}
public void StartInstance(string gameName)
{
StringMessage msg = new StringMessage();
msg.value = gameName;
networkClient.Send((short)CustomMessageTypes.StartInstanceRequest, msg);
}
public void Should_be_able_to_send_string_message_and_have_it_delivered_to_all_consumers()
{
var message = new StringMessage();
_bus.Publish(message);
waitForAsyncCall();
message.TimesConsumed.ShouldEqual(2);
}
private void Update()
{
if (Input.GetKeyDown("f") && enable)
{
if (isOpen)
{
foreach (GameObject player in GameObject.FindGameObjectsWithTag("Player"))
{
if (player.GetComponent <OFBehavior>().isLocalPlayer)
{
inventory = player.GetComponent <Inventory>();
}
}
inventory.PutItem((int)Inventory.Item.flaregun);
GameObject.Find("Canvas").transform.Find("ItemText").gameObject.SetActive(false);
GetComponent <AudioSource>().PlayOneShot(pickupSound);
foreach (NetworkClient client in NetworkClient.allClients)
{
StringMessage msg = new StringMessage(name);
client.Send(getgun, msg);
}
}
else if (boxOpen)
{
inventory.UseItme();
foreach (NetworkClient client in NetworkClient.allClients)
{
StringMessage msg = new StringMessage(name);
client.Send(openbox, msg);
}
}
}
}
public virtual void ServerChangeScene(string newSceneName)
{
if (string.IsNullOrEmpty(newSceneName))
{
if (LogFilter.logError)
{
Debug.LogError("ServerChangeScene empty scene name");
}
return;
}
if (LogFilter.logDebug)
{
Debug.Log("ServerChangeScene " + newSceneName);
}
NetworkServer.SetAllClientsNotReady();
networkSceneName = newSceneName;
s_LoadingSceneAsync = SceneManager.LoadSceneAsync(newSceneName);
StringMessage msg = new StringMessage(networkSceneName);
NetworkServer.SendToAll((short)MsgType.Scene, msg);
s_StartPositionIndex = 0;
s_StartPositions.Clear();
}
public void ReceiveMessage(NetworkMessage message)
{
StringMessage msg = new StringMessage();
msg.value = message.ReadMessage <StringMessage>().value;
string[] deltas = msg.value.Split('|');
if (deltas[0].Equals("Connection"))
{
float r = float.Parse(deltas[1]) / 1000;
float g = float.Parse(deltas[2]) / 1000;
float b = float.Parse(deltas[3]) / 1000;
clr = new Color(r, g, b);
selection.SetActive(true);
loading.SetActive(false);
}
else if (deltas[0].Equals("Game"))
{
StartGame();
}
else if (deltas[0].Equals("Disconnect"))
{
Disconnect();
}
}
public void info_by_message_puts_a_time_stamp_on_it_2()
{
var l1 = new RecordingLogListener {
IsInfoEnabled = true
};
var l2 = new RecordingLogListener {
IsInfoEnabled = false, IsDebugEnabled = true
};
var l3 = new RecordingLogListener {
IsInfoEnabled = true
};
l1.ListensForTypes[typeof(StringMessage)] = true;
l2.ListensForTypes[typeof(StringMessage)] = true;
l3.ListensForTypes[typeof(StringMessage)] = true;
var systemTime = SystemTime.AtLocalTime(DateTime.Today.AddHours(8));
var logger = new Logger(new ILogListener[] { l1, l2, l3 }, new ILogModifier[] { new LogRecordModifier(systemTime) });
var message = new StringMessage("something");
logger.InfoMessage(message);
message.Time.ShouldEqual(systemTime.UtcNow());
}
private void Update()
{
if (Input.GetKeyDown("f") && enable)
{
foreach (GameObject player in GameObject.FindGameObjectsWithTag("Player"))
{
if (player.GetComponent <OFBehavior>().isLocalPlayer)
{
inventory = player.GetComponent <Inventory>();
}
}
int i = 0;
while (i < inventory.item.Length)
{
if (itemName.Equals(inventory.item[i]))
{
inventory.PutItem(i);
break;
}
i++;
}
GameObject.Find("Canvas").transform.Find("ItemText").gameObject.SetActive(false);
GetComponent <AudioSource>().PlayOneShot(pickupSound);
foreach (NetworkClient client in NetworkClient.allClients)
{
StringMessage msg = new StringMessage(name);
client.Send(putItem, msg);
}
}
}
public void SendMessage(KeyValuePair<SimpleServerChildTcpSocket, ChildSocketState> childSocket, string message)
{
// This function sends a simple (string) message to all connected clients
StringMessage msg = new StringMessage();
msg.Message = message;
string description = "<string message: " + msg.Message + ">";
// Serialize it to a binary array
byte[] binaryObject = SerializationHelper.Serialize(msg);
// Start a send on child socket
// Ignore sockets that are disconnecting
if (childSocket.Value == ChildSocketState.Connected)
{
try
{
ConsoleService.Write("Sending to " + childSocket.Key.RemoteEndPoint + ": " + description);
childSocket.Key.WriteAsync(binaryObject, description);
}
catch (Exception ex)
{
// Handle error
ConsoleService.Write("Child Socket error sending message to " + childSocket.Key.RemoteEndPoint + ": [" + ex.GetType().Name + "] " + ex.Message);
ResetChildSocket(childSocket.Key);
}
}
// In case there were any errors, the display may need to be updated
RefreshDisplay();
}
public void sendMessageToClients(string value)
{
var msg = new StringMessage(value);
NetworkServer.SendToAll(stringCode, msg);
Log("Sending message to all clients: " + value);
}
private void OnServerChatMessage(NetworkMessage netMsg)
{
var msg = netMsg.ReadMessage <StringMessage>();
var chatMessage = new StringMessage(msg.value);
NetworkServer.SendToAll((short)ChatMessageBase.ChatMessageTypes.CHAT_MESSAGE, chatMessage);
}
// Send network message to set the client id on the server
void SendClientId(int clientId)
{
// The message contains the client id and the paddle index
StringMessage msg = new StringMessage(clientId.ToString() + "." + paddleIndex.ToString());
NetworkManager.singleton.client.connection.Send(ID_MESSAGE, msg);
}
private static IEnumerator SendSceneLoad(int connectionId)
{
// wait until we've received the loadout
while (!NetworkMatch.m_player_loadout_data.ContainsKey(connectionId))
{
if (!NetworkMatch.m_players.ContainsKey(connectionId)) // disconnected?
{
yield break;
}
yield return(null);
}
StringMessage levelNameMsg = new StringMessage(MPJoinInProgress.NetworkMatchLevelName());
NetworkServer.SendToClient(connectionId, CustomMsgType.SceneLoad, levelNameMsg);
Debug.Log("JIP: sending scene load " + levelNameMsg.value);
if (NetworkMatch.GetMatchState() == MatchState.LOBBY_LOADING_SCENE)
{
yield break;
}
StringMessage sceneNameMsg = new StringMessage(GameplayManager.m_level_info.SceneName);
NetworkServer.SendToClient(connectionId, CustomMsgType.SceneLoaded, sceneNameMsg);
Debug.Log("JIP: sending scene loaded " + sceneNameMsg.value);
}
public void ListenServerMessage(NetworkMessage message)
{
StringMessage DataPackage = new StringMessage();
DataPackage.value = message.ReadMessage <StringMessage>().value;
try
{
DataPackageArr = DataPackage.value.Split('|');
}
finally
{
if (DataPackageArr[0] == "subjectSelect")
{
QuestionAnswerCnv.enabled = false;
subjectSelect.enabled = true;
}
else
{
question.QuestionText = DataPackageArr[0];
question.TrueAnswer = DataPackageArr[1];
question.TrueAnswerImageURL = DataPackageArr[2];
question.WrongAnswer = DataPackageArr[3];
question.WrongAnswerImageURL = DataPackageArr[4];
user.animation.ID = Convert.ToInt32(DataPackageArr[5]);
user.animation.Subject = DataPackageArr[6];
//Timer = 30.0f;
UpdateFactorAnimation();
FillInterface();
}
}
}
public void ReturnAddressFallbackButNotAvailable()
{
IApplicationContext context = TestUtils.GetContext(@"Endpoint\returnAddressTests.xml");
IMessageChannel channel3 = (IMessageChannel) context.GetObject("channel3");
((AbstractApplicationContext) context).Start();
StringMessage message = new StringMessage("*");
channel3.Send(message);
}
public void CreateLobby(NetworkMessage netMsg)
{
StringMessage msg = netMsg.ReadMessage <StringMessage>();
GameLobby lobby = GameLobby.Instance;
//lobby.SetOwner(msg.value);
SendMessageToClient(netMsg, owner, "Lobby created");
}
// SEND MESSAGE TO CLIENT
public void SendChangeStateMessage(string state)
{
StringMessage massage = new StringMessage();
massage.value = state + "|" + GameManagerPC.Instance.gameSession;
// Debug.Log("send: " + massage.value);
NetworkServer.SendToAll(NetworkMessageNumber.msgChangeState, massage);
}
public void removePoints(int ammount)
{
points -= ammount;
StringMessage msg = new StringMessage();
msg.value = playerID + "|" + ammount;
client.Send(134, msg);
}
public override void OnServerSceneChanged(string sceneName)
{
CallbackLog($"OnServerSceneChanged({sceneName})");
StringMessage msg = new StringMessage(networkSceneName);
NetworkServer.SendToAll(CustomMsgType.SceneChanged, msg);
}
public void SendToClientStatus(int id, string status, string etc)
{
StringMessage msg = new StringMessage();
msg.value = id + "|" + status + "|" + etc;
NetworkServer.SendToAll(787, msg);
Debug.Log(msg.value);
}
public void RequestMicrophoneValues()
{
StringMessage msg = new StringMessage(); //Nachricht an alle Clients erstellen
msg.value = isMicrophoneRequested.ToString();
//Von Server an den Client senden
NetworkServer.SendToAll(msgIDMicControl, msg);
}
private void serverReceiveLaneSwitch(NetworkMessage message)
{
StringMessage msg = new StringMessage();
msg.value = message.ReadMessage <StringMessage>().value;
string[] laneSwitch = msg.value.Split('|');
activateLaneSwitch(System.Convert.ToInt16(laneSwitch[0]), laneSwitch[1]);
}
public void sendReadyUp(int ready)
{
StringMessage msg = new StringMessage();
msg.value = ready + "|" + playerID + '|' + vehicleChoice + '|' + name;
client.Send(133, msg);
sendName();
}
void OnServerSurvivorDead(NetworkMessage recvmsg)
{
StringMessage msg = recvmsg.ReadMessage <StringMessage>();
int playerID = int.Parse(msg.value);
GameController.GetInstance().SurvivorDead(playerID);
NetworkServer.SendToAll(SurvivorDeadMsg, msg);
}
/// <summary>
/// This method registers with the network i_messageType, shared both by client and server.
/// When it receives this message, it deserializes the response into T1, then broadcasts a message
/// with i_messageToBroadcast and type T2.
/// T2 is generally an interface that T1 implements, allowing for the receiving methods to be testable.
/// </summary>
public void RegisterMessageHandler <T1, T2>(short i_messageType, string i_messageToBroadcast) where T1 : T2
{
mNetwork.RegisterMessageHandler(i_messageType, (message) => {
StringMessage messageFromServer = message.ReadMessage <StringMessage>();
T1 data = JsonConvert.DeserializeObject <T1>(messageFromServer.value);
MyMessenger.Instance.Send <T2>(i_messageToBroadcast, data);
});
}
public void RequestCompassSensorValues() //Wenn mit den default Werten wie im Inspector eingestellt gearbeitet werden soll
{
StringMessage msg = new StringMessage(); //Nachricht an alle Clients erstellen
msg.value = isCompassRequested.ToString();
//Von Server an den Client senden
NetworkServer.SendToAll(msgIdCompassControl, msg);
}
void OnReceive(string id, byte[] buffer, int offset, int length)
{
StringMessage recvMessage = new StringMessage(id);
recvMessage.RawData = new ArraySegment<byte>(buffer, offset, length);
Debug.Log(recvMessage.Data);
Debug.Log(string.Format("[id:{0}] Recv", id));
}
public void PostChatMessage(string message)
{
if (message.Length == 0)
return;
var msg = new StringMessage(username + " : " + message);
NetworkManager.singleton.client.Send(chatMsg, msg);
chatInput.text = "";
}
public void PollableChannel()
{
IApplicationContext context = TestUtils.GetContext(@"Config\Xml\BridgeParserTests-context.xml");
IMessage message = new StringMessage("test1");
IPollableChannel pollableChannel = (IPollableChannel) context.GetObject("pollableChannel");
pollableChannel.Send(message);
IPollableChannel output1 = (IPollableChannel) context.GetObject("output1");
IMessage reply = output1.Receive(TimeSpan.FromMilliseconds(1000));
Assert.That(reply, Is.EqualTo(message));
}
public void SubscribableChannel()
{
IApplicationContext context = TestUtils.GetContext(@"Config\Xml\BridgeParserTests-context.xml");
IMessage message = new StringMessage("test2");
IMessageChannel subscribableChannel = (IMessageChannel) context.GetObject("subscribableChannel");
subscribableChannel.Send(message);
IPollableChannel output2 = (IPollableChannel) context.GetObject("output2");
IMessage reply = output2.Receive(TimeSpan.Zero);
Assert.That(reply, Is.EqualTo(message));
}
public void testSendAndReceive()
{
ThreadLocalChannel channel = new ThreadLocalChannel();
StringMessage message = new StringMessage("test");
Assert.IsNull(channel.Receive());
Assert.IsTrue(channel.Send(message));
IMessage response = channel.Receive();
Assert.IsNotNull(response);
Assert.That(message, Is.EqualTo(response));
Assert.IsNull(channel.Receive());
}
public void SendChatMessage(string msg)
{
StringMessage strMsg = new StringMessage(msg);
if (isServer)
{
NetworkServer.SendToAll(CHAT_MSG, strMsg); // Send to all clients
}
else if (client.isConnected)
{
client.Send(CHAT_MSG, strMsg); // Sending message from client to server
}
}
public void add_log()
{
var log = new RequestLog();
var stringMessage = new StringMessage("something");
log.AddLog(123.45, stringMessage);
log.AddLog(234, "something");
log.AllSteps()
.ShouldHaveTheSameElementsAs(new RequestStep(123.45, stringMessage), new RequestStep(234, "something"));
}
public void simpleWireTap()
{
IApplicationContext ctx = TestUtils.GetContext(@"Config\WireTapParserTests.xml");
IMessageChannel mainChannel = (IMessageChannel) ctx.GetObject("noSelectors");
IPollableChannel wireTapChannel = (IPollableChannel) ctx.GetObject("wireTapChannel");
Assert.IsNull(wireTapChannel.Receive(TimeSpan.Zero));
IMessage original = new StringMessage("test");
mainChannel.Send(original);
IMessage intercepted = wireTapChannel.Receive(TimeSpan.Zero);
Assert.IsNotNull(intercepted);
Assert.That(intercepted, Is.EqualTo(original));
}
public void OutputChannelWithNoReturnAddress()
{
IApplicationContext context = TestUtils.GetContext(@"Endpoint\returnAddressTests.xml");
IMessageChannel channel4 = (IMessageChannel) context.GetObject("channel4");
IPollableChannel replyChannel = (IPollableChannel) context.GetObject("replyChannel");
((AbstractApplicationContext) context).Start();
StringMessage message = new StringMessage("*");
channel4.Send(message);
IMessage response = replyChannel.Receive(TimeSpan.FromMilliseconds(3000));
Assert.IsNotNull(response);
Assert.That(response.Payload, Is.EqualTo("**"));
}
public void TestCorrelationIdWithSplitter()
{
IMessage message = new StringMessage("test1,test2");
QueueChannel testChannel = new QueueChannel();
MethodInvokingSplitter splitter = new MethodInvokingSplitter(new TestBean(),
typeof (TestBean).GetMethod("Split"));
splitter.OutputChannel = testChannel;
splitter.HandleMessage(message);
IMessage reply1 = testChannel.Receive(TimeSpan.FromMilliseconds(100));
IMessage reply2 = testChannel.Receive(TimeSpan.FromMilliseconds(100));
Assert.That(reply1.Headers.CorrelationId, Is.EqualTo(message.Headers.Id));
Assert.That(reply2.Headers.CorrelationId, Is.EqualTo(message.Headers.Id));
}
public void testSendAndClear()
{
ThreadLocalChannel channel = new ThreadLocalChannel();
StringMessage message1 = new StringMessage("test1");
StringMessage message2 = new StringMessage("test2");
Assert.IsNull(channel.Receive());
Assert.IsTrue(channel.Send(message1));
Assert.IsTrue(channel.Send(message2));
IList<IMessage> clearedMessages = channel.Clear();
Assert.That(clearedMessages.Count, Is.EqualTo(2));
Assert.That(clearedMessages[0], Is.EqualTo(message1));
Assert.That(clearedMessages[1], Is.EqualTo(message2));
Assert.IsNull(channel.Receive());
}
protected override void OnReceive(object sender, ChannelReceiveEventArgs e)
{
base.OnReceive(sender, e);
System.Console.WriteLine(e.Channel.Coding.GetString(e.Data.Array, e.Data.Offset, e.Data.Count));
StringMessage stringMessage = new StringMessage();
if (this.Type == Program.ProlicyType.Flash)
{
stringMessage.Value = Utils.GetFlashPolicy();
}
else
{
stringMessage.Value = Utils.GetSLPolicy();
}
e.Channel.Send(stringMessage);
}
public void PostChatMessage(string message)
{
if (message.Length == 0)
return;
var msg = new StringMessage (message);
NetworkManager.singleton.client.Send (chatMsg, msg);
chatInput.text = "";
chatInput.Select ();
chatInput.ActivateInputField ();
//scroll to bottom
GameObject win = GameObject.Find ("Content");
RectTransform rt = (RectTransform)win.transform;
float y = rt.position.y + rt.sizeDelta.y + 2;
rt.position = new Vector3 (rt.position.x, y, rt.position.y);
}
public void MethodInvokingConsumer()
{
const string objectName = "methodInvokingConsumer";
object channel = _ctx.GetObject(objectName);
Assert.IsTrue(channel is DirectChannel);
ObjectFactoryChannelResolver channelResolver = new ObjectFactoryChannelResolver(_ctx);
Assert.IsNotNull(channelResolver.ResolveChannelName(objectName));
object adapter = _ctx.GetObject(objectName + ".adapter");
Assert.IsNotNull(adapter);
Assert.IsTrue(adapter is EventDrivenConsumer);
TestObject testBean = (TestObject) _ctx.GetObject("testObject");
Assert.IsNull(testBean.GetMessage());
IMessage message = new StringMessage("consumer test");
Assert.IsTrue(((IMessageChannel) channel).Send(message));
Assert.IsNotNull(testBean.GetMessage());
Assert.That(testBean.GetMessage(), Is.EqualTo("consumer test"));
}
public void TestMessageAsReturnValue()
{
QueueChannel requestChannel = new QueueChannel();
new Thread(new ThreadStart(delegate
{
IMessage input = requestChannel.Receive();
StringMessage reply = new StringMessage(input.Payload + "bar");
((IMessageChannel) input.Headers.ReplyChannel).Send(reply);
})).Start();
GatewayProxyFactoryObject proxyFactory = new GatewayProxyFactoryObject();
proxyFactory.ServiceInterface = typeof (ITestService);
proxyFactory.DefaultRequestChannel = requestChannel;
proxyFactory.AfterPropertiesSet();
ITestService service = (ITestService) proxyFactory.GetObject();
IMessage result = service.RequestReplyWithMessageReturnValue("foo");
Assert.That(result.Payload, Is.EqualTo("foobar"));
}
public void debugging_by_message_puts_a_time_stamp_on_it_2()
{
var l1 = new RecordingLogListener { IsInfoEnabled = true };
var l2 = new RecordingLogListener { IsInfoEnabled = false, IsDebugEnabled = true };
var l3 = new RecordingLogListener { IsInfoEnabled = true };
l1.ListensForTypes[typeof(StringMessage)] = true;
l2.ListensForTypes[typeof(StringMessage)] = true;
l3.ListensForTypes[typeof(StringMessage)] = true;
var systemTime = SystemTime.AtLocalTime(DateTime.Today.AddHours(8));
var logger = new Logger(systemTime, new ILogListener[] { l1, l2, l3 });
var message = new StringMessage("something");
logger.DebugMessage(message);
message.Time.ShouldEqual(systemTime.UtcNow());
}
public IMessage CreateSingleMessageFromGroup(IList<IMessage> messages)
{
List<IMessage> sortableList = new List<IMessage>(messages);
sortableList.Sort(new MessageSequenceComparator());
StringBuilder buffer = new StringBuilder();
object correlationId = null;
foreach (IMessage message in sortableList)
{
buffer.Append(message.Payload.ToString());
if (null == correlationId)
{
correlationId = message.Headers.CorrelationId;
}
}
IMessage returnedMessage = new StringMessage(buffer.ToString());
aggregatedMessages.Add(correlationId, returnedMessage);
return returnedMessage;
}
private void ILog(string data) {
//If we are not the editor we need to find the editor
//Clients will send the message to the server (could be the editor)
//If the server receives a msg and is not the editor, he will broadcast the log
//Because on of the clients may be the editor
if (isServer) {
#if UNITY_EDITOR
Debug.Log(data);
#else
RpcClientLog(data);
#endif
} else if (isClient) {
#if UNITY_EDITOR
Debug.Log(data);
#else
var smsg = new StringMessage(data);
connectionToServer.Send(NWDebugMsgType, smsg);
#endif
}
}
public void wireTapWithRejectingSelector()
{
IApplicationContext ctx = TestUtils.GetContext(@"Config\WireTapParserTests.xml");
IMessageChannel mainChannel = (IMessageChannel) ctx.GetObject("rejecting");
IPollableChannel wireTapChannel = (IPollableChannel) ctx.GetObject("wireTapChannel");
Assert.IsNull(wireTapChannel.Receive(TimeSpan.Zero));
IMessage original = new StringMessage("test");
mainChannel.Send(original);
IMessage intercepted = wireTapChannel.Receive(TimeSpan.Zero);
Assert.IsNull(intercepted);
}
public void SendStringMessage()
{
// get the text in the input field
StringMessage strMessage = new StringMessage(messageFied.text);
castLead.GetComponent<Demo3Character>().HandleMessage(strMessage);
messageFied.text = "";
}
public void SubmitSpell()
{
foreach (Transform obj in strokeObjects)
{
GameObject.Destroy(obj.gameObject);
}
strokeObjects.Clear();
MessageBase message = new StringMessage(new string(spell.ToArray()));
spell.Clear();
NetworkClient client = NetworkManager.singleton.client;
client.Send(1002, message);
}
// TODO public void TestCheckedExceptionRethrownAsIs
//[Test, ExpectedException(typeof(TestException))]
//public void TestCheckedExceptionRethrownAsIs() {
// GatewayProxyFactoryObject proxyFactory = new GatewayProxyFactoryObject();
// DirectChannel channel = new DirectChannel();
// EventDrivenConsumer consumer = new EventDrivenConsumer(channel, new MessageHandler() {
// public void handleMessage(Message<?> message) {
// MethodInfo method = ReflectionUtils.GetMethod(typeof(GatewayProxyFactoryObjectTests), "throwTestException",null);
// method.Invoke(this, null);
// }
// });
// consumer.start();
// proxyFactory.setDefaultRequestChannel(channel);
// proxyFactory.setServiceInterface(TestExceptionThrowingInterface.class);
// proxyFactory.afterPropertiesSet();
// TestExceptionThrowingInterface proxy = (TestExceptionThrowingInterface) proxyFactory.getObject();
// proxy.throwCheckedException("test");
//}
private static void StartResponder(IPollableChannel requestChannel)
{
new Thread(new ThreadStart(delegate
{
IMessage input = requestChannel.Receive();
StringMessage reply = new StringMessage(input.Payload + "bar");
((IMessageChannel) input.Headers.ReplyChannel).Send(reply);
})).Start();
}
public void TestRequestReplyWithTypeConversion()
{
QueueChannel requestChannel = new QueueChannel();
new Thread(new ThreadStart(delegate
{
IMessage input = requestChannel.Receive();
StringMessage reply = new StringMessage(input.Payload + "456");
((IMessageChannel) input.Headers.ReplyChannel).Send(reply);
})).Start();
GatewayProxyFactoryObject proxyFactory = new GatewayProxyFactoryObject();
proxyFactory.ServiceInterface = typeof (ITestService);
proxyFactory.DefaultRequestChannel = requestChannel;
proxyFactory.AfterPropertiesSet();
ITestService service = (ITestService) proxyFactory.GetObject();
int result = service.RequestReplyWithIntegers(123);
Assert.That(result, Is.EqualTo(123456));
}
void SendExample2()
{
StringMessage message = new StringMessage("Basic/Example2");
message.Data = "data=Hello world";
session.Send(message);
}
public void TestClear()
{
QueueChannel channel = new QueueChannel(2);
StringMessage message1 = new StringMessage("test1");
StringMessage message2 = new StringMessage("test2");
StringMessage message3 = new StringMessage("test3");
Assert.IsTrue(channel.Send(message1));
Assert.IsTrue(channel.Send(message2));
Assert.IsFalse(channel.Send(message3, TimeSpan.Zero));
IList<IMessage> clearedMessages = channel.Clear();
Assert.IsNotNull(clearedMessages);
Assert.That(clearedMessages.Count, Is.EqualTo(2));
Assert.IsTrue(channel.Send(message3));
}
public HtmlTag VisualizePartial(StringMessage message)
{
return new CommentTag(message.Message);
}
