Add out of memory checks for set, hash table.

Author: fragglet

test/test-hash-table.c

@@ -89,6 +89,18 @@ void test_hash_table_new_free(void)
 	/* Free the hash table */
 
 	hash_table_free(hash_table);
+
+	/* Test out of memory scenario */
+
+	alloc_test_set_limit(0);
+	hash_table = hash_table_new(int_hash, int_equal);
+	assert(hash_table == NULL);
+	assert(alloc_test_get_allocated() == 0);
+
+	alloc_test_set_limit(8 * sizeof(void *));
+	hash_table = hash_table_new(int_hash, int_equal);
+	assert(hash_table == NULL);
+	assert(alloc_test_get_allocated() == 0);
 }
 
 /* Test insert and lookup functions */
@@ -367,13 +379,60 @@ void test_hash_table_free_functions(void)
 	assert(allocated_values == 0);
 }
 
+/* Test for out of memory scenario */
+
+void test_hash_table_out_of_memory(void)
+{
+	HashTable *hash_table;
+	int values[66];
+	int i;
+
+	hash_table = hash_table_new(int_hash, int_equal);
+
+	/* Test normal failure */
+
+	alloc_test_set_limit(0);
+	values[0] = 0;
+	assert(hash_table_insert(hash_table, &values[0], &values[0]) == 0);
+	assert(hash_table_num_entries(hash_table) == 0);
+
+	alloc_test_set_limit(-1);
+
+	/* Test failure when increasing table size.
+	 * The initial table size is 193 entries.  The table increases in
+	 * size when 1/3 full, so the 66th entry should cause the insert
+	 * to fail. */
+
+	for (i=0; i<65; ++i) {
+		values[i] = i;
+
+		assert(hash_table_insert(hash_table,
+		                         &values[i], &values[i]) != 0);
+		assert(hash_table_num_entries(hash_table) == i + 1);
+	}
+
+	assert(hash_table_num_entries(hash_table) == 65);
+
+	/* Test the 66th insert */
+
+	alloc_test_set_limit(0);
+
+	values[65] = 65;
+
+	assert(hash_table_insert(hash_table, &values[65], &values[65]) == 0);
+	assert(hash_table_num_entries(hash_table) == 65);
+
+	hash_table_free(hash_table);
+}
+
 static UnitTestFunction tests[] = {
 	test_hash_table_new_free,
 	test_hash_table_insert_lookup,
 	test_hash_table_remove,
 	test_hash_table_iterating,
 	test_hash_table_iterating_remove,
 	test_hash_table_free_functions,
+	test_hash_table_out_of_memory,
 	NULL
 };
 

test/test-set.c

@@ -87,6 +87,17 @@ void test_set_new_free(void)
 	/* Free the set */
 
 	set_free(set);
+
+	/* Test out of memory scenario */
+
+	alloc_test_set_limit(0);
+	set = set_new(int_hash, int_equal);
+	assert(set == NULL);
+
+	alloc_test_set_limit(7 * sizeof(void *));
+	set = set_new(int_hash, int_equal);
+	assert(set == NULL);
+	assert(alloc_test_get_allocated() == 0);
 }
 
 void test_set_insert(void)
@@ -446,6 +457,52 @@ void test_set_free_function(void)
 	assert(allocated_values == 0);
 }
 
+/* Test for out of memory scenario */
+
+void test_set_out_of_memory(void)
+{
+	Set *set;
+	int values[66];
+	int i;
+
+	set = set_new(int_hash, int_equal);
+
+	/* Test normal failure */
+
+	alloc_test_set_limit(0);
+	values[0] = 0;
+	assert(set_insert(set, &values[0]) == 0);
+	assert(set_num_entries(set) == 0);
+
+	alloc_test_set_limit(-1);
+
+	/* Test failure when increasing table size.
+	 * The initial table size is 193 entries.  The table increases in
+	 * size when 1/3 full, so the 66th entry should cause the insert
+	 * to fail. */
+
+	for (i=0; i<65; ++i) {
+		values[i] = i;
+
+		assert(set_insert(set, &values[i]) != 0);
+		assert(set_num_entries(set) == i + 1);
+	}
+
+	assert(set_num_entries(set) == 65);
+
+	/* Test the 66th insert */
+
+	alloc_test_set_limit(0);
+
+	values[65] = 65;
+
+	assert(set_insert(set, &values[65]) == 0);
+	assert(set_num_entries(set) == 65);
+
+	set_free(set);
+}
+
+
 static UnitTestFunction tests[] = {
 	test_set_new_free,
 	test_set_insert,
@@ -457,6 +514,7 @@ static UnitTestFunction tests[] = {
 	test_set_iterating_remove,
 	test_set_to_array,
 	test_set_free_function,
+	test_set_out_of_memory,
 	NULL
 };