orthanc: UnitTestsSources/MultiThreadingTests.cpp comparison

comparison UnitTestsSources/MultiThreadingTests.cpp @ 2666:2540ac79ab6c jobs

SequenceOfOperationsJob serialization

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Fri, 08 Jun 2018 15:05:32 +0200
parents	389d050a2e66
children	5fa2f2ce74f0

comparison

equal deleted inserted replaced

-:389d050a2e66
+:2540ac79ab6c
 #include "PrecompiledHeadersUnitTests.h"
 #include "gtest/gtest.h"
 #include "../Core/FileStorage/MemoryStorageArea.h"
 #include "../Core/JobsEngine/JobsEngine.h"
+#include "../Core/Logging.h"
 #include "../Core/MultiThreading/SharedMessageQueue.h"
 #include "../Core/OrthancException.h"
 #include "../Core/SerializationToolbox.h"
 #include "../Core/SystemToolbox.h"
 #include "../Core/Toolbox.h"
 engine.Stop();
 }
+static bool CheckSameJson(const Json::Value& a,
+const Json::Value& b)
+{
+std::string s = a.toStyledString();
+std::string t = b.toStyledString();
+if (s == t)
+{
+return true;
+}
+else
+{
+LOG(ERROR) << "Expected serialization: " << s;
+LOG(ERROR) << "Actual serialization: " << t;
+return false;
+}
+}
+static bool CheckIdempotentSerialization(IJobUnserializer& unserializer,
+IJob& job)
+{
+Json::Value a = 42;
+if (!job.Serialize(a))
+{
+return false;
+}
+else
+{
+std::auto_ptr<IJob> unserialized(unserializer.UnserializeJob(a));
+Json::Value b = 43;
+if (unserialized->Serialize(b))
+{
+return CheckSameJson(a, b);
+}
+else
+{
+return false;
+}
+}
+}
+static bool CheckIdempotentSerialization(IJobUnserializer& unserializer,
+IJobOperation& operation)
+{
+Json::Value a = 42;
+operation.Serialize(a);
+std::auto_ptr<IJobOperation> unserialized(unserializer.UnserializeOperation(a));
+Json::Value b = 43;
+unserialized->Serialize(b);
+return CheckSameJson(a, b);
+}
+static bool CheckIdempotentSerialization(IJobUnserializer& unserializer,
+JobOperationValue& value)
+{
+Json::Value a = 42;
+value.Serialize(a);
+std::auto_ptr<JobOperationValue> unserialized(unserializer.UnserializeValue(a));
+Json::Value b = 43;
+unserialized->Serialize(b);
+return CheckSameJson(a, b);
+}
 TEST(JobsSerialization, BadFileFormat)
 {
 GenericJobUnserializer unserializer;
 Json::Value s;
 }
 TEST(JobsSerialization, GenericValues)
 {
+GenericJobUnserializer unserializer;
 Json::Value s;
 {
 NullOperationValue null;
-s = 42;
+ASSERT_TRUE(CheckIdempotentSerialization(unserializer, null));
 null.Serialize(s);
 }
-GenericJobUnserializer unserializer;
 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException);
 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException);
 std::auto_ptr<JobOperationValue> value;
 value.reset(unserializer.UnserializeValue(s));
 ASSERT_EQ(JobOperationValue::Type_Null, value->GetType());
 {
 StringOperationValue str("Hello");
-s = 42;
+ASSERT_TRUE(CheckIdempotentSerialization(unserializer, str));
 str.Serialize(s);
 }
 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException);
 ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException);
 }
 TEST(JobsSerialization, GenericOperations)
 {
+DummyUnserializer unserializer;
 Json::Value s;
 {
 LogJobOperation operation;
-s = 42;
+ASSERT_TRUE(CheckIdempotentSerialization(unserializer, operation));
 operation.Serialize(s);
 }
-DummyUnserializer unserializer;
 ASSERT_THROW(unserializer.UnserializeJob(s), OrthancException);
 ASSERT_THROW(unserializer.UnserializeValue(s), OrthancException);
 {
 std::auto_ptr<IJobOperation> operation;
 ASSERT_THROW(job.ExecuteStep(), OrthancException);  // Not started yet
 job.Start();
 job.ExecuteStep();
 job.ExecuteStep();
-s = 42;
+{
+DummyUnserializer unserializer;
+ASSERT_TRUE(CheckIdempotentSerialization(unserializer, job));
+}
 ASSERT_TRUE(job.Serialize(s));
 }
 {
 DummyUnserializer unserializer;
 ASSERT_EQ("hello", tmp.GetInstance(0));
 ASSERT_EQ("nope", tmp.GetInstance(1));
 ASSERT_EQ("world", tmp.GetInstance(2));
 ASSERT_TRUE(tmp.IsFailedInstance("nope"));
 }
+// SequenceOfOperationsJob
+{
+SequenceOfOperationsJob job;
+job.SetDescription("hello");
+{
+SequenceOfOperationsJob::Lock lock(job);
+size_t a = lock.AddOperation(new LogJobOperation);
+size_t b = lock.AddOperation(new LogJobOperation);
+lock.Connect(a, b);
+lock.AddInput(a, StringOperationValue("hello"));
+lock.AddInput(a, StringOperationValue("world"));
+lock.SetDicomAssociationTimeout(200);
+lock.SetTrailingOperationTimeout(300);
+}
+ASSERT_EQ(JobStepCode_Continue, job.ExecuteStep().GetCode());
+{
+GenericJobUnserializer unserializer;
+ASSERT_TRUE(CheckIdempotentSerialization(unserializer, job));
+}
+ASSERT_TRUE(job.Serialize(s));
+}
+{
+GenericJobUnserializer unserializer;
+ASSERT_THROW(unserializer.UnserializeValue(s), OrthancException);
+ASSERT_THROW(unserializer.UnserializeOperation(s), OrthancException);
+std::auto_ptr<IJob> job;
+job.reset(unserializer.UnserializeJob(s));
+std::string tmp;
+dynamic_cast<SequenceOfOperationsJob&>(*job).GetDescription(tmp);
+ASSERT_EQ("hello", tmp);
+}
 }
 static bool IsSameTagValue(ParsedDicomFile& dicom1,
 ParsedDicomFile& dicom2,
 ASSERT_EQ(RequestOrigin_Plugins, origin.GetRequestOrigin());
 }
 }
-TEST(JobsSerialization, Registry)
-{
-// TODO : Test serialization of JobsRegistry
-}
 namespace
 {
 class OrthancJobsSerialization : public testing::Test
 {
 private:
 {
 std::string id;
 ASSERT_TRUE(CreateInstance(id));
 Json::Value s;
-{
-DicomInstanceOperationValue instance(GetContext(), id);
-s = 42;
-instance.Serialize(s);
-}
 OrthancJobUnserializer unserializer(GetContext());
+{
+DicomInstanceOperationValue instance(GetContext(), id);
+ASSERT_TRUE(CheckIdempotentSerialization(unserializer, instance));
+instance.Serialize(s);
+}
 std::auto_ptr<JobOperationValue> value;
 value.reset(unserializer.UnserializeValue(s));
 ASSERT_EQ(JobOperationValue::Type_DicomInstance, value->GetType());
 ASSERT_EQ(id, dynamic_cast<DicomInstanceOperationValue&>(*value).GetId());
 {
 std::string id;
 ASSERT_TRUE(CreateInstance(id));
 Json::Value s;
+OrthancJobUnserializer unserializer(GetContext());
 // DeleteResourceOperation
 {
 DeleteResourceOperation operation(GetContext());
-s = 42;
+ASSERT_TRUE(CheckIdempotentSerialization(unserializer, operation));
 operation.Serialize(s);
 }
-OrthancJobUnserializer unserializer(GetContext());
 std::auto_ptr<IJobOperation> operation;
 {
 operation.reset(unserializer.UnserializeOperation(s));
 peer.SetPassword("password");
 peer.SetPkcs11Enabled(true);
 StorePeerOperation operation(peer);
-s = 42;
+ASSERT_TRUE(CheckIdempotentSerialization(unserializer, operation));
 operation.Serialize(s);
 }
 {
 operation.reset(unserializer.UnserializeOperation(s));
 modality.SetPort(1000);
 modality.SetManufacturer(ModalityManufacturer_StoreScp);
 StoreScuOperation operation("TEST", modality);
-s = 42;
+ASSERT_TRUE(CheckIdempotentSerialization(unserializer, operation));
 operation.Serialize(s);
 }
 {
 operation.reset(unserializer.UnserializeOperation(s));
 SystemCallOperation operation(std::string("echo"));
 operation.AddPreArgument("a");
 operation.AddPreArgument("b");
 operation.AddPostArgument("c");
-s = 42;
+ASSERT_TRUE(CheckIdempotentSerialization(unserializer, operation));
 operation.Serialize(s);
 }
 {
 operation.reset(unserializer.UnserializeOperation(s));
 std::auto_ptr<DicomModification> modification(new DicomModification);
 modification->SetupAnonymization(DicomVersion_2008);
 ModifyInstanceOperation operation(GetContext(), RequestOrigin_Lua, modification.release());
-s = 42;
+ASSERT_TRUE(CheckIdempotentSerialization(unserializer, operation));
 operation.Serialize(s);
 }
 {
 operation.reset(unserializer.UnserializeOperation(s));
 ArchiveJob job(tmp, GetContext(), false, false);
 ASSERT_FALSE(job.Serialize(s));  // Cannot serialize this
 }
 // DicomModalityStoreJob
+OrthancJobUnserializer unserializer(GetContext());
 {
 RemoteModalityParameters modality;
 modality.SetApplicationEntityTitle("REMOTE");
 modality.SetHost("192.168.1.1");
 DicomModalityStoreJob job(GetContext());
 job.SetLocalAet("LOCAL");
 job.SetRemoteModality(modality);
 job.SetMoveOriginator("MOVESCU", 42);
-s = 42;
+ASSERT_TRUE(CheckIdempotentSerialization(unserializer, job));
 ASSERT_TRUE(job.Serialize(s));
 }
-OrthancJobUnserializer unserializer(GetContext());
 {
 std::auto_ptr<IJob> job;
 job.reset(unserializer.UnserializeJob(s));
 peer.SetPkcs11Enabled(true);
 OrthancPeerStoreJob job(GetContext());
 job.SetPeer(peer);
-s = 42;
+ASSERT_TRUE(CheckIdempotentSerialization(unserializer, job));
 ASSERT_TRUE(job.Serialize(s));
 }
 {
 std::auto_ptr<IJob> job;
 ResourceModificationJob job(GetContext());
 job.SetModification(modification.release(), true);
 job.SetOrigin(DicomInstanceOrigin::FromLua());
-s = 42;
+ASSERT_TRUE(CheckIdempotentSerialization(unserializer, job));
 ASSERT_TRUE(job.Serialize(s));
 }
 {
 std::auto_ptr<IJob> job;
 ResourceModificationJob& tmp = dynamic_cast<ResourceModificationJob&>(*job);
 ASSERT_TRUE(tmp.IsAnonymization());
 ASSERT_EQ(RequestOrigin_Lua, tmp.GetOrigin().GetRequestOrigin());
 ASSERT_TRUE(tmp.GetModification().IsRemoved(DICOM_TAG_STUDY_DESCRIPTION));
 }
+}
-// SequenceOfOperationsJob.h
-{
+TEST(JobsSerialization, Registry)
-SequenceOfOperationsJob job;
+{
+// TODO : Test serialization of JobsRegistry
-s = 42;
+}
-ASSERT_TRUE(job.Serialize(s));
-}
-std::cout << s;
-}

Mercurial > hg > orthanc

comparison UnitTestsSources/MultiThreadingTests.cpp @ 2666:2540ac79ab6c jobs