Use constants for the number of test values.

Author: fragglet

test/test-avl-tree.c

@@ -28,7 +28,9 @@ CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include "avl-tree.h"
 #include "compare-int.h"
 
-int test_array[1000];
+#define NUM_TEST_VALUES 1000
+
+int test_array[NUM_TEST_VALUES];
 
 #if 0
 /* Tree print function - useful for debugging. */
@@ -161,7 +163,7 @@ AVLTree *create_tree(void)
 
 	tree = avl_tree_new((AVLTreeCompareFunc) int_compare);
 
-	for (i=0; i<1000; ++i) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
 		test_array[i] = i;
 		avl_tree_insert(tree, &test_array[i], &test_array[i]);
 	}
@@ -203,7 +205,7 @@ void test_avl_tree_insert_lookup(void)
 
 	tree = avl_tree_new((AVLTreeCompareFunc) int_compare);
 
-	for (i=0; i<1000; ++i) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
 		test_array[i] = i;
 		avl_tree_insert(tree, &test_array[i], &test_array[i]);
 
@@ -215,7 +217,7 @@ void test_avl_tree_insert_lookup(void)
 
 	/* Check that all values can be read back again */
 
-	for (i=0; i<1000; ++i) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
 		node = avl_tree_lookup_node(tree, &i);
 		assert(node != NULL);
 		value = avl_tree_node_key(node);
@@ -228,7 +230,7 @@ void test_avl_tree_insert_lookup(void)
 
 	i = -1;
 	assert(avl_tree_lookup_node(tree, &i) == NULL);
-	i = 100000;
+	i = NUM_TEST_VALUES + 100;
 	assert(avl_tree_lookup_node(tree, &i) == NULL);
 
 	avl_tree_free(tree);
@@ -327,7 +329,7 @@ void test_avl_tree_lookup(void)
 
 	tree = create_tree();
 
-	for (i=0; i<1000; ++i) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
 		value = avl_tree_lookup(tree, &i);
 
 		assert(value != NULL);
@@ -338,7 +340,7 @@ void test_avl_tree_lookup(void)
 
 	i = -1;
 	assert(avl_tree_lookup(tree, &i) == NULL);
-	i = 1001;
+	i = NUM_TEST_VALUES + 1;
 	assert(avl_tree_lookup(tree, &i) == NULL);
 	i = 8724897;
 	assert(avl_tree_lookup(tree, &i) == NULL);
@@ -358,14 +360,14 @@ void test_avl_tree_remove(void)
 
 	/* Try removing invalid entries */
 
-	i = 100000;
+	i = NUM_TEST_VALUES + 100;
 	assert(avl_tree_remove(tree, &i) == 0);
 	i = -1;
 	assert(avl_tree_remove(tree, &i) == 0);
 
 	/* Delete the nodes from the tree */
 
-	expected_entries = 1000;
+	expected_entries = NUM_TEST_VALUES;
 
 	/* This looping arrangement causes nodes to be removed in a 
 	 * randomish fashion from all over the tree. */

test/test-binary-heap.c

@@ -27,14 +27,16 @@ CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include "binary-heap.h"
 #include "compare-int.h"
 
-int test_array[1000];
+#define NUM_TEST_VALUES 10000
+
+int test_array[NUM_TEST_VALUES];
 
 void test_binary_heap_new_free(void)
 {
 	BinaryHeap *heap;
 	int i;
 
-	for (i=0; i<1000; ++i) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
 		heap = binary_heap_new(BINARY_HEAP_TYPE_MIN, int_compare);
 		binary_heap_free(heap);
 	}
@@ -57,12 +59,12 @@ void test_binary_heap_insert(void)
 
 	heap = binary_heap_new(BINARY_HEAP_TYPE_MIN, int_compare);
 
-	for (i=0; i<1000; ++i) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
 		test_array[i] = i;
 		assert(binary_heap_insert(heap, &test_array[i]) != 0);
 	}
 
-	assert(binary_heap_num_entries(heap) == 1000);
+	assert(binary_heap_num_entries(heap) == NUM_TEST_VALUES);
 
 	binary_heap_free(heap);
 }
@@ -77,7 +79,7 @@ void test_min_heap(void)
 
 	/* Push a load of values onto the heap */
 
-	for (i=0; i<1000; ++i) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
 		test_array[i] = i;
 		assert(binary_heap_insert(heap, &test_array[i]) != 0);
 	}
@@ -110,14 +112,14 @@ void test_max_heap(void)
 
 	/* Push a load of values onto the heap */
 
-	for (i=0; i<1000; ++i) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
 		test_array[i] = i;
 		assert(binary_heap_insert(heap, &test_array[i]) != 0);
 	}
 
 	/* Pop values off the heap and check they are in order */
 
-	i = 1000;
+	i = NUM_TEST_VALUES;
 	while (binary_heap_num_entries(heap) > 0) {
 		val = (int *) binary_heap_pop(heap);
 

test/test-binomial-heap.c

@@ -27,23 +27,25 @@ CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include "binomial-heap.h"
 #include "compare-int.h"
 
-int test_array[1000];
+#define NUM_TEST_VALUES 10000
+
+int test_array[NUM_TEST_VALUES];
 
 void test_binomial_heap_new_free(void)
 {
 	BinomialHeap *heap;
 	int i;
 
-	for (i=0; i<1000; ++i) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
 		heap = binomial_heap_new(BINOMIAL_HEAP_TYPE_MIN, int_compare);
 		binomial_heap_free(heap);
 	}
 
-        /* Test for out of memory */
+	/* Test for out of memory */
 
-        alloc_test_set_limit(0);
+	alloc_test_set_limit(0);
 
-        assert(binomial_heap_new(BINOMIAL_HEAP_TYPE_MIN, int_compare) == NULL);
+	assert(binomial_heap_new(BINOMIAL_HEAP_TYPE_MIN, int_compare) == NULL);
 }
 
 void test_binomial_heap_insert(void)
@@ -53,16 +55,16 @@ void test_binomial_heap_insert(void)
 
 	heap = binomial_heap_new(BINOMIAL_HEAP_TYPE_MIN, int_compare);
 
-	for (i=0; i<1000; ++i) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
 		test_array[i] = i;
 		assert(binomial_heap_insert(heap, &test_array[i]) != 0);
 	}
-	assert(binomial_heap_num_entries(heap) == 1000);
+	assert(binomial_heap_num_entries(heap) == NUM_TEST_VALUES);
 
-        /* Test for out of memory */
+	/* Test for out of memory */
 
-        alloc_test_set_limit(0);
-        assert(binomial_heap_insert(heap, &i) == 0);
+	alloc_test_set_limit(0);
+	assert(binomial_heap_insert(heap, &i) == 0);
 
 	binomial_heap_free(heap);
 }
@@ -77,7 +79,7 @@ void test_min_heap(void)
 
 	/* Push a load of values onto the heap */
 
-	for (i=0; i<1000; ++i) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
 		test_array[i] = i;
 		assert(binomial_heap_insert(heap, &test_array[i]) != 0);
 	}
@@ -92,10 +94,10 @@ void test_min_heap(void)
 		i = *val;
 	}
 
-        /* Test pop on an empty heap */
+	/* Test pop on an empty heap */
 
-        val = (int *) binomial_heap_pop(heap);
-        assert(val == NULL);
+	val = (int *) binomial_heap_pop(heap);
+	assert(val == NULL);
 
 	binomial_heap_free(heap);
 }
@@ -110,29 +112,31 @@ void test_max_heap(void)
 
 	/* Push a load of values onto the heap */
 
-	for (i=0; i<1000; ++i) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
 		test_array[i] = i;
 		assert(binomial_heap_insert(heap, &test_array[i]) != 0);
 	}
 
 	/* Pop values off the heap and check they are in order */
 
-	i = 1000;
+	i = NUM_TEST_VALUES;
 	while (binomial_heap_num_entries(heap) > 0) {
 		val = (int *) binomial_heap_pop(heap);
 
 		assert(*val == i - 1);
 		i = *val;
 	}
 
-        /* Test pop on an empty heap */
+	/* Test pop on an empty heap */
 
-        val = (int *) binomial_heap_pop(heap);
-        assert(val == NULL);
+	val = (int *) binomial_heap_pop(heap);
+	assert(val == NULL);
 
 	binomial_heap_free(heap);
 }
 
+#define TEST_VALUE (NUM_TEST_VALUES / 2)
+
 static BinomialHeap *generate_heap(void)
 {
 	BinomialHeap *heap;
@@ -142,9 +146,9 @@ static BinomialHeap *generate_heap(void)
 
 	/* Push a load of values onto the heap */
 
-	for (i=0; i<1000; ++i) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
 		test_array[i] = i;
-		if (i != 400) {
+		if (i != TEST_VALUE) {
 			assert(binomial_heap_insert(heap, &test_array[i]) != 0);
 		}
 	}
@@ -162,10 +166,10 @@ static void verify_heap(BinomialHeap *heap)
 	int i;
 
 	numvals = binomial_heap_num_entries(heap);
-	assert(numvals == 999);
+	assert(numvals == NUM_TEST_VALUES - 1);
 
-	for (i=0; i<1000; ++i) {
-		if (i == 400) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
+		if (i == TEST_VALUE) {
 			continue;
 		}
 
@@ -197,8 +201,9 @@ static void test_insert_out_of_memory(void)
 		/* Insert should fail */
 
 		alloc_test_set_limit(i);
-		test_array[400] = 400;
-		assert(binomial_heap_insert(heap, &test_array[400]) == 0);
+		test_array[TEST_VALUE] = TEST_VALUE;
+		assert(binomial_heap_insert(heap,
+		                            &test_array[TEST_VALUE]) == 0);
 		alloc_test_set_limit(-1);
 
 		/* Check that the heap is unharmed */

test/test-hash-functions.c

@@ -29,41 +29,43 @@ CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include "hash-int.h"
 #include "hash-string.h"
 
+#define NUM_TEST_VALUES 200
+
 void test_pointer_hash(void)
 {
-	int array[10];
+	int array[NUM_TEST_VALUES];
 	int i, j;
 
 	/* Initialise the array to all zeros */
 
-	for (i=0; i<10; ++i) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
 		array[i] = 0;
 	}
 
 	/* Check hashes are never the same */
 
-	for (i=0; i<10; ++i) {
-		for (j=i+1; j<10; ++j) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
+		for (j=i+1; j<NUM_TEST_VALUES; ++j) {
 			assert(pointer_hash(&array[i]) != pointer_hash(&array[j]));
 		}
 	}
 }
 
 void test_int_hash(void)
 {
-	int array[100];
+	int array[NUM_TEST_VALUES];
 	int i, j;
 
 	/* Initialise all entries in the array */
 
-	for (i=0; i<100; ++i) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
 		array[i] = i;
 	}
 
 	/* Check hashes are never the same */
 
-	for (i=0; i<100; ++i) {
-		for (j=i+1; j<100; ++j) {
+	for (i=0; i<NUM_TEST_VALUES; ++i) {
+		for (j=i+1; j<NUM_TEST_VALUES; ++j) {
 			assert(int_hash(&array[i]) != int_hash(&array[j]));
 		}
 	}