public void Constructor_EstablishTwoWithSamePort_ShouldYieldAccessibleException()
{
var port = Ports.GetNext();
var server1 = DicomServer.Create <DicomCEchoProvider>(port);
while (!server1.IsListening)
{
Thread.Sleep(10);
}
var exception = Record.Exception(() => DicomServer.Create <DicomCEchoProvider>(port));
Assert.IsType <DicomNetworkException>(exception);
Assert.True(server1.IsListening);
Assert.Null(server1.Exception);
}
public async Task WaitForAssociationAsync_TooShortTimeout_ReturnsFalse()
{
var port = Ports.GetNext();
using (DicomServer.Create <MockCEchoProvider>(port))
{
var client = new DicomClient();
client.AddRequest(new DicomCEchoRequest {
OnResponseReceived = (rq, rsp) => Thread.Sleep(100)
});
var task = client.SendAsync("127.0.0.1", port, false, "SCU", "ANY-SCP");
var actual = await client.WaitForAssociationAsync(1);
task.Wait(1000);
Assert.False(actual);
}
}
public async Task ReleaseAsync_AfterAssociation_SendIsCompleted()
{
int port = Ports.GetNext();
using (DicomServer.Create <MockCEchoProvider>(port))
{
var client = new DicomClient();
client.AddRequest(new DicomCEchoRequest());
var task = client.SendAsync("127.0.0.1", port, false, "SCU", "ANY-SCP");
client.WaitForAssociation();
await client.ReleaseAsync();
Thread.Sleep(10);
Assert.True(task.IsCompleted);
}
}
public void AssociationRejected_AssociationNotAllowed_IsInvoked()
{
var port = Ports.GetNext();
using (DicomServer.Create <MockCEchoProvider>(port))
{
var client = new DicomClient();
var reason = DicomRejectReason.NoReasonGiven;
client.AssociationRejected += (sender, args) => reason = args.Reason;
client.AddRequest(new DicomCEchoRequest());
var exception = Record.Exception(() => client.Send("127.0.0.1", port, false, "SCU", "NOTACCEPTEDSCP"));
Assert.Equal(DicomRejectReason.CalledAENotRecognized, reason);
Assert.NotNull(exception);
}
}
public void Send_PrivateNotRegisteredSOPClass_SendFails()
{
var port = Ports.GetNext();
using (DicomServer.Create <SimpleCStoreProvider>(port))
{
DicomStatus status = null;
var request = new DicomCStoreRequest(@".\Test Data\GH355.dcm");
request.OnResponseReceived = (req, res) =>
{ status = res.Status; };
var client = new DicomClient();
client.AddRequest(request);
client.Send("127.0.0.1", port, false, "SCU", "ANY-SCP");
Assert.Equal(DicomStatus.SOPClassNotSupported, status);
}
}
public void Create_TwiceOnSamePortWithDisposalInBetween_DoesNotThrow()
{
var port = Ports.GetNext();
using (DicomServer.Create <DicomCEchoProvider>(port))
{
}
var e = Record.Exception(
() =>
{
using (DicomServer.Create <DicomCEchoProvider>(port))
{
Assert.NotNull(DicomServer.GetInstance(port));
}
});
Assert.Null(e);
}
public void Send_Ipv6AnyListenerKnownSOPClass_SendSucceeds()
{
var port = Ports.GetNext();
using (DicomServer.Create <SimpleCStoreProvider>(NetworkManager.IPv6Any, port))
{
DicomStatus status = null;
var request = new DicomCStoreRequest(@".\Test Data\CT-MONO2-16-ankle");
request.OnResponseReceived = (req, res) =>
{ status = res.Status; };
var client = new DicomClient();
client.AddRequest(request);
client.Send(NetworkManager.IPv6Loopback, port, false, "SCU", "ANY-SCP");
Assert.Equal(DicomStatus.Success, status);
}
}
public void AssociationReleased_SuccessfulSend_IsInvoked()
{
var port = Ports.GetNext();
using (DicomServer.Create <DicomCEchoProvider>(port))
{
var client = new DicomClient();
var released = false;
var handle = new ManualResetEventSlim();
client.AssociationReleased += (sender, args) => { released = true; handle.Set(); };
client.AddRequest(new DicomCEchoRequest());
client.Send("127.0.0.1", port, false, "SCU", "ANY-SCP");
handle.Wait(1000);
Assert.True(released);
}
}
public void Send_SingleRequest_Recognized()
{
int port = Ports.GetNext();
using (DicomServer.Create <DicomCEchoProvider>(port))
{
var counter = 0;
var request = new DicomCEchoRequest {
OnResponseReceived = (req, res) => Interlocked.Increment(ref counter)
};
var client = new DicomClient();
client.AddRequest(request);
client.Send("127.0.0.1", port, false, "SCU", "ANY-SCP");
Assert.Equal(1, counter);
}
}
public async Task ReleaseAsync_AfterAssociation_SendIsCompleted()
{
int port = Ports.GetNext();
using (DicomServer.Create <MockCEchoProvider>(port))
{
Task task = null;
var client = new DicomClient();
client.AssociationAccepted += HandleAssociationAccepted;
client.AddRequest(new DicomCEchoRequest());
task = client.SendAsync("127.0.0.1", port, false, "SCU", "ANY-SCP");
void HandleAssociationAccepted(object sender, AssociationAcceptedEventArgs e)
{
(sender as DicomClient).ReleaseAsync().Wait();
Thread.Sleep(10);
Assert.True(task.IsCompleted);
}
}
}
public async Task SendAsync_SingleRequest_Recognized()
{
int port = Ports.GetNext();
using (DicomServer.Create <DicomCEchoProvider>(port))
{
var counter = 0;
var request = new DicomCEchoRequest {
OnResponseReceived = (req, res) => Interlocked.Increment(ref counter)
};
var client = new DicomClient();
client.AddRequest(request);
var task = client.SendAsync("127.0.0.1", port, false, "SCU", "ANY-SCP");
await Task.WhenAny(task, Task.Delay(10000));
Assert.Equal(1, counter);
}
}
public void Send_KnownSOPClass_SendSucceeds()
{
var port = Ports.GetNext();
using (DicomServer.Create <SimpleCStoreProvider>(port))
{
DicomStatus status = null;
var request = new DicomCStoreRequest(@".\Test Data\CT-MONO2-16-ankle")
{
OnResponseReceived = (req, res) => status = res.Status
};
var client = new DicomClient();
client.AddRequest(request);
client.Send("127.0.0.1", port, false, "SCU", "ANY-SCP");
Assert.Equal(DicomStatus.Success, status);
}
}
public void Send_FromDicomClient_DoesNotDeadlock()
{
var port = Ports.GetNext();
using (var server = DicomServer.Create <DicomCEchoProvider>(port))
{
server.Logger = new XUnitDicomLogger(_output).IncludeTimestamps().IncludeThreadId().IncludePrefix("DicomCEchoProvider");
var client = new Network.DicomClient
{
Logger = new XUnitDicomLogger(_output).IncludeTimestamps().IncludeThreadId().IncludePrefix("DicomClient")
};
for (var i = 0; i < 10; i++)
{
client.AddRequest(new DicomCEchoRequest());
}
client.Send("127.0.0.1", port, false, "SCU", "ANY-SCP");
Assert.False(client.IsSendRequired);
}
}
public async Task Send_FromDicomClient_DoesNotDeadlock()
{
var port = Ports.GetNext();
using (var server = DicomServer.Create <DicomCEchoProvider>(port))
{
server.Logger = new XUnitDicomLogger(_output).IncludeTimestamps().IncludeThreadId().IncludePrefix("DicomCEchoProvider");
var client = new Network.Client.DicomClient("127.0.0.1", port, false, "SCU", "ANY-SCP")
{
Logger = new XUnitDicomLogger(_output).IncludeTimestamps().IncludeThreadId().IncludePrefix("DicomClient")
};
for (var i = 0; i < 10; i++)
{
await client.AddRequestAsync(new DicomCEchoRequest()).ConfigureAwait(false);
}
await client.SendAsync().ConfigureAwait(false);
Assert.Empty(client.QueuedRequests);
}
}
public void IsSendRequired_AddedRequestNotConnected_ReturnsTrue()
{
var port = Ports.GetNext();
using (DicomServer.Create <DicomCEchoProvider>(port))
{
var client = new DicomClient();
client.AddRequest(new DicomCEchoRequest {
OnResponseReceived = (req, res) => Thread.Sleep(100)
});
Assert.True(client.IsSendRequired);
client.Send("127.0.0.1", port, false, "SCU", "ANY-SCP");
Thread.Sleep(100);
client.AddRequest(new DicomCEchoRequest {
OnResponseReceived = (req, res) => Thread.Sleep(100)
});
Assert.True(client.IsSendRequired);
}
}
public void Send_FromDicomClient_DoesNotDeadlock()
{
LogManager.SetImplementation(NLogManager.Instance);
var target = NLogHelper.AssignMemoryTarget(
"Dicom.Network",
@"${message}",
NLog.LogLevel.Trace);
var port = Ports.GetNext();
using (DicomServer.Create <DicomCEchoProvider>(port))
{
var client = new DicomClient();
for (var i = 0; i < 10; i++)
{
client.AddRequest(new DicomCEchoRequest());
}
client.Send("127.0.0.1", port, false, "SCU", "ANY-SCP");
Assert.True(target.Logs.Count > 0);
}
}
public void Stop_IsListening_TrueUntilStopRequested()
{
var port = Ports.GetNext();
var server = DicomServer.Create <DicomCEchoProvider>(port);
while (!server.IsListening)
{
Thread.Sleep(10);
}
for (var i = 0; i < 10; ++i)
{
Thread.Sleep(500);
Assert.True(server.IsListening);
}
server.Stop();
Thread.Sleep(500);
Assert.False(server.IsListening);
}
public void Send_PrivateNotRegisteredSOPClass_SendFails()
{
var uid = new DicomUID("1.1.1.1", "Private Fo-Dicom Storage", DicomUidType.SOPClass);
DicomDataset ds = new DicomDataset(
new DicomUniqueIdentifier(DicomTag.SOPClassUID, uid),
new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3.4.5"));
var port = Ports.GetNext();
using (DicomServer.Create <SimpleCStoreProvider>(port))
{
DicomStatus status = null;
var request = new DicomCStoreRequest(new DicomFile(ds));
request.OnResponseReceived = (req, res) =>
{ status = res.Status; };
var client = new DicomClient();
client.AddRequest(request);
client.Send("127.0.0.1", port, false, "SCU", "ANY-SCP");
Assert.Equal(DicomStatus.SOPClassNotSupported, status);
}
}
public void Send_PrivateRegisteredSOPClass_SendSucceeds()
{
var uid = new DicomUID("1.3.46.670589.11.0.0.12.1", "Private MR Spectrum Storage", DicomUidType.SOPClass);
DicomUID.Register(uid);
var port = Ports.GetNext();
using (DicomServer.Create <SimpleCStoreProvider>(port))
{
DicomStatus status = null;
var request = new DicomCStoreRequest(@".\Test Data\GH355.dcm");
request.OnResponseReceived = (req, res) =>
{ status = res.Status; };
var client = new DicomClient();
client.AddRequest(request);
client.Send("127.0.0.1", port, false, "SCU", "ANY-SCP");
Assert.Equal(DicomStatus.Success, status);
}
}
public void Send_MultipleRequests_AllRecognized(int expected)
{
int port = Ports.GetNext();
using (DicomServer.Create <DicomCEchoProvider>(port))
{
var actual = 0;
var client = new DicomClient();
client.NegotiateAsyncOps(expected, 1);
for (var i = 0; i < expected; ++i)
{
client.AddRequest(new DicomCEchoRequest {
OnResponseReceived = (req, res) => Interlocked.Increment(ref actual)
});
}
client.Send("127.0.0.1", port, false, "SCU", "ANY-SCP");
Assert.Equal(expected, actual);
}
}
public void Create_MultipleInstancesDifferentPorts_AllRegistered()
{
var ports = new int[20].Select(i => Ports.GetNext()).ToArray();
foreach (var port in ports)
{
var server = DicomServer.Create <DicomCEchoProvider>(port);
while (!server.IsListening)
{
Thread.Sleep(10);
}
}
foreach (var port in ports)
{
Assert.Equal(port, DicomServer.GetInstance(port).Port);
}
foreach (var port in ports)
{
DicomServer.GetInstance(port).Dispose();
}
}
public void Send_MultipleTimes_AllRecognized(int expected)
{
var port = Ports.GetNext();
var flag = new ManualResetEventSlim();
using (var server = DicomServer.Create <DicomCEchoProvider>(port))
{
while (!server.IsListening)
{
Thread.Sleep(50);
}
var actual = 0;
var client = new DicomClient();
for (var i = 0; i < expected; ++i)
{
client.AddRequest(
new DicomCEchoRequest
{
OnResponseReceived = (req, res) =>
{
_testOutputHelper.WriteLine($"{i}");
Interlocked.Increment(ref actual);
if (actual == expected)
{
flag.Set();
}
}
});
client.Send("127.0.0.1", port, false, "SCU", "ANY-SCP");
}
flag.Wait(10000);
Assert.Equal(expected, actual);
}
}
public async Task SendMaxPDU()
{
var port = Ports.GetNext();
uint serverPduLength = 400000;
uint clientPduLength = serverPduLength / 2;
using (var server = DicomServer.Create <DicomCEchoProvider>(port, null, new DicomServiceOptions {
MaxPDULength = serverPduLength
}))
{
uint serverPduInAssociationAccepted = 0;
var client = new Client.DicomClient("127.0.0.1", port, false, "SCU", "ANY-SCP");
client.Options = new DicomServiceOptions {
MaxPDULength = clientPduLength
}; // explicitly choose a different value
await client.AddRequestAsync(new DicomCEchoRequest());
client.AssociationAccepted += (sender, e) => serverPduInAssociationAccepted = e.Association.MaximumPDULength;
await client.SendAsync();
Assert.Equal(serverPduLength, serverPduInAssociationAccepted);
}
}
public async Task SendAsync_MultipleTimesParallel_AllRecognized(int expected)
{
int port = Ports.GetNext();
using (
var server = DicomServer.Create <DicomCEchoProvider>(port))
{
await Task.Delay(500);
Assert.True(server.IsListening, "Server is not listening");
var actual = 0;
var requests = Enumerable.Range(0, expected).Select(
async requestIndex =>
{
var client = new DicomClient();
client.AddRequest(
new DicomCEchoRequest
{
OnResponseReceived = (req, res) =>
{
_testOutputHelper.WriteLine("Response #{0}", requestIndex);
Interlocked.Increment(ref actual);
}
});
_testOutputHelper.WriteLine("Sending #{0}", requestIndex);
await client.SendAsync("127.0.0.1", port, false, "SCU", "ANY-SCP");
_testOutputHelper.WriteLine("Sent (or timed out) #{0}", requestIndex);
}).ToList();
await Task.WhenAll(requests);
Assert.Equal(expected, actual);
}
}
public async Task SendAsync_MultipleTimes_AllRecognized(int expected)
{
var port = Ports.GetNext();
var flag = new ManualResetEventSlim();
using (var server = DicomServer.Create <DicomCEchoProvider>(port))
{
while (!server.IsListening)
{
await Task.Delay(50);
}
var actual = 0;
var client = new DicomClient();
for (var i = 0; i < expected; i++)
{
client.AddRequest(
new DicomCEchoRequest
{
OnResponseReceived = (req, res) =>
{
Interlocked.Increment(ref actual);
if (actual == expected)
{
flag.Set();
}
}
});
await client.SendAsync("127.0.0.1", port, false, "SCU", "ANY-SCP");
}
flag.Wait(10000);
Assert.Equal(expected, actual);
}
}
public void Stop_DisconnectedClientsCount_ShouldBeZeroAfterShortDelay()
{
var port = Ports.GetNext();
using (var server = DicomServer.Create <DicomCEchoProvider>(port))
{
while (!server.IsListening)
{
Thread.Sleep(10);
}
var client = new DicomClient();
client.AddRequest(new DicomCEchoRequest());
client.Send("127.0.0.1", port, false, "SCU", "ANY-SCP");
client.Release(0);
Thread.Sleep(100);
server.Stop();
Thread.Sleep(100);
var actual = ((DicomServer <DicomCEchoProvider>)server).CompletedServicesCount;
Assert.Equal(0, actual);
}
}
public async Task ClientHandleNEventReport_SynchronousEvent()
{
var port = Ports.GetNext();
using (DicomServer.Create <SimpleStorageComitmentProvider>(port))
{
DicomStatus status = null;
int verifiedInstances = 0;
DateTime stampNActionResponse = DateTime.MinValue;
DateTime stampNEventReportRequest = DateTime.MinValue;
var dicomClient = new Client.DicomClient("127.0.0.1", port, false, "SCU", "ANY-SCP");
var nActionDicomDataSet = new DicomDataset
{
{ DicomTag.TransactionUID, DicomUIDGenerator.GenerateDerivedFromUUID().UID },
{
DicomTag.ReferencedSOPSequence,
new DicomDataset()
{
{ DicomTag.ReferencedSOPClassUID, "1.2.840.10008.5.1.4.1.1.1" },
{ DicomTag.ReferencedSOPInstanceUID, "1.3.46.670589.30.2273540226.4.54" }
},
new DicomDataset()
{
{ DicomTag.ReferencedSOPClassUID, "1.2.840.10008.5.1.4.1.1.1" },
{ DicomTag.ReferencedSOPInstanceUID, "1.3.46.670589.30.2273540226.4.59" }
}
}
};
var nActionRequest = new DicomNActionRequest(DicomUID.StorageCommitmentPushModel,
DicomUID.StorageCommitmentPushModel, 1)
{
Dataset = nActionDicomDataSet,
OnResponseReceived = (DicomNActionRequest request, DicomNActionResponse response) =>
{
status = response.Status;
stampNActionResponse = DateTime.Now;
},
};
await dicomClient.AddRequestAsync(nActionRequest);
dicomClient.OnNEventReportRequest = (eventReq) =>
{
var refSopSequence = eventReq.Dataset.GetSequence(DicomTag.ReferencedSOPSequence);
foreach (var item in refSopSequence.Items)
{
verifiedInstances += 1;
}
stampNEventReportRequest = DateTime.Now;
return(Task.FromResult(new DicomNEventReportResponse(eventReq, DicomStatus.Success)));
};
dicomClient.AssociationLingerTimeoutInMs = (int)TimeSpan.FromSeconds(5).TotalMilliseconds;
await dicomClient.SendAsync().ConfigureAwait(false);
Assert.Equal(DicomStatus.Success, status);
Assert.Equal(2, verifiedInstances);
Assert.True(stampNActionResponse < stampNEventReportRequest);
}
}
