1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
/* $Id$ */
/*
* Copyright (C)2003-2006 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "test.h"
/* To prevent warning about "translation unit is empty"
* when this test is disabled.
*/
int dummy_fifobuf_test;
#if INCLUDE_FIFOBUF_TEST
#include <pjlib.h>
int fifobuf_test()
{
enum { SIZE = 1024, MAX_ENTRIES = 128,
MIN_SIZE = 4, MAX_SIZE = 64,
LOOP=10000 };
pj_pool_t *pool;
pj_fifobuf_t fifo;
unsigned available = SIZE;
void *entries[MAX_ENTRIES];
void *buffer;
int i;
pool = pj_pool_create(mem, NULL, SIZE+256, 0, NULL);
if (!pool)
return -10;
buffer = pj_pool_alloc(pool, SIZE);
if (!buffer)
return -20;
pj_fifobuf_init (&fifo, buffer, SIZE);
// Test 1
for (i=0; i<LOOP*MAX_ENTRIES; ++i) {
int size;
int c, f;
c = i%2;
f = (i+1)%2;
do {
size = MIN_SIZE+(pj_rand() % MAX_SIZE);
entries[c] = pj_fifobuf_alloc (&fifo, size);
} while (entries[c] == 0);
if ( i!=0) {
pj_fifobuf_free(&fifo, entries[f]);
}
}
if (entries[(i+1)%2])
pj_fifobuf_free(&fifo, entries[(i+1)%2]);
if (pj_fifobuf_max_size(&fifo) < SIZE-4) {
pj_assert(0);
return -1;
}
// Test 2
entries[0] = pj_fifobuf_alloc (&fifo, MIN_SIZE);
if (!entries[0]) return -1;
for (i=0; i<LOOP*MAX_ENTRIES; ++i) {
int size = MIN_SIZE+(pj_rand() % MAX_SIZE);
entries[1] = pj_fifobuf_alloc (&fifo, size);
if (entries[1])
pj_fifobuf_unalloc(&fifo, entries[1]);
}
pj_fifobuf_unalloc(&fifo, entries[0]);
if (pj_fifobuf_max_size(&fifo) < SIZE-4) {
pj_assert(0);
return -2;
}
// Test 3
for (i=0; i<LOOP; ++i) {
int count, j;
for (count=0; available>=MIN_SIZE+4 && count < MAX_ENTRIES;) {
int size = MIN_SIZE+(pj_rand() % MAX_SIZE);
entries[count] = pj_fifobuf_alloc (&fifo, size);
if (entries[count]) {
available -= (size+4);
++count;
}
}
for (j=0; j<count; ++j) {
pj_fifobuf_free (&fifo, entries[j]);
}
available = SIZE;
}
if (pj_fifobuf_max_size(&fifo) < SIZE-4) {
pj_assert(0);
return -3;
}
pj_pool_release(pool);
return 0;
}
#endif /* INCLUDE_FIFOBUF_TEST */
|
