open.cpp

00001 /*
00002  * mbed Microcontroller Library
00003  * Copyright (c) 2006-2016 ARM Limited
00004  *
00005  * Licensed under the Apache License, Version 2.0 (the "License");
00006  * you may not use this file except in compliance with the License.
00007  * You may obtain a copy of the License at
00008  *
00009  *     http://www.apache.org/licenses/LICENSE-2.0
00010  *
00011  * Unless required by applicable law or agreed to in writing, software
00012  * distributed under the License is distributed on an "AS IS" BASIS,
00013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00014  * See the License for the specific language governing permissions and
00015  * limitations under the License.
00016  */
00017 
00018 /** @file open.cpp Test cases to open KVs in the CFSTORE using the drv->Open() interface.
00019  *
00020  * Please consult the documentation under the test-case functions for
00021  * a description of the individual test case.
00022  */
00023 
00024 #include "mbed.h"
00025 #include "cfstore_config.h"
00026 #include "cfstore_test.h"
00027 #include "cfstore_debug.h"
00028 #include "Driver_Common.h"
00029 #include "configuration_store.h"
00030 #include "utest/utest.h"
00031 #include "unity/unity.h"
00032 #include "greentea-client/test_env.h"
00033 #include "cfstore_utest.h"
00034 #ifdef YOTTA_CFG_CFSTORE_UVISOR
00035 #include "uvisor-lib/uvisor-lib.h"
00036 #endif /* YOTTA_CFG_CFSTORE_UVISOR */
00037 
00038 #include <stdio.h>
00039 #include <string.h>
00040 #include <stdlib.h>     /*rand()*/
00041 #include <inttypes.h>
00042 
00043 using namespace utest::v1;
00044 
00045 static char cfstore_open_utest_msg_g[CFSTORE_UTEST_MSG_BUF_SIZE];
00046 
00047 /* Configure secure box. */
00048 #ifdef YOTTA_CFG_CFSTORE_UVISOR
00049 UVISOR_BOX_NAMESPACE("com.arm.mbed.cfstore.test.open.box1");
00050 UVISOR_BOX_CONFIG(cfstore_open_box1, UVISOR_BOX_STACK_SIZE);
00051 #endif /* YOTTA_CFG_CFSTORE_UVISOR */
00052 
00053 
00054 /// @cond CFSTORE_DOXYGEN_DISABLE
00055 #ifdef CFSTORE_DEBUG
00056 #define CFSTORE_OPEN_GREENTEA_TIMEOUT_S     3000
00057 #else
00058 #define CFSTORE_OPEN_GREENTEA_TIMEOUT_S     1000
00059 #endif
00060 /// @endcond
00061 
00062 
00063 /* support functions */
00064 
00065 /*
00066  * open tests that focus on testing cfstore_open()
00067  * cfstore_handle_t cfstore_open(const char* key_name, char* data, ARM_CFSTORE_SIZE* len, cfstore_key_desc_t* kdesc)
00068  */
00069 
00070 /* KV data for test_01 */
00071 static cfstore_kv_data_t cfstore_open_test_01_kv_data[] = {
00072         { "yotta.hello-world.animal{wobbly-dog}{foot}frontLeft", "missing"},
00073         { NULL, NULL},
00074 };
00075 
00076 
00077 /* report whether built/configured for flash sync or async mode */
00078 static control_t cfstore_open_test_00(const size_t call_count)
00079 {
00080     int32_t ret = ARM_DRIVER_ERROR;
00081 
00082     (void) call_count;
00083     ret = cfstore_test_startup();
00084     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to perform test startup (ret=%d).\n", __func__, (int) ret);
00085     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00086     return CaseNext;
00087 }
00088 
00089 /** @brief
00090  * Basic open test which does the following:
00091  * - creates KV with default rw perms and writes some data to the value blob.
00092  * - closes the newly created KV.
00093  * - opens the KV with the default permissions (r-only)
00094  * - reads the KV data and checks its the same as the previously created data.
00095  * - closes the opened key
00096  *
00097  * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
00098  */
00099 control_t cfstore_open_test_01_end(const size_t call_count)
00100 {
00101     char* read_buf;
00102     int32_t ret = ARM_DRIVER_ERROR;
00103     ARM_CFSTORE_SIZE len = 0;
00104     ARM_CFSTORE_DRIVER* drv = &cfstore_driver;
00105     ARM_CFSTORE_KEYDESC kdesc;
00106     ARM_CFSTORE_HANDLE_INIT(hkey);
00107     cfstore_kv_data_t *node;
00108     ARM_CFSTORE_FMODE flags;
00109 
00110     CFSTORE_DBGLOG("%s:entered\n", __func__);
00111     (void) call_count;
00112     node = cfstore_open_test_01_kv_data;
00113     memset(&kdesc, 0, sizeof(kdesc));
00114     memset(&flags, 0, sizeof(flags));
00115 
00116     kdesc.drl = ARM_RETENTION_WHILE_DEVICE_ACTIVE;
00117     CFSTORE_DBGLOG("%s:About to create new node (key_name=\"%s\", value=\"%s\")\n", __func__, node->key_name, node->value);
00118     ret = drv->Create(node->key_name, strlen(node->value), &kdesc, hkey);
00119     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create node (key_name=\"%s\", value=\"%s\")(ret=%d)\n", __func__, node->key_name, node->value, (int) ret);
00120     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00121 
00122     CFSTORE_DBGLOG("%s:length of KV=%d (key_name=\"%s\", value=\"%s\")\n", __func__, (int) len, node->key_name, node->value);
00123     len = strlen(node->value);
00124     ret = drv->Write(hkey, (char*) node->value, &len);
00125     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to write key (key_name=\"%s\", value=\"%s\")(ret=%d)\n", __func__, node->key_name, node->value, (int) ret);
00126     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00127 
00128     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to write full value data (key_name=\"%s\", value=\"%s\"), len=%d, (ret=%d)\n", __func__, node->key_name, node->value, (int) len, (int) ret);
00129     TEST_ASSERT_MESSAGE(len == strlen(node->value), cfstore_open_utest_msg_g);
00130 
00131     CFSTORE_DBGLOG("Created KV successfully (key_name=\"%s\", value=\"%s\")\n", node->key_name, node->value);
00132     ret = drv->Close(hkey);
00133     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to close handle (ret=%d)\n", __func__, (int) ret);
00134     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00135 
00136     /* now open the newly created key */
00137     ret = drv->Open(node->key_name, flags, hkey);
00138     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to open node (key_name=\"%s\", value=\"%s\")(ret=%d)\n", __func__, node->key_name, node->value, (int) ret);
00139     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00140 
00141     len = strlen(node->value) + 1;
00142     read_buf = (char*) malloc(len);
00143     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to allocated read buffer \n", __func__);
00144     TEST_ASSERT_MESSAGE(read_buf != NULL, cfstore_open_utest_msg_g);
00145 
00146     CFSTORE_DBGLOG("Opened KV successfully (key_name=\"%s\", value=\"%s\")\n", node->key_name, node->value);
00147     memset(read_buf, 0, len);
00148     ret = drv->Read(hkey, read_buf, &len);
00149     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to write key (key_name=\"%s\", value=\"%s\")\n", __func__, node->key_name, node->value);
00150     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00151 
00152     /* check read data is as expected */
00153     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: read value data (%s) != KV value data (key_name=\"%s\", value=\"%s\")\n", __func__, read_buf, node->key_name, node->value);
00154     TEST_ASSERT_MESSAGE(strncmp(read_buf, node->value, strlen(node->value)) == 0, cfstore_open_utest_msg_g);
00155 
00156     if(read_buf){
00157         free(read_buf);
00158     }
00159     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Close() call failed.\n", __func__);
00160     TEST_ASSERT_MESSAGE(drv->Close(hkey) >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00161 
00162     ret = drv->Uninitialize();
00163     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
00164     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00165     return CaseNext;
00166 }
00167 
00168 static cfstore_kv_data_t cfstore_open_test_02_data[] = {
00169         CFSTORE_INIT_1_TABLE_MID_NODE,
00170         { NULL, NULL},
00171 };
00172 
00173 /**
00174  * @brief   test to open() a pre-existing key and try to write it, which should fail
00175  *          as by default pre-existing keys are opened read-only
00176  *
00177  * Basic open test which does the following:
00178  * - creates KV with default rw perms and writes some data to the value blob.
00179  * - closes the newly created KV.
00180  * - opens the KV with the default permissions (read-only)
00181  * - tries to write the KV data which should fail because KV was not opened with write flag set.
00182  * - closes the opened key
00183  *
00184  * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
00185  */
00186 control_t cfstore_open_test_02_end(const size_t call_count)
00187 {
00188     int32_t ret = ARM_DRIVER_ERROR;
00189     ARM_CFSTORE_SIZE len = 0;
00190     ARM_CFSTORE_DRIVER* drv = &cfstore_driver;
00191     ARM_CFSTORE_KEYDESC kdesc;
00192     ARM_CFSTORE_HANDLE_INIT(hkey);
00193     ARM_CFSTORE_FMODE flags;
00194 
00195     CFSTORE_FENTRYLOG("%s:entered\n", __func__);
00196     (void) call_count;
00197     memset(&kdesc, 0, sizeof(kdesc));
00198     /* dont set any flags to get default settings */
00199     memset(&flags, 0, sizeof(flags));
00200     kdesc.drl = ARM_RETENTION_WHILE_DEVICE_ACTIVE;
00201     len = strlen(cfstore_open_test_02_data[0].value);
00202     ret = cfstore_test_create(cfstore_open_test_02_data[0].key_name, (char*) cfstore_open_test_02_data[0].value, &len, &kdesc);
00203     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create KV in store (ret=%d).\n", __func__, (int) ret);
00204     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00205 
00206     /* by default, owner of key opens with read-only permissions*/
00207     ret = drv->Open(cfstore_open_test_02_data[0].key_name, flags, hkey);
00208     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to open node (key_name=\"%s\")(ret=%d)\n", __func__, cfstore_open_test_02_data[0].key_name, (int) ret);
00209     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00210 
00211     len = strlen(cfstore_open_test_02_data[0].value);
00212     ret = drv->Write(hkey, cfstore_open_test_02_data[0].value, &len);
00213     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: call to Write() succeeded when should have failed (key_name=\"%s\")(ret=%d).\n", __func__, cfstore_open_test_02_data[0].key_name, (int) ret);
00214     TEST_ASSERT_MESSAGE(ret == ARM_CFSTORE_DRIVER_ERROR_KEY_READ_ONLY, cfstore_open_utest_msg_g);
00215 
00216     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Close() call failed.\n", __func__);
00217     TEST_ASSERT_MESSAGE(drv->Close(hkey) >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00218 
00219     ret = drv->Uninitialize();
00220     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
00221     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00222     return CaseNext;
00223 }
00224 
00225 
00226 /**
00227  * @brief   test to open() a pre-existing key and try to write it, which should succeed
00228  *          because the key was opened read-write permissions explicitly
00229  *
00230  * Basic open test which does the following:
00231  * - creates KV with default rw perms and writes some data to the value blob.
00232  * - closes the newly created KV.
00233  * - opens the KV with the rw permissions (non default)
00234  * - tries to write the KV data which should succeeds because KV was opened with write flag set.
00235  * - closes the opened key
00236  *
00237  * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
00238  */
00239 control_t cfstore_open_test_03_end(const size_t call_count)
00240 {
00241     int32_t ret = ARM_DRIVER_ERROR;
00242     ARM_CFSTORE_SIZE len = 0;
00243     ARM_CFSTORE_DRIVER* drv = &cfstore_driver;
00244     ARM_CFSTORE_KEYDESC kdesc;
00245     ARM_CFSTORE_HANDLE_INIT(hkey);
00246     ARM_CFSTORE_FMODE flags;
00247 
00248     CFSTORE_FENTRYLOG("%s:entered\n", __func__);
00249     (void) call_count;
00250     memset(&kdesc, 0, sizeof(kdesc));
00251     /* dont set any flags to get default settings */
00252     memset(&flags, 0, sizeof(flags));
00253     kdesc.drl = ARM_RETENTION_WHILE_DEVICE_ACTIVE;
00254     len = strlen(cfstore_open_test_02_data[0].value);
00255     ret = cfstore_test_create(cfstore_open_test_02_data[0].key_name, (char*) cfstore_open_test_02_data[0].value, &len, &kdesc);
00256     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create KV in store (ret=%d).\n", __func__, (int) ret);
00257     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00258 
00259     /* opens with read-write permissions*/
00260     flags.read = true;
00261     flags.write = true;
00262     ret = drv->Open(cfstore_open_test_02_data[0].key_name, flags, hkey);
00263     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to open node (key_name=\"%s\")(ret=%d)\n", __func__, cfstore_open_test_02_data[0].key_name, (int) ret);
00264     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00265 
00266     len = strlen(cfstore_open_test_02_data[0].value);
00267     ret = drv->Write(hkey, cfstore_open_test_02_data[0].value, &len);
00268     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: call to Write() failed when should have succeeded (key_name=\"%s\")(ret=%d).\n", __func__, cfstore_open_test_02_data[0].key_name, (int) ret);
00269     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00270 
00271     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Close() call failed.\n", __func__);
00272     TEST_ASSERT_MESSAGE(drv->Close(hkey) >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00273 
00274     ret = drv->Uninitialize();
00275     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
00276     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00277     return CaseNext;
00278 }
00279 
00280 
00281 
00282 /** @brief  test to call cfstore_open() with a key_name string that exceeds
00283  *          the maximum length
00284  *
00285  * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
00286  */
00287 control_t cfstore_open_test_04_end(const size_t call_count)
00288 {
00289     char kv_name_good[CFSTORE_KEY_NAME_MAX_LENGTH+1]; /* extra char for terminating null */
00290     char kv_name_bad[CFSTORE_KEY_NAME_MAX_LENGTH+2];
00291     int32_t ret = ARM_DRIVER_ERROR;
00292     ARM_CFSTORE_SIZE len = 0;
00293     ARM_CFSTORE_DRIVER* drv = &cfstore_driver;
00294     ARM_CFSTORE_KEYDESC kdesc;
00295     ARM_CFSTORE_FMODE flags;
00296 
00297     CFSTORE_FENTRYLOG("%s:entered\n", __func__);
00298     (void) call_count;
00299     memset(kv_name_good, 0, CFSTORE_KEY_NAME_MAX_LENGTH+1);
00300     memset(kv_name_bad, 0, CFSTORE_KEY_NAME_MAX_LENGTH+2);
00301     memset(&kdesc, 0, sizeof(kdesc));
00302     /* dont set any flags to get default settings */
00303     memset(&flags, 0, sizeof(flags));
00304 
00305     len = CFSTORE_KEY_NAME_MAX_LENGTH;
00306     ret = cfstore_test_kv_name_gen(kv_name_good, len);
00307     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: unable to generate kv_name_good.\n", __func__);
00308     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK , cfstore_open_utest_msg_g);
00309 
00310     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: kv_name_good is not the correct length (len=%d, expected=%d).\n", __func__, (int) strlen(kv_name_good), (int) len);
00311     TEST_ASSERT_MESSAGE(strlen(kv_name_good) == CFSTORE_KEY_NAME_MAX_LENGTH, cfstore_open_utest_msg_g);
00312 
00313     ret = cfstore_test_create(kv_name_good, kv_name_good, &len, &kdesc);
00314     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create KV in store for kv_name_good(ret=%d).\n", __func__, (int) ret);
00315     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00316 
00317     len = CFSTORE_KEY_NAME_MAX_LENGTH+1;
00318     ret = cfstore_test_kv_name_gen(kv_name_bad, len);
00319     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: unable to generate kv_name_bad.\n", __func__);
00320     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK , cfstore_open_utest_msg_g);
00321 
00322     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: kv_name_bad is not the correct length (len=%d, expected=%d).\n", __func__, (int) strlen(kv_name_bad), (int) len);
00323     TEST_ASSERT_MESSAGE(strlen(kv_name_bad) == CFSTORE_KEY_NAME_MAX_LENGTH+1, cfstore_open_utest_msg_g);
00324 
00325     memset(&kdesc, 0, sizeof(kdesc));
00326     ret = cfstore_test_create(kv_name_bad, kv_name_bad, &len, &kdesc);
00327     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: created KV in store for kv_name_bad when should have failed(ret=%d).\n", __func__, (int) ret);
00328     TEST_ASSERT_MESSAGE(ret < ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00329 
00330     ret = drv->Uninitialize();
00331     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
00332     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00333     return CaseNext;
00334 }
00335 
00336 
00337 /// @cond CFSTORE_DOXYGEN_DISABLE
00338 typedef struct cfstore_open_kv_name_ascii_node {
00339     uint32_t code;
00340     uint32_t f_allowed : 1;
00341 } cfstore_open_kv_name_ascii_node;
00342 /// @endcond
00343 
00344 static const uint32_t cfstore_open_kv_name_ascii_table_code_sentinel_g = 256;
00345 
00346 /*@brief    table recording ascii character codes permitted in kv names */
00347 static cfstore_open_kv_name_ascii_node cfstore_open_kv_name_ascii_table[] =
00348 {
00349         {0, false},         /* codes 0-44 not allowed */
00350         {45, true},         /* codes 45-46 == [-.] allowed */
00351         {47, false},        /* code 47 not allowed */
00352         {48, true},         /* codes 48-57 not allowed */
00353         {58, false},        /* codes 46-64 not allowed */
00354         {64, true},         /* codes 64-91 allowed [@A-Z] */
00355         {91, false},        /* code 91-96 not allowed */
00356         {95, true},         /* code 95 allowed '_' */
00357         {96, false},        /* codes 96 not allowed */
00358         {97, true},         /* codes 65-90 allowed [A-Z] and {*/
00359         {123, false},       /* codes 123 '}' not allowed on its own*/
00360         {124, false},       /* codes 124 not allowed */
00361         {125, false},       /* code 125 '}' not allowed on its own*/
00362         {126, false},       /* codes 126-255 not allowed */
00363         {cfstore_open_kv_name_ascii_table_code_sentinel_g, false},       /* sentinel */
00364 };
00365 
00366 /// @cond CFSTORE_DOXYGEN_DISABLE
00367 enum cfstore_open_kv_name_pos {
00368     cfstore_open_kv_name_pos_start = 0x0,
00369     cfstore_open_kv_name_pos_mid,
00370     cfstore_open_kv_name_pos_end,
00371     cfstore_open_kv_name_pos_max
00372 };
00373 /// @endcond
00374 
00375 /** @brief  test to call cfstore_open() with key_name that in includes
00376  *          illegal characters
00377  *          - the character(s) can be at the beginning of the key_name
00378  *          - the character(s) can be at the end of the key_name
00379  *          - the character(s) can be somewhere within the key_name string
00380  *          - a max-length string of random characters (legal and illegal)
00381  *          - a max-length string of random illegal characters only
00382  *
00383  * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
00384  */
00385 control_t cfstore_open_test_05_end(const size_t call_count)
00386 {
00387     bool f_allowed = false;
00388     char kv_name[CFSTORE_KEY_NAME_MAX_LENGTH+1];    /* extra char for terminating null */
00389     uint32_t j = 0;
00390     int32_t ret = ARM_DRIVER_OK;
00391     size_t name_len = CFSTORE_KEY_NAME_MAX_LENGTH;
00392     ARM_CFSTORE_KEYDESC kdesc;
00393     cfstore_open_kv_name_ascii_node* node = NULL;
00394     uint32_t pos;
00395     ARM_CFSTORE_DRIVER* drv = &cfstore_driver;
00396 
00397     CFSTORE_FENTRYLOG("%s:entered\n", __func__);
00398     (void) call_count;
00399 
00400 #ifdef CFSTORE_DEBUG
00401     /* symbol only used why debug is enabled */
00402     const char* pos_str = NULL;
00403 #endif
00404 
00405     /* create bad keyname strings with invalid character code at start of keyname */
00406     node = cfstore_open_kv_name_ascii_table;
00407     while(node->code !=  cfstore_open_kv_name_ascii_table_code_sentinel_g)
00408     {
00409         /* loop over range */
00410         for(j = node->code; j < (node+1)->code; j++)
00411         {
00412             /* set the start, mid, last character of the name to the test char code */
00413             for(pos = (uint32_t) cfstore_open_kv_name_pos_start; pos < (uint32_t) cfstore_open_kv_name_pos_max; pos++)
00414             {
00415                 name_len = CFSTORE_KEY_NAME_MAX_LENGTH;
00416                 memset(kv_name, 0, CFSTORE_KEY_NAME_MAX_LENGTH+1);
00417                 memset(&kdesc, 0, sizeof(kdesc));
00418                 kdesc.drl = ARM_RETENTION_WHILE_DEVICE_ACTIVE;
00419 
00420                 ret = cfstore_test_kv_name_gen(kv_name, name_len);
00421                 CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: unable to generate kv_name.\n", __func__);
00422                 TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK , cfstore_open_utest_msg_g);
00423                 CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: kv_name incorrect length (len=%d, expected= %d).\n", __func__, (int) strlen(kv_name), (int) name_len);
00424                 TEST_ASSERT_MESSAGE(strlen(kv_name) == name_len, cfstore_open_utest_msg_g);
00425 
00426                 /* overwrite a char at the pos start, mid, end of the kv_name with an ascii char code (both illegal and legal)*/
00427                 switch(pos)
00428                 {
00429                 case cfstore_open_kv_name_pos_start:
00430                     kv_name[0] = (char) j;
00431                     break;
00432                 case cfstore_open_kv_name_pos_mid:
00433                     /* create bad keyname strings with invalid character code in the middle of keyname */
00434                     kv_name[name_len/2] = (char) j;
00435                     break;
00436                 case cfstore_open_kv_name_pos_end:
00437                     /* create bad keyname strings with invalid character code at end of keyname */
00438                     kv_name[name_len-1] = (char) j;
00439                     break;
00440                 default:
00441                     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: unexpected value of pos (pos=%d).\n", __func__, (int) pos);
00442                     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00443                     break;
00444                 }
00445 
00446 #ifdef CFSTORE_DEBUG
00447                 /* processing only required when debug trace enabled */
00448                 switch(pos)
00449                 {
00450                 case cfstore_open_kv_name_pos_start:
00451                     pos_str = "start";
00452                     break;
00453                 case cfstore_open_kv_name_pos_mid:
00454                     pos_str = "middle";
00455                     break;
00456                 case cfstore_open_kv_name_pos_end:
00457                     pos_str = "end";
00458                     break;
00459                 default:
00460                     break;
00461                 }
00462 #endif
00463                 ret = cfstore_test_create(kv_name, kv_name, &name_len, &kdesc);
00464 
00465                 /* special cases */
00466                 switch(j)
00467                 {
00468                 case 0 :
00469                 case 46 :
00470                     switch(pos)
00471                     {
00472                     /* for code = 0 (null terminator). permitted at mid and end of string */
00473                     /* for code = 46 ('.'). permitted at mid and end of string but not at start */
00474                     case cfstore_open_kv_name_pos_start:
00475                         f_allowed = false;
00476                         break;
00477                     case cfstore_open_kv_name_pos_mid:
00478                     case cfstore_open_kv_name_pos_end:
00479                     default:
00480                         f_allowed = true;
00481                         break;
00482                     }
00483                     break;
00484                 default:
00485                     f_allowed = node->f_allowed;
00486                     break;
00487                 }
00488                 if(f_allowed == true)
00489                 {
00490                     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to create KV in store when kv_name contains valid characters (code=%d, ret=%d).\n", __func__, (int) j, (int) ret);
00491                     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00492                     /* revert CFSTORE_LOG for more trace */
00493                     CFSTORE_DBGLOG("Successfully created a KV with valid keyname containing ascii character code %d (%c) at the %s of the keyname.\n", (int) j, (int) j, pos_str);
00494                     CFSTORE_LOG("%c", '.');
00495 
00496                     ret = cfstore_test_delete(kv_name);
00497                     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to delete KV previously created (code=%d, ret=%d).\n", __func__, (int) j, (int) ret);
00498                     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00499                 }
00500                 else
00501                 {   /*node->f_allowed == false => not allowed to create kv name with ascii code */
00502                     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: created KV in store when kv_name contains an invalid character (code=%d, ret=%d).\n", __func__, (int) j, (int) ret);
00503                     TEST_ASSERT_MESSAGE(ret < ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00504                     /* revert CFSTORE_LOG for more trace */
00505                     CFSTORE_DBGLOG("Successfully failed to create a KV with an invalid keyname containing ascii character code %d at the %s of the keyname.\n", (int) j, pos_str);
00506                     CFSTORE_LOG("%c", '.');
00507                 }
00508             }
00509         }
00510         node++;
00511     }
00512 
00513     CFSTORE_LOG("%c", '\n');
00514     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
00515     TEST_ASSERT_MESSAGE(drv->Uninitialize() >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00516     return CaseNext;
00517 }
00518 
00519 
00520 static const char cfstore_open_ascii_illegal_buf_g[] = "!\"�$%&'()*+,./:;<=>?@[\\]^_`{|}~"; /* 31 chars */
00521 
00522 /** @brief  test to call cfstore_open() with key_name that in includes
00523  *          illegal characters
00524  *          - a max-length string of random illegal characters only
00525  *
00526  * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
00527  */
00528 control_t cfstore_open_test_06_end(const size_t call_count)
00529 {
00530     char kv_name[CFSTORE_KEY_NAME_MAX_LENGTH+1];    /* extra char for terminating null */
00531     size_t i = 0;
00532     uint32_t pos = 0;
00533     int32_t ret = ARM_DRIVER_OK;
00534     size_t name_len = CFSTORE_KEY_NAME_MAX_LENGTH;
00535     ARM_CFSTORE_KEYDESC kdesc;
00536     size_t buf_data_max = 0;
00537     ARM_CFSTORE_DRIVER* drv = &cfstore_driver;
00538 
00539     CFSTORE_FENTRYLOG("%s:entered\n", __func__);
00540     (void) call_count;
00541 
00542     /* create bad keyname strings with invalid character code at start of keyname */
00543     buf_data_max = strlen(cfstore_open_ascii_illegal_buf_g);
00544     name_len = CFSTORE_KEY_NAME_MAX_LENGTH;
00545     memset(kv_name, 0, CFSTORE_KEY_NAME_MAX_LENGTH+1);
00546     kdesc.drl = ARM_RETENTION_WHILE_DEVICE_ACTIVE;
00547 
00548     /* generate a kv name of illegal chars*/
00549     for(i = 0; i < name_len; i++)
00550     {
00551         pos = rand() % (buf_data_max+1);
00552         kv_name[i] = cfstore_open_ascii_illegal_buf_g[pos];
00553     }
00554 
00555     ret = cfstore_test_create(kv_name, kv_name, &name_len, &kdesc);
00556     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: created KV in store when kv_name contains invalid characters (ret=%d).\n", __func__, (int) ret);
00557     TEST_ASSERT_MESSAGE(ret < ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00558 
00559     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
00560     TEST_ASSERT_MESSAGE(drv->Uninitialize() >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00561     return CaseNext;
00562 }
00563 
00564 /** @brief  test to call cfstore_open() with key_name that in includes
00565  *          illegal characters
00566  *          - a max-length string of random characters (legal and illegal)
00567  *
00568  * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
00569  */
00570 control_t cfstore_open_test_07_end(const size_t call_count)
00571 {
00572     char kv_name[CFSTORE_KEY_NAME_MAX_LENGTH+1];    /* extra char for terminating null */
00573     size_t i = 0;
00574     int32_t ret = ARM_DRIVER_OK;
00575     size_t name_len = CFSTORE_KEY_NAME_MAX_LENGTH;
00576     ARM_CFSTORE_KEYDESC kdesc;
00577     size_t buf_data_max = 0;
00578     ARM_CFSTORE_DRIVER* drv = &cfstore_driver;
00579 
00580     CFSTORE_FENTRYLOG("%s:entered\n", __func__);
00581     (void) call_count;
00582 
00583     /* create bad keyname strings with invalid character code at start of keyname */
00584     buf_data_max = strlen(cfstore_open_ascii_illegal_buf_g);
00585     name_len = CFSTORE_KEY_NAME_MAX_LENGTH;
00586     memset(kv_name, 0, CFSTORE_KEY_NAME_MAX_LENGTH+1);
00587     kdesc.drl = ARM_RETENTION_WHILE_DEVICE_ACTIVE;
00588 
00589     ret = cfstore_test_kv_name_gen(kv_name, name_len);
00590     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: unable to generate kv_name.\n", __func__);
00591     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK , cfstore_open_utest_msg_g);
00592 
00593     /* pepper the illegal chars across the string*/
00594     for(i++; i < buf_data_max; i++){
00595         kv_name[rand() % (name_len+1)] = cfstore_open_ascii_illegal_buf_g[i];
00596     }
00597     ret = cfstore_test_create(kv_name, kv_name, &name_len, &kdesc);
00598     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: created KV in store when kv_name contains invalid characters (ret=%d).\n", __func__, (int) ret);
00599     TEST_ASSERT_MESSAGE(ret < ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00600 
00601     CFSTORE_TEST_UTEST_MESSAGE(cfstore_open_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
00602     TEST_ASSERT_MESSAGE(drv->Uninitialize() >= ARM_DRIVER_OK, cfstore_open_utest_msg_g);
00603     return CaseNext;
00604 }
00605 
00606 /// @cond CFSTORE_DOXYGEN_DISABLE
00607 utest::v1::status_t greentea_setup(const size_t number_of_cases)
00608 {
00609     GREENTEA_SETUP(CFSTORE_OPEN_GREENTEA_TIMEOUT_S, "default_auto");
00610     return greentea_test_setup_handler(number_of_cases);
00611 }
00612 
00613 Case cases[] = {
00614            /*          1         2         3         4         5         6        7  */
00615            /* 1234567890123456789012345678901234567890123456789012345678901234567890 */
00616         Case("OPEN_test_00", cfstore_open_test_00),
00617         Case("OPEN_test_01_start", cfstore_utest_default_start),
00618         Case("OPEN_test_01_end", cfstore_open_test_01_end),
00619         Case("OPEN_test_02_start", cfstore_utest_default_start),
00620         Case("OPEN_test_02_end", cfstore_open_test_02_end),
00621         Case("OPEN_test_03_start", cfstore_utest_default_start),
00622         Case("OPEN_test_03_end", cfstore_open_test_03_end),
00623         Case("OPEN_test_04_start", cfstore_utest_default_start),
00624         Case("OPEN_test_04_end", cfstore_open_test_04_end),
00625         Case("OPEN_test_05_start", cfstore_utest_default_start),
00626         Case("OPEN_test_05_end", cfstore_open_test_05_end),
00627         Case("OPEN_test_06_start", cfstore_utest_default_start),
00628         Case("OPEN_test_06_end", cfstore_open_test_06_end),
00629         Case("OPEN_test_07_start", cfstore_utest_default_start),
00630         Case("OPEN_test_07_end", cfstore_open_test_07_end),
00631 };
00632 
00633 
00634 /* Declare your test specification with a custom setup handler */
00635 Specification specification(greentea_setup, cases);
00636 
00637 int main()
00638 {
00639     return !Harness::run(specification);
00640 }
00641 /// @endcond