[CONPRO-1430] BlockWiseTransfer Error

[platform/upstream/iotivity.git] / service / notification / unittest / NSConsumerTest.cpp

diff --git a/service/notification/unittest/NSConsumerTest.cpp b/service/notification/unittest/NSConsumerTest.cpp
index 4360a2b..4a57bde 100644 (file)
--- a/service/notification/unittest/NSConsumerTest.cpp
+++ b/service/notification/unittest/NSConsumerTest.cpp
@@ -52,6 +52,8 @@ namespace
     };
 
     NSConsumerConfig cfg;
+
+    NSProviderSimulator::NS_TopicStateList g_topicStateList;
 }
 
 class TestWithMock: public testing::Test
@@ -253,6 +255,8 @@ TEST_F(NotificationConsumerTest, DiscoverProviderWithNonAccepterWhenStartedConsu
     responseCon.wait_for(lock, g_waitForResponse);
 
     EXPECT_EQ(NS_DISCOVERED, revState);
+
+    ASSERT_NE(nullptr, g_provider) << "error: discovery failure";
 }
 
 TEST_F(NotificationConsumerTest, DiscoverProviderWithNonAccepterWhenRescan)
@@ -280,6 +284,9 @@ TEST_F(NotificationConsumerTest, DiscoverProviderWithNonAccepterWhenRescan)
 TEST_F(NotificationConsumerTest, ExpectSubscribeSuccess)
 {
     NSProviderState revState = NS_DENY;
+
+    ASSERT_NE(nullptr, g_provider) << "error: discovery failure";
+
     mocks.OnCallFunc(NSProviderChangedCallback).Do(
             [this, & revState](NSProvider * , NSProviderState state)
             {
@@ -301,11 +308,14 @@ TEST_F(NotificationConsumerTest, ExpectReceiveNotification)
     uint64_t id = 10;
     std::string title = "title";
     std::string msg = "msg";
+    uint64_t revId = 0;
 
-    mocks.ExpectCallFunc(NSNotificationReceivedCallbackEmpty).Do(
-            [this](NSMessage * message)
+    mocks.OnCallFunc(NSNotificationReceivedCallbackEmpty).Do(
+            [this, & revId](NSMessage * message)
             {
                 std::cout << "Income Notification : " << message->messageId << std::endl;
+                revId = message->messageId;
+                responseCon.notify_all();
             });
 
     g_providerSimul.notifyMessage(id, title, msg);
@@ -313,16 +323,31 @@ TEST_F(NotificationConsumerTest, ExpectReceiveNotification)
     std::unique_lock< std::mutex > lock{ mutexForCondition };
     responseCon.wait_for(lock, g_waitForResponse);
 
+    EXPECT_EQ(id, revId);
     NSStopConsumer();
+    g_providerSimul.deleteNotificationResource();
 }
 
 TEST_F(NotificationConsumerTest, ExpectReceiveSubAllowWithAccepterisProvider)
 {
     g_providerSimul.setAccepter((int)NSSelector::NS_SELECTION_PROVIDER);
     NSProviderState revState = NS_DENY;
+    g_providerSimul.createNotificationResource();
+    {
+        std::unique_lock< std::mutex > lock{ mutexForCondition };
+        responseCon.wait_for(lock, g_waitForResponse);
+    }
 
     mocks.OnCallFunc(NSProviderChangedCallback).Do(
-            [this, & revState](NSProvider * , NSProviderState state)
+            [this, & revState](NSProvider * provider, NSProviderState state)
+            {
+                std::cout << "Income Changed Callback : " << state << std::endl;
+                revState = state;
+                g_provider = provider;
+                responseCon.notify_all();
+            });
+    mocks.OnCallFunc(NSProviderChangedCallback).Do(
+            [this, & revState](NSProvider *, NSProviderState state)
             {
                 std::cout << "Income Changed Callback : " << state << std::endl;
                 revState = state;
@@ -348,6 +373,7 @@ TEST_F(NotificationConsumerTest, ExpectReceiveNotificationWithAccepterisProvider
             {
                 std::cout << "Income Notification : " << message->messageId << std::endl;
                 revId = message->messageId;
+                responseCon.notify_all();
             });
 
     g_providerSimul.notifyMessage(id, title, msg);
@@ -369,6 +395,7 @@ TEST_F(NotificationConsumerTest, ExpectCallbackReadCheckWhenProviderNotifySync)
             [this](NSMessage * message)
             {
                 std::cout << "Income Notification : " << message->messageId << std::endl;
+                responseCon.notify_all();
             });
 
     mocks.OnCallFunc(NSSyncCallbackEmpty).Do(
@@ -377,6 +404,7 @@ TEST_F(NotificationConsumerTest, ExpectCallbackReadCheckWhenProviderNotifySync)
                 std::cout << "Income SyncInfo : " << sync->messageId
                         << ", State : " << sync->state << std::endl;
                 type = sync->state;
+                responseCon.notify_all();
             });
 
     g_providerSimul.notifyMessage(id, title, msg);
@@ -405,6 +433,7 @@ TEST_F(NotificationConsumerTest, ExpectCallbackDismissCheckWhenProviderNotifySyn
             [this](NSMessage * message)
             {
                 std::cout << "Income Notification : " << message->messageId << std::endl;
+                responseCon.notify_all();
             });
 
     mocks.OnCallFunc(NSSyncCallbackEmpty).Do(
@@ -413,6 +442,7 @@ TEST_F(NotificationConsumerTest, ExpectCallbackDismissCheckWhenProviderNotifySyn
                 std::cout << "Income Notification : " << sync->messageId
                         << ", State : " << sync->state << std::endl;
                 type = sync->state;
+                responseCon.notify_all();
             });
 
     g_providerSimul.notifyMessage(id, title, msg);
@@ -452,6 +482,7 @@ TEST_F(NotificationConsumerTest, ExpectCallbackReadCheckWhenConsumerPostSync)
                 std::cout << "Income Notification : " << sync->messageId
                         << ", State : " << sync->state << std::endl;
                 type = sync->state;
+                responseCon.notify_all();
             });
 
     g_providerSimul.notifyMessage(id, title, msg);
@@ -485,6 +516,7 @@ TEST_F(NotificationConsumerTest, ExpectCallbackDismissCheckWhenConsumerPostSync)
                 std::cout << "Income Notification : " << sync->messageId
                         << ", State : " << sync->state << std::endl;
                 state = sync->state;
+                responseCon.notify_all();
             });
 
     g_providerSimul.notifyMessage(id, title, msg);
@@ -494,8 +526,96 @@ TEST_F(NotificationConsumerTest, ExpectCallbackDismissCheckWhenConsumerPostSync)
     }
 
     EXPECT_EQ(NS_SYNC_DELETED, state);
-//    g_providerSimul.deleteNotificationResource();
-//    NSStopConsumer();
+}
+
+TEST_F(NotificationConsumerTest, ExpectGetProviderSuccessWithValidProviderId)
+{
+    ASSERT_NE(nullptr, g_provider) << "error: discovery failure";
+
+    NSProvider * provider = NSConsumerGetProvider(g_provider->providerId);
+    int ret = strcmp(provider->providerId, g_provider->providerId);
+    EXPECT_EQ(0, ret);
+    free(provider);
+}
+
+TEST_F(NotificationConsumerTest, ExpectGetProviderSuccessWithInvalidProviderId)
+{
+    NSProvider * provider = NSConsumerGetProvider("123456789012345678901234567890123457");
+    EXPECT_EQ(provider, (void*)NULL);
+}
+
+TEST_F(NotificationConsumerTest, ExpectGetProviderSuccessWithNULL)
+{
+    NSProvider * provider = NSConsumerGetProvider(NULL);
+    EXPECT_EQ(provider, (void*)NULL);
+}
+
+TEST_F(NotificationConsumerTest, ExpectGetTopicListIsNULL)
+{
+    ASSERT_NE(nullptr, g_provider) << "error: discovery failure";
+
+    NSTopicLL * currentTopics = NSConsumerGetTopicList(g_provider->providerId);
+    EXPECT_EQ(NULL, currentTopics);
+}
+
+TEST_F(NotificationConsumerTest, ExpectCallbackTopicUpdated)
+{
+    NSProviderState revState = NS_STOPPED;
+    mocks.OnCallFunc(NSProviderChangedCallback).Do(
+        [this, & revState](NSProvider * , NSProviderState state)
+        {
+            std::cout << "Income Changed Callback : " << state << std::endl;
+            revState = state;
+            responseCon.notify_all();
+        });
+
+    NSProviderSimulator::NS_TopicList topics;
+    topics.push_back("1");
+    topics.push_back("2");
+    topics.push_back("3");
+
+    g_providerSimul.setTopics(topics);
+
+    std::unique_lock< std::mutex > lock{ mutexForCondition };
+    responseCon.wait_for(lock, g_waitForResponse);
+
+    EXPECT_EQ(NS_TOPIC, revState);
+}
+
+TEST_F(NotificationConsumerTest, ExpectEQTopicList)
+{
+    bool isSame = false;
+
+    NSProviderSimulator::NS_TopicList topics;
+    topics.push_back("1");
+    topics.push_back("2");
+    topics.push_back("3");
+
+    ASSERT_NE(nullptr, g_provider) << "error: discovery failure";
+
+    NSTopicLL * retTopic = NSConsumerGetTopicList(g_provider->providerId);
+    std::for_each (topics.begin(), topics.end(),
+            [this, & retTopic, & isSame](const std::string & str)
+            {
+                isSame = (str == std::string(retTopic->topicName));
+                retTopic = retTopic->next;
+            });
+
+    EXPECT_EQ(true, isSame);
+}
+
+TEST_F(NotificationConsumerTest, ExpectFailUpdateTopicOnConsumer)
+{
+    ASSERT_NE(nullptr, g_provider) << "error: discovery failure";
+
+    NSTopicLL * retTopic = NSConsumerGetTopicList(g_provider->providerId);
+    for (; retTopic; retTopic = retTopic->next)
+    {
+        retTopic->state = NS_TOPIC_SUBSCRIBED;
+    }
+    NSResult ret = NSConsumerUpdateTopicList(g_provider->providerId, retTopic);
+
+    EXPECT_EQ(NS_ERROR, ret);
 }
 
 TEST_F(NotificationConsumerTest, ExpectCallbackDeletedProvider)
@@ -505,7 +625,6 @@ TEST_F(NotificationConsumerTest, ExpectCallbackDeletedProvider)
             [& type, this](NSProvider * , NSProviderState state)
             {
                 std::cout << "Income Changed Callback : " << state << std::endl;
-                //EXPECT_EQ(state, NS_STOPPED);
                 type = state;
                 responseCon.notify_all();
             });
@@ -513,20 +632,8 @@ TEST_F(NotificationConsumerTest, ExpectCallbackDeletedProvider)
     g_providerSimul.deleteNotificationResource();
 
     std::unique_lock< std::mutex > lock{ mutexForCondition };
-    responseCon.wait_for(lock, g_waitForResponse);
+    responseCon.wait_for(lock, std::chrono::milliseconds(2000));
 
     EXPECT_EQ(type, NS_STOPPED);
     NSStopConsumer();
 }
-
-//TEST_F(NotificationConsumerTest, ExpectUnsubscribeSuccess)
-//{
-//    NSResult ret = NSUnsubscribe(g_provider->providerId);
-//    std::unique_lock< std::mutex > lock{ mutexForCondition };
-//    responseCon.wait_for(lock, g_waitForResponse);
-//
-//    g_providerSimul.deleteNotificationResource();
-//    NSStopConsumer();
-//
-//    EXPECT_EQ(NS_OK, ret);
-//}