Added unit test cases for cablockwisetransfer.c api

Added unit test cases for cablockwisetransfer.c api.

Change-Id: Idf6570aebc4bd5f15202d6f0236b126199768851
Signed-off-by: hyuna0213.jo <hyuna0213.jo@samsung.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/5947
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: Jon A. Cruz <jon@joncruz.org>

diff --git a/resource/csdk/connectivity/common/src/cathreadpool_pthreads.c b/resource/csdk/connectivity/common/src/cathreadpool_pthreads.c
index 636036e..0fb57de 100644 (file)
--- a/resource/csdk/connectivity/common/src/cathreadpool_pthreads.c
+++ b/resource/csdk/connectivity/common/src/cathreadpool_pthreads.c
@@ -109,10 +109,7 @@ CAResult_t ca_thread_pool_init(int32_t num_of_threads, ca_thread_pool_t *thread_
     if(!(*thread_pool)->details->list_lock)
     {
         OIC_LOG(ERROR, TAG, "Failed to create thread-pool mutex");
-        OICFree((*thread_pool)->details);
-        OICFree(*thread_pool);
-        *thread_pool = NULL;
-        return CA_STATUS_FAILED;
+        goto exit;
     }
 
     (*thread_pool)->details->threads_list = u_arraylist_create();
@@ -124,15 +121,17 @@ CAResult_t ca_thread_pool_init(int32_t num_of_threads, ca_thread_pool_t *thread_
         {
             OIC_LOG(ERROR, TAG, "Failed to free thread-pool mutex");
         }
-
-        OICFree((*thread_pool)->details);
-        OICFree(*thread_pool);
-        *thread_pool = NULL;
-        return CA_STATUS_FAILED;
+        goto exit;
     }
 
     OIC_LOG(DEBUG, TAG, "OUT");
     return CA_STATUS_OK;
+
+exit:
+    OICFree((*thread_pool)->details);
+    OICFree(*thread_pool);
+    *thread_pool = NULL;
+    return CA_STATUS_FAILED;
 }
 
 CAResult_t ca_thread_pool_add_task(ca_thread_pool_t thread_pool, ca_thread_func method,

diff --git a/resource/csdk/connectivity/inc/cablockwisetransfer.h b/resource/csdk/connectivity/inc/cablockwisetransfer.h
index f25cb2e..24bab6c 100644 (file)
--- a/resource/csdk/connectivity/inc/cablockwisetransfer.h
+++ b/resource/csdk/connectivity/inc/cablockwisetransfer.h
@@ -34,6 +34,12 @@
 #include "uarraylist.h"
 #include "cacommon.h"
 #include "caprotocolmessage.h"
+#include "camessagehandler.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
 /**
  * Callback to send block data.
@@ -110,11 +116,6 @@ typedef enum
     CA_BLOCK_RECEIVED_ALREADY
 } CABlockState_t;
 
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
 /**
  * Initializes the block-wise transfer context.
  * @param[in]  CASendThreadFunc    function point to add data in send queue thread.
@@ -550,6 +551,12 @@ CABlockData_t *CACreateNewBlockData(const CAData_t *sendData);
 CAResult_t CARemoveBlockDataFromList(const CABlockDataID_t *blockID);
 
 /**
+ * Remove all block data in block-wise transfer list.
+ * @return ::CASTATUS_OK or ERROR CODES (::CAResult_t error codes in cacommon.h).
+ */
+CAResult_t CARemoveAllBlockDataFromList();
+
+/**
  * Check if data exist in block-wise transfer list.
  * @param[in]   blockID     ID set of CABlockData.
  * @return true or false.

diff --git a/resource/csdk/connectivity/src/cablockwisetransfer.c b/resource/csdk/connectivity/src/cablockwisetransfer.c
index 007ea77..e0d65af 100644 (file)
--- a/resource/csdk/connectivity/src/cablockwisetransfer.c
+++ b/resource/csdk/connectivity/src/cablockwisetransfer.c
@@ -40,6 +40,7 @@
 #include "caremotehandler.h"
 #include "cablockwisetransfer.h"
 #include "oic_malloc.h"
+#include "oic_string.h"
 #include "camutex.h"
 #include "logger.h"
 
@@ -112,6 +113,7 @@ CAResult_t CATerminateBlockWiseTransfer()
 
     if (g_context.dataList)
     {
+        CARemoveAllBlockDataFromList();
         u_arraylist_free(&g_context.dataList);
     }
 
@@ -2028,11 +2030,20 @@ CAData_t* CACreateNewDataSet(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint
 
         // get resource uri information from received response message
         // to send next request message to remote device
-        CAResponseInfo_t resInfo = { 0 };
-        CAGetResponseInfoFromPDU(pdu, &resInfo, endpoint);
+        CAResponseInfo_t* resInfo = (CAResponseInfo_t*)OICCalloc(1, sizeof(*resInfo));
+        if (!resInfo)
+        {
+            OIC_LOG(ERROR, TAG, "memory allocation failed");
+            OICFree(requestData.token);
+            return NULL;
+        }
 
+        CAGetResponseInfoFromPDU(pdu, resInfo, endpoint);
         requestInfo->method = CA_GET;
-        requestInfo->info.resourceUri = resInfo.info.resourceUri;
+        requestInfo->info.resourceUri = OICStrdup(resInfo->info.resourceUri);
+
+        // after copying the resource uri, destroy response info.
+        CADestroyResponseInfoInternal(resInfo);
     }
 
     CAData_t *data = (CAData_t *) OICCalloc(1, sizeof(CAData_t));
@@ -2600,6 +2611,33 @@ CAResult_t CARemoveBlockDataFromList(const CABlockDataID_t *blockID)
     return CA_STATUS_OK;
 }
 
+CAResult_t CARemoveAllBlockDataFromList()
+{
+    OIC_LOG(DEBUG, TAG, "CARemoveAllBlockDataFromList");
+
+    ca_mutex_lock(g_context.blockDataListMutex);
+
+    size_t len = u_arraylist_length(g_context.dataList);
+    for (size_t i = len; i > 0; i--)
+    {
+        CABlockData_t *removedData = u_arraylist_remove(g_context.dataList, i - 1);
+        if (removedData)
+        {
+            // destroy memory
+            if (removedData->sentData)
+            {
+                CADestroyDataSet(removedData->sentData);
+            }
+            CADestroyBlockID(removedData->blockDataId);
+            OICFree(removedData->payload);
+            OICFree(removedData);
+        }
+    }
+    ca_mutex_unlock(g_context.blockDataListMutex);
+
+    return CA_STATUS_OK;
+}
+
 void CADestroyDataSet(CAData_t* data)
 {
     VERIFY_NON_NULL_VOID(data, TAG, "data");

diff --git a/resource/csdk/connectivity/src/caprotocolmessage.c b/resource/csdk/connectivity/src/caprotocolmessage.c
index 5ef5a87..42b8d67 100644 (file)
--- a/resource/csdk/connectivity/src/caprotocolmessage.c
+++ b/resource/csdk/connectivity/src/caprotocolmessage.c
@@ -202,8 +202,7 @@ coap_pdu_t *CAParsePDU(const char *data, uint32_t length, uint32_t *outCode,
     if (0 >= ret)
     {
         OIC_LOG(ERROR, TAG, "pdu parse failed");
-        coap_delete_pdu(outpdu);
-        return NULL;
+        goto exit;
     }
 
 #ifdef WITH_TCP
@@ -218,15 +217,13 @@ coap_pdu_t *CAParsePDU(const char *data, uint32_t length, uint32_t *outCode,
         {
             OIC_LOG_V(ERROR, TAG, "coap version is not available : %d",
                       outpdu->hdr->coap_hdr_udp_t.version);
-            coap_delete_pdu(outpdu);
-            return NULL;
+            goto exit;
         }
         if (outpdu->hdr->coap_hdr_udp_t.token_length > CA_MAX_TOKEN_LEN)
         {
             OIC_LOG_V(ERROR, TAG, "token length has been exceed : %d",
                       outpdu->hdr->coap_hdr_udp_t.token_length);
-            coap_delete_pdu(outpdu);
-            return NULL;
+            goto exit;
         }
     }
 
@@ -236,6 +233,10 @@ coap_pdu_t *CAParsePDU(const char *data, uint32_t length, uint32_t *outCode,
     }
 
     return outpdu;
+
+exit:
+    coap_delete_pdu(outpdu);
+    return NULL;
 }
 
 coap_pdu_t *CAGeneratePDUImpl(code_t code, const CAInfo_t *info,
@@ -849,7 +850,7 @@ CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
                 {
                     outInfo->payloadFormat = CA_FORMAT_UNSUPPORTED;
                     OIC_LOG_V(DEBUG, TAG, "option[%d] has an unsupported format [%d]",
-                            opt_iter.type, (uint8_t)buf[0]);
+                              opt_iter.type, (uint8_t)buf[0]);
                 }
             }
             else if (COAP_OPTION_ACCEPT == opt_iter.type)
@@ -863,7 +864,7 @@ CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
                     outInfo->acceptFormat = CA_FORMAT_UNSUPPORTED;
                 }
                 OIC_LOG_V(DEBUG, TAG, "option[%d] has an unsupported format [%d]",
-                        opt_iter.type, (uint8_t)buf[0]);
+                          opt_iter.type, (uint8_t)buf[0]);
             }
             else
             {

diff --git a/resource/csdk/connectivity/test/SConscript b/resource/csdk/connectivity/test/SConscript
index 53b2d6e..efa854c 100644 (file)
--- a/resource/csdk/connectivity/test/SConscript
+++ b/resource/csdk/connectivity/test/SConscript
@@ -69,9 +69,10 @@ if env.get('LOGGING'):
 ######################################################################
 catests = catest_env.Program('catests', ['catests.cpp',
                                          'caprotocolmessagetest.cpp',
-                                               'ca_api_unittest.cpp',
-                                               'camutex_tests.cpp',
-                                               'uarraylist_test.cpp'
+                                         'cablocktransfertest.cpp',
+                                         'ca_api_unittest.cpp',
+                                         'camutex_tests.cpp',
+                                         'uarraylist_test.cpp'
                                                ])
 
 Alias("test", [catests])

diff --git a/resource/csdk/connectivity/test/cablocktransfertest.cpp b/resource/csdk/connectivity/test/cablocktransfertest.cpp
new file mode 100644 (file)
index 0000000..d43c6f5
--- /dev/null
+++ b/resource/csdk/connectivity/test/cablocktransfertest.cpp
@@ -0,0 +1,541 @@
+/* ****************************************************************
+ *
+ * Copyright 2016 Samsung Electronics All Rights Reserved.
+ *
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ ******************************************************************/
+
+#include "gtest/gtest.h"
+#include "cainterface.h"
+#include "cautilinterface.h"
+#include "cacommon.h"
+#include "caprotocolmessage.h"
+#include "cablockwisetransfer.h"
+
+#define LARGE_PAYLOAD_LENGTH    1024
+
+class CABlockTransferTests : public testing::Test {
+    protected:
+    virtual void SetUp() {
+        CAInitialize();
+    }
+
+    virtual void TearDown()
+    {
+        CATerminate();
+    }
+};
+
+TEST_F(CABlockTransferTests, CACreateNewDataSetTest)
+{
+    CAEndpoint_t* tempRep = NULL;
+    CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
+
+    coap_pdu_t *pdu = NULL;
+    coap_list_t *options = NULL;
+    coap_transport_type transport = coap_udp;
+
+    CAToken_t tempToken = NULL;
+    CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
+
+    CAInfo_t requestData;
+    memset(&requestData, 0, sizeof(CAInfo_t));
+    requestData.token = tempToken;
+    requestData.tokenLength = CA_MAX_TOKEN_LEN;
+    requestData.type = CA_MSG_NONCONFIRM;
+
+    requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
+    if (!requestData.payload)
+    {
+        CADestroyToken(tempToken);
+        FAIL() << "requestData.payload allocation failed";
+    }
+    memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
+    requestData.payloadSize = sizeof(requestData.payload);
+    requestData.type = CA_MSG_NONCONFIRM;
+
+    pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
+
+    CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
+    EXPECT_TRUE(cadata != NULL);
+
+    CABlockData_t *currData = CACreateNewBlockData(cadata);
+    EXPECT_TRUE(currData != NULL);
+
+    if (currData)
+    {
+        CAData_t *getData = CAGetDataSetFromBlockDataList(currData->blockDataId);
+        EXPECT_TRUE(getData != NULL);
+
+        CARemoveBlockDataFromList(currData->blockDataId);
+    }
+
+    CADestroyDataSet(cadata);
+    coap_delete_list(options);
+    coap_delete_pdu(pdu);
+
+    CADestroyToken(tempToken);
+    CADestroyEndpoint(tempRep);
+    free(requestData.payload);
+}
+
+TEST_F(CABlockTransferTests, CAGetBlockDataFromBlockDataListTest)
+{
+    CAEndpoint_t* tempRep = NULL;
+    CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
+
+    coap_pdu_t *pdu = NULL;
+    coap_list_t *options = NULL;
+    coap_transport_type transport = coap_udp;
+
+    CAToken_t tempToken = NULL;
+    CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
+
+    CAInfo_t requestData;
+    memset(&requestData, 0, sizeof(CAInfo_t));
+    requestData.token = tempToken;
+    requestData.tokenLength = CA_MAX_TOKEN_LEN;
+    requestData.type = CA_MSG_NONCONFIRM;
+
+    pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
+
+    CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
+    EXPECT_TRUE(cadata != NULL);
+
+    CABlockData_t *currData = CACreateNewBlockData(cadata);
+    EXPECT_TRUE(currData != NULL);
+
+    if (currData)
+    {
+        CABlockData_t *data = CAGetBlockDataFromBlockDataList(currData->blockDataId);
+        EXPECT_TRUE(data != NULL);
+
+        CARemoveBlockDataFromList(currData->blockDataId);
+    }
+
+    CADestroyDataSet(cadata);
+    coap_delete_list(options);
+    coap_delete_pdu(pdu);
+
+    CADestroyToken(tempToken);
+    CADestroyEndpoint(tempRep);
+    free(requestData.payload);
+}
+
+TEST_F(CABlockTransferTests, CAGetPayloadFromBlockDataListTest)
+{
+    CAEndpoint_t* tempRep = NULL;
+    CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
+
+    coap_pdu_t *pdu = NULL;
+    coap_list_t *options = NULL;
+    coap_transport_type transport = coap_udp;
+
+    CAToken_t tempToken = NULL;
+    CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
+
+    CAInfo_t requestData;
+    memset(&requestData, 0, sizeof(CAInfo_t));
+    requestData.token = tempToken;
+    requestData.tokenLength = CA_MAX_TOKEN_LEN;
+    requestData.type = CA_MSG_NONCONFIRM;
+
+    pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
+
+    CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
+    EXPECT_TRUE(cadata != NULL);
+
+    CABlockData_t *currData = CACreateNewBlockData(cadata);
+    EXPECT_TRUE(currData != NULL);
+
+    size_t fullPayload = 0;
+    CAPayload_t payload = CAGetPayloadFromBlockDataList(currData->blockDataId,
+                                                        &fullPayload);
+
+    size_t payloadLen = (payload != NULL) ? strlen((const char*) payload) : 0;
+    EXPECT_TRUE(fullPayload == payloadLen);
+
+    CARemoveBlockDataFromList(currData->blockDataId);
+    CADestroyDataSet(cadata);
+    coap_delete_list(options);
+    coap_delete_pdu(pdu);
+
+    CADestroyToken(tempToken);
+    CADestroyEndpoint(tempRep);
+    free(requestData.payload);
+}
+
+// request and block option1
+TEST_F(CABlockTransferTests, CAAddBlockOptionTest)
+{
+    CAEndpoint_t* tempRep = NULL;
+    CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
+
+    coap_pdu_t *pdu = NULL;
+    coap_list_t *options = NULL;
+    coap_transport_type transport = coap_udp;
+
+    CAToken_t tempToken = NULL;
+    CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
+
+    CAInfo_t requestData;
+    memset(&requestData, 0, sizeof(CAInfo_t));
+    requestData.token = tempToken;
+    requestData.tokenLength = CA_MAX_TOKEN_LEN;
+
+    requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
+    if(!requestData.payload)
+    {
+        CADestroyToken(tempToken);
+        FAIL() << "requestData.payload allocation failed";
+    }
+    memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
+    requestData.payloadSize = sizeof(requestData.payload);
+    requestData.type = CA_MSG_NONCONFIRM;
+
+    pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
+
+    EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption(&pdu, &requestData, tempRep, &options));
+
+    coap_delete_list(options);
+    coap_delete_pdu(pdu);
+
+    CADestroyToken(tempToken);
+    CADestroyEndpoint(tempRep);
+    free(requestData.payload);
+}
+
+// request and block option1
+TEST_F(CABlockTransferTests, CAAddBlockOption1InRequest)
+{
+    CAEndpoint_t* tempRep = NULL;
+    CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
+
+    coap_pdu_t *pdu = NULL;
+    coap_list_t *options = NULL;
+    coap_transport_type transport = coap_udp;
+
+    CAToken_t tempToken = NULL;
+    CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
+
+    CAInfo_t requestData;
+    memset(&requestData, 0, sizeof(CAInfo_t));
+    requestData.token = tempToken;
+    requestData.tokenLength = CA_MAX_TOKEN_LEN;
+
+    requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
+    if(!requestData.payload)
+    {
+        CADestroyToken(tempToken);
+        FAIL() << "requestData.payload allocation failed";
+    }
+    memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
+    requestData.payloadSize = sizeof(requestData.payload);
+    requestData.type = CA_MSG_NONCONFIRM;
+
+    pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
+
+    CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
+    EXPECT_TRUE(cadata != NULL);
+
+    CABlockData_t *currData = CACreateNewBlockData(cadata);
+    EXPECT_TRUE(currData != NULL);
+
+    EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
+                                                    COAP_OPTION_BLOCK1));
+
+    EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption1(&pdu, &requestData,
+                                              requestData.payloadSize,
+                                              currData->blockDataId, &options));
+
+    CADestroyDataSet(cadata);
+    coap_delete_list(options);
+    coap_delete_pdu(pdu);
+
+    CADestroyToken(tempToken);
+    CADestroyEndpoint(tempRep);
+    free(requestData.payload);
+}
+
+// response and block option1
+TEST_F(CABlockTransferTests, CAAddBlockOption1InResponse)
+{
+    CAEndpoint_t* tempRep = NULL;
+    CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
+
+    coap_pdu_t *pdu = NULL;
+    coap_list_t *options = NULL;
+    coap_transport_type transport = coap_udp;
+
+    CAToken_t tempToken = NULL;
+    CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
+
+    CAInfo_t responseData;
+    memset(&responseData, 0, sizeof(CAInfo_t));
+    responseData.token = tempToken;
+    responseData.tokenLength = CA_MAX_TOKEN_LEN;
+    responseData.type = CA_MSG_NONCONFIRM;
+    responseData.messageId = 1;
+
+    responseData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
+    if(!responseData.payload)
+    {
+        CADestroyToken(tempToken);
+        FAIL() << "requestData.payload allocation failed";
+    }
+    memset(responseData.payload, '1', sizeof(responseData.payload) - 1);
+    responseData.payloadSize = sizeof(responseData.payload);
+
+    pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
+
+    CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
+    EXPECT_TRUE(cadata != NULL);
+
+    CABlockData_t *currData = CACreateNewBlockData(cadata);
+    EXPECT_TRUE(currData != NULL);
+
+    EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
+                                                    COAP_OPTION_BLOCK1));
+
+    EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption1(&pdu, &responseData,
+                                              responseData.payloadSize,
+                                              currData->blockDataId, &options));
+
+    CADestroyDataSet(cadata);
+    coap_delete_list(options);
+    coap_delete_pdu(pdu);
+
+    CADestroyToken(tempToken);
+    CADestroyEndpoint(tempRep);
+    free(responseData.payload);
+}
+
+// response and block option2
+TEST_F(CABlockTransferTests, CAAddBlockOption2InResponse)
+{
+    CAEndpoint_t* tempRep = NULL;
+    CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
+
+    coap_pdu_t *pdu = NULL;
+    coap_list_t *options = NULL;
+    coap_transport_type transport = coap_udp;
+
+    CAToken_t tempToken = NULL;
+    CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
+
+    CAInfo_t responseData;
+    memset(&responseData, 0, sizeof(CAInfo_t));
+    responseData.token = tempToken;
+    responseData.tokenLength = CA_MAX_TOKEN_LEN;
+    responseData.type = CA_MSG_NONCONFIRM;
+    responseData.messageId = 1;
+
+    responseData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
+    if(!responseData.payload)
+    {
+        CADestroyToken(tempToken);
+        FAIL() << "requestData.payload allocation failed";
+    }
+    memset(responseData.payload, '1', sizeof(responseData.payload) - 1);
+    responseData.payloadSize = sizeof(responseData.payload);
+
+    pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
+
+    CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
+    EXPECT_TRUE(cadata != NULL);
+
+    CABlockData_t *currData = CACreateNewBlockData(cadata);
+    EXPECT_TRUE(currData != NULL);
+
+    EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
+                                                    COAP_OPTION_BLOCK2));
+
+    EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption2(&pdu, &responseData,
+                                              responseData.payloadSize,
+                                              currData->blockDataId, &options));
+
+    CADestroyDataSet(cadata);
+    coap_delete_list(options);
+    coap_delete_pdu(pdu);
+
+    CADestroyToken(tempToken);
+    CADestroyEndpoint(tempRep);
+    free(responseData.payload);
+}
+
+// request and block option1
+TEST_F(CABlockTransferTests, CAAddBlockOption2InRequest)
+{
+    CAEndpoint_t* tempRep = NULL;
+    CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
+
+    coap_pdu_t *pdu = NULL;
+    coap_list_t *options = NULL;
+    coap_transport_type transport = coap_udp;
+
+    CAToken_t tempToken = NULL;
+    CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
+
+    CAInfo_t requestData;
+    memset(&requestData, 0, sizeof(CAInfo_t));
+    requestData.token = tempToken;
+    requestData.tokenLength = CA_MAX_TOKEN_LEN;
+
+    requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
+    if(!requestData.payload)
+    {
+        CADestroyToken(tempToken);
+        FAIL() << "requestData.payload allocation failed";
+    }
+    memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
+    requestData.payloadSize = sizeof(requestData.payload);
+    requestData.type = CA_MSG_NONCONFIRM;
+
+    pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
+
+    CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
+    EXPECT_TRUE(cadata != NULL);
+
+    CABlockData_t *currData = CACreateNewBlockData(cadata);
+    EXPECT_TRUE(currData != NULL);
+
+    EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
+                                                    COAP_OPTION_BLOCK2));
+
+    EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption2(&pdu, &requestData,
+                                              requestData.payloadSize,
+                                              currData->blockDataId, &options));
+
+    CARemoveBlockDataFromList(currData->blockDataId);
+    CADestroyDataSet(cadata);
+    coap_delete_list(options);
+    coap_delete_pdu(pdu);
+
+    CADestroyToken(tempToken);
+    CADestroyEndpoint(tempRep);
+    free(requestData.payload);
+}
+
+TEST_F(CABlockTransferTests, CAGetBlockSizeOptionFromPduTest)
+{
+    CAEndpoint_t* tempRep = NULL;
+    CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
+
+    coap_pdu_t *pdu = NULL;
+    coap_list_t *options = NULL;
+    coap_transport_type transport = coap_udp;
+
+    CAToken_t tempToken = NULL;
+    CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
+
+    CAInfo_t requestData;
+    memset(&requestData, 0, sizeof(CAInfo_t));
+    requestData.token = tempToken;
+    requestData.tokenLength = CA_MAX_TOKEN_LEN;
+    requestData.type = CA_MSG_NONCONFIRM;
+
+    pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
+
+    size_t totalPayloadLen = 0;
+    EXPECT_FALSE(CAIsPayloadLengthInPduWithBlockSizeOption(pdu, COAP_OPTION_SIZE1,
+                                                           &totalPayloadLen));
+
+    coap_delete_list(options);
+    coap_delete_pdu(pdu);
+
+    CADestroyToken(tempToken);
+    CADestroyEndpoint(tempRep);
+    free(requestData.payload);
+}
+
+TEST_F(CABlockTransferTests, CASetNextBlockOption1Test)
+{
+    CAEndpoint_t* tempRep = NULL;
+    CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
+
+    coap_pdu_t *pdu = NULL;
+    coap_list_t *options = NULL;
+    coap_transport_type transport = coap_udp;
+
+    CAToken_t tempToken = NULL;
+    CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
+
+    CAInfo_t responseData;
+    memset(&responseData, 0, sizeof(CAInfo_t));
+    responseData.token = tempToken;
+    responseData.tokenLength = CA_MAX_TOKEN_LEN;
+    responseData.type = CA_MSG_NONCONFIRM;
+    responseData.messageId = 1;
+
+    pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
+
+    CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
+    EXPECT_TRUE(cadata != NULL);
+
+    CABlockData_t *currData = CACreateNewBlockData(cadata);
+    EXPECT_TRUE(currData != NULL);
+
+    coap_block_t block = {0, 0, 0};
+    EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption1(pdu, tempRep, cadata, block, pdu->length));
+
+    EXPECT_EQ(CA_STATUS_OK, CAHandleRequestResponse());
+
+    CADestroyDataSet(cadata);
+    coap_delete_list(options);
+    coap_delete_pdu(pdu);
+
+    CADestroyToken(tempToken);
+    CADestroyEndpoint(tempRep);
+    free(responseData.payload);
+}
+
+TEST_F(CABlockTransferTests, CASetNextBlockOption2Test)
+{
+    CAEndpoint_t* tempRep = NULL;
+    CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
+
+    coap_pdu_t *pdu = NULL;
+    coap_list_t *options = NULL;
+    coap_transport_type transport = coap_udp;
+
+    CAToken_t tempToken = NULL;
+    CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
+
+    CAInfo_t requestData;
+    memset(&requestData, 0, sizeof(CAInfo_t));
+    requestData.token = tempToken;
+    requestData.tokenLength = CA_MAX_TOKEN_LEN;
+    requestData.type = CA_MSG_NONCONFIRM;
+
+    pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
+
+    CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
+    EXPECT_TRUE(cadata != NULL);
+
+    CABlockData_t *currData = CACreateNewBlockData(cadata);
+    EXPECT_TRUE(currData != NULL);
+
+    coap_block_t block = {0, 0, 0};
+    EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption2(pdu, tempRep, cadata, block, pdu->length));
+
+    CADestroyDataSet(cadata);
+    coap_delete_list(options);
+    coap_delete_pdu(pdu);
+
+    CADestroyToken(tempToken);
+    CADestroyEndpoint(tempRep);
+    free(requestData.payload);
+}