32 int comparer_elmt(
const Elmt* a,
const Elmt * b){
33 return a->elmt - b->elmt;
36 void initialiser_elmt(
Elmt* v,
int elmt ){
40 void print_elmt(
const Elmt * c ){
41 printf(
"elmt : %d", c->elmt );
44 Elmt * creer_elmt(
int elmt ){
46 initialiser_elmt( res, elmt );
50 void supprimer_elmt(
Elmt* elmt ){
54 Elmt * copier_elmt(
const Elmt * elmt ) {
55 return creer_elmt( elmt->elmt );
64 Ensemble * ens = creer_ensemble( NULL, NULL, NULL );
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 );
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 );
83 retirer_element( ens, 1 );
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 );
95 liberer_ensemble( ens );
98 (
int (*)(
const intptr_t,
const intptr_t)) comparer_elmt,
99 (intptr_t (*)(
const intptr_t )) copier_elmt,
100 (
void (*)( intptr_t )) supprimer_elmt
105 initialiser_elmt( &elmt, 1 );
106 ajouter_element( ens, (intptr_t) &elmt );
108 initialiser_elmt( &elmt, 5 );
109 ajouter_element( ens, (intptr_t) &elmt );
111 initialiser_elmt( &elmt, -1 );
112 ajouter_element( ens, (intptr_t) &elmt );
114 initialiser_elmt( &elmt, 1 );
115 ajouter_element( ens, (intptr_t) &elmt );
117 initialiser_elmt( &elmt, 5 );
118 ajouter_element( ens, (intptr_t) &elmt );
120 initialiser_elmt( &elmt, 4 );
121 ajouter_element( ens, (intptr_t) &elmt );
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 );
141 initialiser_elmt( &elmt, 1 );
142 retirer_element( ens, (intptr_t) &elmt );
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 );
162 liberer_ensemble( ens );
167 int test_creer_ensemble(){
174 int test_liberer_ensemble(){
177 Ensemble * ens = creer_ensemble( NULL, NULL, NULL );
179 liberer_ensemble( ens );
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
188 liberer_ensemble( ens );
194 int test_ajouter_element(){
201 int test_ajouter_elements(){
204 Ensemble * ens1 = creer_ensemble( NULL, NULL, NULL );
206 ajouter_element( ens1, 1 );
207 ajouter_element( ens1, 2 );
208 ajouter_element( ens1, 5 );
210 Ensemble * ens2 = creer_ensemble( NULL, NULL, NULL );
212 ajouter_element( ens2, 2 );
213 ajouter_element( ens2, 5 );
214 ajouter_element( ens2, 7 );
215 ajouter_element( ens2, 9 );
217 ajouter_elements( ens1, ens2 );
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 );
228 liberer_ensemble( ens1 );
229 liberer_ensemble( ens2 );
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
242 initialiser_elmt( &elmt, 1 );
243 ajouter_element( ens1, (intptr_t) &elmt );
245 initialiser_elmt( &elmt, 5 );
246 ajouter_element( ens1, (intptr_t) &elmt );
248 initialiser_elmt( &elmt, 4 );
249 ajouter_element( ens1, (intptr_t) &elmt );
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
258 initialiser_elmt( &elmt, 4 );
259 ajouter_element( ens2, (intptr_t) &elmt );
261 initialiser_elmt( &elmt, 5 );
262 ajouter_element( ens2, (intptr_t) &elmt );
264 initialiser_elmt( &elmt, 7 );
265 ajouter_element( ens2, (intptr_t) &elmt );
268 ajouter_elements( ens1, ens2 );
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 );
287 liberer_ensemble( ens1 );
288 liberer_ensemble( ens2 );
293 int test_retirer_element(){
300 int test_retirer_elements(){
303 Ensemble * ens1 = creer_ensemble( NULL, NULL, NULL );
305 ajouter_element( ens1, 1 );
306 ajouter_element( ens1, 2 );
307 ajouter_element( ens1, 5 );
309 Ensemble * ens2 = creer_ensemble( NULL, NULL, NULL );
311 ajouter_element( ens2, 2 );
312 ajouter_element( ens2, 5 );
313 ajouter_element( ens2, 7 );
314 ajouter_element( ens2, 9 );
316 retirer_elements( ens1, ens2 );
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 );
327 liberer_ensemble( ens1 );
328 liberer_ensemble( ens2 );
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
339 initialiser_elmt( &elmt, 5 );
340 ajouter_element( ens1, (intptr_t) &elmt );
342 initialiser_elmt( &elmt, 1 );
343 ajouter_element( ens1, (intptr_t) &elmt );
345 initialiser_elmt( &elmt, 4 );
346 ajouter_element( ens1, (intptr_t) &elmt );
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
355 initialiser_elmt( &elmt, 7 );
356 ajouter_element( ens2, (intptr_t) &elmt );
358 initialiser_elmt( &elmt, 5 );
359 ajouter_element( ens2, (intptr_t) &elmt );
361 initialiser_elmt( &elmt, 4 );
362 ajouter_element( ens2, (intptr_t) &elmt );
365 retirer_elements( ens1, ens2 );
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 );
384 liberer_ensemble( ens1 );
385 liberer_ensemble( ens2 );
390 int test_vider_ensemble(){
393 Ensemble * ens1 = creer_ensemble( NULL, NULL, NULL );
395 ajouter_element( ens1, 2 );
396 ajouter_element( ens1, 1 );
397 ajouter_element( ens1, 5 );
399 vider_ensemble( ens1 );
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 );
409 liberer_ensemble( ens1 );
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
420 initialiser_elmt( &elmt, 4 );
421 ajouter_element( ens1, (intptr_t) &elmt );
423 initialiser_elmt( &elmt, 1 );
424 ajouter_element( ens1, (intptr_t) &elmt );
426 initialiser_elmt( &elmt, 4 );
427 ajouter_element( ens1, (intptr_t) &elmt );
429 vider_ensemble( ens1 );
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 );
445 liberer_ensemble( ens1 );
450 int test_est_dans_l_ensemble(){
456 int test_taille_ensemble(){
459 Ensemble * ens = creer_ensemble( NULL, NULL, NULL );
461 TEST( taille_ensemble(ens) == 0 , result );
463 liberer_ensemble( ens );
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
471 TEST( taille_ensemble(ens) == 0 , result );
473 liberer_ensemble( ens );
479 int test_comparer_ensemble(){
482 Ensemble * ens1 = creer_ensemble( NULL, NULL, NULL );
484 Ensemble * ens2 = creer_ensemble( NULL, NULL, NULL );
486 TEST( comparer_ensemble(ens1, ens2) == 0, result );
488 ajouter_element( ens1, 2 );
489 ajouter_element( ens1, 1 );
490 ajouter_element( ens1, 5 );
492 ajouter_element( ens2, 1 );
493 ajouter_element( ens2, 2 );
494 ajouter_element( ens2, 5 );
496 TEST( comparer_ensemble(ens1, ens2) == 0, result );
498 ajouter_element( ens1, 7 );
500 TEST( comparer_ensemble(ens1, ens2) == 1, result );
502 ajouter_element( ens1, 4 );
504 TEST( comparer_ensemble(ens1, ens2) == -1, result );
506 ajouter_element( ens2, 7 );
508 TEST( comparer_ensemble(ens1, ens2) == -1, result );
510 ajouter_element( ens2, 8 );
512 TEST( comparer_ensemble(ens1, ens2) == -1, result );
514 ajouter_element( ens2, 4 );
516 TEST( comparer_ensemble(ens1, ens2) == -1, result );
518 ajouter_element( ens2, 4 );
520 TEST( comparer_ensemble(ens1, ens2) == -1, result );
522 ajouter_element( ens1, 9 );
524 TEST( comparer_ensemble(ens1, ens2) == 1, result );
526 ajouter_element( ens1, 8 );
528 TEST( comparer_ensemble(ens1, ens2) == 1, result );
530 ajouter_element( ens2, 9 );
532 TEST( comparer_ensemble(ens1, ens2) == 0, result );
534 liberer_ensemble( ens1 );
535 liberer_ensemble( ens2 );
540 int test_copier_ensemble(){
543 Ensemble * ens1 = creer_ensemble( NULL, NULL, NULL );
544 Ensemble * ens2 = copier_ensemble( ens1 );
546 TEST( ens1 != ens2, result );
547 TEST( comparer_ensemble( ens1, ens2 ) == 0, result );
549 liberer_ensemble( ens1 );
550 liberer_ensemble( ens2 );
553 ens1 = creer_ensemble( NULL, NULL, NULL );
555 ajouter_element( ens1, 2 );
556 ajouter_element( ens1, 1 );
557 ajouter_element( ens1, 5 );
559 ens2 = copier_ensemble( ens1 );
561 TEST( ens1 != ens2, result );
562 TEST( comparer_ensemble( ens1, ens2 ) == 0, result );
564 liberer_ensemble( ens1 );
565 liberer_ensemble( ens2 );
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
574 ens2 = copier_ensemble( ens1 );
576 TEST( ens1 != ens2, result );
577 TEST( comparer_ensemble( ens1, ens2 ) == 0, result );
579 liberer_ensemble( ens1 );
580 liberer_ensemble( ens2 );
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
592 initialiser_elmt( &elmt, 3 );
593 ajouter_element( ens1, (intptr_t) &elmt );
595 initialiser_elmt( &elmt, 1 );
596 ajouter_element( ens1, (intptr_t) &elmt );
598 initialiser_elmt( &elmt, 4 );
599 ajouter_element( ens1, (intptr_t) &elmt );
601 ens2 = copier_ensemble( ens1 );
603 TEST( ens1 != ens2, result );
604 TEST( comparer_ensemble( ens1, ens2 ) == 0, result );
606 liberer_ensemble( ens1 );
607 liberer_ensemble( ens2 );
618 void action( intptr_t element,
void* data ){
620 if( info->min < element && element < info->max ){
627 int test_pour_tout_element(){
630 Ensemble * ens1 = creer_ensemble( NULL, NULL, NULL );
632 ajouter_element( ens1, -2 );
633 ajouter_element( ens1, 3 );
634 ajouter_element( ens1, 1 );
639 data.result = result;
641 pour_tout_element( ens1, action, &data );
643 liberer_ensemble( ens1 );
645 result = data.result;
649 int test_print_ensemble(){
651 Ensemble * ens = creer_ensemble( NULL, NULL, NULL );
653 print_ensemble( ens, NULL );
656 ajouter_element( ens, -2 );
657 ajouter_element( ens, 3 );
658 ajouter_element( ens, 1 );
660 print_ensemble( ens, NULL );
663 liberer_ensemble( ens );
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
673 initialiser_elmt( &elmt, 1 );
674 ajouter_element( ens, (intptr_t) &elmt );
676 initialiser_elmt( &elmt, 5 );
677 ajouter_element( ens, (intptr_t) &elmt );
679 initialiser_elmt( &elmt, -1 );
680 ajouter_element( ens, (intptr_t) &elmt );
682 print_ensemble( ens, (
void(*)(
const intptr_t)) print_elmt );
685 liberer_ensemble( ens );
690 int test_swap_ensemble(){
693 Ensemble * ens1 = creer_ensemble( NULL, NULL, NULL );
695 ajouter_element( ens1, 1 );
696 ajouter_element( ens1, 2 );
697 ajouter_element( ens1, 5 );
699 Ensemble * ens2 = creer_ensemble( NULL, NULL, NULL );
701 ajouter_element( ens2, 3 );
702 ajouter_element( ens2, 4 );
704 swap_ensemble( ens1, ens2 );
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 );
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 );
715 liberer_ensemble( ens1 );
716 liberer_ensemble( ens2 );
721 int test_trouver_ensemble(){
724 Ensemble * ens1 = creer_ensemble( NULL, NULL, NULL );
726 ajouter_element( ens1, 1 );
727 ajouter_element( ens1, 2 );
728 ajouter_element( ens1, 5 );
732 TEST( ! iterateur_ensemble_est_vide( it ), result );
733 TEST( get_element( it ) == 2, result );
735 it = trouver_ensemble( ens1, -1 );
737 TEST( iterateur_ensemble_est_vide( it ), result );
739 liberer_ensemble( ens1 );
744 int test_premier_iterateur_ensemble(){
747 Ensemble * ens = creer_ensemble( NULL, NULL, NULL );
753 && iterateur_ensemble_est_vide(it)
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 );
768 it = premier_iterateur_ensemble( ens );
772 && ! iterateur_ensemble_est_vide(it)
773 && get_element(it) == -10
777 liberer_ensemble( ens );
782 int test_iterateur_suivant_ensemble(){
785 Ensemble * ens = creer_ensemble( NULL, NULL, NULL );
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 );
801 ! iterateur_ensemble_est_vide(it) && get_element(it) == -10, result
804 it = iterateur_suivant_ensemble( it );
806 ! iterateur_ensemble_est_vide(it) && get_element(it) == -4, result
809 it = iterateur_suivant_ensemble( it );
811 ! iterateur_ensemble_est_vide(it) && get_element(it) == -1, result
814 it = iterateur_suivant_ensemble( it );
816 ! iterateur_ensemble_est_vide(it) && get_element(it) == 1, result
819 it = iterateur_suivant_ensemble( it );
821 ! iterateur_ensemble_est_vide(it) && get_element(it) == 2, result
824 it = iterateur_suivant_ensemble( it );
826 ! iterateur_ensemble_est_vide(it) && get_element(it) == 4, result
829 it = iterateur_suivant_ensemble( it );
831 ! iterateur_ensemble_est_vide(it) && get_element(it) == 6, result
834 it = iterateur_suivant_ensemble( it );
836 ! iterateur_ensemble_est_vide(it) && get_element(it) == 9, result
839 it = iterateur_suivant_ensemble( it );
840 TEST( iterateur_ensemble_est_vide(it), result );
842 it = iterateur_suivant_ensemble( it );
844 ! iterateur_ensemble_est_vide(it) && get_element(it) == -10, result
847 liberer_ensemble( ens );
852 int test_iterateur_precedent_ensemble(){
855 Ensemble * ens = creer_ensemble( NULL, NULL, NULL );
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 );
871 ! iterateur_ensemble_est_vide(it) && get_element(it) == -10, result
874 it = iterateur_precedent_ensemble( it );
875 TEST( iterateur_ensemble_est_vide(it), result );
877 it = iterateur_precedent_ensemble( it );
879 ! iterateur_ensemble_est_vide(it) && get_element(it) == 9, result
882 it = iterateur_precedent_ensemble( it );
884 ! iterateur_ensemble_est_vide(it) && get_element(it) == 6, result
887 it = iterateur_precedent_ensemble( it );
889 ! iterateur_ensemble_est_vide(it) && get_element(it) == 4, result
892 it = iterateur_precedent_ensemble( it );
894 ! iterateur_ensemble_est_vide(it) && get_element(it) == 2, result
897 it = iterateur_precedent_ensemble( it );
899 ! iterateur_ensemble_est_vide(it) && get_element(it) == 1, result
902 it = iterateur_precedent_ensemble( it );
904 ! iterateur_ensemble_est_vide(it) && get_element(it) == -1, result
907 it = iterateur_precedent_ensemble( it );
909 ! iterateur_ensemble_est_vide(it) && get_element(it) == -4, result
912 it = iterateur_precedent_ensemble( it );
914 ! iterateur_ensemble_est_vide(it) && get_element(it) == -10, result
917 it = iterateur_precedent_ensemble( it );
918 TEST( iterateur_ensemble_est_vide(it), result );
921 liberer_ensemble( ens );
926 int test_iterateur_ensemble_est_vide(){
933 int test_get_element(){
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();
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();
967 fprintf( stderr,
"Certains tests du fichier %s ont échoués.\n", __FILE__ );