Projet Informatique Théorique 2016
Instructions et Documentation
test_ensemble.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 "automate.h"
23 #include "outils.h"
24 
25 #include <stdio.h>
26 #include <stdlib.h>
27 
28 typedef struct {
29  int elmt;
30 } Elmt;
31 
32 int comparer_elmt( const Elmt* a, const Elmt * b){
33  return a->elmt - b->elmt;
34 }
35 
36 void initialiser_elmt( Elmt* v, int elmt ){
37  v->elmt = elmt;
38 }
39 
40 void print_elmt( const Elmt * c ){
41  printf( "elmt : %d", c->elmt );
42 }
43 
44 Elmt * creer_elmt( int elmt ){
45  Elmt * res = xmalloc(sizeof(Elmt));
46  initialiser_elmt( res, elmt );
47  return res;
48 }
49 
50 void supprimer_elmt( Elmt* elmt ){
51  xfree( elmt );
52 }
53 
54 Elmt * copier_elmt( const Elmt * elmt ) {
55  return creer_elmt( elmt->elmt );
56 };
57 
58 
59 
60 
61 int general_tests(){
62  int result = 1;
63 
64  Ensemble * ens = creer_ensemble( NULL, NULL, NULL );
65 
66  ajouter_element( ens, 1 );
67  ajouter_element( ens, 5 );
68  ajouter_element( ens, -1 );
69  ajouter_element( ens, 1 );
70  ajouter_element( ens, 5 );
71  ajouter_element( ens, 4 );
72 
73  TEST( taille_ensemble(ens) == 4, result );
74  TEST( est_dans_l_ensemble( ens, 1 ), result );
75  TEST( est_dans_l_ensemble( ens, 5 ), result );
76  TEST( est_dans_l_ensemble( ens, -1 ), result );
77  TEST( est_dans_l_ensemble( ens, 4 ), result );
78  TEST( ! est_dans_l_ensemble( ens, 2 ), result );
79  TEST( ! est_dans_l_ensemble( ens, 3 ), result );
80  TEST( ! est_dans_l_ensemble( ens, 6 ), result );
81  TEST( ! est_dans_l_ensemble( ens, -2 ), result );
82 
83  retirer_element( ens, 1 );
84 
85  TEST( taille_ensemble(ens) == 3, result );
86  TEST( ! est_dans_l_ensemble( ens, 1 ), result );
87  TEST( est_dans_l_ensemble( ens, 5 ), result );
88  TEST( est_dans_l_ensemble( ens, -1 ), result );
89  TEST( est_dans_l_ensemble( ens, 4 ), result );
90  TEST( ! est_dans_l_ensemble( ens, 2 ), result );
91  TEST( ! est_dans_l_ensemble( ens, 3 ), result );
92  TEST( ! est_dans_l_ensemble( ens, 6 ), result );
93  TEST( ! est_dans_l_ensemble( ens, -2 ), result );
94 
95  liberer_ensemble( ens );
96 
97  ens = creer_ensemble(
98  (int (*)( const intptr_t, const intptr_t)) comparer_elmt,
99  (intptr_t (*)( const intptr_t )) copier_elmt,
100  (void (*)( intptr_t )) supprimer_elmt
101  );
102 
103  Elmt elmt;
104 
105  initialiser_elmt( &elmt, 1 );
106  ajouter_element( ens, (intptr_t) &elmt );
107 
108  initialiser_elmt( &elmt, 5 );
109  ajouter_element( ens, (intptr_t) &elmt );
110 
111  initialiser_elmt( &elmt, -1 );
112  ajouter_element( ens, (intptr_t) &elmt );
113 
114  initialiser_elmt( &elmt, 1 );
115  ajouter_element( ens, (intptr_t) &elmt );
116 
117  initialiser_elmt( &elmt, 5 );
118  ajouter_element( ens, (intptr_t) &elmt );
119 
120  initialiser_elmt( &elmt, 4 );
121  ajouter_element( ens, (intptr_t) &elmt );
122 
123  TEST( taille_ensemble(ens) == 4, result );
124  initialiser_elmt( &elmt, 1 );
125  TEST( est_dans_l_ensemble( ens, (intptr_t) &elmt ), result );
126  initialiser_elmt( &elmt, 5 );
127  TEST( est_dans_l_ensemble( ens, (intptr_t) &elmt ), result );
128  initialiser_elmt( &elmt, -1 );
129  TEST( est_dans_l_ensemble( ens, (intptr_t) &elmt ), result );
130  initialiser_elmt( &elmt, 4 );
131  TEST( est_dans_l_ensemble( ens, (intptr_t) &elmt ), result );
132  initialiser_elmt( &elmt, 2 );
133  TEST( ! est_dans_l_ensemble( ens, (intptr_t) &elmt ), result );
134  initialiser_elmt( &elmt, 3 );
135  TEST( ! est_dans_l_ensemble( ens, (intptr_t) &elmt ), result );
136  initialiser_elmt( &elmt, 6 );
137  TEST( ! est_dans_l_ensemble( ens, (intptr_t) &elmt ), result );
138  initialiser_elmt( &elmt, -2 );
139  TEST( ! est_dans_l_ensemble( ens, (intptr_t) &elmt ), result );
140 
141  initialiser_elmt( &elmt, 1 );
142  retirer_element( ens, (intptr_t) &elmt );
143 
144  TEST( taille_ensemble(ens) == 3, result );
145  initialiser_elmt( &elmt, 1 );
146  TEST( ! est_dans_l_ensemble( ens, (intptr_t) &elmt ), result );
147  initialiser_elmt( &elmt, 5 );
148  TEST( est_dans_l_ensemble( ens, (intptr_t) &elmt ), result );
149  initialiser_elmt( &elmt, -1 );
150  TEST( est_dans_l_ensemble( ens, (intptr_t) &elmt ), result );
151  initialiser_elmt( &elmt, 4 );
152  TEST( est_dans_l_ensemble( ens, (intptr_t) &elmt ), result );
153  initialiser_elmt( &elmt, 2 );
154  TEST( ! est_dans_l_ensemble( ens, (intptr_t) &elmt ), result );
155  initialiser_elmt( &elmt, 3 );
156  TEST( ! est_dans_l_ensemble( ens, (intptr_t) &elmt ), result );
157  initialiser_elmt( &elmt, 6 );
158  TEST( ! est_dans_l_ensemble( ens, (intptr_t) &elmt ), result );
159  initialiser_elmt( &elmt, -2 );
160  TEST( ! est_dans_l_ensemble( ens, (intptr_t) &elmt ), result );
161 
162  liberer_ensemble( ens );
163 
164  return result;
165 }
166 
167 int test_creer_ensemble(){
168  int result = 1;
169 
170  // Voir general_tests
171  return result;
172 }
173 
174 int test_liberer_ensemble(){
175  int result = 1;
176 
177  Ensemble * ens = creer_ensemble( NULL, NULL, NULL );
178 
179  liberer_ensemble( ens );
180 
181 
182  ens = creer_ensemble(
183  (int (*)( const intptr_t, const intptr_t)) comparer_elmt,
184  (intptr_t (*)( const intptr_t )) copier_elmt,
185  (void (*)( intptr_t )) supprimer_elmt
186  );
187 
188  liberer_ensemble( ens );
189 
190  // Voir general_tests
191  return result;
192 }
193 
194 int test_ajouter_element(){
195  int result = 1;
196 
197  //Voir general_tests
198  return result;
199 }
200 
201 int test_ajouter_elements(){
202  int result = 1;
203 
204  Ensemble * ens1 = creer_ensemble( NULL, NULL, NULL );
205 
206  ajouter_element( ens1, 1 );
207  ajouter_element( ens1, 2 );
208  ajouter_element( ens1, 5 );
209 
210  Ensemble * ens2 = creer_ensemble( NULL, NULL, NULL );
211 
212  ajouter_element( ens2, 2 );
213  ajouter_element( ens2, 5 );
214  ajouter_element( ens2, 7 );
215  ajouter_element( ens2, 9 );
216 
217  ajouter_elements( ens1, ens2 );
218 
219  TEST( taille_ensemble(ens1) == 5, result );
220  TEST( est_dans_l_ensemble( ens1, 1 ), result );
221  TEST( est_dans_l_ensemble( ens1, 2 ), result );
222  TEST( ! est_dans_l_ensemble( ens1, 4 ), result );
223  TEST( ! est_dans_l_ensemble( ens1, 3 ), result );
224  TEST( est_dans_l_ensemble( ens1, 5 ), result );
225  TEST( est_dans_l_ensemble( ens1, 7 ), result );
226  TEST( est_dans_l_ensemble( ens1, 9 ), result );
227 
228  liberer_ensemble( ens1 );
229  liberer_ensemble( ens2 );
230 
231 
232 
233  ens1 = creer_ensemble(
234  (int (*)( const intptr_t, const intptr_t)) comparer_elmt,
235  (intptr_t (*)( const intptr_t )) copier_elmt,
236  (void (*)( intptr_t )) supprimer_elmt
237  );
238 
239 
240  Elmt elmt;
241 
242  initialiser_elmt( &elmt, 1 );
243  ajouter_element( ens1, (intptr_t) &elmt );
244 
245  initialiser_elmt( &elmt, 5 );
246  ajouter_element( ens1, (intptr_t) &elmt );
247 
248  initialiser_elmt( &elmt, 4 );
249  ajouter_element( ens1, (intptr_t) &elmt );
250 
251 
252  ens2 = creer_ensemble(
253  (int (*)( const intptr_t, const intptr_t)) comparer_elmt,
254  (intptr_t (*)( const intptr_t )) copier_elmt,
255  (void (*)( intptr_t )) supprimer_elmt
256  );
257 
258  initialiser_elmt( &elmt, 4 );
259  ajouter_element( ens2, (intptr_t) &elmt );
260 
261  initialiser_elmt( &elmt, 5 );
262  ajouter_element( ens2, (intptr_t) &elmt );
263 
264  initialiser_elmt( &elmt, 7 );
265  ajouter_element( ens2, (intptr_t) &elmt );
266 
267 
268  ajouter_elements( ens1, ens2 );
269 
270 
271  TEST( taille_ensemble(ens1) == 4, result );
272  initialiser_elmt( &elmt, 1 );
273  TEST( est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
274  initialiser_elmt( &elmt, 2 );
275  TEST( ! est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
276  initialiser_elmt( &elmt, 3 );
277  TEST( ! est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
278  initialiser_elmt( &elmt, 4 );
279  TEST( est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
280  initialiser_elmt( &elmt, 5 );
281  TEST( est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
282  initialiser_elmt( &elmt, 6 );
283  TEST( ! est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
284  initialiser_elmt( &elmt, 7 );
285  TEST( est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
286 
287  liberer_ensemble( ens1 );
288  liberer_ensemble( ens2 );
289 
290  return result;
291 }
292 
293 int test_retirer_element(){
294  int result = 1;
295 
296  //Voir general_tests
297  return result;
298 }
299 
300 int test_retirer_elements(){
301  int result = 1;
302 
303  Ensemble * ens1 = creer_ensemble( NULL, NULL, NULL );
304 
305  ajouter_element( ens1, 1 );
306  ajouter_element( ens1, 2 );
307  ajouter_element( ens1, 5 );
308 
309  Ensemble * ens2 = creer_ensemble( NULL, NULL, NULL );
310 
311  ajouter_element( ens2, 2 );
312  ajouter_element( ens2, 5 );
313  ajouter_element( ens2, 7 );
314  ajouter_element( ens2, 9 );
315 
316  retirer_elements( ens1, ens2 );
317 
318  TEST( taille_ensemble(ens1) == 1, result );
319  TEST( est_dans_l_ensemble( ens1, 1 ), result );
320  TEST( ! est_dans_l_ensemble( ens1, 2 ), result );
321  TEST( ! est_dans_l_ensemble( ens1, 4 ), result );
322  TEST( ! est_dans_l_ensemble( ens1, 3 ), result );
323  TEST( ! est_dans_l_ensemble( ens1, 5 ), result );
324  TEST( ! est_dans_l_ensemble( ens1, 7 ), result );
325  TEST( ! est_dans_l_ensemble( ens1, 9 ), result );
326 
327  liberer_ensemble( ens1 );
328  liberer_ensemble( ens2 );
329 
330  ens1 = creer_ensemble(
331  (int (*)( const intptr_t, const intptr_t)) comparer_elmt,
332  (intptr_t (*)( const intptr_t )) copier_elmt,
333  (void (*)( intptr_t )) supprimer_elmt
334  );
335 
336 
337  Elmt elmt;
338 
339  initialiser_elmt( &elmt, 5 );
340  ajouter_element( ens1, (intptr_t) &elmt );
341 
342  initialiser_elmt( &elmt, 1 );
343  ajouter_element( ens1, (intptr_t) &elmt );
344 
345  initialiser_elmt( &elmt, 4 );
346  ajouter_element( ens1, (intptr_t) &elmt );
347 
348 
349  ens2 = creer_ensemble(
350  (int (*)( const intptr_t, const intptr_t)) comparer_elmt,
351  (intptr_t (*)( const intptr_t )) copier_elmt,
352  (void (*)( intptr_t )) supprimer_elmt
353  );
354 
355  initialiser_elmt( &elmt, 7 );
356  ajouter_element( ens2, (intptr_t) &elmt );
357 
358  initialiser_elmt( &elmt, 5 );
359  ajouter_element( ens2, (intptr_t) &elmt );
360 
361  initialiser_elmt( &elmt, 4 );
362  ajouter_element( ens2, (intptr_t) &elmt );
363 
364 
365  retirer_elements( ens1, ens2 );
366 
367 
368  TEST( taille_ensemble(ens1) == 1, result );
369  initialiser_elmt( &elmt, 1 );
370  TEST( est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
371  initialiser_elmt( &elmt, 2 );
372  TEST( ! est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
373  initialiser_elmt( &elmt, 3 );
374  TEST( ! est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
375  initialiser_elmt( &elmt, 4 );
376  TEST( ! est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
377  initialiser_elmt( &elmt, 5 );
378  TEST( ! est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
379  initialiser_elmt( &elmt, 6 );
380  TEST( ! est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
381  initialiser_elmt( &elmt, 7 );
382  TEST( ! est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
383 
384  liberer_ensemble( ens1 );
385  liberer_ensemble( ens2 );
386 
387  return result;
388 }
389 
390 int test_vider_ensemble(){
391  int result = 1;
392 
393  Ensemble * ens1 = creer_ensemble( NULL, NULL, NULL );
394 
395  ajouter_element( ens1, 2 );
396  ajouter_element( ens1, 1 );
397  ajouter_element( ens1, 5 );
398 
399  vider_ensemble( ens1 );
400 
401  TEST( taille_ensemble(ens1) == 0, result );
402  TEST( ! est_dans_l_ensemble( ens1, 1 ), result );
403  TEST( ! est_dans_l_ensemble( ens1, 2 ), result );
404  TEST( ! est_dans_l_ensemble( ens1, 4 ), result );
405  TEST( ! est_dans_l_ensemble( ens1, 3 ), result );
406  TEST( ! est_dans_l_ensemble( ens1, 5 ), result );
407  TEST( ! est_dans_l_ensemble( ens1, 6 ), result );
408 
409  liberer_ensemble( ens1 );
410 
411  ens1 = creer_ensemble(
412  (int (*)( const intptr_t, const intptr_t)) comparer_elmt,
413  (intptr_t (*)( const intptr_t )) copier_elmt,
414  (void (*)( intptr_t )) supprimer_elmt
415  );
416 
417 
418  Elmt elmt;
419 
420  initialiser_elmt( &elmt, 4 );
421  ajouter_element( ens1, (intptr_t) &elmt );
422 
423  initialiser_elmt( &elmt, 1 );
424  ajouter_element( ens1, (intptr_t) &elmt );
425 
426  initialiser_elmt( &elmt, 4 );
427  ajouter_element( ens1, (intptr_t) &elmt );
428 
429  vider_ensemble( ens1 );
430 
431  TEST( taille_ensemble(ens1) == 0, result );
432  initialiser_elmt( &elmt, 1 );
433  TEST( ! est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
434  initialiser_elmt( &elmt, 2 );
435  TEST( ! est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
436  initialiser_elmt( &elmt, 3 );
437  TEST( ! est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
438  initialiser_elmt( &elmt, 4 );
439  TEST( ! est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
440  initialiser_elmt( &elmt, 5 );
441  TEST( ! est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
442  initialiser_elmt( &elmt, 6 );
443  TEST( ! est_dans_l_ensemble( ens1, (intptr_t) &elmt ), result );
444 
445  liberer_ensemble( ens1 );
446 
447  return result;
448 }
449 
450 int test_est_dans_l_ensemble(){
451  int result = 1;
452  // Voir general_tests
453  return result;
454 }
455 
456 int test_taille_ensemble(){
457  int result = 1;
458 
459  Ensemble * ens = creer_ensemble( NULL, NULL, NULL );
460 
461  TEST( taille_ensemble(ens) == 0 , result );
462 
463  liberer_ensemble( ens );
464 
465  ens = creer_ensemble(
466  (int (*)( const intptr_t, const intptr_t)) comparer_elmt,
467  (intptr_t (*)( const intptr_t )) copier_elmt,
468  (void (*)( intptr_t )) supprimer_elmt
469  );
470 
471  TEST( taille_ensemble(ens) == 0 , result );
472 
473  liberer_ensemble( ens );
474 
475  // Voir general_tests
476  return result;
477 }
478 
479 int test_comparer_ensemble(){
480  int result = 1;
481 
482  Ensemble * ens1 = creer_ensemble( NULL, NULL, NULL );
483 
484  Ensemble * ens2 = creer_ensemble( NULL, NULL, NULL );
485 
486  TEST( comparer_ensemble(ens1, ens2) == 0, result );
487 
488  ajouter_element( ens1, 2 );
489  ajouter_element( ens1, 1 );
490  ajouter_element( ens1, 5 );
491 
492  ajouter_element( ens2, 1 );
493  ajouter_element( ens2, 2 );
494  ajouter_element( ens2, 5 );
495 
496  TEST( comparer_ensemble(ens1, ens2) == 0, result );
497 
498  ajouter_element( ens1, 7 );
499 
500  TEST( comparer_ensemble(ens1, ens2) == 1, result );
501 
502  ajouter_element( ens1, 4 );
503 
504  TEST( comparer_ensemble(ens1, ens2) == -1, result );
505 
506  ajouter_element( ens2, 7 );
507 
508  TEST( comparer_ensemble(ens1, ens2) == -1, result );
509 
510  ajouter_element( ens2, 8 );
511 
512  TEST( comparer_ensemble(ens1, ens2) == -1, result );
513 
514  ajouter_element( ens2, 4 );
515 
516  TEST( comparer_ensemble(ens1, ens2) == -1, result );
517 
518  ajouter_element( ens2, 4 );
519 
520  TEST( comparer_ensemble(ens1, ens2) == -1, result );
521 
522  ajouter_element( ens1, 9 );
523 
524  TEST( comparer_ensemble(ens1, ens2) == 1, result );
525 
526  ajouter_element( ens1, 8 );
527 
528  TEST( comparer_ensemble(ens1, ens2) == 1, result );
529 
530  ajouter_element( ens2, 9 );
531 
532  TEST( comparer_ensemble(ens1, ens2) == 0, result );
533 
534  liberer_ensemble( ens1 );
535  liberer_ensemble( ens2 );
536 
537  return result;
538 }
539 
540 int test_copier_ensemble(){
541  int result = 1;
542 
543  Ensemble * ens1 = creer_ensemble( NULL, NULL, NULL );
544  Ensemble * ens2 = copier_ensemble( ens1 );
545 
546  TEST( ens1 != ens2, result );
547  TEST( comparer_ensemble( ens1, ens2 ) == 0, result );
548 
549  liberer_ensemble( ens1 );
550  liberer_ensemble( ens2 );
551 
552 
553  ens1 = creer_ensemble( NULL, NULL, NULL );
554 
555  ajouter_element( ens1, 2 );
556  ajouter_element( ens1, 1 );
557  ajouter_element( ens1, 5 );
558 
559  ens2 = copier_ensemble( ens1 );
560 
561  TEST( ens1 != ens2, result );
562  TEST( comparer_ensemble( ens1, ens2 ) == 0, result );
563 
564  liberer_ensemble( ens1 );
565  liberer_ensemble( ens2 );
566 
567 
568 
569  ens1 = creer_ensemble(
570  (int (*)( const intptr_t, const intptr_t)) comparer_elmt,
571  (intptr_t (*)( const intptr_t )) copier_elmt,
572  (void (*)( intptr_t )) supprimer_elmt
573  );
574  ens2 = copier_ensemble( ens1 );
575 
576  TEST( ens1 != ens2, result );
577  TEST( comparer_ensemble( ens1, ens2 ) == 0, result );
578 
579  liberer_ensemble( ens1 );
580  liberer_ensemble( ens2 );
581 
582 
583 
584  ens1 = creer_ensemble(
585  (int (*)( const intptr_t, const intptr_t)) comparer_elmt,
586  (intptr_t (*)( const intptr_t )) copier_elmt,
587  (void (*)( intptr_t )) supprimer_elmt
588  );
589 
590  Elmt elmt;
591 
592  initialiser_elmt( &elmt, 3 );
593  ajouter_element( ens1, (intptr_t) &elmt );
594 
595  initialiser_elmt( &elmt, 1 );
596  ajouter_element( ens1, (intptr_t) &elmt );
597 
598  initialiser_elmt( &elmt, 4 );
599  ajouter_element( ens1, (intptr_t) &elmt );
600 
601  ens2 = copier_ensemble( ens1 );
602 
603  TEST( ens1 != ens2, result );
604  TEST( comparer_ensemble( ens1, ens2 ) == 0, result );
605 
606  liberer_ensemble( ens1 );
607  liberer_ensemble( ens2 );
608 
609  return result;
610 }
611 
612 typedef struct {
613  int min;
614  int max;
615  int result;
616 } data_t ;
617 
618 void action( intptr_t element, void* data ){
619  data_t * info = (data_t*) data;
620  if( info->min < element && element < info->max ){
621  info->result &= 1;
622  }else{
623  info->result &= 0;
624  }
625 }
626 
627 int test_pour_tout_element(){
628  int result = 1;
629 
630  Ensemble * ens1 = creer_ensemble( NULL, NULL, NULL );
631 
632  ajouter_element( ens1, -2 );
633  ajouter_element( ens1, 3 );
634  ajouter_element( ens1, 1 );
635 
636  data_t data;
637  data.min = -3;
638  data.max = 4;
639  data.result = result;
640 
641  pour_tout_element( ens1, action, &data );
642 
643  liberer_ensemble( ens1 );
644 
645  result = data.result;
646  return result;
647 }
648 
649 int test_print_ensemble(){
650  int result = 1;
651  Ensemble * ens = creer_ensemble( NULL, NULL, NULL );
652 
653  print_ensemble( ens, NULL );
654  printf("\n");
655 
656  ajouter_element( ens, -2 );
657  ajouter_element( ens, 3 );
658  ajouter_element( ens, 1 );
659 
660  print_ensemble( ens, NULL );
661  printf("\n");
662 
663  liberer_ensemble( ens );
664 
665  ens = creer_ensemble(
666  (int (*)( const intptr_t, const intptr_t)) comparer_elmt,
667  (intptr_t (*)( const intptr_t )) copier_elmt,
668  (void (*)( intptr_t )) supprimer_elmt
669  );
670 
671  Elmt elmt;
672 
673  initialiser_elmt( &elmt, 1 );
674  ajouter_element( ens, (intptr_t) &elmt );
675 
676  initialiser_elmt( &elmt, 5 );
677  ajouter_element( ens, (intptr_t) &elmt );
678 
679  initialiser_elmt( &elmt, -1 );
680  ajouter_element( ens, (intptr_t) &elmt );
681 
682  print_ensemble( ens, (void(*)(const intptr_t)) print_elmt );
683  printf("\n");
684 
685  liberer_ensemble( ens );
686 
687  return result;
688 }
689 
690 int test_swap_ensemble(){
691  int result = 1;
692 
693  Ensemble * ens1 = creer_ensemble( NULL, NULL, NULL );
694 
695  ajouter_element( ens1, 1 );
696  ajouter_element( ens1, 2 );
697  ajouter_element( ens1, 5 );
698 
699  Ensemble * ens2 = creer_ensemble( NULL, NULL, NULL );
700 
701  ajouter_element( ens2, 3 );
702  ajouter_element( ens2, 4 );
703 
704  swap_ensemble( ens1, ens2 );
705 
706  TEST( taille_ensemble( ens1 )==2, result );
707  TEST( est_dans_l_ensemble( ens1, 3 ), result );
708  TEST( est_dans_l_ensemble( ens1, 4 ), result );
709 
710  TEST( taille_ensemble( ens2 )==3, result );
711  TEST( est_dans_l_ensemble( ens2, 1 ), result );
712  TEST( est_dans_l_ensemble( ens2, 2 ), result );
713  TEST( est_dans_l_ensemble( ens2, 5 ), result );
714 
715  liberer_ensemble( ens1 );
716  liberer_ensemble( ens2 );
717 
718  return result;
719 }
720 
721 int test_trouver_ensemble(){
722  int result = 1;
723 
724  Ensemble * ens1 = creer_ensemble( NULL, NULL, NULL );
725 
726  ajouter_element( ens1, 1 );
727  ajouter_element( ens1, 2 );
728  ajouter_element( ens1, 5 );
729 
730  Ensemble_iterateur it = trouver_ensemble( ens1, 2 );
731 
732  TEST( ! iterateur_ensemble_est_vide( it ), result );
733  TEST( get_element( it ) == 2, result );
734 
735  it = trouver_ensemble( ens1, -1 );
736 
737  TEST( iterateur_ensemble_est_vide( it ), result );
738 
739  liberer_ensemble( ens1 );
740 
741  return result;
742 }
743 
744 int test_premier_iterateur_ensemble(){
745  int result = 1;
746 
747  Ensemble * ens = creer_ensemble( NULL, NULL, NULL );
748 
749  Ensemble_iterateur it = premier_iterateur_ensemble( ens );
750 
751  TEST(
752  1
753  && iterateur_ensemble_est_vide(it)
754  , result
755  );
756 
757  ajouter_element( ens, 1 );
758  ajouter_element( ens, -4 );
759  ajouter_element( ens, 9 );
760  ajouter_element( ens, 9 );
761  ajouter_element( ens, -1 );
762  ajouter_element( ens, -10 );
763  ajouter_element( ens, 4 );
764  ajouter_element( ens, 4 );
765  ajouter_element( ens, 6 );
766  ajouter_element( ens, 2 );
767 
768  it = premier_iterateur_ensemble( ens );
769 
770  TEST(
771  1
772  && ! iterateur_ensemble_est_vide(it)
773  && get_element(it) == -10
774  , result
775  );
776 
777  liberer_ensemble( ens );
778 
779  return result;
780 }
781 
782 int test_iterateur_suivant_ensemble(){
783  int result = 1;
784 
785  Ensemble * ens = creer_ensemble( NULL, NULL, NULL );
786 
787  ajouter_element( ens, 1 );
788  ajouter_element( ens, -4 );
789  ajouter_element( ens, 9 );
790  ajouter_element( ens, 9 );
791  ajouter_element( ens, -1 );
792  ajouter_element( ens, -10 );
793  ajouter_element( ens, 4 );
794  ajouter_element( ens, 4 );
795  ajouter_element( ens, 6 );
796  ajouter_element( ens, 2 );
797 
798  Ensemble_iterateur it = premier_iterateur_ensemble( ens );
799 
800  TEST(
801  ! iterateur_ensemble_est_vide(it) && get_element(it) == -10, result
802  );
803 
804  it = iterateur_suivant_ensemble( it );
805  TEST(
806  ! iterateur_ensemble_est_vide(it) && get_element(it) == -4, result
807  );
808 
809  it = iterateur_suivant_ensemble( it );
810  TEST(
811  ! iterateur_ensemble_est_vide(it) && get_element(it) == -1, result
812  );
813 
814  it = iterateur_suivant_ensemble( it );
815  TEST(
816  ! iterateur_ensemble_est_vide(it) && get_element(it) == 1, result
817  );
818 
819  it = iterateur_suivant_ensemble( it );
820  TEST(
821  ! iterateur_ensemble_est_vide(it) && get_element(it) == 2, result
822  );
823 
824  it = iterateur_suivant_ensemble( it );
825  TEST(
826  ! iterateur_ensemble_est_vide(it) && get_element(it) == 4, result
827  );
828 
829  it = iterateur_suivant_ensemble( it );
830  TEST(
831  ! iterateur_ensemble_est_vide(it) && get_element(it) == 6, result
832  );
833 
834  it = iterateur_suivant_ensemble( it );
835  TEST(
836  ! iterateur_ensemble_est_vide(it) && get_element(it) == 9, result
837  );
838 
839  it = iterateur_suivant_ensemble( it );
840  TEST( iterateur_ensemble_est_vide(it), result );
841 
842  it = iterateur_suivant_ensemble( it );
843  TEST(
844  ! iterateur_ensemble_est_vide(it) && get_element(it) == -10, result
845  );
846 
847  liberer_ensemble( ens );
848 
849  return result;
850 }
851 
852 int test_iterateur_precedent_ensemble(){
853  int result = 1;
854 
855  Ensemble * ens = creer_ensemble( NULL, NULL, NULL );
856 
857  ajouter_element( ens, 1 );
858  ajouter_element( ens, -4 );
859  ajouter_element( ens, 9 );
860  ajouter_element( ens, 9 );
861  ajouter_element( ens, -1 );
862  ajouter_element( ens, -10 );
863  ajouter_element( ens, 4 );
864  ajouter_element( ens, 4 );
865  ajouter_element( ens, 6 );
866  ajouter_element( ens, 2 );
867 
868  Ensemble_iterateur it = premier_iterateur_ensemble( ens );
869 
870  TEST(
871  ! iterateur_ensemble_est_vide(it) && get_element(it) == -10, result
872  );
873 
874  it = iterateur_precedent_ensemble( it );
875  TEST( iterateur_ensemble_est_vide(it), result );
876 
877  it = iterateur_precedent_ensemble( it );
878  TEST(
879  ! iterateur_ensemble_est_vide(it) && get_element(it) == 9, result
880  );
881 
882  it = iterateur_precedent_ensemble( it );
883  TEST(
884  ! iterateur_ensemble_est_vide(it) && get_element(it) == 6, result
885  );
886 
887  it = iterateur_precedent_ensemble( it );
888  TEST(
889  ! iterateur_ensemble_est_vide(it) && get_element(it) == 4, result
890  );
891 
892  it = iterateur_precedent_ensemble( it );
893  TEST(
894  ! iterateur_ensemble_est_vide(it) && get_element(it) == 2, result
895  );
896 
897  it = iterateur_precedent_ensemble( it );
898  TEST(
899  ! iterateur_ensemble_est_vide(it) && get_element(it) == 1, result
900  );
901 
902  it = iterateur_precedent_ensemble( it );
903  TEST(
904  ! iterateur_ensemble_est_vide(it) && get_element(it) == -1, result
905  );
906 
907  it = iterateur_precedent_ensemble( it );
908  TEST(
909  ! iterateur_ensemble_est_vide(it) && get_element(it) == -4, result
910  );
911 
912  it = iterateur_precedent_ensemble( it );
913  TEST(
914  ! iterateur_ensemble_est_vide(it) && get_element(it) == -10, result
915  );
916 
917  it = iterateur_precedent_ensemble( it );
918  TEST( iterateur_ensemble_est_vide(it), result );
919 
920 
921  liberer_ensemble( ens );
922 
923  return result;
924 }
925 
926 int test_iterateur_ensemble_est_vide(){
927  int result = 1;
928 
929  // Voir test_premier_iterateur
930  return result;
931 }
932 
933 int test_get_element(){
934  int result = 1;
935 
936  //Voir test_trouver_element();
937  return result;
938 }
939 
940 
941 int main(){
942  int result = 1;
943 
944  result &= general_tests();
945  result &= test_creer_ensemble();
946  result &= test_liberer_ensemble();
947  result &= test_ajouter_element();
948  result &= test_ajouter_elements();
949  result &= test_retirer_element();
950  result &= test_retirer_elements();
951  result &= test_vider_ensemble();
952  result &= test_est_dans_l_ensemble();
953  result &= test_taille_ensemble();
954  result &= test_comparer_ensemble();
955  result &= test_copier_ensemble();
956  result &= test_pour_tout_element();
957 // result &= test_print_ensemble();
958  result &= test_swap_ensemble();
959  result &= test_trouver_ensemble();
960  result &= test_premier_iterateur_ensemble();
961  result &= test_iterateur_suivant_ensemble();
962  result &= test_iterateur_precedent_ensemble();
963  result &= test_iterateur_ensemble_est_vide();
964  result &= test_get_element();
965 
966  if( ! result ){
967  fprintf( stderr, "Certains tests du fichier %s ont échoués.\n", __FILE__ );
968  return 1;
969  }
970 
971  return 0;
972 }
973