Projet Informatique Théorique 2016
Instructions et Documentation
test_table.c
1 /*
2  * Ce fichier fait partie d'un projet de programmation donné en Licence 3
3  * à l'Université de Bordeaux
4  *
5  * Copyright (C) 2015 Adrien Boussicault
6  *
7  * This Library is free software: you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation, either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This Library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this Library. If not, see <http://www.gnu.org/licenses/>.
19  */
20 
21 
22 #include "table.h"
23 #include "outils.h"
24 
25 #include <stdarg.h>
26 
27 #include "ensemble.h"
28 
29 typedef struct {
30  int cle;
31 } Cle;
32 
33 int comparer_cle( const Cle* a, const Cle * b){
34  return a->cle - b->cle;
35 }
36 
37 void initialiser_cle( Cle* v, int cle ){
38  v->cle = cle;
39 }
40 
41 void print_cle( const Cle * c ){
42  printf( "cle : %d", c->cle );
43 }
44 
45 Cle * creer_cle( int cle ){
46  Cle * res = xmalloc(sizeof(Cle));
47  initialiser_cle( res, cle );
48  return res;
49 }
50 
51 void supprimer_cle( Cle* cle ){
52  xfree( cle );
53 }
54 
55 
56 typedef struct {
57  int valeur;
58 } Valeur;
59 
60 void initialiser_valeur( Valeur* v, int valeur ){
61  v->valeur = valeur;
62 }
63 
64 Valeur * creer_valeur( int valeur ){
65  Valeur * res = xmalloc(sizeof(Valeur));
66  initialiser_valeur( res, valeur );
67  return res;
68 }
69 
70 void supprimer_valeur( Valeur* valeur ){
71  xfree( valeur );
72 }
73 
74 void print_valeur( const Valeur * v ){
75  printf( "valeur : %d", v->valeur );
76 }
77 
78 
79 
80 Cle * copier_cle( const Cle * cle ) {
81  return creer_cle( cle->cle );
82 };
83 
84 
85 int general_test(){
86  int result = 1;
87  // Tester la création d'une table dont les clés sont des entiers
88  Table * table = creer_table( NULL, NULL, NULL );
89 
90  add_table( table, 1,11);
91  TEST( get_cle( trouver_table( table, 1 ) ) == 1, result );
92  TEST( get_valeur( trouver_table( table, 1 ) ) == 11, result );
93 
94  add_table( table, 1,21);
95  TEST( get_cle( trouver_table( table, 1 ) ) == 1, result );
96  TEST( get_valeur( trouver_table( table, 1 ) ) == 21, result );
97 
98  add_table( table, 5,12);
99  TEST( get_cle( trouver_table( table, 5 ) ) == 5, result );
100  TEST( get_valeur( trouver_table( table, 5 ) ) == 12, result );
101 
102  add_table( table, 2,12);
103  TEST( get_cle( trouver_table( table, 2 ) ) == 2, result );
104  TEST( get_valeur( trouver_table( table, 2 ) ) == 12, result );
105 
106  add_table( table, 2,13);
107  TEST( get_cle( trouver_table( table, 2 ) ) == 2, result );
108  TEST( get_valeur( trouver_table( table, 2 ) ) == 13, result );
109 
110  delete_table( table, 2 );
111 
112  TEST( iterateur_est_vide( trouver_table(table, 2) ), result );
113  TEST( ! iterateur_est_vide( trouver_table(table, 5) ), result );
114  TEST( ! iterateur_est_vide( trouver_table(table, 1) ), result );
115 
116  TEST( get_cle( trouver_table(table, 5) )==5, result );
117  TEST( get_valeur( trouver_table(table, 5) )==12, result );
118 
119  TEST( get_cle( trouver_table(table, 1) )==1, result );
120  TEST( get_valeur( trouver_table(table, 1) )==21, result );
121 
122  add_table( table, -1,-11);
123  TEST( get_cle( trouver_table( table, -1 ) ) == -1, result );
124  TEST( get_valeur( trouver_table( table, -1 ) ) == -11, result );
125 
126  liberer_table( table );
127 
128  // Tester la création d'une table dont les clés sont des entiers
129  table = creer_table(
130  (int (*)( const intptr_t, const intptr_t )) comparer_cle,
131  (intptr_t (*)( const intptr_t )) copier_cle,
132  (void (*)(intptr_t)) supprimer_cle
133  );
134 
135  Cle cle;
136  initialiser_cle( &cle, 1 );
137  add_table( table, (intptr_t) &cle, 21);
138  TEST( ((Cle*) get_cle( trouver_table( table, (intptr_t) &cle ) ))->cle == 1, result );
139  TEST( get_valeur( trouver_table( table, (intptr_t) &cle ) ) == 21, result );
140 
141  initialiser_cle( &cle, 2 );
142  add_table( table, (intptr_t) &cle, 22);
143  TEST( ((Cle*) get_cle( trouver_table( table, (intptr_t) &cle ) ))->cle == 2, result );
144  TEST( get_valeur( trouver_table( table, (intptr_t) &cle ) ) == 22, result );
145 
146  initialiser_cle( &cle, 5 );
147  add_table( table, (intptr_t) &cle, 25);
148  TEST( ((Cle*) get_cle( trouver_table( table, (intptr_t) &cle ) ))->cle == 5, result );
149  TEST( get_valeur( trouver_table( table, (intptr_t) &cle ) ) == 25, result );
150 
151  initialiser_cle( &cle, 2 );
152  add_table( table, (intptr_t) &cle, 23);
153  TEST( ((Cle*) get_cle( trouver_table( table, (intptr_t) &cle ) ))->cle == 2, result );
154  TEST( get_valeur( trouver_table( table, (intptr_t) &cle ) ) == 23, result );
155 
156  initialiser_cle( &cle, 1 );
157  add_table( table, (intptr_t) &cle, 81);
158  TEST( ((Cle*) get_cle( trouver_table( table, (intptr_t) &cle ) ))->cle == 1, result );
159  TEST( get_valeur( trouver_table( table, (intptr_t) &cle ) ) == 81, result );
160 
161 
162  initialiser_cle( &cle, 2 );
163  delete_table( table, (intptr_t) &cle );
164 
165  initialiser_cle( &cle, 2 );
166  TEST( iterateur_est_vide( trouver_table(table, (intptr_t) &cle) ), result );
167  initialiser_cle( &cle, 5 );
168  TEST( ! iterateur_est_vide( trouver_table(table, (intptr_t) &cle) ), result );
169  initialiser_cle( &cle, 1 );
170  TEST( ! iterateur_est_vide( trouver_table(table, (intptr_t) &cle) ), result );
171 
172  initialiser_cle( &cle, -3 );
173  add_table( table, (intptr_t) &cle, -23);
174  TEST( ((Cle*) get_cle( trouver_table( table, (intptr_t) &cle ) ))->cle == -3, result );
175  TEST( get_valeur( trouver_table( table, (intptr_t) &cle ) ) == -23, result );
176 
177  liberer_table( table );
178  return result;
179 }
180 
181 int test_creer_table(){
182  int result = 1;
183  // Tester la création d'une table dont les clés sont des entiers
184  Table * table = creer_table( NULL, NULL, NULL );
185 
186  TEST( table!=NULL, result );
187 
188  liberer_table( table );
189 
190  // Tester la création d'une table dont les clés sont des entiers
191  table = creer_table(
192  (int (*)( const intptr_t, const intptr_t )) comparer_cle,
193  (intptr_t (*)( const intptr_t )) copier_cle,
194  (void (*)(intptr_t)) supprimer_cle
195  );
196 
197  TEST( table!=NULL, result );
198 
199  liberer_table( table );
200 
201  return result;
202 }
203 
204 int test_liberer_table(){
205  // Voir general_test et creer_test
206  return 1;
207 }
208 
209 int test_add_table(){
210  // Voir general tests
211  return 1;
212 }
213 
214 int test_delete_table(){
215  // Voir general_test
216  return 1;
217 }
218 
219 int test_vider_table(){
220  int result = 1;
221 
222  Table * table = creer_table( NULL, NULL, NULL );
223 
224  add_table( table, 1,11);
225  add_table( table, 1,21);
226  add_table( table, 5,12);
227  add_table( table, 2,12);
228  add_table( table, 2,13);
229  delete_table( table, 2 );
230  add_table( table, -1,-11);
231 
232  vider_table( table );
233 
234  TEST( iterateur_est_vide( trouver_table( table, 1 ) ), result );
235  TEST( iterateur_est_vide( trouver_table( table, 5 ) ), result );
236  TEST( iterateur_est_vide( trouver_table( table, 2 ) ), result );
237  TEST( iterateur_est_vide( trouver_table( table, -1 ) ) , result );
238 
239  liberer_table( table );
240 
241  // Tester la création d'une table dont les clés sont des entiers
242  table = creer_table(
243  (int (*)( const intptr_t, const intptr_t )) comparer_cle,
244  (intptr_t (*)( const intptr_t )) copier_cle,
245  (void (*)(intptr_t)) supprimer_cle
246  );
247 
248  Cle cle;
249  initialiser_cle( &cle, 1 );
250  add_table( table, (intptr_t) &cle, 21);
251 
252  initialiser_cle( &cle, 2 );
253  add_table( table, (intptr_t) &cle, 22);
254 
255  initialiser_cle( &cle, 5 );
256  add_table( table, (intptr_t) &cle, 25);
257 
258  initialiser_cle( &cle, 2 );
259  add_table( table, (intptr_t) &cle, 22);
260 
261  initialiser_cle( &cle, 1 );
262  add_table( table, (intptr_t) &cle, 81);
263 
264  delete_table( table, (intptr_t) &cle );
265 
266  initialiser_cle( &cle, -3 );
267  add_table( table, (intptr_t) &cle, -23);
268 
269  vider_table( table );
270 
271  initialiser_cle( &cle, 1 );
272  TEST( iterateur_est_vide( trouver_table( table, (intptr_t) &cle ) ), result );
273  initialiser_cle( &cle, 5 );
274  TEST( iterateur_est_vide( trouver_table( table, (intptr_t) &cle ) ), result );
275  initialiser_cle( &cle, 2 );
276  TEST( iterateur_est_vide( trouver_table( table, (intptr_t) &cle ) ), result );
277  initialiser_cle( &cle, -1 );
278  TEST( iterateur_est_vide( trouver_table( table, (intptr_t) &cle ) ), result );
279  initialiser_cle( &cle, -3 );
280  TEST( iterateur_est_vide( trouver_table( table, (intptr_t) &cle ) ), result );
281 
282  liberer_table( table );
283 
284  return result;
285 }
286 
287 int test_print_table(){
288  int result = 1;
289 
290  Table * table = creer_table( NULL, NULL, NULL );
291 
292  print_table( table, NULL, NULL, "\n" );
293 
294  liberer_table( table );
295 
296  table = creer_table( NULL, NULL, NULL );
297 
298  add_table( table, 1,11);
299  add_table( table, 1,21);
300  add_table( table, 5,12);
301  add_table( table, 2,12);
302  add_table( table, 2,13);
303 
304  print_table( table, NULL, NULL, "\n" );
305 
306  liberer_table( table );
307 
308  table = creer_table(
309  (int (*)( const intptr_t, const intptr_t )) comparer_cle,
310  (intptr_t (*)( const intptr_t )) copier_cle,
311  (void (*)(intptr_t)) supprimer_cle
312  );
313 
314  Cle cle;
315  initialiser_cle( &cle, 1 );
316  add_table( table, (intptr_t) &cle, (intptr_t) creer_valeur(11) );
317 
318  initialiser_cle( &cle, 2 );
319  add_table( table, (intptr_t) &cle, (intptr_t) creer_valeur(12) );
320 
321  initialiser_cle( &cle, -1 );
322  add_table( table, (intptr_t) &cle, (intptr_t) creer_valeur(-11) );
323 
324  initialiser_cle( &cle, 5 );
325  add_table( table, (intptr_t) &cle, (intptr_t) creer_valeur(15) );
326 
327  print_table(
328  table,
329  (void(*)(const intptr_t)) print_cle,
330  (void(*)(const intptr_t)) print_valeur,
331  "\n"
332  );
333 
334  pour_toute_valeur_table( table, ( void(*)(intptr_t) )supprimer_valeur );
335 
336  liberer_table( table );
337 
338 
339  return result;
340 }
341 
342 int test_pour_toute_valeur_table(){
343  Table * table = creer_table( NULL, NULL, NULL );
344 
345  add_table( table, 1, (intptr_t) creer_valeur(1) );
346  add_table( table, 2, (intptr_t) creer_valeur(2) );
347  add_table( table, 3, (intptr_t) creer_valeur(3) );
348  add_table( table, 5, (intptr_t) creer_valeur(5) );
349 
350  pour_toute_valeur_table( table, ( void(*)(intptr_t) )supprimer_valeur );
351 
352  liberer_table( table );
353 
354  return 1;
355 }
356 
357 void action( const intptr_t cle, intptr_t valeur, void * data ){
358  if( cle+10 != ((Valeur*)valeur)->valeur ) (*(int*) data) = 0;
359 }
360 
361 int test_pour_toute_cle_valeur_table(){
362  int result = 1;
363 
364  Table * table = creer_table( NULL, NULL, NULL );
365 
366  add_table( table, 1, (intptr_t) creer_valeur(11) );
367  add_table( table, 2, (intptr_t) creer_valeur(12) );
368  add_table( table, 3, (intptr_t) creer_valeur(13) );
369  add_table( table, 5, (intptr_t) creer_valeur(15) );
370 
371  pour_toute_cle_valeur_table( table, action, &result );
372 
373  pour_toute_valeur_table( table, ( void(*)(intptr_t) ) supprimer_valeur );
374 
375  liberer_table( table );
376 
377  return result;
378 }
379 
380 int test_trouver_table(){
381  int result = 1;
382  Table * table = creer_table( NULL, NULL, NULL );
383 
384  add_table( table, 1, 1 );
385  add_table( table, 3, 3 );
386  add_table( table, 1, -1 );
387 
388  TEST( get_cle( trouver_table( table, 3 ) ) == 3, result );
389  TEST( get_cle( trouver_table( table, 1 ) ) == 1, result );
390  TEST( get_valeur( trouver_table( table, 1 ) ) == -1, result );
391 
392  liberer_table( table );
393 
394  // Voir general_test;
395  return result;
396 }
397 
398 int test_get_cle(){
399  // Voir general_test
400  return 1;
401 }
402 
403 int test_get_valeur(){
404  // Voir general_test
405  return 1;
406 }
407 
408 
409 int main(){
410 
411  int result = 1;
412 
413  result &= general_test();
414  result &= test_creer_table();
415  result &= test_liberer_table();
416  result &= test_add_table();
417  result &= test_delete_table();
418  result &= test_vider_table();
419 // result &= test_print_table();
420  result &= test_pour_toute_valeur_table();
421  result &= test_pour_toute_cle_valeur_table();
422  result &= test_trouver_table();
423  result &= test_get_cle();
424  result &= test_get_valeur();
425 
426  if( ! result ){
427  fprintf( stderr, "Certains tests du fichier %s ont échoués.\n", __FILE__ );
428  return 1;
429  }
430 
431  return 0;
432 }
void vider_table(Table *table)
Supprime toutes les clés de la table.
Definition: table.c:201
intptr_t get_cle(Table_iterateur it)
Renvoie la clé de l'association pointée par l'itérateur passé en paramètre.
Definition: table.c:47
void pour_toute_cle_valeur_table(const Table *table, void(*action)(const intptr_t cle, intptr_t valeur, void *data), void *data)
La fonction passe en revue toutes les associaitons (clé, valeur) de la table, et apelle la fonction p...
Definition: table.c:169
void liberer_table(Table *table)
Cette fonction détruit une table. La mémoire qui a été allouée par la table pour stocker les clés son...
Definition: table.c:131
intptr_t delete_table(Table *table, const intptr_t cle)
Supprime une clé de la table. La mémoire de la clé est libérée et la valeur associée à la clé est per...
Definition: table.c:150
intptr_t get_valeur(Table_iterateur it)
Renvoie la valeur de l'association pointée par l'itérateur passé en paramètre.
Definition: table.c:52
void pour_toute_valeur_table(const Table *table, void(*action)(intptr_t valeur))
La fonction passe en revue toutes les valeurs de la table passée en paramètre et apelle la fonction p...
Definition: table.c:192
void print_table(Table *table, void(*print_cle)(const intptr_t cle), void(*print_valeur)(const intptr_t valeur), const char *text_de_fin)
Affiche la table. Vous devez donner en paramètres de print_table, des fonctions pour afficher les clé...
Definition: table.c:227
int iterateur_est_vide(Table_iterateur iterator)
Renvoie 1 si l'itérateur passé en paramètre est vide. Renvoie 0 sinon.
Definition: table.c:265
Table_iterateur trouver_table(const Table *table, const intptr_t cle)
Renvoie un itérateur positionné sur l'association dont la clé est identique (pour la fonction de comp...
Definition: table.c:241
Definition: table.c:39
Table * creer_table(int(*comparer_cle)(const intptr_t cle1, const intptr_t cle2), intptr_t(*copier_cle)(const intptr_t cle), void(*supprimer_cle)(intptr_t cle))
Renvoie une nouvelle table.
Definition: table.c:117
void add_table(Table *table, const intptr_t cle, const intptr_t valeur)
La fonction add_table() ajoute une association entre une clé et une valeur. Pour cela, add_table(), crée une copie de la clé passée en paramètre, l'enregistre dans la table et l'associe à la valeur passée en paramètre. La mémoire de la copie de la clé est gérée par la table. La mémoire de la clé passée en paramètre reste à la charge de l'utilisateur.
Definition: table.c:137
Definition: automate.h:50