orthanc: UnitTestsSources/MultiThreadingTests.cpp comparison

comparison UnitTestsSources/MultiThreadingTests.cpp @ 3786:3801435e34a1 SylvainRouquette/fix-issue169-95b752c

integration Orthanc-1.6.0->SylvainRouquette

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Thu, 19 Mar 2020 11:48:30 +0100
parents	763533d6dd67 56f2397f027a
children

comparison

equal deleted inserted replaced

-:763533d6dd67
+:3801435e34a1
 /**
 * Orthanc - A Lightweight, RESTful DICOM Store
 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
 * Department, University Hospital of Liege, Belgium
-* Copyright (C) 2017-2019 Osimis S.A., Belgium
+* Copyright (C) 2017-2020 Osimis S.A., Belgium
 *
 * This program is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 #include "PrecompiledHeadersUnitTests.h"
 #include "gtest/gtest.h"
+#include "../Core/Compatibility.h"
 #include "../Core/FileStorage/MemoryStorageArea.h"
 #include "../Core/JobsEngine/JobsEngine.h"
 #include "../Core/Logging.h"
 #include "../Core/MultiThreading/SharedMessageQueue.h"
 #include "../Core/OrthancException.h"
 virtual void Reset() ORTHANC_OVERRIDE
 {
 }
-virtual JobStepResult Step() ORTHANC_OVERRIDE
+virtual JobStepResult Step(const std::string& jobId) ORTHANC_OVERRIDE
 {
 if (fails_)
 {
 return JobStepResult::Failure(ErrorCode_ParameterOutOfRange, NULL);
 }
 ASSERT_FALSE(q.WaitEmpty(1));
 q.Enqueue(new DynamicInteger(20, s));
 q.Enqueue(new DynamicInteger(30, s));
 q.Enqueue(new DynamicInteger(40, s));
-std::auto_ptr<DynamicInteger> i;
+std::unique_ptr<DynamicInteger> i;
 i.reset(dynamic_cast<DynamicInteger*>(q.Dequeue(1))); ASSERT_EQ(10, i->GetValue());
 i.reset(dynamic_cast<DynamicInteger*>(q.Dequeue(1))); ASSERT_EQ(20, i->GetValue());
 i.reset(dynamic_cast<DynamicInteger*>(q.Dequeue(1))); ASSERT_EQ(30, i->GetValue());
 ASSERT_FALSE(q.WaitEmpty(1));
 i.reset(dynamic_cast<DynamicInteger*>(q.Dequeue(1))); ASSERT_EQ(40, i->GetValue());
 std::string id;
 SequenceOfOperationsJob* job = NULL;
 {
-std::auto_ptr<SequenceOfOperationsJob> a(new SequenceOfOperationsJob);
+std::unique_ptr<SequenceOfOperationsJob> a(new SequenceOfOperationsJob);
 job = a.get();
 engine.GetRegistry().Submit(id, a.release(), 0);
 }
 boost::this_thread::sleep(boost::posix_time::milliseconds(500));
 {
 return false;
 }
 else
 {
-std::auto_ptr<IJob> unserialized(unserializer.UnserializeJob(a));
+std::unique_ptr<IJob> unserialized(unserializer.UnserializeJob(a));
 Json::Value b = 43;
 if (unserialized->Serialize(b))
 {
 return (CheckSameJson(a, b));
 {
 return false;
 }
 else
 {
-std::auto_ptr<SetOfInstancesJob> unserialized
+std::unique_ptr<SetOfInstancesJob> unserialized
 (dynamic_cast<SetOfInstancesJob*>(unserializer.UnserializeJob(a)));
 Json::Value b = 43;
 if (unserialized->Serialize(b))
 {
 IJobOperation& operation)
 {
 Json::Value a = 42;
 operation.Serialize(a);
-std::auto_ptr<IJobOperation> unserialized(unserializer.UnserializeOperation(a));
+std::unique_ptr<IJobOperation> unserialized(unserializer.UnserializeOperation(a));
 Json::Value b = 43;
 unserialized->Serialize(b);
 return CheckSameJson(a, b);
 JobOperationValue& value)
 {
 Json::Value a = 42;
 value.Serialize(a);
-std::auto_ptr<JobOperationValue> unserialized(unserializer.UnserializeValue(a));
+std::unique_ptr<JobOperationValue> unserialized(unserializer.UnserializeValue(a));
 Json::Value b = 43;
 unserialized->Serialize(b);
 return CheckSameJson(a, b);
 values.Serialize(s);
 }
 {
 GenericJobUnserializer unserializer;
-std::auto_ptr<JobOperationValues> values(JobOperationValues::Unserialize(unserializer, s));
+std::unique_ptr<JobOperationValues> values(JobOperationValues::Unserialize(unserializer, s));
 ASSERT_EQ(3u, values->GetSize());
 ASSERT_EQ(JobOperationValue::Type_Null, values->GetValue(0).GetType());
 ASSERT_EQ(JobOperationValue::Type_String, values->GetValue(1).GetType());
 ASSERT_EQ(JobOperationValue::Type_String, values->GetValue(2).GetType());
 }
 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException);
 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException);
-std::auto_ptr<JobOperationValue> value;
+std::unique_ptr<JobOperationValue> value;
 value.reset(unserializer.UnserializeValue(s));
 ASSERT_EQ(JobOperationValue::Type_Null, value->GetType());
 {
 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException);
 ASSERT_THROW(unserializer.UnserializeValue(s), OrthancException);
 {
-std::auto_ptr<IJobOperation> operation;
+std::unique_ptr<IJobOperation> operation;
 operation.reset(unserializer.UnserializeOperation(s));
 // Make sure that we have indeed unserialized a log operation
 Json::Value dummy;
 ASSERT_THROW(dynamic_cast<DeleteResourceOperation&>(*operation).Serialize(dummy), std::bad_cast);
 job.SetDescription("description");
 job.AddInstance("hello");
 job.AddInstance("nope");
 job.AddInstance("world");
 job.SetPermissive(true);
-ASSERT_THROW(job.Step(), OrthancException);  // Not started yet
+ASSERT_THROW(job.Step("jobId"), OrthancException);  // Not started yet
 ASSERT_FALSE(job.HasTrailingStep());
 ASSERT_FALSE(job.IsTrailingStepDone());
 job.Start();
-ASSERT_EQ(JobStepCode_Continue, job.Step().GetCode());
+ASSERT_EQ(JobStepCode_Continue, job.Step("jobId").GetCode());
-ASSERT_EQ(JobStepCode_Continue, job.Step().GetCode());
+ASSERT_EQ(JobStepCode_Continue, job.Step("jobId").GetCode());
 {
 DummyUnserializer unserializer;
 ASSERT_TRUE(CheckIdempotentSetOfInstances(unserializer, job));
 }
 {
 DummyUnserializer unserializer;
 ASSERT_THROW(unserializer.UnserializeValue(s), OrthancException);
 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException);
-std::auto_ptr<IJob> job;
+std::unique_ptr<IJob> job;
 job.reset(unserializer.UnserializeJob(s));
 const DummyInstancesJob& tmp = dynamic_cast<const DummyInstancesJob&>(*job);
 ASSERT_FALSE(tmp.IsStarted());
 ASSERT_TRUE(tmp.IsPermissive());
 lock.AddInput(a, s2);
 lock.SetDicomAssociationTimeout(200);
 lock.SetTrailingOperationTimeout(300);
 }
-ASSERT_EQ(JobStepCode_Continue, job.Step().GetCode());
+ASSERT_EQ(JobStepCode_Continue, job.Step("jobId").GetCode());
 {
 GenericJobUnserializer unserializer;
 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, job));
 }
 {
 GenericJobUnserializer unserializer;
 ASSERT_THROW(unserializer.UnserializeValue(s), OrthancException);
 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException);
-std::auto_ptr<IJob> job;
+std::unique_ptr<IJob> job;
 job.reset(unserializer.UnserializeJob(s));
 std::string tmp;
 dynamic_cast<SequenceOfOperationsJob&>(*job).GetDescription(tmp);
 ASSERT_EQ("hello", tmp);
 TEST(JobsSerialization, DicomModification)
 {
 Json::Value s;
 ParsedDicomFile source(true);
-source.Insert(DICOM_TAG_STUDY_DESCRIPTION, "Test 1", false);
+source.Insert(DICOM_TAG_STUDY_DESCRIPTION, "Test 1", false, "");
-source.Insert(DICOM_TAG_SERIES_DESCRIPTION, "Test 2", false);
+source.Insert(DICOM_TAG_SERIES_DESCRIPTION, "Test 2", false, "");
-source.Insert(DICOM_TAG_PATIENT_NAME, "Test 3", false);
+source.Insert(DICOM_TAG_PATIENT_NAME, "Test 3", false, "");
-std::auto_ptr<ParsedDicomFile> modified(source.Clone(true));
+std::unique_ptr<ParsedDicomFile> modified(source.Clone(true));
 {
 DicomModification modification;
 modification.SetLevel(ResourceType_Series);
 modification.Clear(DICOM_TAG_STUDY_DESCRIPTION);
 {
 DicomModification modification(s);
 ASSERT_EQ(ResourceType_Series, modification.GetLevel());
-std::auto_ptr<ParsedDicomFile> second(source.Clone(true));
+std::unique_ptr<ParsedDicomFile> second(source.Clone(true));
 modification.Apply(*second);
 std::string s;
 ASSERT_TRUE(second->GetTagValue(s, DICOM_TAG_STUDY_DESCRIPTION));
 ASSERT_TRUE(s.empty());
 class OrthancJobsSerialization : public testing::Test
 {
 private:
 MemoryStorageArea              storage_;
 SQLiteDatabaseWrapper          db_;   // The SQLite DB is in memory
-std::auto_ptr<ServerContext>   context_;
+std::unique_ptr<ServerContext>   context_;
 TimeoutDicomConnectionManager  manager_;
 public:
 OrthancJobsSerialization()
 {
 bool CreateInstance(std::string& id)
 {
 // Create a sample DICOM file
 ParsedDicomFile dicom(true);
 dicom.Replace(DICOM_TAG_PATIENT_NAME, std::string("JODOGNE"),
-false, DicomReplaceMode_InsertIfAbsent);
+false, DicomReplaceMode_InsertIfAbsent, "");
 DicomInstanceToStore toStore;
 toStore.SetParsedDicomFile(dicom);
 return (context_->Store(id, toStore) == StoreStatus_Success);
 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, instance));
 instance.Serialize(s);
 }
-std::auto_ptr<JobOperationValue> value;
+std::unique_ptr<JobOperationValue> value;
 value.reset(unserializer.UnserializeValue(s));
 ASSERT_EQ(JobOperationValue::Type_DicomInstance, value->GetType());
 ASSERT_EQ(id, dynamic_cast<DicomInstanceOperationValue&>(*value).GetId());
 {
 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, operation));
 operation.Serialize(s);
 }
-std::auto_ptr<IJobOperation> operation;
+std::unique_ptr<IJobOperation> operation;
 {
 operation.reset(unserializer.UnserializeOperation(s));
 Json::Value dummy;
 RemoteModalityParameters modality;
 modality.SetApplicationEntityTitle("REMOTE");
 modality.SetHost("192.168.1.1");
 modality.SetPortNumber(1000);
 modality.SetManufacturer(ModalityManufacturer_StoreScp);
-modality.SetPreferredTransferSyntax("1.2.840.10008.1.2");
+ASSERT_EQ("1.2.840.10008.1.2", modality.GetPreferredTransferSyntax());
+modality.SetPreferredTransferSyntax("1.2.840.10008.1.2.1");
+ASSERT_EQ("1.2.840.10008.1.2.1", modality.GetPreferredTransferSyntax());
 StoreScuOperation operation("TEST", modality);
 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, operation));
 operation.Serialize(s);
 }
 // ModifyInstanceOperation
 {
-std::auto_ptr<DicomModification> modification(new DicomModification);
+std::unique_ptr<DicomModification> modification(new DicomModification);
 modification->SetupAnonymization(DicomVersion_2008);
 ModifyInstanceOperation operation(GetContext(), RequestOrigin_Lua, modification.release());
 ASSERT_TRUE(CheckIdempotentSerialization(unserializer, operation));
 RemoteModalityParameters modality;
 modality.SetApplicationEntityTitle("REMOTE");
 modality.SetHost("192.168.1.1");
 modality.SetPortNumber(1000);
 modality.SetManufacturer(ModalityManufacturer_StoreScp);
-modality.SetPreferredTransferSyntax("1.2.840.10008.1.2");
+ASSERT_EQ("1.2.840.10008.1.2", modality.GetPreferredTransferSyntax());
+modality.SetPreferredTransferSyntax("1.2.840.10008.1.2.1");
+ASSERT_EQ("1.2.840.10008.1.2.1", modality.GetPreferredTransferSyntax());
 DicomModalityStoreJob job(GetContext());
 job.SetLocalAet("LOCAL");
 job.SetRemoteModality(modality);
 job.SetMoveOriginator("MOVESCU", 42);
 ASSERT_TRUE(CheckIdempotentSetOfInstances(unserializer, job));
 ASSERT_TRUE(job.Serialize(s));
 }
 {
-std::auto_ptr<IJob> job;
+std::unique_ptr<IJob> job;
 job.reset(unserializer.UnserializeJob(s));
 DicomModalityStoreJob& tmp = dynamic_cast<DicomModalityStoreJob&>(*job);
 ASSERT_EQ("LOCAL", tmp.GetLocalAet());
 ASSERT_EQ("REMOTE", tmp.GetRemoteModality().GetApplicationEntityTitle());
 ASSERT_TRUE(CheckIdempotentSetOfInstances(unserializer, job));
 ASSERT_TRUE(job.Serialize(s));
 }
 {
-std::auto_ptr<IJob> job;
+std::unique_ptr<IJob> job;
 job.reset(unserializer.UnserializeJob(s));
 OrthancPeerStoreJob& tmp = dynamic_cast<OrthancPeerStoreJob&>(*job);
 ASSERT_EQ("http://localhost/", tmp.GetPeer().GetUrl());
 ASSERT_EQ("username", tmp.GetPeer().GetUsername());
 }
 // ResourceModificationJob
 {
-std::auto_ptr<DicomModification> modification(new DicomModification);
+std::unique_ptr<DicomModification> modification(new DicomModification);
 modification->SetupAnonymization(DicomVersion_2008);
 ResourceModificationJob job(GetContext());
 job.SetModification(modification.release(), ResourceType_Patient, true);
 job.SetOrigin(DicomInstanceOrigin::FromLua());
 ASSERT_TRUE(CheckIdempotentSetOfInstances(unserializer, job));
 ASSERT_TRUE(job.Serialize(s));
 }
 {
-std::auto_ptr<IJob> job;
+std::unique_ptr<IJob> job;
 job.reset(unserializer.UnserializeJob(s));
 ResourceModificationJob& tmp = dynamic_cast<ResourceModificationJob&>(*job);
 ASSERT_TRUE(tmp.IsAnonymization());
 ASSERT_EQ(RequestOrigin_Lua, tmp.GetOrigin().GetRequestOrigin());
 a = job.GetTargetStudyUid();
 ASSERT_TRUE(job.LookupTargetSeriesUid(b, series));
 job.AddTrailingStep();
 job.Start();
-ASSERT_EQ(JobStepCode_Continue, job.Step().GetCode());
+ASSERT_EQ(JobStepCode_Continue, job.Step("jobId").GetCode());
-ASSERT_EQ(JobStepCode_Success, job.Step().GetCode());
+ASSERT_EQ(JobStepCode_Success, job.Step("jobId").GetCode());
 study2 = job.GetTargetStudy();
 ASSERT_FALSE(study2.empty());
 ASSERT_TRUE(CheckIdempotentSetOfInstances(unserializer, job));
 ASSERT_TRUE(job.Serialize(s));
 }
 {
-std::auto_ptr<IJob> job;
+std::unique_ptr<IJob> job;
 job.reset(unserializer.UnserializeJob(s));
 SplitStudyJob& tmp = dynamic_cast<SplitStudyJob&>(*job);
 ASSERT_TRUE(tmp.IsKeepSource());
 ASSERT_EQ(study, tmp.GetSourceStudy());
 ASSERT_EQ(job.GetTargetStudy(), study);
 job.AddTrailingStep();
 job.Start();
-ASSERT_EQ(JobStepCode_Continue, job.Step().GetCode());
+ASSERT_EQ(JobStepCode_Continue, job.Step("jobId").GetCode());
-ASSERT_EQ(JobStepCode_Success, job.Step().GetCode());
+ASSERT_EQ(JobStepCode_Success, job.Step("jobId").GetCode());
 ASSERT_TRUE(CheckIdempotentSetOfInstances(unserializer, job));
 ASSERT_TRUE(job.Serialize(s));
 }
 GetContext().GetIndex().GetAllUuids(tmp, ResourceType_Series);
 ASSERT_EQ(3u, tmp.size());
 }
 {
-std::auto_ptr<IJob> job;
+std::unique_ptr<IJob> job;
 job.reset(unserializer.UnserializeJob(s));
 MergeStudyJob& tmp = dynamic_cast<MergeStudyJob&>(*job);
 ASSERT_TRUE(tmp.IsKeepSource());
 ASSERT_EQ(study, tmp.GetTargetStudy());
 {
 DummyUnserializer unserializer;
 ASSERT_TRUE(CheckIdempotentSetOfInstances(unserializer, job));
 }
-ASSERT_EQ(JobStepCode_Success, job.Step().GetCode());
+ASSERT_EQ(JobStepCode_Success, job.Step("jobId").GetCode());
 ASSERT_EQ(1u, job.GetPosition());
 ASSERT_FALSE(job.IsTrailingStepDone());
 {
 DummyUnserializer unserializer;
 ASSERT_TRUE(CheckIdempotentSetOfInstances(unserializer, job));
 }
-ASSERT_THROW(job.Step(), OrthancException);
+ASSERT_THROW(job.Step("jobId"), OrthancException);
 }
 {
 Json::Value s;
 {
 DummyUnserializer unserializer;
 ASSERT_TRUE(CheckIdempotentSetOfInstances(unserializer, job));
 }
-ASSERT_EQ(JobStepCode_Continue, job.Step().GetCode());
+ASSERT_EQ(JobStepCode_Continue, job.Step("jobId").GetCode());
 ASSERT_EQ(1u, job.GetPosition());
 ASSERT_FALSE(job.IsTrailingStepDone());
 {
 DummyUnserializer unserializer;
 ASSERT_TRUE(CheckIdempotentSetOfInstances(unserializer, job));
 }
-ASSERT_EQ(JobStepCode_Success, job.Step().GetCode());
+ASSERT_EQ(JobStepCode_Success, job.Step("jobId").GetCode());
 ASSERT_EQ(2u, job.GetPosition());
 ASSERT_FALSE(job.IsTrailingStepDone());
 {
 DummyUnserializer unserializer;
 ASSERT_TRUE(CheckIdempotentSetOfInstances(unserializer, job));
 }
-ASSERT_THROW(job.Step(), OrthancException);
+ASSERT_THROW(job.Step("jobId"), OrthancException);
 }
 {
 Json::Value s;
 {
 DummyUnserializer unserializer;
 ASSERT_TRUE(CheckIdempotentSetOfInstances(unserializer, job));
 }
-ASSERT_EQ(JobStepCode_Success, job.Step().GetCode());
+ASSERT_EQ(JobStepCode_Success, job.Step("jobId").GetCode());
 ASSERT_EQ(1u, job.GetPosition());
 ASSERT_TRUE(job.IsTrailingStepDone());
 {
 DummyUnserializer unserializer;
 ASSERT_TRUE(CheckIdempotentSetOfInstances(unserializer, job));
 }
-ASSERT_THROW(job.Step(), OrthancException);
+ASSERT_THROW(job.Step("jobId"), OrthancException);
 }
 {
 Json::Value s;
 {
 DummyUnserializer unserializer;
 ASSERT_TRUE(CheckIdempotentSetOfInstances(unserializer, job));
 }
-ASSERT_EQ(JobStepCode_Continue, job.Step().GetCode());
+ASSERT_EQ(JobStepCode_Continue, job.Step("jobId").GetCode());
 ASSERT_EQ(1u, job.GetPosition());
 ASSERT_FALSE(job.IsTrailingStepDone());
 {
 DummyUnserializer unserializer;
 ASSERT_TRUE(CheckIdempotentSetOfInstances(unserializer, job));
 }
-ASSERT_EQ(JobStepCode_Success, job.Step().GetCode());
+ASSERT_EQ(JobStepCode_Success, job.Step("jobId").GetCode());
 ASSERT_EQ(2u, job.GetPosition());
 ASSERT_TRUE(job.IsTrailingStepDone());
 {
 DummyUnserializer unserializer;
 ASSERT_TRUE(CheckIdempotentSetOfInstances(unserializer, job));
 }
-ASSERT_THROW(job.Step(), OrthancException);
+ASSERT_THROW(job.Step("jobId"), OrthancException);
 }
 }
 TEST(JobsSerialization, RemoteModalityParameters)
 ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_Echo));
 ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_Find));
 ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_Get));
 ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_Store));
 ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_Move));
+ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_NAction));
+ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_NEventReport));
 }
 s = Json::nullValue;
 {
 ASSERT_THROW(modality.SetPortNumber(0), OrthancException);
 ASSERT_THROW(modality.SetPortNumber(65535), OrthancException);
 modality.SetApplicationEntityTitle("HELLO");
 modality.SetHost("world");
 modality.SetPortNumber(45);
-modality.SetManufacturer(ModalityManufacturer_Dcm4Chee);
+modality.SetManufacturer(ModalityManufacturer_GenericNoWildcardInDates);
-modality.SetPreferredTransferSyntax("1.2.840.10008.1.2");
+ASSERT_EQ("1.2.840.10008.1.2", modality.GetPreferredTransferSyntax());
+modality.SetPreferredTransferSyntax("1.2.840.10008.1.2.1");
+ASSERT_EQ("1.2.840.10008.1.2.1", modality.GetPreferredTransferSyntax());
 modality.Serialize(s, true);
 ASSERT_EQ(Json::objectValue, s.type());
 }
 {
 RemoteModalityParameters modality(s);
 ASSERT_EQ("HELLO", modality.GetApplicationEntityTitle());
 ASSERT_EQ("world", modality.GetHost());
 ASSERT_EQ(45u, modality.GetPortNumber());
-ASSERT_EQ(ModalityManufacturer_Dcm4Chee, modality.GetManufacturer());
+ASSERT_EQ(ModalityManufacturer_GenericNoWildcardInDates, modality.GetManufacturer());
 ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_Echo));
 ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_Find));
 ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_Get));
 ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_Store));
 ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_Move));
+ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_NAction));
+ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_NEventReport));
 }
 s["Port"] = "46";
 {
 operations.insert(DicomRequestType_Echo);
 operations.insert(DicomRequestType_Find);
 operations.insert(DicomRequestType_Get);
 operations.insert(DicomRequestType_Move);
 operations.insert(DicomRequestType_Store);
+operations.insert(DicomRequestType_NAction);
-ASSERT_EQ(5u, operations.size());
+operations.insert(DicomRequestType_NEventReport);
+ASSERT_EQ(7u, operations.size());
 for (std::set<DicomRequestType>::const_iterator
 it = operations.begin(); it != operations.end(); ++it)
 {
 {
 ASSERT_TRUE(modality.IsRequestAllowed(*it2));
 }
 }
 }
 }
-}
+{
+Json::Value s;
+s["AllowStorageCommitment"] = false;
+s["AET"] = "AET";
+s["Host"] = "host";
+s["Port"] = "104";
+RemoteModalityParameters modality(s);
+ASSERT_TRUE(modality.IsAdvancedFormatNeeded());
+ASSERT_EQ("AET", modality.GetApplicationEntityTitle());
+ASSERT_EQ("host", modality.GetHost());
+ASSERT_EQ(104u, modality.GetPortNumber());
+ASSERT_FALSE(modality.IsRequestAllowed(DicomRequestType_NAction));
+ASSERT_FALSE(modality.IsRequestAllowed(DicomRequestType_NEventReport));
+}
+{
+Json::Value s;
+s["AllowNAction"] = false;
+s["AllowNEventReport"] = true;
+s["AET"] = "AET";
+s["Host"] = "host";
+s["Port"] = "104";
+RemoteModalityParameters modality(s);
+ASSERT_TRUE(modality.IsAdvancedFormatNeeded());
+ASSERT_EQ("AET", modality.GetApplicationEntityTitle());
+ASSERT_EQ("host", modality.GetHost());
+ASSERT_EQ(104u, modality.GetPortNumber());
+ASSERT_FALSE(modality.IsRequestAllowed(DicomRequestType_NAction));
+ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_NEventReport));
+}
+{
+Json::Value s;
+s["AllowNAction"] = true;
+s["AllowNEventReport"] = true;
+s["AET"] = "AET";
+s["Host"] = "host";
+s["Port"] = "104";
+RemoteModalityParameters modality(s);
+ASSERT_FALSE(modality.IsAdvancedFormatNeeded());
+ASSERT_EQ("AET", modality.GetApplicationEntityTitle());
+ASSERT_EQ("host", modality.GetHost());
+ASSERT_EQ(104u, modality.GetPortNumber());
+ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_NAction));
+ASSERT_TRUE(modality.IsRequestAllowed(DicomRequestType_NEventReport));
+}
+}

Mercurial > hg > orthanc

comparison UnitTestsSources/MultiThreadingTests.cpp @ 3786:3801435e34a1 SylvainRouquette/fix-issue169-95b752c