pal_sst_tests.c

00001 // ----------------------------------------------------------------------------
00002 // Copyright 2018 ARM Ltd.
00003 //
00004 // Licensed under the Apache License, Version 2.0 (the "License");
00005 // you may not use this file except in compliance with the License.
00006 // You may obtain a copy of the License at
00007 //
00008 //     http://www.apache.org/licenses/LICENSE-2.0
00009 //
00010 // Unless required by applicable law or agreed to in writing, software
00011 // distributed under the License is distributed on an "AS IS" BASIS,
00012 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013 // See the License for the specific language governing permissions and
00014 // limitations under the License.
00015 // ----------------------------------------------------------------------------
00016 
00017 #include "unity.h"
00018 #include "unity_fixture.h"
00019 #include "test_runners.h"
00020 #include "pal.h"
00021 
00022 #ifdef MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT
00023 
00024 #include "kvstore_global_api.h"
00025 #include "pal_sst.h"
00026 
00027 #define TEST_PAL_SST_MAX_ITEM_NAME_SIZE           120
00028 #define TEST_PAL_SST_MAX_INPUT_DATA_SIZE          10
00029 
00030 #define TRACE_GROUP "PAL"
00031 
00032 
00033 
00034 /** test vector **/
00035 typedef struct pal_SSTItemsTestVector {
00036     char item_name[TEST_PAL_SST_MAX_ITEM_NAME_SIZE + 1];    /* item name */
00037     uint8_t input_data[TEST_PAL_SST_MAX_INPUT_DATA_SIZE]; /* item input data */
00038     size_t input_data_size; /* input data size */
00039     uint32_t input_flags; /* input flags. currently supported:
00040                              PAL_SST_WRITE_ONCE_FLAG
00041                              PAL_SST_CONFIDENTIALITY_FLAG
00042                              PAL_SST_REPLAY_PROTECTION_FLAG */
00043     uint8_t output_data[TEST_PAL_SST_MAX_INPUT_DATA_SIZE]; /* buffer for output data */
00044     size_t output_data_size;  /* output data actual size */
00045     palSSTItemInfo_t output_item_info; /*output item info.
00046                                        Includes: stored item size and item flags */
00047 }pal_SSTItemsTestVector_t;
00048 
00049 #ifdef DEBUG
00050 static void print_test_data(const pal_SSTItemsTestVector_t* data_array, size_t data_array_size)
00051 {
00052     size_t i, j, index;
00053     char data_char[100];
00054 
00055     PAL_LOG_DBG("--------------------------------------------");
00056     for (i = 0; i < data_array_size; i++) {
00057         PAL_LOG_DBG("-------------------------");
00058         PAL_LOG_DBG("item name: %s", data_array[i].item_name);
00059         index = 0;
00060         for (j = 0; j < data_array[i].input_data_size; j++) {
00061             index += sprintf(&data_char[index], " 0x%"PRIx8"", data_array[i].input_data[j]);
00062         }
00063         data_char[index] = '\0';
00064         PAL_LOG_DBG("item input data: %s", data_char);
00065         PAL_LOG_DBG("input data flags: 0x%" PRIx32 "", data_array[i].input_flags);
00066         index = 0;
00067         for (j = 0; j < data_array[i].output_data_size; j++) {
00068             index += sprintf(&data_char[index], " 0x%"PRIx8"", data_array[i].output_data[j]);
00069         }
00070         data_char[index] = '\0';
00071         PAL_LOG_DBG("item output data: %s", data_char);
00072         PAL_LOG_DBG("output data flags: 0x%" PRIx32 "", data_array[i].output_item_info.SSTFlagsBitmap);
00073     }
00074     PAL_LOG_DBG("--------------------------------------------");
00075 }
00076 #endif //ifdef DEBUG
00077 
00078 #endif // MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT
00079 
00080 TEST_GROUP(pal_sst);
00081 
00082 TEST_SETUP(pal_sst)
00083 {
00084 
00085 #ifdef MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT
00086     palStatus_t pal_status;
00087 
00088     pal_status = pal_init();
00089     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, pal_status);
00090 
00091     //reset SST
00092     pal_status = pal_SSTReset ();
00093     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, pal_status);
00094 
00095 #if !PAL_USE_HW_TRNG
00096     // If no hardware trng - entropy must be injected for random to work
00097     uint8_t entropy_buf[48] = { 0 };
00098     pal_status = pal_osEntropyInject(entropy_buf, sizeof(entropy_buf));
00099     TEST_ASSERT(pal_status == PAL_SUCCESS || pal_status == PAL_ERR_ENTROPY_EXISTS);
00100 #endif
00101 
00102 #endif
00103 
00104 }
00105 
00106 TEST_TEAR_DOWN(pal_sst)
00107 {
00108 
00109 #ifdef MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT
00110     palStatus_t pal_status;
00111 
00112     //reset SST
00113     pal_status = pal_SSTReset ();
00114     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, pal_status);
00115 #endif
00116 
00117 }
00118 
00119 
00120 /*! \brief Check basic usage of the following APIs: `pal_SSTSet()`, pal_SSTGetInfo, `pal_SSTGet()` and `pal_SSTRemove`.
00121  *
00122  * | # |    Step                                                                                       |  Expected   |
00123  * |---|--------------------------------|----------------------------------------------------------------------------|
00124  * | 1 | Set valid item using pal_SSTSet()                                                             | PAL_SUCCESS |
00125  * | 2 | Get item info using pal_SSTGetInfo()                                                          | PAL_SUCCESS |
00126  * | 3 | compare the input data size with received data size using pal_SSTGetInfo()                    | PAL_SUCCESS |
00127  * | 4 | Get item using pal_SSTGet()                                                                   | PAL_SUCCESS |
00128  * | 5 | Check the the data fetched with pal_SSTGet() is equal to data set with pal_SSTSet()           | PAL_SUCCESS |
00129  * | 6 | Remove data using pal_SSTRemove                                                               | PAL_SUCCESS |
00130  */
00131 TEST(pal_sst, pal_sst_test_basic)
00132 {
00133 
00134 #ifdef MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT
00135 
00136     /**test data set for the current test**/
00137     static pal_SSTItemsTestVector_t pal_sst_items_data[] =
00138     {
00139         /*  item name         input data                        input data size input flags      out data    outdatasize   outiteminfo
00140             ---------         ---------                         ---------       -----------      ----------- -----------   ----------- */
00141 
00142             {{"qwqwqw"},      {1,2,3,4,5},                      5,              0x0,             {0},        0,            {0}},
00143             {{"131"},         {0xa,0xb,0xc,0xd,0xe},            6,              0x0,             {0},        0,            {0}},
00144             {{"a"},           {10,20,30,40},                    11,             0x0,             {0},        0,            {0}},
00145             {{"sds-.23k"},   {0x11,0x22,0x33},                  3,              0x0,             {0},        0,            {0}},
00146             {{"__123dkf"},   {0xAA,0xBB,0xCC,0xDD,0xEE,0xFF},   7,              0x0,             {0},        0,            {0}},
00147     };
00148 
00149 
00150     size_t pal_sst_items_data_size = (sizeof(pal_sst_items_data) / sizeof(pal_sst_items_data[0]));
00151     palStatus_t status = PAL_SUCCESS;
00152     size_t i;
00153 
00154 #ifdef DEBUG
00155     PAL_LOG_DBG("\nbefore test");
00156     print_test_data(pal_sst_items_data, pal_sst_items_data_size);
00157 #endif
00158 
00159     for (i = 0; i < pal_sst_items_data_size; i++) {
00160 
00161         PAL_LOG_DBG("iteration %d\n", i);
00162 
00163         /*#1*/
00164         status = pal_SSTSet (pal_sst_items_data[i].item_name, pal_sst_items_data[i].input_data,
00165                             pal_sst_items_data[i].input_data_size, pal_sst_items_data[i].input_flags);
00166         TEST_ASSERT_EQUAL(PAL_SUCCESS, status);
00167 
00168         /*#2*/
00169         status = pal_SSTGetInfo (pal_sst_items_data[i].item_name, &(pal_sst_items_data[i].output_item_info));
00170         TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00171 
00172         /*#3*/
00173         TEST_ASSERT_EQUAL(pal_sst_items_data[i].input_data_size, pal_sst_items_data[i].output_item_info.itemSize);
00174 
00175         /*#4*/
00176         status = pal_SSTGet (pal_sst_items_data[i].item_name, pal_sst_items_data[i].output_data, TEST_PAL_SST_MAX_INPUT_DATA_SIZE, &(pal_sst_items_data[i].output_data_size));
00177         TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00178 
00179         /*#5*/
00180         TEST_ASSERT_EQUAL_MEMORY(pal_sst_items_data[i].input_data, pal_sst_items_data[i].output_data, pal_sst_items_data[i].output_data_size);
00181 
00182         /*#6*/
00183         status = pal_SSTRemove (pal_sst_items_data[i].item_name);
00184         TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00185 
00186     }
00187 
00188 #ifdef DEBUG
00189     PAL_LOG_DBG("\nafter test");
00190     print_test_data(pal_sst_items_data, pal_sst_items_data_size);
00191 #endif 
00192 
00193 #else //MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT
00194     TEST_IGNORE_MESSAGE("Ignored, MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT is not defined");
00195 #endif
00196 
00197 }
00198 
00199 
00200 /*! \brief: Check basic iterator behavior.
00201  * Tested APIs: `pal_SSTIteratorOpen()`, `pal_SSTIteratorNext()` and `pal_SSTIteratorClose()`.
00202  *
00203  * | # |    Step                                                                                       |  Expected   |
00204  * |---|--------------------------------|----------------------------------------------------------------------------|
00205  * | 1 | Set valid items using pal_SSTSet()                                                            | PAL_SUCCESS |
00206  * | 2 | Open iterator using  pal_SSTIteratorOpen() with test prefix                                   | PAL_SUCCESS |
00207  * | 3 | Get next item for the test prefix defined in step (2). Should success since item exists       | PAL_SUCCESS |
00208  * | 4 | Get next item for the test prefix defined in step (2). Should success since item exists       | PAL_SUCCESS |
00209  * | 5 | Get next item for the test prefix defined in step (2). Should FAIL since item not exists      | PAL_ERR_SST_ITEM_NOT_FOUND |
00210  * | 6 | Close iterator using  pal_SSTIteratorClose()                                                  | PAL_SUCCESS |
00211  */
00212 TEST(pal_sst, pal_sst_test_iterator)
00213 {
00214 
00215 #ifdef MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT
00216 
00217     palStatus_t status = PAL_SUCCESS;
00218     size_t i;
00219     palSSTIterator_t pal_iterator;
00220     char output_item_name[TEST_PAL_SST_MAX_ITEM_NAME_SIZE];
00221 
00222     /**test data set for the current test**/
00223     static const pal_SSTItemsTestVector_t pal_sst_items_data[] =
00224     {
00225         /*  item name         input data                        input data size input flags      out data    outdatasize   outiteminfo
00226             ---------         ---------                         ---------       -----------      ----------- -----------   ----------- */
00227             {{"test_item_1"}, {1,2,3,4,5},                      5,              0x0,             {0},        0,            {0}},
00228             {{"dummy123"},    {0xa,0xb,0xc,0xd,0xe},            6,              0x0,             {0},        0,            {0}},
00229             {{"test_item_2"}, {6,7,8,9,10,11,12},               10,             0x0,             {0},        0,            {0}},
00230             {{"temp_item_1"}, {10,20,30,40},                    11,             0x0,             {0},        0,            {0}},
00231             {{"dummy456"},    {0x11,0x22,0x33},                 3,              0x0,             {0},        0,            {0}},
00232             {{"temp_item_2"}, {0xAA,0xBB,0xCC,0xDD,0xEE,0xFF},  7,              0x0,             {0},        0,            {0}},
00233     };
00234 
00235     /**test prefixes for test data**/
00236     const char* test_prefix[2] = { "dummy", "temp_" };
00237 
00238     size_t pal_sst_items_data_size = (sizeof(pal_sst_items_data) / sizeof(pal_sst_items_data[0]));
00239 
00240 
00241 #ifdef DEBUG
00242     PAL_LOG_DBG("\nbefore test");
00243     print_test_data(pal_sst_items_data, pal_sst_items_data_size);
00244 #endif
00245 
00246 
00247     /*#1*/
00248     for (i = 0; i < pal_sst_items_data_size; i++) {
00249 
00250         PAL_LOG_DBG("iteration\n %d", i);
00251 
00252         status = pal_SSTSet (pal_sst_items_data[i].item_name, pal_sst_items_data[i].input_data,
00253                             pal_sst_items_data[i].input_data_size, pal_sst_items_data[i].input_flags);
00254         TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00255     }
00256 
00257     for (i = 0; i < 2; i++) {
00258         /*#2*/
00259         status = pal_SSTIteratorOpen (&pal_iterator, test_prefix[i]);
00260         TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00261 
00262         /*#3*/
00263         status = pal_SSTIteratorNext (pal_iterator, output_item_name, TEST_PAL_SST_MAX_ITEM_NAME_SIZE);
00264         TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00265 
00266         /*#4*/
00267         status = pal_SSTIteratorNext (pal_iterator, output_item_name, TEST_PAL_SST_MAX_ITEM_NAME_SIZE);
00268         TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00269 
00270         /*#5*/
00271         status = pal_SSTIteratorNext (pal_iterator, output_item_name, TEST_PAL_SST_MAX_ITEM_NAME_SIZE);
00272         TEST_ASSERT_EQUAL_HEX(PAL_ERR_SST_ITEM_NOT_FOUND, status);
00273 
00274         /*#6*/
00275         status = pal_SSTIteratorClose (pal_iterator);
00276         TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00277     }
00278 
00279 #ifdef DEBUG
00280     PAL_LOG_DBG("\nafter test");
00281     print_test_data(pal_sst_items_data, pal_sst_items_data_size);
00282 #endif
00283 
00284 #else //MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT
00285         TEST_IGNORE_MESSAGE("Ignored, MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT is not defined");
00286 #endif
00287 
00288 }
00289 
00290 
00291 /*! \brief Check functionality of the input flags:
00292  *  PAL_SST_WRITE_ONCE_FLAG, PAL_SST_ENCRYPT_FLAG, PAL_SST_ENCRYPT_FLAG, PAL_SST_ROLLBACK_PROTECT_FLAG
00293  *
00294  * | #  |    Step                                                                                       |  Expected   |
00295  * |--- |--------------------------------|----------------------------------------------------------------------------|
00296    |item 0|
00297  * | 1  | Set item with PAL_SST_WRITE_ONCE_FLAG using pal_SSTSet()                                      | PAL_SUCCESS |
00298  * | 2  | Get item info using pal_SSTGetInfo()                                                          | PAL_SUCCESS |
00299  * | 3  | compare the PAL_SST_WRITE_ONCE_FLAG set with pal_SSTSet() with received flags using pal_SSTGetInfo() | EQUAL|
00300  * | 4  | Set item again using pal_SSTSet(). Should fail, because of WRITE_ONCE flag                    | PAL_ERR_SST_WRITE_PROTECTED |
00301  * | 5  | Remove data using pal_SSTRemove. Should fail, because of WRITE_ONCE flag                      | PAL_ERR_SST_WRITE_PROTECTED |
00302  * |item 1|
00303  * | 1  | Set item with PAL_SST_REPLAY_PROTECTION_FLAG using pal_SSTSet()                               | PAL_SUCCESS |
00304  * | 2  | Get item info using pal_SSTGetInfo()                                                          | PAL_SUCCESS |
00305  * | 3  | Set item again using pal_SSTSet(). Should success                                             | PAL_SUCCESS |
00306  * | 4  | Remove data using pal_SSTRemove.                                                              | PAL_SUCCESS |
00307  * |item 2|
00308  * | 1  | Set (item 1) with no flags using pal_SSTSet(). Should fail since no PAL_SST_REPLAY_PROTECTION_FLAG was set | PAL_SUCCESS |
00309  * | 2  | Get item info using pal_SSTGetInfo()                                                          | PAL_SUCCESS |
00310  * | 3  | Remove data using pal_SSTRemove.                                                              | PAL_SUCCESS |
00311  * |item 3|
00312  * | 1  | Set item with PAL_SST_CONFIDENTIALITY_FLAG using pal_SSTSet()                                 | PAL_SUCCESS |
00313  * | 2  | Get item info using pal_SSTGetInfo()                                                          | PAL_SUCCESS |
00314  * | 3  | Set item again using pal_SSTSet().                                                            | PAL_SUCCESS |
00315  * | 4  | Remove data using pal_SSTRemove.                                                              | PAL_SUCCESS |
00316  * |item 4|
00317  * | 1  | Set item with PAL_SST_WRITE_ONCE_FLAG and PAL_SST_REPLAY_PROTECTION_FLAG using pal_SSTSet()   | PAL_SUCCESS |
00318  * | 2  | Get item info using pal_SSTGetInfo()                                                          | PAL_SUCCESS |
00319  * | 3  | compare the PAL_SST_WRITE_ONCE_FLAG set with pal_SSTSet() with received flag using pal_SSTGetInfo() |EQUAL |
00320  * | 4  | Set item again using pal_SSTSet(). Should fail, because PAL_SST_WRITE_ONCE_FLAG set           | PAL_ERR_SST_WRITE_PROTECTED |
00321  * | 5  | Remove data using pal_SSTRemove. Should fail, because PAL_SST_WRITE_ONCE_FLAG set             | PAL_ERR_SST_WRITE_PROTECTED |
00322  * |item 5|
00323  * | 1  | Set item (item 1) with PAL_SST_REPLAY_PROTECTION_FLAG using pal_SSTSet(). Should success since data is different | PAL_SUCCESS |
00324  * | 2  | Get item info using pal_SSTGetInfo()                                                          | PAL_SUCCESS |
00325  * | 3  | Remove data using pal_SSTRemove.                                                              | PAL_SUCCESS |
00326  */
00327 TEST(pal_sst, pal_sst_test_flags)
00328 {
00329 
00330 #ifdef MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT
00331 
00332     palStatus_t status = PAL_SUCCESS;
00333 
00334     /**test data set for the current test**/
00335     static pal_SSTItemsTestVector_t pal_sst_items_data[] =
00336     {
00337         /*  item name         input data             input data size input flags                                              out data    outdatasize   outiteminfo
00338             ---------         ---------              ------------    -----------                                              ----------- -----------   ----------- */
00339         /*0*/  {{"a"},        {1,2,3,4,5},               5,             PAL_SST_WRITE_ONCE_FLAG,                                  {0},        0,           {0}},
00340         /*1*/  {{"bbcd"},     {0xa,0xb,0xc,0xd,0xe},     5,             PAL_SST_REPLAY_PROTECTION_FLAG,                           {0},        0,           {0}},
00341         /*2*/  {{"bbcd"},     {10,20,30},                3,             0x0,                                                      {0},        0,           {0}},
00342         /*3*/  {{"1_23_4"},   {0x1,0x3,0x5,0x7,0x9},     6,             PAL_SST_CONFIDENTIALITY_FLAG,                             {0},        0,           {0}},
00343         /*4*/  {{"_a_K34s"},  {0x1,0x3,0x5,0x7,0x9},     6,             PAL_SST_WRITE_ONCE_FLAG | PAL_SST_REPLAY_PROTECTION_FLAG, {0},        0,           {0}},
00344         /*5*/  {{"bbcd"},     {0xa,0xb,0xc,0xd,0xf},     5,             PAL_SST_REPLAY_PROTECTION_FLAG,                           {0},        0,           {0}},
00345     };
00346 
00347 
00348 #ifdef DEBUG
00349     size_t pal_sst_items_data_size = (sizeof(pal_sst_items_data) / sizeof(pal_sst_items_data[0]));
00350     PAL_LOG_DBG("\nbefore test");
00351     print_test_data(pal_sst_items_data, pal_sst_items_data_size);
00352 #endif
00353 
00354 
00355     /****** item 0 ********/
00356     /*#1*/
00357     status = pal_SSTSet (pal_sst_items_data[0].item_name, pal_sst_items_data[0].input_data,
00358                         pal_sst_items_data[0].input_data_size, pal_sst_items_data[0].input_flags);
00359     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00360 
00361     /*#2*/
00362     status = pal_SSTGetInfo (pal_sst_items_data[0].item_name, &(pal_sst_items_data[0].output_item_info));
00363     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00364 
00365     /*#3*/
00366     TEST_ASSERT_EQUAL(pal_sst_items_data[0].input_flags & PAL_SST_WRITE_ONCE_FLAG, 
00367                     pal_sst_items_data[0].output_item_info.SSTFlagsBitmap & PAL_SST_WRITE_ONCE_FLAG);
00368 
00369     /*#4*/
00370     status = pal_SSTSet (pal_sst_items_data[0].item_name, pal_sst_items_data[0].input_data,
00371                         pal_sst_items_data[0].input_data_size, pal_sst_items_data[0].input_flags);
00372     TEST_ASSERT_EQUAL_HEX(PAL_ERR_SST_WRITE_PROTECTED, status);
00373 
00374     /*#5*/
00375     status = pal_SSTRemove (pal_sst_items_data[0].item_name);
00376     TEST_ASSERT_EQUAL_HEX(PAL_ERR_SST_WRITE_PROTECTED, status);
00377     /****** item 0 ********/
00378 
00379     /****** item 1 ********/
00380     /*#1*/
00381     status = pal_SSTSet (pal_sst_items_data[1].item_name, pal_sst_items_data[1].input_data,
00382                         pal_sst_items_data[1].input_data_size, pal_sst_items_data[1].input_flags);
00383     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00384 
00385     /*#2*/
00386     status = pal_SSTGetInfo (pal_sst_items_data[1].item_name, &(pal_sst_items_data[1].output_item_info));
00387     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00388 
00389     /*#3*/
00390     status = pal_SSTSet (pal_sst_items_data[1].item_name, pal_sst_items_data[1].input_data,
00391                         pal_sst_items_data[1].input_data_size, pal_sst_items_data[1].input_flags);
00392     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00393 
00394     /*#4*/
00395     status = pal_SSTRemove (pal_sst_items_data[1].item_name);
00396     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00397     /****** item 1 ********/
00398 
00399     /****** item 2 ********/
00400     /*#1*/
00401     status = pal_SSTSet (pal_sst_items_data[2].item_name, pal_sst_items_data[2].input_data,
00402                         pal_sst_items_data[2].input_data_size, pal_sst_items_data[2].input_flags);
00403     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00404 
00405     /*#2*/
00406     status = pal_SSTGetInfo (pal_sst_items_data[2].item_name, &(pal_sst_items_data[2].output_item_info));
00407     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00408 
00409     /*#3*/
00410     status = pal_SSTRemove (pal_sst_items_data[2].item_name);
00411     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00412     /****** item 2 ********/
00413 
00414     /****** item 3 ********/
00415     /*#1*/
00416     status = pal_SSTSet (pal_sst_items_data[3].item_name, pal_sst_items_data[3].input_data,
00417                         pal_sst_items_data[3].input_data_size, pal_sst_items_data[3].input_flags);
00418     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00419 
00420     /*#2*/
00421     status = pal_SSTGetInfo (pal_sst_items_data[3].item_name, &(pal_sst_items_data[3].output_item_info));
00422     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00423 
00424     /*#3*/
00425     status = pal_SSTSet (pal_sst_items_data[3].item_name, pal_sst_items_data[3].input_data,
00426                         pal_sst_items_data[3].input_data_size, pal_sst_items_data[3].input_flags);
00427     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00428 
00429     /*#4*/
00430     status = pal_SSTRemove (pal_sst_items_data[3].item_name);
00431     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00432     /****** item 3 ********/
00433 
00434     /****** item 4 ********/
00435     /*#1*/
00436     status = pal_SSTSet (pal_sst_items_data[4].item_name, pal_sst_items_data[4].input_data,
00437                         pal_sst_items_data[4].input_data_size, pal_sst_items_data[4].input_flags);
00438     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00439 
00440     /*#2*/
00441     status = pal_SSTGetInfo (pal_sst_items_data[4].item_name, &(pal_sst_items_data[4].output_item_info));
00442     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00443 
00444     /*#3*/
00445     TEST_ASSERT_EQUAL(pal_sst_items_data[4].input_flags & PAL_SST_WRITE_ONCE_FLAG, pal_sst_items_data[4].output_item_info.SSTFlagsBitmap & PAL_SST_WRITE_ONCE_FLAG);
00446 
00447     /*#4*/
00448     status = pal_SSTSet (pal_sst_items_data[4].item_name, pal_sst_items_data[4].input_data,
00449                         pal_sst_items_data[4].input_data_size, pal_sst_items_data[4].input_flags);
00450     TEST_ASSERT_EQUAL_HEX(PAL_ERR_SST_WRITE_PROTECTED, status);
00451 
00452     /*#5*/
00453     status = pal_SSTRemove (pal_sst_items_data[4].item_name);
00454     TEST_ASSERT_EQUAL_HEX(PAL_ERR_SST_WRITE_PROTECTED, status);
00455     /****** item 4 ********/
00456 
00457     /****** item 5 ********/
00458     /*#1*/
00459     status = pal_SSTSet (pal_sst_items_data[5].item_name, pal_sst_items_data[5].input_data,
00460                         pal_sst_items_data[5].input_data_size, pal_sst_items_data[5].input_flags);
00461     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00462 
00463     /*#2*/
00464     status = pal_SSTGetInfo (pal_sst_items_data[5].item_name, &(pal_sst_items_data[5].output_item_info));
00465     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00466 
00467     /*#3*/
00468     status = pal_SSTRemove (pal_sst_items_data[5].item_name);
00469     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00470     /****** item 5********/
00471 
00472 #ifdef DEBUG
00473     PAL_LOG_DBG("\nafter test");
00474     print_test_data(pal_sst_items_data, pal_sst_items_data_size);
00475 #endif 
00476 
00477 #else //MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT
00478     TEST_IGNORE_MESSAGE("Ignored, MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT is not defined");
00479 #endif
00480 
00481 }
00482 
00483 
00484 /*! \brief Check few non standard scenarios listed below:
00485  *
00486  * | # |    Step                                                                                       |  Expected   |
00487  * |---|--------------------------------|----------------------------------------------------------------------------|
00488  * | 1 | Set item with pointer to NULL buffer and zero data size using pal_SSTSet()                    | PAL_SUCCESS |
00489  * | 2 | Get item using with NULL buffer and zero buffer size using pal_SSTGet()                       | PAL_SUCCESS |
00490  * | 3 | Get a non existing item using  pal_SSTGet()                                                   | PAL_ERR_SST_ITEM_NOT_FOUND |
00491  * | 4 | Set valid item of 120 chars using pal_SSTSet()                                                | PAL_SUCCESS |
00492  * | 5 | Reset storage using pal_SSTReset()                                                            | PAL_SUCCESS |
00493  * | 6 | Get a non existing item using  pal_SSTGet() since called after pal_SSTReset                   | PAL_ERR_SST_ITEM_NOT_FOUND |
00494  */
00495 TEST(pal_sst, pal_sst_test_special_cases)
00496 {
00497 
00498 #ifdef MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT
00499 
00500     palStatus_t status = PAL_SUCCESS;
00501 
00502     static pal_SSTItemsTestVector_t pal_sst_items_data[] =
00503     {
00504         /*  item name        input data    input data size                     input flags      out data    outdatasize   outiteminfo
00505             ---------        ---------     ---------                           -----------      ----------- -----------   ----------- */
00506             {{"dede"},       {0},           0,                                     0x0,           {0},         0,           {0}   },
00507             {{"qzqzqzqzq"},  {1,2,3,10,5},  TEST_PAL_SST_MAX_INPUT_DATA_SIZE + 1,  0x0,           {0},         0,           {0}   },
00508     };
00509 
00510 #ifdef DEBUG
00511     size_t pal_sst_items_data_size = (sizeof(pal_sst_items_data) / sizeof(pal_sst_items_data[0]));
00512     PAL_LOG_DBG("\nbefore test");
00513     print_test_data(pal_sst_items_data, pal_sst_items_data_size);
00514 #endif
00515 
00516     /*#1*/
00517     status = pal_SSTSet (pal_sst_items_data[0].item_name, NULL, 0, pal_sst_items_data[0].input_flags);
00518     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00519 
00520     /*#2*/
00521     status = pal_SSTGet (pal_sst_items_data[0].item_name, NULL, pal_sst_items_data[0].input_data_size, &pal_sst_items_data[0].output_data_size);
00522     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00523 
00524     /*#3*/
00525     status = pal_SSTGet (pal_sst_items_data[1].item_name, NULL, 0, &pal_sst_items_data[1].output_data_size);
00526     TEST_ASSERT_EQUAL_HEX(PAL_ERR_SST_ITEM_NOT_FOUND, status);
00527 
00528     /*#4*/
00529     memset(pal_sst_items_data[1].item_name, 'a', TEST_PAL_SST_MAX_ITEM_NAME_SIZE);
00530     status = pal_SSTSet (pal_sst_items_data[1].item_name, pal_sst_items_data[1].input_data, pal_sst_items_data[1].input_data_size,
00531                         pal_sst_items_data[0].input_flags);
00532     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00533 
00534     /*#5*/
00535     status = pal_SSTReset ();
00536     TEST_ASSERT_EQUAL_HEX(PAL_SUCCESS, status);
00537 
00538     /*#6*/
00539     status = pal_SSTGet (pal_sst_items_data[1].item_name, pal_sst_items_data[1].input_data, pal_sst_items_data[1].input_data_size,
00540                         &pal_sst_items_data[1].output_data_size);
00541     TEST_ASSERT_EQUAL_HEX(PAL_ERR_SST_ITEM_NOT_FOUND, status);
00542 
00543 #ifdef DEBUG
00544     PAL_LOG_DBG("\nafter test");
00545     print_test_data(pal_sst_items_data, pal_sst_items_data_size);
00546 #endif
00547 
00548 #else //MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT
00549    TEST_IGNORE_MESSAGE("Ignored, MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT is not defined");
00550 #endif
00551 
00552 
00553 }
00554