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