From: hyuna0213.jo Date: Wed, 16 Mar 2016 07:15:12 +0000 (+0900) Subject: Added unit test cases for cablockwisetransfer.c api X-Git-Tag: 1.2.0+RC1~416 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=c9bbd973d1a9651c2e226dc8cd4f87b5fdf51fba;p=platform%2Fupstream%2Fiotivity.git Added unit test cases for cablockwisetransfer.c api Added unit test cases for cablockwisetransfer.c api. Change-Id: Idf6570aebc4bd5f15202d6f0236b126199768851 Signed-off-by: hyuna0213.jo Reviewed-on: https://gerrit.iotivity.org/gerrit/5947 Tested-by: jenkins-iotivity Reviewed-by: Jon A. Cruz --- diff --git a/resource/csdk/connectivity/common/src/cathreadpool_pthreads.c b/resource/csdk/connectivity/common/src/cathreadpool_pthreads.c index 636036e..0fb57de 100644 --- 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 --- 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 --- 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 --- 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 --- 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 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); +}