Remove namespaces from event module's tests

test/cases/event/EventHandlerTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-14
+ * Changed:         2022-11-09
  *
  * */
 
@@ -11,6 +11,9 @@
 #include <ls_std/ls_std_core.hpp>
 #include <ls_std/ls_std_event.hpp>
 
+using namespace ls::std::core;
+using namespace ls::std::event;
+
 namespace
 {
   class EventHandlerTest : public ::testing::Test
@@ -32,18 +35,18 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::EventHandler eventHandler{""};
+                     EventHandler eventHandler{""};
                    }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
+                   catch (const IllegalArgumentException &_exception)
                    {
                      throw;
                    }
-                 }, ls::std::core::IllegalArgumentException);
+                 }, IllegalArgumentException);
   }
 
   TEST_F(EventHandlerTest, getId)
   {
-    ls::std::event::EventHandler eventHandler{"EventId"};
+    EventHandler eventHandler{"EventId"};
     ASSERT_STREQ("EventId", eventHandler.getId().c_str());
   }
 }

test/cases/event/EventManagerTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-27
- * Changed:         2022-05-20
+ * Changed:         2022-11-09
  *
  * */
 
@@ -11,6 +11,12 @@
 #include <ls_std/ls_std_event.hpp>
 #include <ls_std_event_test.hpp>
 
+using namespace ls::std::core;
+using namespace ls::std::core::type;
+using namespace ls::std::event;
+using namespace ::std;
+using namespace ls_std_event_test;
+
 namespace
 {
   class EventManagerTest : public ::testing::Test
@@ -29,7 +35,7 @@ namespace
 
   TEST_F(EventManagerTest, getClassName)
   {
-    ls::std::event::EventManager eventManager{};
+    EventManager eventManager{};
     ASSERT_STREQ("EventManager", eventManager.getClassName().c_str());
   }
 
@@ -38,14 +44,14 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::EventManager eventManager{};
-                     eventManager.subscribe("", ::std::make_shared<ls_std_event_test::DailyNewsAgency>());
+                     EventManager eventManager{};
+                     eventManager.subscribe("", make_shared<DailyNewsAgency>());
                    }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
+                   catch (const IllegalArgumentException &_exception)
                    {
                      throw;
                    }
-                 }, ls::std::core::IllegalArgumentException);
+                 }, IllegalArgumentException);
   }
 
   TEST_F(EventManagerTest, subscribe_no_listener)
@@ -53,14 +59,14 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::EventManager eventManager{};
+                     EventManager eventManager{};
                      eventManager.subscribe("TMP_ID", nullptr);
                    }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
+                   catch (const IllegalArgumentException &_exception)
                    {
                      throw;
                    }
-                 }, ls::std::core::IllegalArgumentException);
+                 }, IllegalArgumentException);
   }
 
   TEST_F(EventManagerTest, subscribe_no_event_handler_available)
@@ -68,14 +74,14 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::EventManager eventManager{};
-                     eventManager.subscribe("TMP_DIR", ::std::make_shared<ls_std_event_test::DailyNewsAgency>());
+                     EventManager eventManager{};
+                     eventManager.subscribe("TMP_DIR", make_shared<DailyNewsAgency>());
                    }
-                   catch (const ls::std::core::EventNotSubscribedException &_exception)
+                   catch (const EventNotSubscribedException &_exception)
                    {
                      throw;
                    }
-                 }, ls::std::core::EventNotSubscribedException);
+                 }, EventNotSubscribedException);
   }
 
   TEST_F(EventManagerTest, unsubscribe_empty_id)
@@ -83,14 +89,14 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::EventManager eventManager{};
-                     eventManager.unsubscribe("", ::std::make_shared<ls_std_event_test::DailyNewsAgency>());
+                     EventManager eventManager{};
+                     eventManager.unsubscribe("", make_shared<DailyNewsAgency>());
                    }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
+                   catch (const IllegalArgumentException &_exception)
                    {
                      throw;
                    }
-                 }, ls::std::core::IllegalArgumentException);
+                 }, IllegalArgumentException);
   }
 
   TEST_F(EventManagerTest, unsubscribe_no_listener)
@@ -98,27 +104,27 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::EventManager eventManager{};
+                     EventManager eventManager{};
                      eventManager.unsubscribe("TMP_ID", nullptr);
                    }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
+                   catch (const IllegalArgumentException &_exception)
                    {
                      throw;
                    }
-                 }, ls::std::core::IllegalArgumentException);
+                 }, IllegalArgumentException);
   }
 
   TEST_F(EventManagerTest, addEventHandler)
   {
-    ls::std::event::EventManager eventManager{};
-    ASSERT_TRUE(eventManager.addEventHandler(::std::make_shared<ls::std::event::EventHandler>("TMP_ID")));
+    EventManager eventManager{};
+    ASSERT_TRUE(eventManager.addEventHandler(make_shared<EventHandler>("TMP_ID")));
   }
 
   TEST_F(EventManagerTest, addEventHandler_event_handler_already_exists)
   {
-    ls::std::event::EventManager eventManager{};
-    ASSERT_TRUE(eventManager.addEventHandler(::std::make_shared<ls::std::event::EventHandler>("TMP_ID")));
-    ASSERT_FALSE(eventManager.addEventHandler(::std::make_shared<ls::std::event::EventHandler>("TMP_ID")));
+    EventManager eventManager{};
+    ASSERT_TRUE(eventManager.addEventHandler(make_shared<EventHandler>("TMP_ID")));
+    ASSERT_FALSE(eventManager.addEventHandler(make_shared<EventHandler>("TMP_ID")));
   }
 
   TEST_F(EventManagerTest, addEventHandler_no_reference)
@@ -126,14 +132,14 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::EventManager eventManager{};
+                     EventManager eventManager{};
                      eventManager.addEventHandler(nullptr);
                    }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
+                   catch (const IllegalArgumentException &_exception)
                    {
                      throw;
                    }
-                 }, ls::std::core::IllegalArgumentException);
+                 }, IllegalArgumentException);
   }
 
   TEST_F(EventManagerTest, fire_event_handler_not_available)
@@ -141,26 +147,26 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::EventManager eventManager{};
-                     eventManager.fire(ls::std::event::Event{"TMP_ID"});
+                     EventManager eventManager{};
+                     eventManager.fire(Event{"TMP_ID"});
                    }
-                   catch (const ls::std::core::EventNotHandledException &_exception)
+                   catch (const EventNotHandledException &_exception)
                    {
                      throw;
                    }
-                 }, ls::std::core::EventNotHandledException);
+                 }, EventNotHandledException);
   }
 
   TEST_F(EventManagerTest, hasEventHandler)
   {
-    ls::std::event::EventManager eventManager{};
-    eventManager.addEventHandler(::std::make_shared<ls::std::event::EventHandler>("TMP_ID"));
+    EventManager eventManager{};
+    eventManager.addEventHandler(make_shared<EventHandler>("TMP_ID"));
     ASSERT_TRUE(eventManager.hasEventHandler("TMP_ID"));
   }
 
   TEST_F(EventManagerTest, hasEventHandler_no_event_handler_available)
   {
-    ls::std::event::EventManager eventManager{};
+    EventManager eventManager{};
     ASSERT_FALSE(eventManager.hasEventHandler("TMP_ID"));
   }
 
@@ -169,20 +175,20 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::EventManager eventManager{};
+                     EventManager eventManager{};
                      eventManager.hasEventHandler("");
                    }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
+                   catch (const IllegalArgumentException &_exception)
                    {
                      throw;
                    }
-                 }, ls::std::core::IllegalArgumentException);
+                 }, IllegalArgumentException);
   }
 
   TEST_F(EventManagerTest, removeEventHandler)
   {
-    ls::std::event::EventManager eventManager{};
-    ::std::shared_ptr<ls::std::event::EventHandler> eventHandler = ::std::make_shared<ls::std::event::EventHandler>("TMP_ID");
+    EventManager eventManager{};
+    shared_ptr<EventHandler> eventHandler = make_shared<EventHandler>("TMP_ID");
     eventManager.addEventHandler(eventHandler);
 
     ASSERT_TRUE(eventManager.removeEventHandler(eventHandler));
@@ -190,8 +196,8 @@ namespace
 
   TEST_F(EventManagerTest, removeEventHandler_no_event_handler_available)
   {
-    ls::std::event::EventManager eventManager{};
-    ASSERT_FALSE(eventManager.removeEventHandler(::std::make_shared<ls::std::event::EventHandler>("TMP_ID")));
+    EventManager eventManager{};
+    ASSERT_FALSE(eventManager.removeEventHandler(make_shared<EventHandler>("TMP_ID")));
   }
 
   TEST_F(EventManagerTest, removeEventHandler_no_reference)
@@ -199,41 +205,41 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::EventManager eventManager{};
+                     EventManager eventManager{};
                      eventManager.removeEventHandler(nullptr);
                    }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
+                   catch (const IllegalArgumentException &_exception)
                    {
                      throw;
                    }
-                 }, ls::std::core::IllegalArgumentException);
+                 }, IllegalArgumentException);
   }
 
   TEST_F(EventManagerTest, production_example)
   {
-    ::std::string news, expectedNews{};
-    ls::std::core::type::event_id seriousNewsEventId = ls_std_event_test::SeriousNewsEvent{""}.getId();
-    ls::std::core::type::event_id gossipNewsEventId = ls_std_event_test::GossipNewsEvent{""}.getId();
+    string news, expectedNews{};
+    event_id seriousNewsEventId = SeriousNewsEvent{""}.getId();
+    event_id gossipNewsEventId = GossipNewsEvent{""}.getId();
 
     // create event handler
 
-    ::std::shared_ptr<ls::std::event::EventHandler> seriousNewsEventHandler = ::std::make_shared<ls::std::event::EventHandler>(seriousNewsEventId);   // event id
-    ::std::shared_ptr<ls::std::event::EventHandler> gossipNewsEventHandler = ::std::make_shared<ls::std::event::EventHandler>(gossipNewsEventId);     // event id
+    shared_ptr<EventHandler> seriousNewsEventHandler = make_shared<EventHandler>(seriousNewsEventId);   // event id
+    shared_ptr<EventHandler> gossipNewsEventHandler = make_shared<EventHandler>(gossipNewsEventId);     // event id
 
     // create and fill event manager with handler
 
-    ::std::shared_ptr<ls::std::event::EventManager> eventManager = ::std::make_shared<ls::std::event::EventManager>();
+    shared_ptr<EventManager> eventManager = make_shared<EventManager>();
     eventManager->addEventHandler(seriousNewsEventHandler);
     eventManager->addEventHandler(gossipNewsEventHandler);
 
     // create news agency (listener)
 
-    ::std::shared_ptr<ls_std_event_test::DailyNewsAgency> dailyNews = ::std::make_shared<ls_std_event_test::DailyNewsAgency>();
-    ::std::shared_ptr<ls_std_event_test::GossipNewsAgency> gossipNews = ::std::make_shared<ls_std_event_test::GossipNewsAgency>();
+    shared_ptr<DailyNewsAgency> dailyNews = make_shared<DailyNewsAgency>();
+    shared_ptr<GossipNewsAgency> gossipNews = make_shared<GossipNewsAgency>();
 
     // fire SeriousNewsEvent event with no effect
 
-    eventManager->fire(ls_std_event_test::SeriousNewsEvent(news)); // event call
+    eventManager->fire(SeriousNewsEvent(news)); // event call
     ASSERT_TRUE(dailyNews->getNews().empty());
     ASSERT_TRUE(gossipNews->getNews().empty());
 
@@ -242,7 +248,7 @@ namespace
     eventManager->subscribe(seriousNewsEventId, dailyNews);
     eventManager->subscribe(seriousNewsEventId, gossipNews);
     news = "COVID-19 is still going on!";
-    eventManager->fire(ls_std_event_test::SeriousNewsEvent(news)); // event call
+    eventManager->fire(SeriousNewsEvent(news)); // event call
 
     expectedNews = "DailyNewsAgency: " + news;
     ASSERT_STREQ(expectedNews.c_str(), dailyNews->getNews().c_str());
@@ -255,7 +261,7 @@ namespace
     // unsubscribe SeriousNewsEvent from GossipNewsAgency
 
     eventManager->unsubscribe(seriousNewsEventId, gossipNews);
-    eventManager->fire(ls_std_event_test::SeriousNewsEvent(news)); // event call
+    eventManager->fire(SeriousNewsEvent(news)); // event call
 
     expectedNews = "DailyNewsAgency: " + news;
     ASSERT_STREQ(expectedNews.c_str(), dailyNews->getNews().c_str());
@@ -270,12 +276,12 @@ namespace
     eventManager->subscribe(seriousNewsEventId, gossipNews);
 
     news = "COVID-19 is still going on!";
-    eventManager->fire(ls_std_event_test::SeriousNewsEvent(news)); // event call
+    eventManager->fire(SeriousNewsEvent(news)); // event call
     expectedNews = "GossipNewsAgency: " + news;
     ASSERT_STREQ(expectedNews.c_str(), gossipNews->getNews().c_str());
 
     news = "ape likes banana!";
-    eventManager->fire(ls_std_event_test::GossipNewsEvent(news)); // event call
+    eventManager->fire(GossipNewsEvent(news)); // event call
     expectedNews = "GossipNewsAgency: " + news;
     ASSERT_STREQ(expectedNews.c_str(), gossipNews->getNews().c_str());
   }

test/cases/event/EventTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-26
- * Changed:         2022-05-14
+ * Changed:         2022-11-09
  *
  * */
 
@@ -11,6 +11,10 @@
 #include <ls_std/ls_std_core.hpp>
 #include <ls_std/ls_std_event.hpp>
 
+using namespace ls::std::core;
+using namespace ls::std::core::type;
+using namespace ls::std::event;
+
 namespace
 {
   class EventTest : public ::testing::Test
@@ -31,7 +35,7 @@ namespace
 
   TEST_F(EventTest, getClassName)
   {
-    ls::std::event::Event event{"TMP_ID"};
+    Event event{"TMP_ID"};
     ASSERT_STREQ("Event", event.getClassName().c_str());
   }
 
@@ -40,38 +44,38 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::Event event{""};
+                     Event event{""};
                    }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
+                   catch (const IllegalArgumentException &_exception)
                    {
                      throw;
                    }
-                 }, ls::std::core::IllegalArgumentException);
+                 }, IllegalArgumentException);
   }
 
   TEST_F(EventTest, addParameter)
   {
-    ls::std::event::Event event{"TMP_ID"};
+    Event event{"TMP_ID"};
     ASSERT_TRUE(event.getParameterList().empty());
 
-    ASSERT_TRUE(event.addParameter(ls::std::core::type::event_parameter("key", "yes")));
-    ASSERT_TRUE(event.addParameter(ls::std::core::type::event_parameter("facing_door", "yes")));
+    ASSERT_TRUE(event.addParameter(event_parameter("key", "yes")));
+    ASSERT_TRUE(event.addParameter(event_parameter("facing_door", "yes")));
   }
 
   TEST_F(EventTest, addParameter_element_already_exists)
   {
-    ls::std::event::Event event{"TMP_ID"};
+    Event event{"TMP_ID"};
     ASSERT_TRUE(event.getParameterList().empty());
 
-    ASSERT_TRUE(event.addParameter(ls::std::core::type::event_parameter("key", "yes")));
-    ASSERT_FALSE(event.addParameter(ls::std::core::type::event_parameter("key", "yes")));
+    ASSERT_TRUE(event.addParameter(event_parameter("key", "yes")));
+    ASSERT_FALSE(event.addParameter(event_parameter("key", "yes")));
   }
 
   TEST_F(EventTest, clearParameterList)
   {
-    ls::std::event::Event event{"OPEN_DOOR_EVENT"};
-    event.addParameter(ls::std::core::type::event_parameter("key", "yes"));
-    event.addParameter(ls::std::core::type::event_parameter("facing_door", "yes"));
+    Event event{"OPEN_DOOR_EVENT"};
+    event.addParameter(event_parameter("key", "yes"));
+    event.addParameter(event_parameter("facing_door", "yes"));
     ASSERT_EQ(2, event.getParameterList().size());
 
     event.clearParameterList();
@@ -81,23 +85,23 @@ namespace
 
   TEST_F(EventTest, getId)
   {
-    ls::std::event::Event event{"OPEN_DOOR_EVENT"};
+    Event event{"OPEN_DOOR_EVENT"};
     ASSERT_STREQ("OPEN_DOOR_EVENT", event.getId().c_str());
   }
 
   TEST_F(EventTest, getParameterList)
   {
-    ls::std::event::Event event{"OPEN_DOOR_EVENT"};
+    Event event{"OPEN_DOOR_EVENT"};
     ASSERT_TRUE(event.getParameterList().empty());
   }
 
   TEST_F(EventTest, removeParameter)
   {
-    ls::std::event::Event event{"OPEN_DOOR_EVENT"};
+    Event event{"OPEN_DOOR_EVENT"};
     ASSERT_TRUE(event.getParameterList().empty());
 
-    event.addParameter(ls::std::core::type::event_parameter("key", "yes"));
-    event.addParameter(ls::std::core::type::event_parameter("facing_door", "yes"));
+    event.addParameter(event_parameter("key", "yes"));
+    event.addParameter(event_parameter("facing_door", "yes"));
 
     ASSERT_TRUE(event.removeParameter("key"));
     ASSERT_TRUE(event.removeParameter("facing_door"));
@@ -105,7 +109,7 @@ namespace
 
   TEST_F(EventTest, removeParameter_elenent_does_not_exist)
   {
-    ls::std::event::Event event{"OPEN_DOOR_EVENT"};
+    Event event{"OPEN_DOOR_EVENT"};
 
     ASSERT_FALSE(event.removeParameter("key"));
     ASSERT_FALSE(event.removeParameter("facing_door"));
@@ -113,7 +117,7 @@ namespace
 
   TEST_F(EventTest, setId)
   {
-    ls::std::event::Event event{"OPEN_DOOR_EVENT"};
+    Event event{"OPEN_DOOR_EVENT"};
     ASSERT_STREQ("OPEN_DOOR_EVENT", event.getId().c_str());
 
     event.setId("ANOTHER_EVENT");
@@ -125,13 +129,13 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::Event event{"TMP_ID"};
+                     Event event{"TMP_ID"};
                      event.setId("");
                    }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
+                   catch (const IllegalArgumentException &_exception)
                    {
                      throw;
                    }
-                 }, ls::std::core::IllegalArgumentException);
+                 }, IllegalArgumentException);
   }
 }

test/cases/event/NarratorTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-11-14
- * Changed:         2022-05-20
+ * Changed:         2022-11-09
  *
  * */
 
@@ -12,6 +12,12 @@
 #include <ls_std/ls_std_event.hpp>
 #include <ls_std_event_test.hpp>
 
+using namespace ls::std::core;
+using namespace ls::std::core::interface_type;
+using namespace ls::std::event;
+using namespace ::std;
+using namespace ls_std_event_test;
+
 namespace
 {
   class NarratorTest : public ::testing::Test
@@ -27,17 +33,17 @@ namespace
       void TearDown() override
       {}
 
-      ::std::shared_ptr<ls_std_event_test::TestDataMercedesCar> mercedes1{};
-      ::std::shared_ptr<ls_std_event_test::TestDataMercedesCar> mercedes2{};
-      ::std::shared_ptr<ls_std_event_test::TestDataMercedesCar> mercedes3{};
+      shared_ptr<TestDataMercedesCar> mercedes1{};
+      shared_ptr<TestDataMercedesCar> mercedes2{};
+      shared_ptr<TestDataMercedesCar> mercedes3{};
 
       void createCars()
       {
-        this->mercedes1 = ::std::make_shared<ls_std_event_test::TestDataMercedesCar>();
+        this->mercedes1 = make_shared<TestDataMercedesCar>();
         this->mercedes1->setColor("pink");
-        this->mercedes2 = ::std::make_shared<ls_std_event_test::TestDataMercedesCar>();
+        this->mercedes2 = make_shared<TestDataMercedesCar>();
         this->mercedes2->setColor("blue");
-        this->mercedes3 = ::std::make_shared<ls_std_event_test::TestDataMercedesCar>();
+        this->mercedes3 = make_shared<TestDataMercedesCar>();
         this->mercedes3->setColor("red");
       }
   };
@@ -45,20 +51,20 @@ namespace
   TEST_F(NarratorTest, addListener)
   {
     this->createCars();
-    ls::std::event::Narrator paintingMachine{};
+    Narrator paintingMachine{};
 
-    ASSERT_TRUE(paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes1)));
-    ASSERT_TRUE(paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes2)));
-    ASSERT_TRUE(paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes3)));
+    ASSERT_TRUE(paintingMachine.addListener(dynamic_pointer_cast<IListener>(this->mercedes1)));
+    ASSERT_TRUE(paintingMachine.addListener(dynamic_pointer_cast<IListener>(this->mercedes2)));
+    ASSERT_TRUE(paintingMachine.addListener(dynamic_pointer_cast<IListener>(this->mercedes3)));
   }
 
   TEST_F(NarratorTest, addListener_listener_already_exists)
   {
     this->createCars();
-    ls::std::event::Narrator paintingMachine{};
+    Narrator paintingMachine{};
 
-    ASSERT_TRUE(paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes1)));
-    ASSERT_FALSE(paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes1)));
+    ASSERT_TRUE(paintingMachine.addListener(dynamic_pointer_cast<IListener>(this->mercedes1)));
+    ASSERT_FALSE(paintingMachine.addListener(dynamic_pointer_cast<IListener>(this->mercedes1)));
   }
 
   TEST_F(NarratorTest, addListener_no_reference)
@@ -66,23 +72,23 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::Narrator paintingMachine{};
+                     Narrator paintingMachine{};
                      paintingMachine.addListener(nullptr);
                    }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
+                   catch (const IllegalArgumentException &_exception)
                    {
                      throw;
                    }
-                 }, ls::std::core::IllegalArgumentException);
+                 }, IllegalArgumentException);
   }
 
   TEST_F(NarratorTest, clear)
   {
     this->createCars();
-    ls::std::event::Narrator paintingMachine{};
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes1));
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes2));
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes3));
+    Narrator paintingMachine{};
+    paintingMachine.addListener(dynamic_pointer_cast<IListener>(this->mercedes1));
+    paintingMachine.addListener(dynamic_pointer_cast<IListener>(this->mercedes2));
+    paintingMachine.addListener(dynamic_pointer_cast<IListener>(this->mercedes3));
 
     ASSERT_FALSE(paintingMachine.getListeners().empty());
     paintingMachine.clear();
@@ -91,17 +97,17 @@ namespace
 
   TEST_F(NarratorTest, getListeners)
   {
-    ls::std::event::Narrator narrator{};
+    Narrator narrator{};
     ASSERT_TRUE(narrator.getListeners().empty());
   }
 
   TEST_F(NarratorTest, removeListener)
   {
     this->createCars();
-    ls::std::event::Narrator paintingMachine{};
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes1));
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes2));
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes3));
+    Narrator paintingMachine{};
+    paintingMachine.addListener(dynamic_pointer_cast<IListener>(this->mercedes1));
+    paintingMachine.addListener(dynamic_pointer_cast<IListener>(this->mercedes2));
+    paintingMachine.addListener(dynamic_pointer_cast<IListener>(this->mercedes3));
 
     ASSERT_TRUE(paintingMachine.removeListener(this->mercedes2));
     ASSERT_TRUE(paintingMachine.removeListener(this->mercedes1));
@@ -112,7 +118,7 @@ namespace
   TEST_F(NarratorTest, removeListener_no_listener_available)
   {
     this->createCars();
-    ls::std::event::Narrator paintingMachine{};
+    Narrator paintingMachine{};
     ASSERT_FALSE(paintingMachine.removeListener(this->mercedes2));
   }
 
@@ -121,30 +127,30 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::Narrator paintingMachine{};
+                     Narrator paintingMachine{};
                      paintingMachine.removeListener(nullptr);
                    }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
+                   catch (const IllegalArgumentException &_exception)
                    {
                      throw;
                    }
-                 }, ls::std::core::IllegalArgumentException);
+                 }, IllegalArgumentException);
   }
 
   TEST_F(NarratorTest, tell)
   {
     this->createCars();
-    ls::std::event::Narrator paintingMachine{};
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes1));
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes2));
-    paintingMachine.addListener(::std::dynamic_pointer_cast<ls::std::core::interface_type::IListener>(this->mercedes3));
+    Narrator paintingMachine{};
+    paintingMachine.addListener(dynamic_pointer_cast<IListener>(this->mercedes1));
+    paintingMachine.addListener(dynamic_pointer_cast<IListener>(this->mercedes2));
+    paintingMachine.addListener(dynamic_pointer_cast<IListener>(this->mercedes3));
 
     ASSERT_STREQ("pink", this->mercedes1->getColor().c_str());
     ASSERT_STREQ("blue", this->mercedes2->getColor().c_str());
     ASSERT_STREQ("red", this->mercedes3->getColor().c_str());
 
-    ls_std_event_test::Colour newColor{"black"};
-    paintingMachine.tell(static_cast<const ls::std::core::Class &>(newColor));
+    Colour newColor{"black"};
+    paintingMachine.tell(static_cast<const Class &>(newColor));
 
     ASSERT_STREQ("black", this->mercedes1->getColor().c_str());
     ASSERT_STREQ("black", this->mercedes2->getColor().c_str());

test/cases/event/serialization/SerializableJsonEventTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2020-12-20
- * Changed:         2022-05-20
+ * Changed:         2022-11-09
  *
  * */
 
@@ -11,6 +11,11 @@
 #include <ls_std/ls_std_core.hpp>
 #include <ls_std/ls_std_event.hpp>
 
+using namespace ls::std::core;
+using namespace ls::std::core::type;
+using namespace ls::std::event;
+using namespace ::std;
+
 namespace
 {
   class SerializableJsonEventTest : public ::testing::Test
@@ -32,38 +37,38 @@ namespace
     EXPECT_THROW({
                    try
                    {
-                     ls::std::event::SerializableJsonEvent serializable{nullptr};
+                     SerializableJsonEvent serializable{nullptr};
                    }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
+                   catch (const IllegalArgumentException &_exception)
                    {
                      throw;
                    }
-                 }, ls::std::core::IllegalArgumentException);
+                 }, IllegalArgumentException);
   }
 
   TEST_F(SerializableJsonEventTest, marshal)
   {
-    ls::std::event::Event event{"OPEN_DOOR_EVENT"};
-    event.addParameter(ls::std::core::type::event_parameter{"key_available", "true"});
-    event.addParameter(ls::std::core::type::event_parameter{"door_id", "16675"});
+    Event event{"OPEN_DOOR_EVENT"};
+    event.addParameter(event_parameter{"key_available", "true"});
+    event.addParameter(event_parameter{"door_id", "16675"});
 
-    ls::std::event::SerializableJsonEvent serializable{::std::make_shared<ls::std::event::Event>(event)};
+    SerializableJsonEvent serializable{make_shared<Event>(event)};
 
-    ls::std::core::type::byte_field data = serializable.marshal();
+    byte_field data = serializable.marshal();
     ASSERT_FALSE(data.empty());
-    ::std::string expectedString = R"({"id":"OPEN_DOOR_EVENT","parameterList":{"door_id":["door_id","16675"],"key_available":["key_available","true"]}})";
+    string expectedString = R"({"id":"OPEN_DOOR_EVENT","parameterList":{"door_id":["door_id","16675"],"key_available":["key_available","true"]}})";
     ASSERT_STREQ(expectedString.c_str(), data.c_str());
   }
 
   TEST_F(SerializableJsonEventTest, unmarshal)
   {
-    ls::std::event::Event event{"TMP_EVENT"};
-    ls::std::event::SerializableJsonEvent serializable{::std::make_shared<ls::std::event::Event>(event)};
-    ::std::string jsonString = R"({"id":"OPEN_DOOR_EVENT","parameterList":{"door_id":["door_id","16675"],"key_available":["key_available","true"]}})";
+    Event event{"TMP_EVENT"};
+    SerializableJsonEvent serializable{make_shared<Event>(event)};
+    string jsonString = R"({"id":"OPEN_DOOR_EVENT","parameterList":{"door_id":["door_id","16675"],"key_available":["key_available","true"]}})";
 
     serializable.unmarshal(jsonString);
     ASSERT_STREQ("OPEN_DOOR_EVENT", serializable.getValue()->getId().c_str());
-    ls::std::core::type::event_parameter_list parameterList = serializable.getValue()->getParameterList();
+    event_parameter_list parameterList = serializable.getValue()->getParameterList();
 
     ASSERT_FALSE(parameterList.empty());
     ASSERT_EQ(2, parameterList.size());
@@ -73,18 +78,18 @@ namespace
 
   TEST_F(SerializableJsonEventTest, setValue_parameter_not_set)
   {
-    ls::std::event::Event event{"TMP_EVENT"};
-    ls::std::event::SerializableJsonEvent serializable{::std::make_shared<ls::std::event::Event>(event)};
+    Event event{"TMP_EVENT"};
+    SerializableJsonEvent serializable{make_shared<Event>(event)};
 
     EXPECT_THROW({
                    try
                    {
                      serializable.setValue(nullptr);
                    }
-                   catch (const ls::std::core::IllegalArgumentException &_exception)
+                   catch (const IllegalArgumentException &_exception)
                    {
                      throw;
                    }
-                 }, ls::std::core::IllegalArgumentException);
+                 }, IllegalArgumentException);
   }
 }