| | | 1 | | #include <stdio.h> |
| | | 2 | | #include <stdlib.h> |
| | | 3 | | #include <string.h> |
| | | 4 | | #include <pthread.h> |
| | | 5 | | #include <unistd.h> |
| | | 6 | | #include <assert.h> |
| | | 7 | | #include "db_connection.h" |
| | | 8 | | |
| | | 9 | | // ------------------------------------------------------------ |
| | | 10 | | // MOCK IMPLEMENTASYONLAR - db_connection.c'deki static fonksiyonlar |
| | | 11 | | // ------------------------------------------------------------ |
| | | 12 | | |
| | | 13 | | // Stack operasyonları için mock |
| | | 14 | | #define MAX_POOL_SIZE 100 |
| | | 15 | | |
| | | 16 | | static int mock_free_stack[MAX_POOL_SIZE]; |
| | | 17 | | static int mock_free_top = -1; |
| | | 18 | | static int mock_used_stack[MAX_POOL_SIZE]; |
| | | 19 | | static int mock_used_top = -1; |
| | | 20 | | |
| | | 21 | | // Mock stack_push - gerçek implementasyonun aynısı |
| | 22 | 22 | | int mock_stack_push(int stack[], int *top, int value) { |
| | 22 | 23 | | if (*top >= MAX_POOL_SIZE - 1) return -1; |
| | | 24 | | |
| | 22 | 25 | | stack[++(*top)] = value; |
| | 22 | 26 | | return 0; |
| | | 27 | | } |
| | | 28 | | |
| | | 29 | | // Mock stack_pop |
| | 8 | 30 | | int mock_stack_pop(int stack[], int *top) { |
| | 8 | 31 | | if (*top < 0) return -1; |
| | | 32 | | |
| | 7 | 33 | | return stack[(*top)--]; |
| | | 34 | | } |
| | | 35 | | |
| | | 36 | | // ------------------------------------------------------------ |
| | | 37 | | // MOCK POOL STRUCT |
| | | 38 | | // ------------------------------------------------------------ |
| | | 39 | | typedef struct db_conn_s { |
| | | 40 | | PGconn *pg_conn; |
| | | 41 | | bool in_use; |
| | | 42 | | int index; |
| | | 43 | | } db_conn_t; |
| | | 44 | | |
| | | 45 | | typedef struct ConnectionPool { |
| | | 46 | | db_conn_t *connections; |
| | | 47 | | int free_stack[MAX_POOL_SIZE]; |
| | | 48 | | int free_top; |
| | | 49 | | int used_stack[MAX_POOL_SIZE]; |
| | | 50 | | int used_top; |
| | | 51 | | int size; |
| | | 52 | | int used_cnt; |
| | | 53 | | pthread_mutex_t lock; |
| | | 54 | | pthread_cond_t cond; |
| | | 55 | | int timeout_ms; |
| | | 56 | | PoolExhaustionPolicy policy; |
| | | 57 | | } db_pool_t; |
| | | 58 | | |
| | | 59 | | // Mock global pool |
| | | 60 | | static db_pool_t mock_pool; |
| | | 61 | | |
| | | 62 | | // ------------------------------------------------------------ |
| | | 63 | | // MOCK DB CONNECTION FUNCTIONS |
| | | 64 | | // ------------------------------------------------------------ |
| | | 65 | | |
| | | 66 | | // db_pool_acquire'in mock versiyonu |
| | 8 | 67 | | DBConnection *mock_db_pool_acquire(void) { |
| | 8 | 68 | | if (mock_pool.free_top < 0) { |
| | | 69 | | // Pool boş, policy'e göre davran |
| | 3 | 70 | | if (mock_pool.policy == FAIL_FAST) { |
| | 1 | 71 | | return NULL; |
| | | 72 | | } |
| | | 73 | | |
| | | 74 | | // QUEUE_REQUESTS için basit mock |
| | 2 | 75 | | return NULL; |
| | | 76 | | } |
| | | 77 | | |
| | 5 | 78 | | int idx = mock_stack_pop(mock_pool.free_stack, &mock_pool.free_top); |
| | | 79 | | |
| | 5 | 80 | | if (idx < 0) return NULL; |
| | | 81 | | |
| | 5 | 82 | | mock_pool.connections[idx].in_use = true; |
| | 5 | 83 | | mock_stack_push(mock_pool.used_stack, &mock_pool.used_top, idx); |
| | 5 | 84 | | mock_pool.used_cnt++; |
| | 5 | 85 | | return (DBConnection *)&mock_pool.connections[idx]; |
| | | 86 | | } |
| | | 87 | | |
| | | 88 | | // db_pool_release'in mock versiyonu |
| | 5 | 89 | | void mock_db_pool_release(DBConnection *conn) { |
| | 5 | 90 | | db_conn_t *db_conn = (db_conn_t *)conn; |
| | 5 | 91 | | int idx = db_conn->index; |
| | 5 | 92 | | db_conn->in_use = false; |
| | 5 | 93 | | mock_pool.used_cnt--; |
| | | 94 | | // Used stack'ten çıkar |
| | | 95 | | int i; |
| | | 96 | | |
| | 5 | 97 | | for (i = 0; i <= mock_pool.used_top; i++) { |
| | 5 | 98 | | if (mock_pool.used_stack[i] == idx) { |
| | 7 | 99 | | for (int j = i; j < mock_pool.used_top; j++) { |
| | 2 | 100 | | mock_pool.used_stack[j] = mock_pool.used_stack[j + 1]; |
| | | 101 | | } |
| | | 102 | | |
| | 5 | 103 | | mock_pool.used_top--; |
| | 5 | 104 | | break; |
| | | 105 | | } |
| | | 106 | | } |
| | | 107 | | |
| | | 108 | | // Free stack'e ekle |
| | 5 | 109 | | mock_stack_push(mock_pool.free_stack, &mock_pool.free_top, idx); |
| | 5 | 110 | | } |
| | | 111 | | |
| | | 112 | | // db_pool_init'in mock versiyonu |
| | 4 | 113 | | void mock_db_pool_init(int pool_size, PoolExhaustionPolicy policy) { |
| | 4 | 114 | | memset(&mock_pool, 0, sizeof(mock_pool)); |
| | 4 | 115 | | mock_pool.size = pool_size; |
| | 4 | 116 | | mock_pool.policy = policy; |
| | 4 | 117 | | mock_pool.free_top = -1; |
| | 4 | 118 | | mock_pool.used_top = -1; |
| | 4 | 119 | | mock_pool.used_cnt = 0; |
| | 4 | 120 | | mock_pool.connections = calloc(pool_size, sizeof(db_conn_t)); |
| | | 121 | | |
| | 13 | 122 | | for (int i = 0; i < pool_size; i++) { |
| | 9 | 123 | | mock_pool.connections[i].index = i; |
| | 9 | 124 | | mock_pool.connections[i].in_use = false; |
| | 9 | 125 | | mock_pool.connections[i].pg_conn = NULL; |
| | 9 | 126 | | mock_stack_push(mock_pool.free_stack, &mock_pool.free_top, i); |
| | | 127 | | } |
| | 4 | 128 | | } |
| | | 129 | | |
| | | 130 | | // db_pool_destroy'in mock versiyonu |
| | 4 | 131 | | void mock_db_pool_destroy(void) { |
| | 4 | 132 | | if (mock_pool.connections) { |
| | 4 | 133 | | free(mock_pool.connections); |
| | 4 | 134 | | mock_pool.connections = NULL; |
| | | 135 | | } |
| | | 136 | | |
| | 4 | 137 | | mock_pool.free_top = -1; |
| | 4 | 138 | | mock_pool.used_top = -1; |
| | 4 | 139 | | mock_pool.used_cnt = 0; |
| | 4 | 140 | | } |
| | | 141 | | |
| | | 142 | | // ------------------------------------------------------------ |
| | | 143 | | // TEST FONKSIYONLARI |
| | | 144 | | // ------------------------------------------------------------ |
| | | 145 | | |
| | 2 | 146 | | void *waiting_worker(void *arg) { |
| | 2 | 147 | | DBConnection *c = mock_db_pool_acquire(); |
| | 2 | 148 | | *(DBConnection **)arg = c; |
| | 2 | 149 | | return NULL; |
| | | 150 | | } |
| | | 151 | | |
| | 1 | 152 | | void test_fifo_logic() { |
| | 1 | 153 | | printf("Testing FIFO logic...\n"); |
| | | 154 | | // Pool'u başlat |
| | 1 | 155 | | mock_db_pool_init(1, QUEUE_REQUESTS); |
| | | 156 | | // Mock connection |
| | 1 | 157 | | mock_pool.connections[0].pg_conn = (PGconn *)0xDEADBEEF; |
| | 1 | 158 | | mock_pool.connections[0].in_use = false; |
| | | 159 | | // Free stack'i temizle ve baştan ekle |
| | 1 | 160 | | mock_pool.free_top = -1; |
| | 1 | 161 | | mock_stack_push(mock_pool.free_stack, &mock_pool.free_top, 0); |
| | | 162 | | // Thread A acquires the only connection |
| | 1 | 163 | | DBConnection *c1 = mock_db_pool_acquire(); |
| | 1 | 164 | | assert(c1 != NULL); |
| | 1 | 165 | | assert(mock_pool.used_cnt == 1); |
| | | 166 | | // Thread B tries to acquire and should block (mock'ta blocking yok, NULL döner) |
| | | 167 | | pthread_t t1, t2; |
| | 1 | 168 | | DBConnection *res1 = NULL, *res2 = NULL; |
| | 1 | 169 | | pthread_create(&t1, NULL, waiting_worker, &res1); |
| | 1 | 170 | | usleep(100000); |
| | | 171 | | // Thread C tries to acquire and should block behind B |
| | 1 | 172 | | pthread_create(&t2, NULL, waiting_worker, &res2); |
| | 1 | 173 | | usleep(100000); |
| | | 174 | | // Release connection |
| | 1 | 175 | | mock_db_pool_release(c1); |
| | 1 | 176 | | pthread_join(t1, NULL); |
| | 1 | 177 | | pthread_join(t2, NULL); |
| | 1 | 178 | | mock_db_pool_destroy(); |
| | 1 | 179 | | printf("FIFO Logic Test Passed\n"); |
| | 1 | 180 | | } |
| | | 181 | | |
| | 1 | 182 | | void test_stack_operations() { |
| | 1 | 183 | | printf("Testing stack operations...\n"); |
| | | 184 | | int stack[10]; |
| | 1 | 185 | | int top = -1; |
| | | 186 | | // Push test |
| | 1 | 187 | | int r1 = mock_stack_push(stack, &top, 5); |
| | 1 | 188 | | assert(r1 == 0); |
| | 1 | 189 | | assert(top == 0); |
| | 1 | 190 | | assert(stack[0] == 5); |
| | 1 | 191 | | r1 = mock_stack_push(stack, &top, 10); |
| | 1 | 192 | | assert(r1 == 0); |
| | 1 | 193 | | assert(top == 1); |
| | 1 | 194 | | assert(stack[1] == 10); |
| | | 195 | | // Pop test |
| | 1 | 196 | | int val = mock_stack_pop(stack, &top); |
| | 1 | 197 | | assert(val == 10); |
| | 1 | 198 | | assert(top == 0); |
| | 1 | 199 | | val = mock_stack_pop(stack, &top); |
| | 1 | 200 | | assert(val == 5); |
| | 1 | 201 | | assert(top == -1); |
| | | 202 | | // Empty pop test |
| | 1 | 203 | | val = mock_stack_pop(stack, &top); |
| | 1 | 204 | | assert(val == -1); |
| | 1 | 205 | | printf("Stack Operations Test Passed\n"); |
| | 1 | 206 | | } |
| | | 207 | | |
| | 1 | 208 | | void test_pool_initialization() { |
| | 1 | 209 | | printf("Testing pool initialization...\n"); |
| | 1 | 210 | | mock_db_pool_init(5, FAIL_FAST); |
| | 1 | 211 | | assert(mock_pool.size == 5); |
| | 1 | 212 | | assert(mock_pool.free_top == 4); // 0-4 arası 5 eleman |
| | 1 | 213 | | assert(mock_pool.used_top == -1); |
| | 1 | 214 | | assert(mock_pool.used_cnt == 0); |
| | | 215 | | |
| | | 216 | | // Free stack kontrolü |
| | 6 | 217 | | for (int i = 0; i <= mock_pool.free_top; i++) { |
| | 5 | 218 | | assert(mock_pool.free_stack[i] == i); |
| | | 219 | | } |
| | | 220 | | |
| | 1 | 221 | | mock_db_pool_destroy(); |
| | 1 | 222 | | printf("Pool Initialization Test Passed\n"); |
| | 1 | 223 | | } |
| | | 224 | | |
| | 1 | 225 | | void test_acquire_release() { |
| | 1 | 226 | | printf("Testing acquire/release cycle...\n"); |
| | 1 | 227 | | mock_db_pool_init(2, FAIL_FAST); |
| | | 228 | | // İki connection al |
| | 1 | 229 | | DBConnection *c1 = mock_db_pool_acquire(); |
| | 1 | 230 | | DBConnection *c2 = mock_db_pool_acquire(); |
| | 1 | 231 | | assert(c1 != NULL); |
| | 1 | 232 | | assert(c2 != NULL); |
| | 1 | 233 | | assert(mock_pool.used_cnt == 2); |
| | 1 | 234 | | assert(mock_pool.free_top == -1); // Tüm connection'lar kullanımda |
| | | 235 | | // Birini release et |
| | 1 | 236 | | mock_db_pool_release(c1); |
| | 1 | 237 | | assert(mock_pool.used_cnt == 1); |
| | 1 | 238 | | assert(mock_pool.free_top == 0); // 1 connection free |
| | | 239 | | // Tekrar acquire et |
| | 1 | 240 | | DBConnection *c3 = mock_db_pool_acquire(); |
| | 1 | 241 | | assert(c3 != NULL); |
| | 1 | 242 | | assert(mock_pool.used_cnt == 2); |
| | 1 | 243 | | assert(mock_pool.free_top == -1); |
| | 1 | 244 | | mock_db_pool_release(c2); |
| | 1 | 245 | | mock_db_pool_release(c3); |
| | 1 | 246 | | mock_db_pool_destroy(); |
| | 1 | 247 | | printf("Acquire/Release Test Passed\n"); |
| | 1 | 248 | | } |
| | | 249 | | |
| | 1 | 250 | | void test_fail_fast() { |
| | 1 | 251 | | printf("Testing FAIL_FAST policy...\n"); |
| | 1 | 252 | | mock_db_pool_init(1, FAIL_FAST); |
| | 1 | 253 | | DBConnection *c1 = mock_db_pool_acquire(); |
| | 1 | 254 | | assert(c1 != NULL); |
| | | 255 | | // İkinci acquire hemen NULL dönmeli |
| | 1 | 256 | | DBConnection *c2 = mock_db_pool_acquire(); |
| | 1 | 257 | | assert(c2 == NULL); |
| | 1 | 258 | | mock_db_pool_release(c1); |
| | 1 | 259 | | mock_db_pool_destroy(); |
| | 1 | 260 | | printf("FAIL_FAST Test Passed\n"); |
| | 1 | 261 | | } |
| | | 262 | | |
| | | 263 | | // ------------------------------------------------------------ |
| | | 264 | | // MAIN |
| | | 265 | | // ------------------------------------------------------------ |
| | | 266 | | |
| | 1 | 267 | | int main() { |
| | 1 | 268 | | printf("\n========================================\n"); |
| | 1 | 269 | | printf(" DB POOL FIFO TESTS - MOCK VERSION\n"); |
| | 1 | 270 | | printf("========================================\n\n"); |
| | 1 | 271 | | test_stack_operations(); |
| | 1 | 272 | | test_pool_initialization(); |
| | 1 | 273 | | test_acquire_release(); |
| | 1 | 274 | | test_fail_fast(); |
| | 1 | 275 | | test_fifo_logic(); |
| | 1 | 276 | | printf("\n========================================\n"); |
| | 1 | 277 | | printf(" ALL TESTS PASSED!\n"); |
| | 1 | 278 | | printf("========================================\n\n"); |
| | 1 | 279 | | return 0; |
| | | 280 | | } |