Add unittest test-case for cafragmentation code.

Signed-off-by: jaehyun Cho <jaehyun3.cho@samsung.com>
Change-Id: Id98b2151b8149d892d1e063ca893c85fd672af50
Reviewed-on: https://gerrit.iotivity.org/gerrit/14353
Reviewed-by: Jaehong Jo <jaehong.jo@samsung.com>
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: jihwan seo <jihwan.seo@samsung.com>
Reviewed-by: Phil Coval <philippe.coval@osg.samsung.com>
Reviewed-by: Dan Mihai <Daniel.Mihai@microsoft.com>
Reviewed-by: Ashok Babu Channa <ashok.channa@samsung.com>

diff --git a/resource/csdk/connectivity/test/ca_api_unittest.cpp b/resource/csdk/connectivity/test/ca_api_unittest.cpp
old mode 100644 (file)
new mode 100755 (executable)
index 8fb19fa..f76d819
--- a/resource/csdk/connectivity/test/ca_api_unittest.cpp
+++ b/resource/csdk/connectivity/test/ca_api_unittest.cpp
@@ -25,6 +25,7 @@
 #include "cacommon.h"
 #include "oic_string.h"
 #include "oic_malloc.h"
+#include "cafragmentation.h"
 
 #define CA_TRANSPORT_ADAPTER_SCOPE  1000
 
@@ -544,3 +545,129 @@ TEST(CAGetPortNumberTest, CAGetPortNumberToAssign)
     ASSERT_EQ(static_cast<uint16_t>(0), CAGetAssignedPortNumber(CA_ADAPTER_TCP, CA_IPV6));
 #endif
 }
+
+TEST(CAfragmentationTest, FragmentTest)
+{
+#if defined(LE_ADAPTER)
+    const size_t dataLen = 30;
+    uint8_t *data = (uint8_t *) malloc(dataLen*sizeof(uint8_t));
+    memset(data, 'a', dataLen);
+
+    uint32_t midPacketCount = 0;
+    size_t remainingLen = 0;
+    size_t totalLength = 0;
+
+    EXPECT_EQ(CA_STATUS_OK, CAGenerateVariableForFragmentation(dataLen,
+                                                               &midPacketCount,
+                                                               &remainingLen,
+                                                               &totalLength));
+
+    uint8_t dataHeader[CA_BLE_HEADER_SIZE] = {0};
+    const uint8_t tmpSourcePort = 1;
+    const uint8_t tmpDestPort = 1;
+
+    EXPECT_EQ(CA_STATUS_OK, CAGenerateHeader(dataHeader,
+                                             CA_BLE_PACKET_START,
+                                             tmpSourcePort,
+                                             CA_BLE_PACKET_NON_SECURE,
+                                             tmpDestPort));
+    EXPECT_TRUE(dataHeader != NULL);
+
+    uint8_t lengthHeader[CA_BLE_LENGTH_HEADER_SIZE] = {0};
+
+    EXPECT_EQ(CA_STATUS_OK, CAGenerateHeaderPayloadLength(lengthHeader,
+                                                          CA_BLE_LENGTH_HEADER_SIZE,
+                                                          dataLen));
+    EXPECT_TRUE(lengthHeader != NULL);
+
+    uint8_t dataSegment[CA_SUPPORTED_BLE_MTU_SIZE] = {0};
+
+    EXPECT_EQ(CA_STATUS_OK, CAMakeFirstDataSegment(dataSegment,
+                                                   data,
+                                                   CA_BLE_FIRST_SEGMENT_PAYLOAD_SIZE,
+                                                   dataHeader,
+                                                   lengthHeader));
+    EXPECT_TRUE(dataSegment != NULL);
+
+    EXPECT_EQ(CA_STATUS_OK, CAGenerateHeader(dataHeader,
+                                             CA_BLE_PACKET_NOT_START,
+                                             tmpSourcePort,
+                                             CA_BLE_PACKET_NON_SECURE,
+                                             tmpDestPort));
+    EXPECT_TRUE(dataHeader != NULL);
+
+    EXPECT_EQ(CA_STATUS_OK, CAMakeRemainDataSegment(dataSegment,
+                                                    remainingLen,
+                                                    data,
+                                                    dataLen,
+                                                    0,
+                                                    dataHeader));
+    EXPECT_TRUE(dataSegment != NULL);
+
+    free(data);
+#endif
+}
+
+TEST(CAfragmentationTest, DefragmentTest)
+{
+#if defined(LE_ADAPTER)
+    const size_t dataLen = 30;
+    uint8_t *data = (uint8_t *) malloc(dataLen*sizeof(uint8_t));
+    memset(data, 'a', dataLen);
+
+    uint32_t midPacketCount = 0;
+    size_t remainingLen = 0;
+    size_t totalLength = 0;
+
+    EXPECT_EQ(CA_STATUS_OK, CAGenerateVariableForFragmentation(dataLen,
+                                                               &midPacketCount,
+                                                               &remainingLen,
+                                                               &totalLength));
+
+    uint8_t dataHeader[CA_BLE_HEADER_SIZE] = {0};
+    const uint8_t tmpSourcePort = 1;
+    const uint8_t tmpDestPort = 1;
+
+    EXPECT_EQ(CA_STATUS_OK, CAGenerateHeader(dataHeader,
+                                             CA_BLE_PACKET_START,
+                                             tmpSourcePort,
+                                             CA_BLE_PACKET_NON_SECURE,
+                                             tmpDestPort));
+    EXPECT_TRUE(dataHeader != NULL);
+
+    uint8_t lengthHeader[CA_BLE_LENGTH_HEADER_SIZE] = {0};
+
+    EXPECT_EQ(CA_STATUS_OK, CAGenerateHeaderPayloadLength(lengthHeader,
+                                                          CA_BLE_LENGTH_HEADER_SIZE,
+                                                          dataLen));
+    EXPECT_TRUE(lengthHeader != NULL);
+
+    uint8_t dataSegment[CA_SUPPORTED_BLE_MTU_SIZE] = {0};
+
+    EXPECT_EQ(CA_STATUS_OK, CAMakeFirstDataSegment(dataSegment,
+                                                   data,
+                                                   CA_BLE_FIRST_SEGMENT_PAYLOAD_SIZE,
+                                                   dataHeader,
+                                                   lengthHeader));
+    EXPECT_TRUE(dataSegment != NULL);
+
+    CABLEPacketStart_t startFlag = CA_BLE_PACKET_NOT_START;
+    CABLEPacketSecure_t secureFlag = CA_BLE_PACKET_NON_SECURE;
+    uint16_t sourcePort = 0;
+    uint16_t destPort = 0;
+
+    EXPECT_EQ(CA_STATUS_OK, CAParseHeader(dataSegment,
+                                          &startFlag,
+                                          &sourcePort,
+                                          &secureFlag,
+                                          &destPort));
+
+    uint32_t parseDataLength = 0;
+
+    EXPECT_EQ(CA_STATUS_OK, CAParseHeaderPayloadLength(dataSegment,
+                                                       CA_BLE_LENGTH_HEADER_SIZE,
+                                                       &parseDataLength));
+
+    free(data);
+#endif
+}