File:  [Qemu by Fabrice Bellard] / qemu / check-qdict.c
Revision 1.1.1.2 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:24:11 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu0150, qemu0141, qemu0140, qemu0130, HEAD
qemu 0.13.0

    1: /*
    2:  * QDict unit-tests.
    3:  *
    4:  * Copyright (C) 2009 Red Hat Inc.
    5:  *
    6:  * Authors:
    7:  *  Luiz Capitulino <lcapitulino@redhat.com>
    8:  *
    9:  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
   10:  * See the COPYING.LIB file in the top-level directory.
   11:  */
   12: #include <check.h>
   13: 
   14: #include "qint.h"
   15: #include "qdict.h"
   16: #include "qstring.h"
   17: #include "qemu-common.h"
   18: 
   19: /*
   20:  * Public Interface test-cases
   21:  *
   22:  * (with some violations to access 'private' data)
   23:  */
   24: 
   25: START_TEST(qdict_new_test)
   26: {
   27:     QDict *qdict;
   28: 
   29:     qdict = qdict_new();
   30:     fail_unless(qdict != NULL);
   31:     fail_unless(qdict_size(qdict) == 0);
   32:     fail_unless(qdict->base.refcnt == 1);
   33:     fail_unless(qobject_type(QOBJECT(qdict)) == QTYPE_QDICT);
   34: 
   35:     // destroy doesn't exit yet
   36:     free(qdict);
   37: }
   38: END_TEST
   39: 
   40: START_TEST(qdict_put_obj_test)
   41: {
   42:     QInt *qi;
   43:     QDict *qdict;
   44:     QDictEntry *ent;
   45:     const int num = 42;
   46: 
   47:     qdict = qdict_new();
   48: 
   49:     // key "" will have tdb hash 12345
   50:     qdict_put_obj(qdict, "", QOBJECT(qint_from_int(num)));
   51: 
   52:     fail_unless(qdict_size(qdict) == 1);
   53:     ent = QLIST_FIRST(&qdict->table[12345 % QDICT_BUCKET_MAX]);
   54:     qi = qobject_to_qint(ent->value);
   55:     fail_unless(qint_get_int(qi) == num);
   56: 
   57:     // destroy doesn't exit yet
   58:     QDECREF(qi);
   59:     qemu_free(ent->key);
   60:     qemu_free(ent);
   61:     qemu_free(qdict);
   62: }
   63: END_TEST
   64: 
   65: START_TEST(qdict_destroy_simple_test)
   66: {
   67:     QDict *qdict;
   68: 
   69:     qdict = qdict_new();
   70:     qdict_put_obj(qdict, "num", QOBJECT(qint_from_int(0)));
   71:     qdict_put_obj(qdict, "str", QOBJECT(qstring_from_str("foo")));
   72: 
   73:     QDECREF(qdict);
   74: }
   75: END_TEST
   76: 
   77: static QDict *tests_dict = NULL;
   78: 
   79: static void qdict_setup(void)
   80: {
   81:     tests_dict = qdict_new();
   82:     fail_unless(tests_dict != NULL);
   83: }
   84: 
   85: static void qdict_teardown(void)
   86: {
   87:     QDECREF(tests_dict);
   88:     tests_dict = NULL;
   89: }
   90: 
   91: START_TEST(qdict_get_test)
   92: {
   93:     QInt *qi;
   94:     QObject *obj;
   95:     const int value = -42;
   96:     const char *key = "test";
   97: 
   98:     qdict_put(tests_dict, key, qint_from_int(value));
   99: 
  100:     obj = qdict_get(tests_dict, key);
  101:     fail_unless(obj != NULL);
  102: 
  103:     qi = qobject_to_qint(obj);
  104:     fail_unless(qint_get_int(qi) == value);
  105: }
  106: END_TEST
  107: 
  108: START_TEST(qdict_get_int_test)
  109: {
  110:     int ret;
  111:     const int value = 100;
  112:     const char *key = "int";
  113: 
  114:     qdict_put(tests_dict, key, qint_from_int(value));
  115: 
  116:     ret = qdict_get_int(tests_dict, key);
  117:     fail_unless(ret == value);
  118: }
  119: END_TEST
  120: 
  121: START_TEST(qdict_get_try_int_test)
  122: {
  123:     int ret;
  124:     const int value = 100;
  125:     const char *key = "int";
  126: 
  127:     qdict_put(tests_dict, key, qint_from_int(value));
  128: 
  129:     ret = qdict_get_try_int(tests_dict, key, 0);
  130:     fail_unless(ret == value);
  131: }
  132: END_TEST
  133: 
  134: START_TEST(qdict_get_str_test)
  135: {
  136:     const char *p;
  137:     const char *key = "key";
  138:     const char *str = "string";
  139: 
  140:     qdict_put(tests_dict, key, qstring_from_str(str));
  141: 
  142:     p = qdict_get_str(tests_dict, key);
  143:     fail_unless(p != NULL);
  144:     fail_unless(strcmp(p, str) == 0);
  145: }
  146: END_TEST
  147: 
  148: START_TEST(qdict_get_try_str_test)
  149: {
  150:     const char *p;
  151:     const char *key = "key";
  152:     const char *str = "string";
  153: 
  154:     qdict_put(tests_dict, key, qstring_from_str(str));
  155: 
  156:     p = qdict_get_try_str(tests_dict, key);
  157:     fail_unless(p != NULL);
  158:     fail_unless(strcmp(p, str) == 0);
  159: }
  160: END_TEST
  161: 
  162: START_TEST(qdict_haskey_not_test)
  163: {
  164:     fail_unless(qdict_haskey(tests_dict, "test") == 0);
  165: }
  166: END_TEST
  167: 
  168: START_TEST(qdict_haskey_test)
  169: {
  170:     const char *key = "test";
  171: 
  172:     qdict_put(tests_dict, key, qint_from_int(0));
  173:     fail_unless(qdict_haskey(tests_dict, key) == 1);
  174: }
  175: END_TEST
  176: 
  177: START_TEST(qdict_del_test)
  178: {
  179:     const char *key = "key test";
  180: 
  181:     qdict_put(tests_dict, key, qstring_from_str("foo"));
  182:     fail_unless(qdict_size(tests_dict) == 1);
  183: 
  184:     qdict_del(tests_dict, key);
  185: 
  186:     fail_unless(qdict_size(tests_dict) == 0);
  187:     fail_unless(qdict_haskey(tests_dict, key) == 0);
  188: }
  189: END_TEST
  190: 
  191: START_TEST(qobject_to_qdict_test)
  192: {
  193:     fail_unless(qobject_to_qdict(QOBJECT(tests_dict)) == tests_dict);
  194: }
  195: END_TEST
  196: 
  197: START_TEST(qdict_iterapi_test)
  198: {
  199:     int count;
  200:     const QDictEntry *ent;
  201: 
  202:     fail_unless(qdict_first(tests_dict) == NULL);
  203: 
  204:     qdict_put(tests_dict, "key1", qint_from_int(1));
  205:     qdict_put(tests_dict, "key2", qint_from_int(2));
  206:     qdict_put(tests_dict, "key3", qint_from_int(3));
  207: 
  208:     count = 0;
  209:     for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){
  210:         fail_unless(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1);
  211:         count++;
  212:     }
  213: 
  214:     fail_unless(count == qdict_size(tests_dict));
  215: 
  216:     /* Do it again to test restarting */
  217:     count = 0;
  218:     for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){
  219:         fail_unless(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1);
  220:         count++;
  221:     }
  222: 
  223:     fail_unless(count == qdict_size(tests_dict));
  224: }
  225: END_TEST
  226: 
  227: /*
  228:  * Errors test-cases
  229:  */
  230: 
  231: START_TEST(qdict_put_exists_test)
  232: {
  233:     int value;
  234:     const char *key = "exists";
  235: 
  236:     qdict_put(tests_dict, key, qint_from_int(1));
  237:     qdict_put(tests_dict, key, qint_from_int(2));
  238: 
  239:     value = qdict_get_int(tests_dict, key);
  240:     fail_unless(value == 2);
  241: 
  242:     fail_unless(qdict_size(tests_dict) == 1);
  243: }
  244: END_TEST
  245: 
  246: START_TEST(qdict_get_not_exists_test)
  247: {
  248:     fail_unless(qdict_get(tests_dict, "foo") == NULL);
  249: }
  250: END_TEST
  251: 
  252: /*
  253:  * Stress test-case
  254:  *
  255:  * This is a lot big for a unit-test, but there is no other place
  256:  * to have it.
  257:  */
  258: 
  259: static void remove_dots(char *string)
  260: {
  261:     char *p = strchr(string, ':');
  262:     if (p)
  263:         *p = '\0';
  264: }
  265: 
  266: static QString *read_line(FILE *file, char *key)
  267: {
  268:     char value[128];
  269: 
  270:     if (fscanf(file, "%s%s", key, value) == EOF)
  271:         return NULL;
  272:     remove_dots(key);
  273:     return qstring_from_str(value);
  274: }
  275: 
  276: #define reset_file(file)    fseek(file, 0L, SEEK_SET)
  277: 
  278: START_TEST(qdict_stress_test)
  279: {
  280:     size_t lines;
  281:     char key[128];
  282:     FILE *test_file;
  283:     QDict *qdict;
  284:     QString *value;
  285:     const char *test_file_path = "qdict-test-data.txt";
  286: 
  287:     test_file = fopen(test_file_path, "r");
  288:     fail_unless(test_file != NULL);
  289: 
  290:     // Create the dict
  291:     qdict = qdict_new();
  292:     fail_unless(qdict != NULL);
  293: 
  294:     // Add everything from the test file
  295:     for (lines = 0;; lines++) {
  296:         value = read_line(test_file, key);
  297:         if (!value)
  298:             break;
  299: 
  300:         qdict_put(qdict, key, value);
  301:     }
  302:     fail_unless(qdict_size(qdict) == lines);
  303: 
  304:     // Check if everything is really in there
  305:     reset_file(test_file);
  306:     for (;;) {
  307:         const char *str1, *str2;
  308: 
  309:         value = read_line(test_file, key);
  310:         if (!value)
  311:             break;
  312: 
  313:         str1 = qstring_get_str(value);
  314: 
  315:         str2 = qdict_get_str(qdict, key);
  316:         fail_unless(str2 != NULL);
  317: 
  318:         fail_unless(strcmp(str1, str2) == 0);
  319: 
  320:         QDECREF(value);
  321:     }
  322: 
  323:     // Delete everything
  324:     reset_file(test_file);
  325:     for (;;) {
  326:         value = read_line(test_file, key);
  327:         if (!value)
  328:             break;
  329: 
  330:         qdict_del(qdict, key);
  331:         QDECREF(value);
  332: 
  333:         fail_unless(qdict_haskey(qdict, key) == 0);
  334:     }
  335:     fclose(test_file);
  336: 
  337:     fail_unless(qdict_size(qdict) == 0);
  338:     QDECREF(qdict);
  339: }
  340: END_TEST
  341: 
  342: static Suite *qdict_suite(void)
  343: {
  344:     Suite *s;
  345:     TCase *qdict_public_tcase;
  346:     TCase *qdict_public2_tcase;
  347:     TCase *qdict_stress_tcase;
  348:     TCase *qdict_errors_tcase;
  349: 
  350:     s = suite_create("QDict test-suite");
  351: 
  352:     qdict_public_tcase = tcase_create("Public Interface");
  353:     suite_add_tcase(s, qdict_public_tcase);
  354:     tcase_add_test(qdict_public_tcase, qdict_new_test);
  355:     tcase_add_test(qdict_public_tcase, qdict_put_obj_test);
  356:     tcase_add_test(qdict_public_tcase, qdict_destroy_simple_test);
  357: 
  358:     /* Continue, but now with fixtures */
  359:     qdict_public2_tcase = tcase_create("Public Interface (2)");
  360:     suite_add_tcase(s, qdict_public2_tcase);
  361:     tcase_add_checked_fixture(qdict_public2_tcase, qdict_setup, qdict_teardown);
  362:     tcase_add_test(qdict_public2_tcase, qdict_get_test);
  363:     tcase_add_test(qdict_public2_tcase, qdict_get_int_test);
  364:     tcase_add_test(qdict_public2_tcase, qdict_get_try_int_test);
  365:     tcase_add_test(qdict_public2_tcase, qdict_get_str_test);
  366:     tcase_add_test(qdict_public2_tcase, qdict_get_try_str_test);
  367:     tcase_add_test(qdict_public2_tcase, qdict_haskey_not_test);
  368:     tcase_add_test(qdict_public2_tcase, qdict_haskey_test);
  369:     tcase_add_test(qdict_public2_tcase, qdict_del_test);
  370:     tcase_add_test(qdict_public2_tcase, qobject_to_qdict_test);
  371:     tcase_add_test(qdict_public2_tcase, qdict_iterapi_test);
  372: 
  373:     qdict_errors_tcase = tcase_create("Errors");
  374:     suite_add_tcase(s, qdict_errors_tcase);
  375:     tcase_add_checked_fixture(qdict_errors_tcase, qdict_setup, qdict_teardown);
  376:     tcase_add_test(qdict_errors_tcase, qdict_put_exists_test);
  377:     tcase_add_test(qdict_errors_tcase, qdict_get_not_exists_test);
  378: 
  379:     /* The Big one */
  380:     qdict_stress_tcase = tcase_create("Stress Test");
  381:     suite_add_tcase(s, qdict_stress_tcase);
  382:     tcase_add_test(qdict_stress_tcase, qdict_stress_test);
  383: 
  384:     return s;
  385: }
  386: 
  387: int main(void)
  388: {
  389: 	int nf;
  390: 	Suite *s;
  391: 	SRunner *sr;
  392: 
  393: 	s = qdict_suite();
  394: 	sr = srunner_create(s);
  395: 
  396: 	srunner_run_all(sr, CK_NORMAL);
  397: 	nf = srunner_ntests_failed(sr);
  398: 	srunner_free(sr);
  399: 
  400: 	return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
  401: }

unix.superglobalmegacorp.com