find.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  */
00019 
00020 /** @file find.cpp Test cases to find KVs in the CFSTORE using the drv->Find() interface.
00021  *
00022  * Please consult the documentation under the test-case functions for
00023  * a description of the individual test case.
00024  */
00025 
00026 #include "mbed.h"
00027 #include "cfstore_config.h"
00028 #include "cfstore_test.h"
00029 #include "cfstore_debug.h"
00030 #include "Driver_Common.h"
00031 #include "configuration_store.h"
00032 #include "utest/utest.h"
00033 #include "unity/unity.h"
00034 #include "greentea-client/test_env.h"
00035 #include "cfstore_utest.h"
00036 #ifdef YOTTA_CFG_CFSTORE_UVISOR
00037 #include "uvisor-lib/uvisor-lib.h"
00038 #endif /* YOTTA_CFG_CFSTORE_UVISOR */
00039 
00040 #include <stdio.h>
00041 #include <stdlib.h>
00042 #include <string.h>
00043 #include <assert.h>
00044 #include <inttypes.h>
00045 
00046 using namespace utest::v1;
00047 
00048 static char cfstore_find_utest_msg_g[CFSTORE_UTEST_MSG_BUF_SIZE];
00049 
00050 /* Configure secure box. */
00051 #ifdef YOTTA_CFG_CFSTORE_UVISOR
00052 UVISOR_BOX_NAMESPACE("com.arm.mbed.cfstore.test.find.box1");
00053 UVISOR_BOX_CONFIG(cfstore_find_box1, UVISOR_BOX_STACK_SIZE);
00054 #endif /* YOTTA_CFG_CFSTORE_UVISOR */
00055 
00056 
00057 /* report whether built/configured for flash sync or async mode */
00058 static control_t cfstore_find_test_00(const size_t call_count)
00059 {
00060     int32_t ret = ARM_DRIVER_ERROR;
00061 
00062     (void) call_count;
00063     ret = cfstore_test_startup();
00064     CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to perform test startup (ret=%d).\n", __func__, (int) ret);
00065     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_find_utest_msg_g);
00066     return CaseNext;
00067 }
00068 
00069 /** @brief  test to call cfstore_find() with a key_name string that exceeds
00070  *          the maximum length
00071  * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
00072  */
00073 control_t cfstore_find_test_01(const size_t call_count)
00074 {
00075     (void) call_count;
00076     /*todo: implement test */
00077     CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Warn: Not implemented\n", __func__);
00078     CFSTORE_DBGLOG("%s: WARN: requires implementation\n", __func__);
00079     TEST_ASSERT_MESSAGE(true, cfstore_find_utest_msg_g);
00080     return CaseNext;
00081 }
00082 
00083 
00084 /** @brief  test to call cfstore_find() with key_name that in includes
00085  *          illegal characters
00086  *          - the character can be at the beginning of the key_name
00087  *          - the character can be at the end of the key_name
00088  *          - the character can be somewhere within the key_name string
00089  *
00090  * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
00091  */
00092 control_t cfstore_find_test_02(const size_t call_count)
00093 {
00094     /*todo: implement test
00095      *
00096      * specify the allowable characters in a set.
00097      * e.g. "0123456789ABCDEFGHIJKLMNOPQRSTUVQXYZabcdefghijklmnopqrstuvwxyz.[]*"
00098      * and use this set as the sell of allowable character codes.
00099      * All other 0-255 values for character codes should not be found in the key_name string
00100      * but the function should be tested for what happens in that case.
00101      *
00102      * Some code may be common here with other functions requiring a key_name e.g. cfstore_find(
00103      */
00104     (void) call_count;
00105     /*todo: implement test */
00106     CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Warn: Not implemented\n", __func__);
00107     CFSTORE_DBGLOG("%s: WARN: requires implementation\n", __func__);
00108     TEST_ASSERT_MESSAGE(true, cfstore_find_utest_msg_g);
00109     return CaseNext;
00110 }
00111 
00112 
00113 /** @brief  test to call cfstore_find() with key_name that in includes
00114  *          illegal characters
00115  *          - the character can be at the beginning of the key_name
00116  *          - the character can be at the end of the key_name
00117  *          - the character can be somewhere within the key_name string
00118  *
00119  * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
00120  */
00121 control_t cfstore_find_test_03_end(const size_t call_count)
00122 {
00123     char* read_buf = NULL;
00124     const uint8_t key_name_max_len = CFSTORE_KEY_NAME_MAX_LENGTH+1;
00125     char key_name_buf[key_name_max_len];
00126     int32_t ret = ARM_DRIVER_ERROR;
00127     ARM_CFSTORE_SIZE len = 0;
00128     ARM_CFSTORE_SIZE max_len = 0;
00129     cfstore_kv_data_t* node;
00130     cfstore_kv_data_t* client_node = cfstore_test_init_1_data;
00131     ARM_CFSTORE_DRIVER* drv = &cfstore_driver;
00132     ARM_CFSTORE_KEYDESC kdesc;
00133     ARM_CFSTORE_HANDLE_INIT(prev);
00134     ARM_CFSTORE_HANDLE_INIT(next);
00135 
00136     CFSTORE_DBGLOG("%s:entered\r\n", __func__);
00137     (void) call_count;
00138     memset(&kdesc, 0, sizeof(kdesc));
00139     memset(key_name_buf, 0, CFSTORE_KEY_NAME_MAX_LENGTH+1);
00140 
00141     /*scan for max length of value blob*/
00142     node = client_node;
00143     while(node->key_name != NULL)
00144     {
00145         len = strlen(node->value);
00146         if(len > max_len){
00147             max_len = len;
00148         }
00149         node++;
00150     }
00151     max_len++;  /* space for a terminating null, if required */
00152     read_buf = (char*) malloc(max_len);
00153     CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Failed to allocated read buffer \r\n", __func__);
00154     TEST_ASSERT_MESSAGE(read_buf != NULL, cfstore_find_utest_msg_g);
00155 
00156     ret = cfstore_test_init_1();
00157     CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to initialise cfstore area with entries\r\n", __func__);
00158     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_find_utest_msg_g);
00159 
00160     /* now find and read back the key values  */
00161     ret = ARM_DRIVER_ERROR;
00162     node = client_node;
00163     while(node->key_name != NULL)
00164     {
00165         CFSTORE_DBGLOG("%s:About to find node (key_name=\"%s\", value=\"%s\")\r\n", __func__, node->key_name, node->value);
00166         ret = drv->Find(node->key_name, prev, next);
00167         CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Failed to find node (key_name=\"%s\", value=\"%s\")\r\n", __func__, node->key_name, node->value);
00168         TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_find_utest_msg_g);
00169 
00170         CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Find failed to return valid key handle\r\n", __func__);
00171         TEST_ASSERT_MESSAGE(next != NULL, cfstore_find_utest_msg_g);
00172 
00173         ret = drv->GetValueLen(next, &len);
00174         CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to write key (key_name=\"%s\", value=\"%s\")\r\n", __func__, node->key_name, node->value);
00175         TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_find_utest_msg_g);
00176 
00177         if(len > 0) {
00178             ret = drv->Read(next, read_buf, &len);
00179             CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to read value (key_name=\"%s\", value=\"%s\")\r\n", __func__, node->key_name, node->value);
00180             TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_find_utest_msg_g);
00181 
00182             /* check read data is as expected */
00183             CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Read value data (%s) != KV value data (key_name=\"%s\", value=\"%s\")\r\n", __func__, read_buf, node->key_name, node->value);
00184             TEST_ASSERT_MESSAGE(strncmp(read_buf, node->value, strlen(node->value)) == 0, cfstore_find_utest_msg_g);
00185 
00186         }
00187         read_buf[len] = '\0';
00188         /* revert to CFSTORE_LOG if more trace required */
00189         CFSTORE_DBGLOG("Successfully found KV and read value data (key_name=\"%s\", value=\"%s\")\r\n", node->key_name, read_buf);
00190         memset(read_buf, 0, len);
00191         drv->Close(next);
00192         node++;
00193     }
00194 
00195     ret = drv->Uninitialize();
00196     CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
00197     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_find_utest_msg_g);
00198     return CaseNext;
00199 }
00200 
00201 
00202 /** @brief  TODO: write test that uses cfstore_find_test_04_kv_data to grow {key, value}
00203  *          from 1 char to 221 chars long.
00204  * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
00205  */
00206 /*
00207  * use this data:
00208  *  static cfstore_kv_data_t cfstore_find_test_04_kv_data[] = {
00209  *        { "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", "abcdefghjklmnopqrstuvwxyzabcdefghjklmnopqrstuvwxyzabcdefghjklmnopqrstuvwxyzabcdefghjklmnopqrstuvwxyzabcdefghjklmnopqrstuvwxyzabcdefghjklmnopqrstuvwxyzabcdefghjklmnopqrstuvwxyzabcdefghjklmnopqrstuvwxyzabcdefghjklmnopqrstuvwxyz"},
00210  *        { NULL, NULL},
00211  * };
00212  *
00213  */
00214 control_t cfstore_find_test_04(const size_t call_count)
00215 {
00216     /*todo: implement test
00217      *
00218      * */
00219     (void) call_count;
00220     /*todo: implement test */
00221     CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Warn: Not implemented\n", __func__);
00222     CFSTORE_DBGLOG("%s: WARN: requires implementation\n", __func__);
00223     TEST_ASSERT_MESSAGE(true, cfstore_find_utest_msg_g);
00224     return CaseNext;
00225 }
00226 
00227 
00228 /**
00229  * @brief   function to test whether a key name is valid, can be added to the
00230  *          cfstore and found by a wildcard string
00231  *
00232  * @param   key_name
00233  *          name of the key to create in the store
00234  * @param   match
00235  *          string to use to try and find key_name in the cfstore
00236  * @param   should_find
00237  *          if true, then 'match' should find 'key_name' in the store
00238  *          if false, then 'match' should not find 'key_name' in the store
00239  *
00240  * @return  status code
00241  *          ARM_DRIVER_OK, the test passed successfully
00242  *          ret < ARM_DRIVER_OK, the test failed with the return code
00243  *          supplying more details
00244  */
00245 static bool cfstore_find_key_name_validate(const char *key_name, const char *match, bool should_find)
00246 {
00247     bool bret = true;
00248     bool btest_status = false;
00249     char* test_data = (char*) "test_data";
00250     int32_t ret = ARM_DRIVER_ERROR;
00251     ARM_CFSTORE_SIZE len = 0;
00252     ARM_CFSTORE_KEYDESC kdesc;
00253 
00254     CFSTORE_FENTRYLOG("%s:entered\r\n", __func__);
00255     memset(&kdesc, 0, sizeof(kdesc));
00256 
00257     /* create  */
00258     kdesc.drl = ARM_RETENTION_WHILE_DEVICE_ACTIVE;
00259     len = strlen(test_data);
00260     ret = cfstore_test_create((const char*) key_name, test_data, &len, &kdesc);
00261     if(ret < ARM_DRIVER_OK){
00262         CFSTORE_ERRLOG("%s:Error: failed to create kv (key_name=%s.\r\n", "cfstore_find_test_05_ex", key_name);
00263         return ret;
00264     }
00265     ret = cfstore_test_kv_is_found(match, &bret);
00266     if(ret < ARM_DRIVER_OK && ret != ARM_CFSTORE_DRIVER_ERROR_KEY_NOT_FOUND){
00267         CFSTORE_ERRLOG("%s:Error: cfstore_test_kv_is_found() failed.\r\n", "cfstore_find_test_05_ex");
00268         return ret;
00269     }
00270     /* dont not use any functions that require finding the created item as they may not work,
00271      * depending on the construction of the test key_name & match strings */
00272     if(should_find == bret)
00273     {
00274         CFSTORE_DBGLOG("%s:Success: Find() behaved as expected.\r\n", "cfstore_find_test_05_ex");
00275         btest_status = true;
00276     }
00277     else
00278     {
00279         CFSTORE_ERRLOG("cfstore_find_test_05_ex: Failed match on %s vs. %s\n",  key_name, match);
00280     }
00281     /*delete using the actual name */
00282     ret = cfstore_test_delete((const char*) key_name);
00283     if(ret < ARM_DRIVER_OK){
00284         CFSTORE_ERRLOG("%s:Error: failed to delete kv (key_name=%s)(ret=%d).\r\n", "cfstore_find_test_05_ex", key_name, (int)ret);
00285     }
00286     return btest_status;
00287 }
00288 
00289 
00290 /// @cond CFSTORE_DOXYGEN_DISABLE
00291 typedef struct cfstore_find_key_name_validate_t {
00292     const char* key_name;
00293     const char* match;
00294     uint32_t f_allowed : 1;
00295 } cfstore_find_key_name_validate_t;
00296 
00297 cfstore_find_key_name_validate_t cfstore_find_test_05_data[] = {
00298         { "yotta.hello-world.animal{wobbly-dog}{foot}backLeft", "yotta.hello-world.animal{*}{foot}backLeft", true},
00299         { "yotta.hello-world.animal{wobbly-dog}{foot}backLeft", "yotta.hello-world.animal{wobbly-dog}{*}backLeft", true},
00300         { "yotta.hello-world.animal{wobbly-dog}{foot}backLeft", "yotta.hello-world.animal{wobbly-dog}{*}*", true},
00301         { "yotta.hello-world.animal{1}{foot}backLeft", "yotta.hello-world.animal{?}{foot}backLeft", false},
00302         { "xyz", "xyz", true},
00303         { "xyzijkXYZ", "XYZ", false},
00304         { "xyzijkXYZ", "*XYZ", true},
00305         { "xyzijkXYZ", "xyz*XYZ", true},
00306         { "xyzijkXYZ", "*yz*XYZ", true},
00307         { "xyzijkXYZ", "*ijk*", true},
00308         { NULL, NULL, false},
00309 };
00310 /// @endcond
00311 
00312 
00313 /** @brief  test whether a key name in the above table are valid, can be added to the
00314  *          cfstore and found by a wildcard string
00315  *
00316  * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
00317  */
00318 control_t cfstore_find_test_05_end(const size_t call_count)
00319 {
00320     bool ret = false;
00321     int32_t ret32 = ARM_DRIVER_ERROR;
00322     ARM_CFSTORE_DRIVER* drv = &cfstore_driver;
00323     cfstore_find_key_name_validate_t* node = cfstore_find_test_05_data;
00324 
00325     (void) call_count;
00326 
00327     while(node->key_name != NULL)
00328     {
00329         ret = cfstore_find_key_name_validate(node->key_name, node->match, node->f_allowed);
00330         CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: test failed (ret=%d)\n", __func__, (int) ret);
00331         TEST_ASSERT_MESSAGE(ret == true, cfstore_find_utest_msg_g);
00332         node++;
00333     }
00334 
00335     ret32 = drv->Uninitialize();
00336     CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
00337     TEST_ASSERT_MESSAGE(ret32 >= ARM_DRIVER_OK, cfstore_find_utest_msg_g);
00338     return CaseNext;
00339 }
00340 
00341 
00342 /// @cond CFSTORE_DOXYGEN_DISABLE
00343 #define CFSTORE_FIND_TEST_06_ENTRY_MATCH_03      { "0123456789abcdef0123456.yxxx.3", "abcdefghijklmnopqrstuvwxyz"}
00344 #define CFSTORE_FIND_TEST_06_ENTRY_MATCH_05      { "0123456789abcdef0123456.yxxx.5", "abcdefghijklmnopqrstuvwxyz"}
00345 #define CFSTORE_FIND_TEST_06_ENTRY_MATCH_07      { "0123456789abcdef0123456.yxxx.7", "abcdefghijklmnopqrstuvwxyz"}
00346 #define CFSTORE_FIND_TEST_06_ENTRY_MATCH_09      { "0123456789abcdef0123456.yxxx.9", "abcdefghijklmnopqrstuvwxyz"}
00347 
00348 #define CFSTORE_FIND_TEST_06_ENTRY_NOMATCH_01      { "0123456789abcdef0123456.xxxx.1", "abcdefghijklmnopqrstuvwxyz"}
00349 #define CFSTORE_FIND_TEST_06_ENTRY_NOMATCH_02      { "0123456789abcdef0123456.xxxx.2", "abcdefghijklmnopqrstuvwxyz"}
00350 #define CFSTORE_FIND_TEST_06_ENTRY_NOMATCH_04      { "0123456789abcdef0123456.xxxx.4", "abcdefghijklmnopqrstuvwxyz"}
00351 #define CFSTORE_FIND_TEST_06_ENTRY_NOMATCH_06      { "0123456789abcdef0123456.xxxx.6", "abcdefghijklmnopqrstuvwxyz"}
00352 #define CFSTORE_FIND_TEST_06_ENTRY_NOMATCH_08      { "0123456789abcdef0123456.xxxx.8", "abcdefghijklmnopqrstuvwxyz"}
00353 #define CFSTORE_FIND_TEST_06_ENTRY_NOMATCH_10      { "0123456789abcdef0123456.xxxx.10", "abcdefghijklmnopqrstuvwxyz"}
00354 #define CFSTORE_FIND_TEST_06_ENTRY_NOMATCH_11      { "0123456789abcdef0123456.xxxx.11", "abcdefghijklmnopqrstuvwxyz"}
00355 
00356 /* table 1: to initialise cfstore with CFSTORE_CREATE_TEST_01_TABLE_MID_ENTRY_01 */
00357 static cfstore_kv_data_t cfstore_find_test_06_data[] = {
00358         CFSTORE_FIND_TEST_06_ENTRY_NOMATCH_01,
00359         CFSTORE_FIND_TEST_06_ENTRY_NOMATCH_02,
00360         CFSTORE_FIND_TEST_06_ENTRY_MATCH_03,
00361         CFSTORE_FIND_TEST_06_ENTRY_NOMATCH_04,
00362         CFSTORE_FIND_TEST_06_ENTRY_MATCH_05,
00363         CFSTORE_FIND_TEST_06_ENTRY_NOMATCH_06,
00364         CFSTORE_FIND_TEST_06_ENTRY_MATCH_07,
00365         CFSTORE_FIND_TEST_06_ENTRY_NOMATCH_08,
00366         CFSTORE_FIND_TEST_06_ENTRY_MATCH_09,
00367         CFSTORE_FIND_TEST_06_ENTRY_NOMATCH_10,
00368         CFSTORE_FIND_TEST_06_ENTRY_NOMATCH_11,
00369         { NULL, NULL},
00370 };
00371 
00372 static cfstore_kv_data_t cfstore_find_test_06_data_match_results[] = {
00373         CFSTORE_FIND_TEST_06_ENTRY_MATCH_03,
00374         CFSTORE_FIND_TEST_06_ENTRY_MATCH_05,
00375         CFSTORE_FIND_TEST_06_ENTRY_MATCH_07,
00376         CFSTORE_FIND_TEST_06_ENTRY_MATCH_09,
00377         { NULL, NULL},
00378 };
00379 /// @endcond
00380 
00381 
00382 /**
00383  * @brief   test to use find to find at least 2 entries in the cfstore,
00384  *          but the query string doesnt match the last 2 entries in the
00385  *          store.
00386  *
00387  * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
00388  */
00389 control_t cfstore_find_test_06_end(const size_t call_count)
00390 {
00391     const char* key_name_query = "0123456789abcdef0123456.y*";
00392     char key_name[CFSTORE_KEY_NAME_MAX_LENGTH+1];
00393     uint8_t len = CFSTORE_KEY_NAME_MAX_LENGTH+1;
00394     int32_t ret = ARM_DRIVER_ERROR;
00395     int32_t find_count = 0;
00396     ARM_CFSTORE_DRIVER* drv = &cfstore_driver;
00397     ARM_CFSTORE_HANDLE_INIT(next);
00398     ARM_CFSTORE_HANDLE_INIT(prev);
00399     cfstore_kv_data_t* node = NULL;
00400 
00401     ret = cfstore_test_create_table(cfstore_find_test_06_data);
00402     CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Failed to add cfstore_find_test_06_data table data (ret=%d).\n", __func__, (int) ret);
00403     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_find_utest_msg_g);
00404 
00405     while((ret = drv->Find(key_name_query, prev, next)) == ARM_DRIVER_OK)
00406     {
00407         len = CFSTORE_KEY_NAME_MAX_LENGTH+1;
00408         ret = drv->GetKeyName(next, key_name, &len);
00409         if(ret < ARM_DRIVER_OK){
00410             CFSTORE_ERRLOG("Error: failed to get key name%s", "\n");
00411             break;
00412         }
00413         CFSTORE_LOG("%s:Found entry key_name=%s\n", __func__, key_name);
00414         node = cfstore_find_test_06_data_match_results;
00415         while(node->key_name != NULL){
00416             if(strncmp(node->key_name, key_name, CFSTORE_KEY_NAME_MAX_LENGTH) == 0){
00417                 find_count++;
00418                 break;
00419             }
00420             node++;
00421         }
00422         CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: unable to find match in match table for %s.\n", __func__, key_name);
00423         TEST_ASSERT_MESSAGE(node->key_name != NULL, cfstore_find_utest_msg_g);
00424 
00425         CFSTORE_HANDLE_SWAP(prev, next);
00426     }
00427 
00428     CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: find_count=%d doesnt match the number of entries in match table = %d.\n", __func__, (int) find_count, (int) (sizeof(cfstore_find_test_06_data_match_results)/sizeof(cfstore_kv_data_t))-1);
00429     TEST_ASSERT_MESSAGE(find_count == (sizeof(cfstore_find_test_06_data_match_results)/sizeof(cfstore_kv_data_t))-1, cfstore_find_utest_msg_g);
00430 
00431     CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: expected ret == ARM_CFSTORE_DRIVER_ERROR_KEY_NOT_FOUND, but ret = %d.\n", __func__, (int) ret);
00432     TEST_ASSERT_MESSAGE(ret == ARM_CFSTORE_DRIVER_ERROR_KEY_NOT_FOUND, cfstore_find_utest_msg_g);
00433 
00434     ret = drv->Uninitialize();
00435     CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
00436     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_find_utest_msg_g);
00437     return CaseNext;
00438 }
00439 
00440 /**
00441  * @brief   test case to check Find() with previous NULL pointer works
00442  *
00443  * @return on success returns CaseNext to continue to next test case, otherwise will assert on errors.
00444  */
00445 control_t cfstore_find_test_07_end(const size_t call_count)
00446 {
00447     const char* key_name_query = "0123456789abcdef0123456.y*";
00448     char key_name[CFSTORE_KEY_NAME_MAX_LENGTH+1];
00449     uint8_t len = CFSTORE_KEY_NAME_MAX_LENGTH+1;
00450     int32_t ret = ARM_DRIVER_ERROR;
00451     int32_t find_count = 0;
00452     ARM_CFSTORE_DRIVER* drv = &cfstore_driver;
00453     ARM_CFSTORE_HANDLE_INIT(next);
00454     cfstore_kv_data_t* node = NULL;
00455 
00456     ret = cfstore_test_create_table(cfstore_find_test_06_data);
00457     CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Failed to add cfstore_find_test_06_data table data (ret=%d).\n", __func__, (int) ret);
00458     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_find_utest_msg_g);
00459 
00460     while(true)
00461     {
00462 
00463         ret = drv->Find(key_name_query, NULL, next);
00464         if(ret == ARM_CFSTORE_DRIVER_ERROR_KEY_NOT_FOUND) {
00465             /* no more attributes found matching search criteria.*/
00466            break;
00467         }
00468 
00469         CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Find() failed(ret=%d).\n", __func__, (int) ret);
00470         TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_find_utest_msg_g);
00471 
00472         len = CFSTORE_KEY_NAME_MAX_LENGTH+1;
00473         ret = drv->GetKeyName(next, key_name, &len);
00474         CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: failed to get key name for next (ret=%d).\n", __func__, (int) ret);
00475         TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_find_utest_msg_g);
00476 
00477         CFSTORE_LOG("%s:Found entry key_name=%s\n", __func__, key_name);
00478         node = cfstore_find_test_06_data_match_results;
00479         while(node->key_name != NULL){
00480             if(strncmp(node->key_name, key_name, CFSTORE_KEY_NAME_MAX_LENGTH) == 0){
00481                 find_count++;
00482                 break;
00483             }
00484             node++;
00485         }
00486         CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: unable to find match in match table for %s.\n", __func__, key_name);
00487         TEST_ASSERT_MESSAGE(node->key_name != NULL, cfstore_find_utest_msg_g);
00488 
00489         /* delete the KV so it wont be found when queried is repeated*/
00490         ret = drv->Delete(next);
00491         CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Delete() on next handled failed(ret=%d).\n", __func__, (int) ret);
00492         TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_find_utest_msg_g);
00493 
00494         ret = drv->Close(next);
00495         CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Close() on next handled failed(ret=%d).\n", __func__, (int) ret);
00496         TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_find_utest_msg_g);
00497     }
00498 
00499     CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: find_count=%d doesnt match the number of entries in match table = %d.\n", __func__, (int) find_count, (int) (sizeof(cfstore_find_test_06_data_match_results)/sizeof(cfstore_kv_data_t))-1);
00500     TEST_ASSERT_MESSAGE(find_count == (sizeof(cfstore_find_test_06_data_match_results)/sizeof(cfstore_kv_data_t))-1, cfstore_find_utest_msg_g);
00501 
00502     CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: expected ret == ret == ARM_CFSTORE_DRIVER_ERROR_KEY_NOT_FOUND, but ret = %d.\n", __func__, (int) ret);
00503     TEST_ASSERT_MESSAGE(ret == ARM_CFSTORE_DRIVER_ERROR_KEY_NOT_FOUND, cfstore_find_utest_msg_g);
00504 
00505     ret = drv->Uninitialize();
00506     CFSTORE_TEST_UTEST_MESSAGE(cfstore_find_utest_msg_g, CFSTORE_UTEST_MSG_BUF_SIZE, "%s:Error: Uninitialize() call failed.\n", __func__);
00507     TEST_ASSERT_MESSAGE(ret >= ARM_DRIVER_OK, cfstore_find_utest_msg_g);
00508     return CaseNext;
00509 }
00510 
00511 
00512 /// @cond CFSTORE_DOXYGEN_DISABLE
00513 utest::v1::status_t greentea_setup(const size_t number_of_cases)
00514 {
00515     GREENTEA_SETUP(400, "default_auto");
00516     return greentea_test_setup_handler(number_of_cases);
00517 }
00518 
00519 Case cases[] = {
00520            /*          1         2         3         4         5         6        7  */
00521            /* 1234567890123456789012345678901234567890123456789012345678901234567890 */
00522         Case("FIND_test_00", cfstore_find_test_00),
00523         Case("FIND_test_01", cfstore_find_test_01),
00524         Case("FIND_test_02", cfstore_find_test_02),
00525         Case("FIND_test_03_start", cfstore_utest_default_start),
00526         Case("FIND_test_03_end", cfstore_find_test_03_end),
00527         Case("FIND_test_04", cfstore_find_test_04),
00528         Case("FIND_test_05_start", cfstore_utest_default_start),
00529         Case("FIND_test_05_end", cfstore_find_test_05_end),
00530         Case("FIND_test_06_start", cfstore_utest_default_start),
00531         Case("FIND_test_06_end", cfstore_find_test_06_end),
00532         Case("FIND_test_07_start", cfstore_utest_default_start),
00533         Case("FIND_test_07_end", cfstore_find_test_07_end),
00534 };
00535 
00536 
00537 /* Declare your test specification with a custom setup handler */
00538 Specification specification(greentea_setup, cases);
00539 
00540 int main()
00541 {
00542     return !Harness::run(specification);
00543 }
00544 /// @endcond
00545