test

Makefile

-all : projet_3
+all : run
 
-projet_3 : projet_3.o test.o
-			gcc -o projet_3 projet_3.o test.o
+run : run.o test.o
+			gcc -o run run.o test.o
 
 
-projet_3.o : projet_3.c
-			  gcc -o projet_3.o -c projet_3.c -W -Wall
+run.o : run.c
+			  gcc -o run.o -c run.c -W -Wall
 
 
-test.o : test.c projet_3.h
-		  gcc -o test.o -c test.c -W -Wall
+test.o : test.c run.h
+		  gcc -o test.o -c test.c -I${HOME}/local/include -W -Wall
 
 
 clean :

projet_3.c

-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <io.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-int is_div(int number, int i) { // Vérifie si i est un diviseur de number.
-    return (number % i == 0) ; // revoi 0 si le nombre n'est pas divisible par i et 1 si il est divisible
-}
-
-int is_prime(int number) { // Vérifie si number est un nombre premier. Return 1 si il est premier, 0 sinon
-    for (int i = 2 ; i < number ; i++) { //regarde les differents nombres pouvant etre diviser number
-        if (is_div(number,i) == 1) { // si i peut diviser number
-            return 0 ; //renvoi 0 => FAUX
-        }
-    }
-    return 1 ; //sinon => VRAI
-}
-
-// travail en likendList
-typedef struct node { // creation d'un node
-    struct node *next; // prochain
-    int *nombre_premier; // nombre_premier
-}node_t;
-
-typedef struct list {
-    int size; // taille de mon noeud
-    node_t *head ; // tete de mon noeud
-} list_t;
-
-list_t *init_node(int value, struct list *list) { // initialsier ma liste avec un premier noued
-
-    struct node *nouveau = malloc(sizeof(*nouveau)) ; // allouer de la memoire pour nouveau
-    if (nouveau == NULL) { // si malloc ne focntionne pas
-        return NULL ;
-    }
-    nouveau -> nombre_premier = (int *) value; // donne la valeur au noued
-    list -> head = nouveau ; // donne une valeur a head
-    list -> size = list -> size + 1 ;
-    nouveau -> next = NULL ; // suivant est NULL
-    return list ;
-}
-
-void add_node(list_t *list, int value)  { // si ne fonctionne pas 1 sinon 0
-    struct node *nouveau = malloc(sizeof(*nouveau)) ;  // allouer de la memoire pour nouveau
-    if (nouveau == NULL) { // si malloc rate
-        return ;
-    }
-    if (list == NULL) {
-        return;
-    }
-    nouveau -> nombre_premier = (int *) value ; // donne une valuer a nouveau
-    nouveau -> next = list -> head ; // ajoute son pointeur
-    list -> head = nouveau ;
-    list -> size = list -> size + 1 ; // augmente la taille de la liste
-}
-
-
-list_t * prime_divs(int number) {
-    // creation d'une stack pour emagasiner les différents nombre premier
-    int premier = 0 ; //pour que se soit le premier de La liste
-    list_t *list = NULL ;
-    for (int i = 2 ; i < number ; i++) {
-        if (is_prime(i) == 1 && is_div(number , i) == 1) { // si i est premier et divise number
-            if (premier == 0) { // si c'est le premier nombre initialise ma liste
-                list = init_node(i,list) ; // j'initialise ma liste
-                premier = 1 ; // ne reviens plus ici
-            }
-            else {
-                add_node(list,i) ; // je le mets dans ma liste
-            }
-        }
-    }
-    return list ;
-}
-
-void *afficherListe(list_t *liste) { // afficher la liste
-
-    if (liste == NULL) {
-        exit(EXIT_FAILURE);
-    }
-
-    node_t *noued = liste -> head;
-
-    while (noued != NULL)
-    {
-        printf("%d ", noued -> nombre_premier);
-        noued = noued -> next;
-    }
-    printf("NULL\n");
-}
-
-void ecrire_dans_fichier(char *input, char *output) {
-    int fichier_entree = open(input,O_RDONLY) ; // ouverture de fichier en mode lecture
-    // O_RDONLY , O_WRONLY ou O_RDWR .
-    //  respectivement l'ouverture du fichier en lecture seule, en écriture seule ou en lecture / écriture.
-    struct stat memoire ; // création de l'espace de la mémoire
-    if (fstat(fichier_entree,&memoire)) {
-        close(fichier_entree) ;
-        return;
-    }
-    /*fstat () obtient des informations d'état sur l'objet spécifié par le descripteur de descripteur ouvert et stocke les informations
-     * dans la zone de mémoire indiquée par l' argument tampon
-     * (Entrée) Le descripteur pour lequel les informations doivent être récupérées.
-     * (Sortie) Un pointeur vers un tampon de type struct stat dans lequel les informations sont retournées.
-     * Valeur de retour => 0 fstat () a réussi. Les informations sont renvoyées dans la mémoire tampon .
-     *                  => -1 fstat () n'a pas réussi. La variable globale errno est définie pour indiquer l'erreur.
-     */
-    int fichier_sortie = open(output,O_WRONLY,|O_TRUNC|O_CREAT) ; // ouverture du fichier en mode ecriture
-    if (fichier_entree == -1 || fichier_sortie == -1) { // si les fichier ne s'ouvrent pas correctement
-        return;
-    }
-    int check = ftruncate(fichier_sortie, memoire.st_size) ;
-    if (check == -1) {
-        close(fichier_entree) ;
-        close(fichier_sortie) ;
-        return;
-    }
-
-    char *line = malloc(sizeof(int)) ; // j'alloue de la memoire pour line
-    while (fgets (line, sizeof(int), (FILE *) fichier_entree) != NULL) { // lire les ligne du fichier input
-        // https://openclassrooms.com/forum/sujet/lire-un-fichier-ligne-a-ligne-48056
-        int nombre = strtol(line,NULL,0) ;
-        // Cette fonction, signifiant string to long, permet de transformer une chaîne de caractères, contenant
-        // la représentation textuelle d'un entier, en un entier type long.
-        void* mapping = mmap(NULL, sizeof(int),PROT_WRITE,MAP_SHARED,fichier_sortie,0) ;
-        /*Établir ne projection en mémoire des fichiers ou des périphériques   (
-        en qq sorte le malloc des fichier
-        argument :
-        1er => L'adresse de départ de la nouvelle projection
-        2eme => longueur
-        3eme => PROT_WRITE On peut écrire dans la zone mémoire.
-        4eme => MAP_SHARED Partager cette projection.
-        5eme => fihcier
-        6eme => ?
-        mmap() renvoie un pointeur sur la zone de mémoire, s'il réussit. En cas d'échec il retourne la valeur MAP_FAILED (c'est-à-dire (void *) -1)
-        http://manpagesfr.free.fr/man/man2/mmap.2.html
-        */
-        memcpy(mapping,line, sizeof(int)) ;
-        /*void * memcpy (void * dest, const void * src, size_t n) copie n caractères de la zone mémoire src vers la zone mémoire dest .
-        argument :
-        dest - Il s'agit du pointeur vers le tableau de destination où le contenu doit être copié, transtypé en un pointeur de type void *.
-        src - Il s'agit d'un pointeur vers la source des données à copier, transtypées en un pointeur de type void *.
-        n - Il s'agit du nombre d'octets à copier.
-        Cette fonction renvoie un pointeur vers la destination
-        https://www.tutorialspoint.com/c_standard_library/c_function_memcpy.htm
-        */
-        fputc((int) mapping, (FILE *) fichier_sortie) ; // Ecriture dans le fichier
-        list_t *liste = prime_divs(nombre) ;
-        if (liste == NULL) {
-            continue ;
-        }
-        else {
-            node_t *noued = liste -> head;
-            while (noued != NULL)
-            {
-                char *nombre_devient_char = NULL;
-                sprintf(nombre_devient_char, "%d", noued -> nombre_premier) ;
-                fputc((int) nombre_devient_char, (FILE *) fichier_sortie) ;
-                noued = noued -> next;
-            }
-            printf("\n");
-        }
-        munmap(mapping, sizeof(int)) ;
-    }
-}
-/* int main() {
-    // test pour is_div(int number, int i)
-    int number = 10 ;
-    int number1 = 11 ;
-    int i = 2 ;
-    printf("%d\n",is_div(number,i)) ; // 1
-    printf("%d\n",is_div(number1,i)) ; // 0
-    // test pour is_prime(int number)
-    int number2 = 1498498411 ;
-    int number3 = 5 ;
-    int number4 = 14545144 ;
-    printf("%d\n",is_prime(number2)) ; // 0
-    printf("%d\n",is_prime(number3)) ; // 1
-    printf("%d\n",is_prime(number4)) ; // 0
-    //prime divis
-    int numbre5 = 14 ;
-    list_t *liste = prime_divs(numbre5) ;
-    // je ne vois pas pq ca ne fonctionne pas
-    printf("%d\n",afficherListe(liste)) ;
-    return 0;
-} */
\ No newline at end of file

projet_3.h

-#ifndef PROJET
-#define PROJET
-
-int is_div(int number, int i);
-int is_prime(int number);
-list_t *init_node(int value, struct list *list);
-void add_node(list_t *list, int value);
-list_t * prime_divs(int number);
-void *afficherListe(list_t *liste);
-void ecrire_dans_fichier(char *input, char *output);
-
-#endif
\ No newline at end of file

run.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int is_div(int number, int i) { // Vérifie si i est un diviseur de number.
+    return (number % i == 0) ; // revoi 0 si le nombre n'est pas divisible par i et 1 si il est divisible
+}
+
+int is_prime(int number) { // Vérifie si number est un nombre premier. Return 1 si il est premier, 0 sinon
+    for (int i = 2 ; i < number ; i++) { //regarde les differents nombres pouvant etre diviser number
+        if (is_div(number,i) != 0) { // si i peut diviser number
+            return 0 ; //renvoi 0 => FAUX
+        }
+    }
+    return 1 ; //sinon => VRAI
+}
+
+int* prime_divs(int number){
+
+    int *ptr;
+    ptr = malloc(sizeof(int)*number);
+    ptr[0] = 0;
+    ptr[1] = 0;
+
+    int i;
+
+    for (i = 2; i < number; i++){
+        if (is_prime(i) == 1 && is_div(number, i)){
+			ptr[i] = i;
+        }
+        else
+        {
+            ptr[i] = 0;
+        }
+
+    }
+    ptr[i] = -1;
+    return ptr;
+
+}
+
+void afficherListe(int* tab) { // afficher la liste
+
+    for (int i = 0; tab[i] != -1; i++)
+    {
+        if (tab[i] != 0){
+        printf("%d\n",tab[i]);
+
+        }
+    }
+
+
+}
+
+/* int main() {
+    // test pour is_div(int number, int i)
+    int number = 10 ;
+    int number1 = 11 ;
+    int i = 3 ;
+    printf("%d\n",is_div(number,i)) ; // 1
+    printf("%d\n",is_div(number1,i)) ; // 0
+    // test pour is_prime(int number)
+    int number2 = 1498498411 ;
+    int number3 = 5 ;
+    int number4 = 14545144 ;
+    printf("%d\n",is_prime(number2)) ; // 0
+    printf("%d\n",is_prime(number3)) ; // 1
+    printf("%d\n",is_prime(number4)) ; // 0
+    //prime divis
+    afficherListe(prime_divs(number));
+    return 0;
+} */
\ No newline at end of file

run.h

+#ifndef RUN
+#define RUN
+
+int is_div(int number, int i);
+int is_prime(int number);
+int* prime_divs(int number);
+void afficherListe(int* tab);
+
+#endif
\ No newline at end of file

test.c

 #include <stdlib.h>
 #include <stdio.h>
-#include "projet_3.h"
+#include "run.h"
+#include <CUnit/CUnit.h>
+#include <CUnit/TestRun.h>
+#include <CUnit/CUError.h>
 
 void test_is_div(void){
     CU_ASSERT_TRUE(is_div(14,7));
 }
 
 
+int main(){
 
+    if (CUE_SUCCESS != CU_initialize_registry())
+    {
+        return CU_get_error();
+    }
 
-if (CUE_SUCCESS != CU_initialize_registry())
-{
-    return CU_get_error();
-}
+    int setup(void){
+        return 0;
+    }
 
-int setup(void){
-    return 0;
-}
+    int teardown(void)
+    {
+        return 0;
+    }
 
-int teardown(void)
-{
-    return 0;
-}
-CU_pSuite pSuite = NULL;
 
-pSuite = CU_add_suite("ma_suite",setup,teardown);
+    CU_pSuite pSuite = NULL;
 
-if (NULL == pSuite)
-{
-    CU_cleanup_registry();
-    return CU_get_error();
-}
+    pSuite = CU_add_suite("ma_suite",setup,teardown);
 
-if (NULL == CU_add_test(pSuite,"test_is_div",test_is_div))
-{
-    CU_cleanup_registry();
-    return CU_get_error();
-}
+    if (NULL == pSuite)
+    {
+        CU_cleanup_registry();
+        return CU_get_error();
+    }
+
+    if (NULL == CU_add_test(pSuite,"test_is_div",test_is_div))
+    {
+        CU_cleanup_registry();
+        return CU_get_error();
+    }
 
 
-CU_basic_run_tests();
-CU_basic_show_failures(CU_get_failure_list());
+    CU_basic_run_tests();
+    CU_basic_show_failures(CU_get_failure_list());
\ No newline at end of file
+}
\ No newline at end of file