epan/fifo_string_cache_test.c

   1 /* fifo_string_cache_test.c
   2  *
   3  * Wireshark - Network traffic analyzer
   4  * By Gerald Combs <gerald@wireshark.org>
   5  * Copyright 1998 Gerald Combs
   6  *
   7  * SPDX-License-Identifier: GPL-2.0-or-later
   8  */
   9
  10 #include "config.h"
  11 #undef G_DISABLE_ASSERT
  12
  13 #include <stdio.h>
  14 #include <string.h>
  15 #include <glib.h>
  16
  17 #include "fifo_string_cache.h"
  18
  19
  20 // Simple test of insertion and checking its true/false values
  21 static void
  22 test_fifo_string_cache_01(void)
  23 {
  24     fifo_string_cache_t fcache;
  25     bool has;
  26
  27     fifo_string_cache_init(&fcache, 10, NULL);
  28
  29     has = fifo_string_cache_insert(&fcache, "alpha");
  30     g_assert_false(has);
  31
  32     has = fifo_string_cache_insert(&fcache, "alpha");
  33     g_assert_true(has);
  34
  35     has = fifo_string_cache_insert(&fcache, "beta");
  36     g_assert_false(has);
  37
  38     has = fifo_string_cache_insert(&fcache, "beta");
  39     g_assert_true(has);
  40
  41     has = fifo_string_cache_insert(&fcache, "alpha");
  42     g_assert_true(has);
  43
  44     fifo_string_cache_free(&fcache);
  45 }
  46
  47 // Is the max_entries honored?
  48 static void
  49 test_fifo_string_cache_02(void)
  50 {
  51     fifo_string_cache_t fcache;
  52     bool has;
  53     fifo_string_cache_init(&fcache, 4, NULL);
  54
  55     // Insert 4 items
  56     has = fifo_string_cache_insert(&fcache, "alpha");
  57     g_assert_false(has);
  58     has = fifo_string_cache_insert(&fcache, "beta");
  59     g_assert_false(has);
  60     has = fifo_string_cache_insert(&fcache, "gamma");
  61     g_assert_false(has);
  62     has = fifo_string_cache_insert(&fcache, "delta");
  63     g_assert_false(has);
  64
  65     // They should all be there
  66     has = fifo_string_cache_contains(&fcache, "alpha");
  67     g_assert_true(has);
  68     has = fifo_string_cache_contains(&fcache, "beta");
  69     g_assert_true(has);
  70     has = fifo_string_cache_contains(&fcache, "gamma");
  71     g_assert_true(has);
  72     has = fifo_string_cache_contains(&fcache, "delta");
  73     g_assert_true(has);
  74
  75     // Add a 5th item
  76     has = fifo_string_cache_insert(&fcache, "epsilon");
  77     g_assert_false(has);
  78
  79     // The first one should no longer be there
  80     has = fifo_string_cache_contains(&fcache, "alpha");
  81     g_assert_false(has); // false
  82     has = fifo_string_cache_contains(&fcache, "beta");
  83     g_assert_true(has);
  84     has = fifo_string_cache_contains(&fcache, "gamma");
  85     g_assert_true(has);
  86     has = fifo_string_cache_contains(&fcache, "delta");
  87     g_assert_true(has);
  88     has = fifo_string_cache_contains(&fcache, "epsilon");
  89     g_assert_true(has);
  90
  91     // Add a 6th item
  92     has = fifo_string_cache_insert(&fcache, "zeta");
  93     g_assert_false(has);
  94
  95     // The first two should no longer be there
  96     has = fifo_string_cache_contains(&fcache, "alpha");
  97     g_assert_false(has); // false
  98     has = fifo_string_cache_contains(&fcache, "beta");
  99     g_assert_false(has); // false
 100     has = fifo_string_cache_contains(&fcache, "gamma");
 101     g_assert_true(has);
 102     has = fifo_string_cache_contains(&fcache, "delta");
 103     g_assert_true(has);
 104     has = fifo_string_cache_contains(&fcache, "epsilon");
 105     g_assert_true(has);
 106     has = fifo_string_cache_contains(&fcache, "zeta");
 107     g_assert_true(has);
 108
 109     fifo_string_cache_free(&fcache);
 110 }
 111
 112 // Check a max_entries == 1, to ensure we don't have any mistakes
 113 // at that end of the range
 114 static void
 115 test_fifo_string_cache_03(void)
 116 {
 117     fifo_string_cache_t fcache;
 118     bool has;
 119     fifo_string_cache_init(&fcache, 1, NULL);
 120
 121     // Insert
 122     has = fifo_string_cache_insert(&fcache, "alpha");
 123     g_assert_false(has);
 124
 125     // Check
 126     has = fifo_string_cache_contains(&fcache, "alpha");
 127     g_assert_true(has);
 128
 129     // Insert
 130     has = fifo_string_cache_insert(&fcache, "beta");
 131     g_assert_false(has);
 132
 133     // Check
 134     has = fifo_string_cache_contains(&fcache, "alpha");
 135     g_assert_false(has);
 136     has = fifo_string_cache_contains(&fcache, "beta");
 137     g_assert_true(has);
 138
 139     // Insert
 140     has = fifo_string_cache_insert(&fcache, "gamma");
 141     g_assert_false(has);
 142
 143     // Check
 144     has = fifo_string_cache_contains(&fcache, "alpha");
 145     g_assert_false(has);
 146     has = fifo_string_cache_contains(&fcache, "beta");
 147     g_assert_false(has);
 148     has = fifo_string_cache_contains(&fcache, "gamma");
 149     g_assert_true(has);
 150
 151     fifo_string_cache_free(&fcache);
 152 }
 153
 154 // Test an unbounded maximum (max_entries == 0)
 155 static void
 156 test_fifo_string_cache_04(void)
 157 {
 158     fifo_string_cache_t fcache;
 159     bool has;
 160     fifo_string_cache_init(&fcache, 0, g_free);
 161
 162     // Insert; we call g_strdup because in this test, the cache owns the string
 163     has = fifo_string_cache_insert(&fcache, g_strdup("alpha"));
 164     g_assert_false(has);
 165
 166     // Check
 167     has = fifo_string_cache_contains(&fcache, "alpha");
 168     g_assert_true(has);
 169
 170     // Insert; we call g_strdup because in this test, the cache owns the string
 171     has = fifo_string_cache_insert(&fcache, g_strdup("beta"));
 172     g_assert_false(has);
 173
 174     // Check
 175     has = fifo_string_cache_contains(&fcache, "alpha");
 176     g_assert_true(has);
 177     has = fifo_string_cache_contains(&fcache, "beta");
 178     g_assert_true(has);
 179
 180     // Insert many
 181     int i;
 182     char *s;
 183     for (i = 0; i < 1000 ; i++) {
 184         s = g_strdup_printf("%d", i);
 185         has = fifo_string_cache_insert(&fcache, s);
 186         g_assert_false(has);
 187     }
 188
 189     // Check everything
 190     has = fifo_string_cache_contains(&fcache, "alpha");
 191     g_assert_true(has);
 192     has = fifo_string_cache_contains(&fcache, "beta");
 193     g_assert_true(has);
 194     for (i = 0; i < 1000 ; i++) {
 195         s = g_strdup_printf("%d", i);
 196         has = fifo_string_cache_contains(&fcache, s);
 197         g_assert_true(has);
 198     }
 199     fifo_string_cache_free(&fcache);
 200 }
 201
 202 int
 203 main(int argc, char **argv)
 204 {
 205     int result;
 206
 207     g_test_init(&argc, &argv, NULL);
 208
 209     g_test_add_func("/fifo_string_cache/01",    test_fifo_string_cache_01);
 210     g_test_add_func("/fifo_string_cache/02",    test_fifo_string_cache_02);
 211     g_test_add_func("/fifo_string_cache/03",    test_fifo_string_cache_03);
 212     g_test_add_func("/fifo_string_cache/04",    test_fifo_string_cache_04);
 213
 214     result = g_test_run();
 215
 216     return result;
 217 }
 218
 219 /*
 220  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 221  *
 222  * Local variables:
 223  * c-basic-offset: 4
 224  * tab-width: 8
 225  * indent-tabs-mode: nil
 226  * End:
 227  *
 228  * vi: set shiftwidth=4 tabstop=8 expandtab:
 229  * :indentSize=4:tabSize=8:noTabs=true:
 230  */