test: switch to catch2 unit tests and add some functions

Added:
  - hashmap_empty()
  - hashmap_contains()
  - hashmap_iter_find()

Author: DavidLeeds

.github/workflows/ci.yml

@@ -2,9 +2,12 @@ name: CI
 
 on:
   push:
-    branches: [ master ]
+    branches: [master]
   pull_request:
-    branches: [ master ]
+    branches: [master]
+
+env:
+  BUILD_DIR: ${{ github.workspace }}/build
 
 jobs:
   build:
@@ -14,35 +17,29 @@ jobs:
       matrix:
         os: [ubuntu-latest]
         compiler: [gcc, clang]
-        build_type: [debug, release]
+        build_type: [Debug, Release]
+
     steps:
-    - uses: actions/checkout@v4
-    - name: install-clang
-      if: matrix.compiler == 'clang'
-      run: |
-        sudo apt-get install -y clang
-        sudo update-alternatives --remove-all cc
-        sudo update-alternatives --install /usr/bin/cc cc /usr/bin/clang 14
-    - name: configure-debug
-      if: matrix.build_type == 'debug'
-      run: |
-        mkdir build
-        cd build
-        cmake -DCMAKE_BUILD_TYPE=Debug -DHASHMAP_BUILD_TESTS=ON -DHASHMAP_BUILD_EXAMPLES=ON ${GITHUB_WORKSPACE}
-    - name: configure-release
-      if: matrix.build_type == 'release'
-      run: |
-        mkdir build
-        cd build
-        cmake -DCMAKE_BUILD_TYPE=Release -DHASHMAP_BUILD_TESTS=ON -DHASHMAP_BUILD_EXAMPLES=ON ${GITHUB_WORKSPACE}
-    - name: make
-      run: |
-        make VERBOSE=1 -C build
-    - name: install
-      run: |
-        cd build
-        sudo make install
-    - name: test
-      run: |
-        cd build
-        ctest --output-on-failure
+      - uses: actions/checkout@v4
+
+      - name: Create build directory
+        run: mkdir -p ${{ env.BUILD_DIR }}
+
+      - name: Install Clang
+        if: matrix.compiler == 'clang'
+        run: |
+          sudo apt-get install -y clang
+          sudo update-alternatives --remove-all cc
+          sudo update-alternatives --install /usr/bin/cc cc /usr/bin/clang 15
+
+      - name: Configure CMake
+        run: cmake -B ${{ env.BUILD_DIR }} -S ${{ github.workspace }} -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DHASHMAP_BUILD_TESTS=ON -DHASHMAP_BUILD_EXAMPLES=ON
+
+      - name: Build
+        run: cmake --build ${{ env.BUILD_DIR }} --config ${{ matrix.build_type }}
+
+      - name: Install
+        run: sudo cmake --install ${{ env.BUILD_DIR }} --config ${{ matrix.build_type }}
+
+      - name: Test
+        run: ctest --output-on-failure --test-dir ${{ env.BUILD_DIR }}

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.5)
 project(hashmap VERSION 2.0.0 LANGUAGES C)
 
-set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD 11)
 
 ##############################################
 # Build options
@@ -108,7 +108,7 @@ export(PACKAGE HashMap)
 
 if(HASHMAP_BUILD_TESTS)
     enable_testing()
-    add_subdirectory(test)
+    add_subdirectory(tests)
 endif()
 
 ##############################################

examples/CMakeLists.txt

@@ -2,6 +2,6 @@ cmake_minimum_required(VERSION 3.5)
 
 # Hashmap example
 add_executable(hashmap_example hashmap_example.c)
-target_compile_options(hashmap_example PRIVATE $<$<C_COMPILER_ID:GNU>:-Wall -Werror>)
+target_compile_options(hashmap_example PRIVATE -Wall -Werror)
 target_link_libraries(hashmap_example PRIVATE HashMap::HashMap)
 

include/hashmap.h

@@ -153,14 +153,23 @@ extern "C" {
 } while (0)
 
 /*
- * Return the number of entries in the hash map.
+ * Return the number of entries in the hashmap.
  *
  * Parameters:
  *   const HASHMAP(<key_type>, <data_type>) *h - hashmap pointer
  */
 #define hashmap_size(h)                                                 \
     ((typeof((h)->map_base.size))(h)->map_base.size)
 
+/*
+ * Return true if the hashmap is empty.
+ *
+ * Parameters:
+ *   const HASHMAP(<key_type>, <data_type>) *h - hashmap pointer
+ */
+#define hashmap_empty(h)                                                \
+    (hashmap_size(h) == 0)
+
 /*
  * Set the hashmap's initial allocation size such that no rehashes are
  * required to fit the specified number of entries.
@@ -174,6 +183,17 @@ extern "C" {
 #define hashmap_reserve(h, capacity)                                    \
     hashmap_base_reserve(&(h)->map_base, capacity)
 
+/*
+ * Get the hashmap's present allocation size.
+ *
+ * Parameters:
+ *   HASHMAP(<key_type>, <data_type>) *h - hashmap pointer
+ *
+ * Returns 0 on success, or -errno on failure.
+ */
+#define hashmap_capacity(h)                                             \
+    ((typeof((h)->map_base.table_size))(h)->map_base.table_size)
+
 /*
  * Add a new entry to the hashmap. If an entry with a matching key
  * already exists -EEXIST is returned.
@@ -205,6 +225,15 @@ extern "C" {
     (typeof((h)->map_types->t_data))hashmap_base_get(&(h)->map_base, (const void *)__map_key); \
 })
 
+/*
+ * Return true if the hashmap contains an entry with the specified key.
+ *
+ * Parameters:
+ *   const HASHMAP(<key_type>, <data_type>) *h - hashmap pointer
+ */
+#define hashmap_contains(h, key)                                        \
+    (hashmap_get(h, key) != NULL)
+
 /*
  * Remove an entry with the specified key from the map.
  *
@@ -271,6 +300,20 @@ extern "C" {
 #define hashmap_iter_next(iter)                                         \
     hashmap_base_iter_next((iter)->iter_map, &(iter)->iter_pos)
 
+/*
+ * Do a constant-time lookup of a hashmap entry and return an iterator to it.
+ * This provides an efficient way to access and remove an entry without
+ * performing two lookups.
+ *
+ * Parameters:
+ *   HASHMAP(<key_type>, <data_type>) *h - hashmap pointer
+ *   <key_type> *key - pointer to the key to lookup
+ *
+ * Returns a valid iterator if the key exists, otherwise an invalid iterator.
+ */
+#define hashmap_iter_find(h, key)                                       \
+    ((HASHMAP_ITER(*(h))){ &(h)->map_base, hashmap_base_iter_find(&(h)->map_base, key) })
+
 /*
  * Remove the hashmap entry pointed to by this iterator and advance the
  * iterator to the next entry.

include/hashmap_base.h

@@ -27,7 +27,7 @@ void hashmap_base_init(struct hashmap_base *hb,
 void hashmap_base_cleanup(struct hashmap_base *hb);
 
 void hashmap_base_set_key_alloc_funcs(struct hashmap_base *hb,
-    void *(*key_dup_func)(const void *), void (*key_free_func)(void *));
+        void *(*key_dup_func)(const void *), void (*key_free_func)(void *));
 
 int hashmap_base_reserve(struct hashmap_base *hb, size_t capacity);
 
@@ -42,6 +42,7 @@ struct hashmap_entry *hashmap_base_iter(const struct hashmap_base *hb,
         const struct hashmap_entry *pos);
 bool hashmap_base_iter_valid(const struct hashmap_base *hb, const struct hashmap_entry *iter);
 bool hashmap_base_iter_next(const struct hashmap_base *hb, struct hashmap_entry **iter);
+struct hashmap_entry *hashmap_base_iter_find(const struct hashmap_base *hb, const void *key);
 bool hashmap_base_iter_remove(struct hashmap_base *hb, struct hashmap_entry **iter);
 const void *hashmap_base_iter_get_key(const struct hashmap_entry *iter);
 void *hashmap_base_iter_get_data(const struct hashmap_entry *iter);
@@ -55,4 +56,3 @@ double hashmap_base_collisions_variance(const struct hashmap_base *hb);
 size_t hashmap_hash_default(const void *data, size_t len);
 size_t hashmap_hash_string(const char *key);
 size_t hashmap_hash_string_i(const char *key);
-

src/hashmap.c

@@ -77,7 +77,7 @@ static inline size_t hashmap_calc_index(const struct hashmap_base *hb, const voi
 static struct hashmap_entry *hashmap_entry_get_populated(const struct hashmap_base *hb,
         const struct hashmap_entry *entry)
 {
-    if (hb->size > 0) {
+    if (hb->size > 0 && entry >= hb->table) {
         for (; entry < &hb->table[hb->table_size]; ++entry) {
             if (entry->key) {
                 return (struct hashmap_entry *)entry;
@@ -119,7 +119,7 @@ static struct hashmap_entry *hashmap_entry_find(const struct hashmap_base *hb,
 
 /*
  * Removes the specified entry and processes the following entries to
- * keep the chain contiguous. This is a required step for hash maps
+ * keep the chain contiguous. This is a required step for hashmaps
  * using linear probing.
  */
 static void hashmap_entry_remove(struct hashmap_base *hb, struct hashmap_entry *removed_entry)
@@ -134,6 +134,7 @@ static void hashmap_entry_remove(struct hashmap_base *hb, struct hashmap_entry *
     if (hb->key_free) {
         hb->key_free(removed_entry->key);
     }
+
     --hb->size;
 
     /* Fill the free slot in the chain */
@@ -183,12 +184,8 @@ static int hashmap_rehash(struct hashmap_base *hb, size_t table_size)
     hb->table_size = table_size;
     hb->table = new_table;
 
-    if (!old_table) {
-        return 0;
-    }
-
     /* Rehash */
-    for (entry = old_table; entry < &old_table[old_size]; ++entry) {
+    for (entry = old_table; entry < old_table + old_size; ++entry) {
         if (!entry->key) {
             continue;
         }
@@ -436,7 +433,7 @@ struct hashmap_entry *hashmap_base_iter(const struct hashmap_base *hb,
  */
 bool hashmap_base_iter_valid(const struct hashmap_base *hb, const struct hashmap_entry *iter)
 {
-    return hb && iter && iter->key && iter >= hb->table && iter < &hb->table[hb->table_size];
+    return hb && iter && iter->key && iter >= hb->table && iter < hb->table + hb->table_size;
 }
 
 /*
@@ -451,6 +448,18 @@ bool hashmap_base_iter_next(const struct hashmap_base *hb, struct hashmap_entry
     return (*iter = hashmap_entry_get_populated(hb, *iter + 1)) != NULL;
 }
 
+/*
+ * Returns an iterator to the hashmap entry with the specified key.
+ * Returns NULL if there is no matching entry.
+ */
+struct hashmap_entry *hashmap_base_iter_find(const struct hashmap_base *hb, const void *key)
+{
+    if (!key) {
+        return NULL;
+    }
+    return hashmap_entry_find(hb, key, false);
+}
+
 /*
  * Remove the hashmap entry pointed to by this iterator and advance the
  * iterator to the next entry.