public void MessageFromSubscriberIsSentToCorrectHost()
{
byte[] b = new byte[1024];
NetworkController nc = new NetworkController();
FakeServer server = new FakeServer();
nc.Servers.Add(server);
Networking.NetworkController = nc;
Networking.Start();
FakeSender sender = new FakeSender();
SenderBase.FactoryMethod = e => sender;
Message msg = new Message();
msg.Data = b;
msg.Sender = EllaConfiguration.Instance.NodeId + 1;
msg.Type = MessageType.Discover;
IPEndPoint ep = new IPEndPoint(IPAddress.Parse("234.234.234.4"), 3456);
server.DiscoveryMessageEvent(msg, ep);
TestSubscriber s = new TestSubscriber();
s.Subscribe();
server.SubscribeResponseMessageEvent(sender._id);
Thread.Sleep(1000);
s.SendMessage();
Thread.Sleep(1000);
Assert.AreEqual(1, sender._messages[MessageType.ApplicationMessage]);
}
public async Task SendRequest <T>(string serviceUri, HttpRequestBase request, Action <T> callback) where T : HttpResponseBase, new()
{
if (typeof(T) == typeof(CreateRoomResponse))
{
var roomId = _createRoomDelegate(_roomProperties, _gameApplication, ((CreateRoomRequest)request).RoomId);
callback(new CreateRoomResponse(roomId) as T);
}
else
if (typeof(T) == typeof(GetServerInfoListResponse))
{
callback(FakeSender.CreateGetServerInfoListResponse <T>() as T);
}
else
if (typeof(T) == typeof(ValidateSessionIdResponse))
{
callback(new ValidateSessionIdResponse()
{
ResultCode = ResultCode.OK
} as T);
}
else
{
callback(new T());
}
}
public void NetworkControllerSubscriptionMessageIsProcessed()
{
byte[] b = new byte[1024];
NetworkController nc = new NetworkController();
FakeServer server = new FakeServer();
nc.Servers.Add(server);
Networking.NetworkController = nc;
Networking.Start();
FakeSender sender = new FakeSender();
SenderBase.FactoryMethod = e => sender;
Message msg = new Message();
msg.Data = b;
msg.Sender = EllaConfiguration.Instance.NodeId + 1;
msg.Type = MessageType.Discover;
IPEndPoint ep = new IPEndPoint(IPAddress.Parse("234.234.234.4"), 3456);
server.DiscoveryMessageEvent(msg, ep);
PublisherWithCallbackMethod p = new PublisherWithCallbackMethod();
Start.Publisher(p);
server.SubscriptionMessage(typeof(bool));
Thread.Sleep(1000);
Assert.IsTrue(sender._messages.ContainsKey(MessageType.SubscribeResponse));
}
public void NetworkControllerSendShutDownMessage()
{
byte[] b = new byte[1024];
NetworkController nc = new NetworkController();
FakeServer server = new FakeServer();
FakeSender sender = new FakeSender();
nc.Servers.Add(server);
Networking.NetworkController = nc;
Networking.Start();
SenderBase.FactoryMethod = e => sender;
Message msg = new Message();
msg.Data = b;
msg.Sender = EllaConfiguration.Instance.NodeId + 1;
msg.Type = MessageType.Discover;
IPEndPoint ep = new IPEndPoint(IPAddress.Parse("234.234.234.4"), 3456);
server.DiscoveryMessageEvent(msg, ep);
Stop.Ella();
Assert.AreEqual(1, sender._messages[MessageType.NodeShutdown]);
}
public void NetworkControllerSubscriptionCacheIsSentOnlyOnce()
{
byte[] b = new byte[1024];
NetworkController nc = new NetworkController();
FakeServer server = new FakeServer();
FakeSender sender = new FakeSender();
nc.Servers.Add(server);
Networking.NetworkController = nc;
Networking.Start();
SenderBase.FactoryMethod = e => sender;
TestSubscriber subscriber = new TestSubscriber();
subscriber.Subscribe();
Message msg = new Message();
msg.Data = b;
msg.Sender = EllaConfiguration.Instance.NodeId + 1;
msg.Type = MessageType.Discover;
IPEndPoint ep = new IPEndPoint(IPAddress.Parse("234.234.234.4"), 3456);
server.DiscoveryMessageEvent(msg, ep);
Thread.Sleep(3000);
Assert.AreEqual(1, sender._messages[MessageType.Subscribe]);
}
public void MessageQueuedForReceive_IsNotLogged_IfReceiveAborts()
{
ManualResetEvent wait = new ManualResetEvent(false);
var sender = new FakeSender
{
Destination = new Endpoint("localhost", 23457),
Messages = new[]
{
new Message
{
Id =
new MessageId
{
MessageIdentifier = Guid.NewGuid(),
SourceInstanceId = Guid.NewGuid()
},
SentAt = DateTime.Now,
Queue = "h",
Data = new byte[] { 1, 2, 4, 5 }
}
}
};
sender.SendCompleted += () => wait.Set();
var logger = new RecordingLogger();
sender.Send();
wait.WaitOne(TimeSpan.FromSeconds(1));
Wait.Until(() => logger.MessagesQueuedForReceive.Any(),
timeoutInMilliseconds: 1000)
.ShouldBeFalse();
}
public void MessageQueuedForReceive_EventNotRaised_IfReceiveAborts()
{
ManualResetEvent wait = new ManualResetEvent(false);
using (var sender = new FakeSender
{
Destination = new Endpoint("localhost", 23457),
FailToAcknowledgeReceipt = true,
Messages = new[] { new Message
{
Id = new MessageId {
MessageIdentifier = Guid.NewGuid(), SourceInstanceId = Guid.NewGuid()
},
SentAt = DateTime.Now,
Queue = "h",
Data = new byte[] { 1, 2, 4, 5 }
} }
})
{
sender.SendCompleted += () => wait.Set();
using (var receiver = SetupReciever())
{
receiver.MessageQueuedForReceive += RecordMessageEvent;
sender.Send();
wait.WaitOne();
Thread.Sleep(1000);
receiver.MessageQueuedForReceive -= RecordMessageEvent;
}
}
Assert.Null(messageEventArgs);
}
public void SetUp()
{
fakeSender = new FakeSender();
var settingsHolder = new SettingsHolder();
faultManager = new FaultManager(fakeSender, new Configure(settingsHolder, new FakeContainer(), new List <Action <IConfigureComponents> >(), null), new BusNotifications());
faultManager.Init(new Address("fake", "fake"));
}
static string address = "25.3.124.57"; // адрес сервера
static void Main(string[] args)
{
var a = new FakeSender(address, port);
a.Send();
a.DataToSend.Add(Encoding.Unicode.GetBytes("ads"));
while (true)
{
}
}
public void NetworkControllerStart()
{
NetworkController nc = new NetworkController();
FakeServer server = new FakeServer();
FakeSender sender = new FakeSender();
nc.Servers.Add(server);
Networking.NetworkController = nc;
Networking.Start();
Assert.IsTrue(server._startedNetwork);
}
public void CanBuildInstructionForPresentLoad()
{
ISender sender = new FakeSender();
InstructionPacketBase instructionPacket = new InstructionPacketReadPresentLoad(SERVO_ID, sender);
Assert.AreEqual(0xFF, instructionPacket.StartByte1);
Assert.AreEqual(0xFF, instructionPacket.StartByte2);
Assert.AreEqual(0x01, instructionPacket.ServoId);
Assert.AreEqual(0x04, instructionPacket.LengthOfCommand);
Assert.AreEqual(0x02, instructionPacket.Instruction);
Assert.AreEqual(0xCE, instructionPacket.CheckSum);
var corectResult = new byte[] { 0XFF, 0XFF, 0X01, 0X04, 0X02, 0X28, 0X02, 0XCE };
Assert.AreEqual(corectResult, instructionPacket.ToByte());
}
public async Task ExecuteAsync_ResponseOk_DoesNotRetry()
{
var options = new DefaultRetryPolicyOptions
{
DeltaBackoff = TimeSpan.FromSeconds(5)
};
var retryPolicy = new DefaultRetryPolicy(options);
var client = new FakeSender().Returns(HttpStatusCode.OK);
var response = await retryPolicy.ExecuteAsync(client.SendRequest);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(1, client.TimesCalled);
}
public void CanCreateInstructionPacketForPingId1()
{
ISender sender = new FakeSender();
var instructionPacket = new InstructionPacketPing(SERVO_ID, sender);
Assert.AreEqual(0xFF, instructionPacket.StartByte1);
Assert.AreEqual(0xFF, instructionPacket.StartByte2);
Assert.AreEqual(0x01, instructionPacket.ServoId);
Assert.AreEqual(0x02, instructionPacket.LengthOfCommand);
Assert.AreEqual(0x01, instructionPacket.Instruction);
Assert.AreEqual(0xFB, instructionPacket.CheckSum);
var corectResult = new byte[] {0XFF, 0XFF, 0X01, 0X02, 0X01, 0XFB};
Assert.AreEqual(corectResult, instructionPacket.ToByte());
}
public void It_removes_staging_id_header()
{
var sender = new FakeSender();
var headers = new Dictionary <string, string>
{
["ServiceControl.Retry.StagingId"] = "SomeId",
["ServiceControl.TargetEndpointAddress"] = "TargetEndpoint"
};
var message = new TransportMessage(Guid.NewGuid().ToString(), headers);
ReturnToSenderDequeuer.HandleMessage(message, new FakeBodyStorage(), sender);
Assert.IsFalse(sender.Message.Headers.ContainsKey("ServiceControl.Retry.StagingId"));
}
public async Task ExecuteAsync_ThrottledRequest_NoHeader_GetsNextWaitTime(HttpStatusCode statusCode)
{
var options = new DefaultRetryPolicyOptions
{
DeltaBackoff = TimeSpan.FromSeconds(10),
MaxCumulativeWaitTime = TimeSpan.FromSeconds(5)
};
var retryPolicy = new DefaultRetryPolicy(options);
var client = new FakeSender().Returns(statusCode);
var response = await retryPolicy.ExecuteAsync(client.SendRequest);
Assert.Equal(statusCode, response.StatusCode);
Assert.Equal(1, client.TimesCalled);
}
public async Task It_removes_staging_id_header()
{
var sender = new FakeSender();
var headers = new Dictionary <string, string>
{
["ServiceControl.Retry.StagingId"] = "SomeId",
["ServiceControl.TargetEndpointAddress"] = "TargetEndpoint"
};
var message = CreateMessage(Guid.NewGuid().ToString(), headers);
await new ReturnToSender(new FakeBodyStorage()).HandleMessage(message, sender)
.ConfigureAwait(false);
Assert.IsFalse(sender.Message.Headers.ContainsKey("ServiceControl.Retry.StagingId"));
}
public void It_fetches_the_body_if_provided()
{
var sender = new FakeSender();
var headers = new Dictionary <string, string>
{
["ServiceControl.Retry.StagingId"] = "SomeId",
["ServiceControl.TargetEndpointAddress"] = "TargetEndpoint",
["ServiceControl.Retry.Attempt.MessageId"] = "MessageBodyId"
};
var message = new TransportMessage(Guid.NewGuid().ToString(), headers);
ReturnToSenderDequeuer.HandleMessage(message, new FakeBodyStorage(), sender);
Assert.AreEqual("MessageBodyId", Encoding.UTF8.GetString(sender.Message.Body));
}
public void It_sends_directly_to_target_if_retry_to_is_not_provided()
{
var sender = new FakeSender();
var headers = new Dictionary <string, string>
{
["ServiceControl.Retry.StagingId"] = "SomeId",
["ServiceControl.TargetEndpointAddress"] = "TargetEndpoint",
};
var message = new TransportMessage(Guid.NewGuid().ToString(), headers);
ReturnToSenderDequeuer.HandleMessage(message, new FakeBodyStorage(), sender);
Assert.AreEqual("TargetEndpoint", sender.Options.Destination.Queue);
Assert.IsFalse(sender.Message.Headers.ContainsKey("ServiceControl.TargetEndpointAddress"));
}
public void It_uses_retry_to_if_provided()
{
var sender = new FakeSender();
var headers = new Dictionary <string, string>
{
["ServiceControl.Retry.StagingId"] = "SomeId",
["ServiceControl.TargetEndpointAddress"] = "TargetEndpoint",
["ServiceControl.RetryTo"] = "Proxy"
};
var message = new TransportMessage(Guid.NewGuid().ToString(), headers);
ReturnToSenderDequeuer.HandleMessage(message, new FakeBodyStorage(), sender);
Assert.AreEqual("Proxy", sender.Options.Destination.Queue);
Assert.AreEqual("TargetEndpoint", sender.Message.Headers["ServiceControl.TargetEndpointAddress"]);
}
public async Task It_sends_directly_to_target_if_retry_to_is_not_provided()
{
var sender = new FakeSender();
var headers = new Dictionary <string, string>
{
["ServiceControl.Retry.StagingId"] = "SomeId",
["ServiceControl.TargetEndpointAddress"] = "TargetEndpoint"
};
var message = CreateMessage(Guid.NewGuid().ToString(), headers);
await new ReturnToSender(new FakeBodyStorage()).HandleMessage(message, sender)
.ConfigureAwait(false);
Assert.AreEqual("TargetEndpoint", sender.Destination);
Assert.IsFalse(sender.Message.Headers.ContainsKey("ServiceControl.TargetEndpointAddress"));
}
public async Task It_fetches_the_body_if_provided()
{
var sender = new FakeSender();
var headers = new Dictionary <string, string>
{
["ServiceControl.Retry.StagingId"] = "SomeId",
["ServiceControl.TargetEndpointAddress"] = "TargetEndpoint",
["ServiceControl.Retry.Attempt.MessageId"] = "MessageBodyId"
};
var message = CreateMessage(Guid.NewGuid().ToString(), headers);
await new ReturnToSender(new FakeBodyStorage()).HandleMessage(message, sender)
.ConfigureAwait(false);
Assert.AreEqual("MessageBodyId", Encoding.UTF8.GetString(sender.Message.Body));
}
public async Task ExecuteAsync_RecoversAfterNotSuccessStatusCode()
{
var options = new DefaultRetryPolicyOptions
{
DeltaBackoff = TimeSpan.FromMilliseconds(100)
};
var retryPolicy = new DefaultRetryPolicy(options);
var client = new FakeSender().Returns(HttpStatusCode.InternalServerError, HttpStatusCode.OK);
var stopwatch = Stopwatch.StartNew();
var response = await retryPolicy.ExecuteAsync(client.SendRequest);
stopwatch.Stop();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(2, client.TimesCalled);
Assert.True(stopwatch.Elapsed > 0.8 * options.DeltaBackoff);
}
public async Task ExecuteAsync_ThrottledRequest_RetryAfterHeaderWithDate_ReadsWaitTimeFromHeader(HttpStatusCode statusCode)
{
var options = new DefaultRetryPolicyOptions
{
DeltaBackoff = TimeSpan.FromMilliseconds(100),
MaxCumulativeWaitTime = TimeSpan.FromSeconds(5)
};
var retryPolicy = new DefaultRetryPolicy(options);
var mockResponse = new HttpResponseMessage(statusCode);
mockResponse.Headers.RetryAfter = new RetryConditionHeaderValue(DateTime.UtcNow.AddSeconds(6));
var client = new FakeSender().Returns(mockResponse);
var response = await retryPolicy.ExecuteAsync(client.SendRequest);
Assert.Equal(statusCode, response.StatusCode);
Assert.Equal(1, client.TimesCalled);
}
public async Task ExecuteAsync_ThrottledRequest_RetryAfterHeaderWithNotPositiveDelta_GetsNextWaitTime(HttpStatusCode statusCode, int waitTimeInSeconds)
{
var options = new DefaultRetryPolicyOptions
{
DeltaBackoff = TimeSpan.FromSeconds(10),
MaxCumulativeWaitTime = TimeSpan.FromSeconds(5)
};
var retryPolicy = new DefaultRetryPolicy(options);
var mockResponse = new HttpResponseMessage(statusCode);
mockResponse.Headers.RetryAfter = new RetryConditionHeaderValue(TimeSpan.FromSeconds(waitTimeInSeconds));
var client = new FakeSender().Returns(mockResponse);
var response = await retryPolicy.ExecuteAsync(client.SendRequest);
Assert.Equal(statusCode, response.StatusCode);
Assert.Equal(1, client.TimesCalled);
}
public void NetworkControllerSendMessage()
{
byte[] data = new byte[1024];
NetworkController nc = new NetworkController();
FakeServer server = new FakeServer();
FakeSender sender = new FakeSender();
nc.Servers.Add(server);
Networking.NetworkController = nc;
Networking.Start();
SenderBase.FactoryMethod = e => sender;
Message msg = new Message();
msg.Data = data;
msg.Sender = EllaConfiguration.Instance.NodeId + 1;
msg.Type = MessageType.Discover;
IPEndPoint ep = new IPEndPoint(IPAddress.Parse("234.234.234.4"), 3456);
server.DiscoveryMessageEvent(msg, ep);
TestSubscriber s = new TestSubscriber();
s.Subscribe();
byte[] b = { 1, 2 };
ApplicationMessage app = new ApplicationMessage();
app.Data = b;
RemoteSubscriptionHandle rh = new RemoteSubscriptionHandle();
rh.PublisherNodeID = EllaConfiguration.Instance.NodeId + 1;
Send.Message(app, rh, s);
Thread.Sleep(1000);
Assert.AreEqual(1, sender._messages[MessageType.ApplicationMessage]);
}
public void CanCreateInstructionPacketForSyncedMovment()
{
ISender sender = new FakeSender();
var movment1 = new MovmentComandAX12(0, 0x010, 0x150);
var movment2 = new MovmentComandAX12(1, 0x220, 0x360);
var movment3 = new MovmentComandAX12(2, 0x030, 0x170);
var movment4 = new MovmentComandAX12(3, 0x220, 0x380);
var instructionPacket = new InstructionPacketSyncMovment(sender, movment1, movment2, movment3, movment4);
var corectResult = new byte[]
{
0XFF, 0XFF, 0XFE, 0X18, 0X83, 0X1E, 0X04, 0X00, 0X10, 0X00, 0X50, 0X01, 0X01,
0X20, 0X02, 0X60, 0X03, 0X02, 0X30, 0X00, 0X70, 0X01, 0X03, 0X20, 0X02, 0X80,
0X03, 0X12
};
Assert.AreEqual(corectResult, instructionPacket.ToByte());
// Console.WriteLine(BitConverter.ToString(corectResult));
// Console.WriteLine(BitConverter.ToString(instructionPacket.ToByte()));
}
public void CanBuildInstructionForReadingTemperature()
{
ISender sender = new FakeSender();
InstructionPacketBase instructionPacket = new InstructionPacketReadTemperature(SERVO_ID, sender);
Assert.AreEqual(0xFF, instructionPacket.StartByte1);
Assert.AreEqual(0xFF, instructionPacket.StartByte2);
Assert.AreEqual(0x01, instructionPacket.ServoId);
Assert.AreEqual(0x04, instructionPacket.LengthOfCommand);
Assert.AreEqual(0x02, instructionPacket.Instruction);
Assert.AreEqual(0xCC, instructionPacket.CheckSum);
var corectResult = new byte[] { 0XFF, 0XFF, 0X01, 0X04, 0X02, 0X2B, 0X01, 0XCC};
Assert.AreEqual(corectResult, instructionPacket.ToByte());
//temp 43 0x2B
//loadL 40 0x28
//loadH 41 0x29
//Load Direction = 0 : CCW Load, Load Direction = 1: CW Load
}
public void NetworkControllerUnsubscribeFrom()
{
byte[] b = new byte[1024];
NetworkController nc = new NetworkController();
FakeServer fs = new FakeServer();
FakeSender sender = new FakeSender();
nc.Servers.Add(fs);
Networking.NetworkController = nc;
Networking.Start();
SenderBase.FactoryMethod = e => sender;
//this discoveryMessage is required to add the Instance to the RemoteHosts,
//which is used in the NetworkController to send messages, subscribe, unsubscribe..
//must call these MessageProcessor methods by hand, because the FakeSender just fakes the Send() implementation
Message msg = new Message();
msg.Data = b;
msg.Sender = EllaConfiguration.Instance.NodeId + 1;
msg.Type = MessageType.Discover;
IPEndPoint ep = new IPEndPoint(IPAddress.Parse("234.234.234.4"), 3456);
fs.DiscoveryMessageEvent(msg, ep);
TestSubscriber s = new TestSubscriber();
s.Subscribe();
Thread.Sleep(1000);
//after subscription is done: new MessageEvent of Type SubscribeResponse is faked in FakeServer
fs.SubscribeResponseMessageEvent(sender._id);
s.UnsubscribeFromRemote();
Thread.Sleep(1000);
Assert.AreEqual(1, sender._messages[MessageType.Unsubscribe]);
}
public async Task ExecuteAsync_RecoversAfterException()
{
var options = new DefaultRetryPolicyOptions
{
DeltaBackoff = TimeSpan.FromMilliseconds(100)
};
var retryPolicy = new DefaultRetryPolicy(options);
var client = new FakeSender()
.Throws(GetExceptionFromStatus(WebExceptionStatus.ConnectionClosed))
.Returns(HttpStatusCode.OK);
var stopwatch = Stopwatch.StartNew();
var response = await retryPolicy.ExecuteAsync(client.SendRequest);
stopwatch.Stop();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(2, client.TimesCalled);
Assert.True(stopwatch.Elapsed > 0.8 * options.DeltaBackoff);
}
public async Task ExecuteAsync_Exception_RetriesUntilCumulativeWaitTimeReached()
{
var options = new DefaultRetryPolicyOptions
{
DeltaBackoff = TimeSpan.FromMilliseconds(100),
MaxCumulativeWaitTime = TimeSpan.FromSeconds(2)
};
var retryPolicy = new DefaultRetryPolicy(options);
var client = new FakeSender().Throws(GetExceptionFromStatus(WebExceptionStatus.ConnectionClosed));
var stopwatch = Stopwatch.StartNew();
await Assert.ThrowsAsync <HttpRequestException>(() => retryPolicy.ExecuteAsync(client.SendRequest));
stopwatch.Stop();
Assert.True(client.TimesCalled > 1);
var maximumPossibleNextWaitTime = 1.2 * options.DeltaBackoff * Math.Pow(2, client.TimesCalled - 1);
Assert.True(stopwatch.Elapsed > options.MaxCumulativeWaitTime - maximumPossibleNextWaitTime);
}
public async Task ExecuteAsync_UnsuccessfulStatusCode_RetriesUntilCumulativeWaitTimeReached()
{
var options = new DefaultRetryPolicyOptions
{
DeltaBackoff = TimeSpan.FromMilliseconds(100),
MaxCumulativeWaitTime = TimeSpan.FromSeconds(2)
};
var retryPolicy = new DefaultRetryPolicy(options);
var client = new FakeSender().Returns(HttpStatusCode.InternalServerError);
var stopwatch = Stopwatch.StartNew();
var response = await retryPolicy.ExecuteAsync(client.SendRequest);
stopwatch.Stop();
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
Assert.True(client.TimesCalled > 1);
var maximumPossibleNextWaitTime = 1.2 * options.DeltaBackoff * Math.Pow(2, client.TimesCalled - 1);
Assert.True(stopwatch.Elapsed > options.MaxCumulativeWaitTime - maximumPossibleNextWaitTime);
}
public async Task <T> SendRequest <T>(string serviceUri, HttpRequestBase request) where T : HttpResponseBase, new()
{
if (typeof(T) == typeof(CreateRoomResponse))
{
var roomId = _createRoomDelegate(_roomProperties, _gameApplication, ((CreateRoomRequest)request).RoomId);
return(new CreateRoomResponse(roomId) as T);
}
if (typeof(T) == typeof(UpdateRoomResponse))
{
var req = request as UpdateRoomRequest;
_updateRoomDelegate(req.RoomId, _gameApplication);
return(new UpdateRoomResponse() as T);
}
if (typeof(T) == typeof(GetServerInfoListResponse))
{
return(FakeSender.CreateGetServerInfoListResponse <T>() as T);
}
;
return(new T());
}
public void NetworkControllerConnectToMulticastGroup()
{
NetworkController nc = new NetworkController();
FakeServer server = new FakeServer();
FakeSender sender = new FakeSender();
nc.Servers.Add(server);
Networking.NetworkController = nc;
Networking.Start();
SenderBase.FactoryMethod = e => sender;
MulticastRemoteSubscriptionhandle h = new MulticastRemoteSubscriptionhandle();
Networking.ConnectToMulticast(h.IpAddress, h.Port);
TestSubscriber s = new TestSubscriber();
s.Subscribe();
Assert.IsTrue(server._connectedToMulticastGroup);
}
