diff --git a/Test_files/empty_input.txt b/Test_files/empty_input.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/expected_output.txt b/Test_files/expected_output.txt
similarity index 100%
rename from expected_output.txt
rename to Test_files/expected_output.txt
diff --git a/input.txt b/Test_files/input.txt
similarity index 100%
rename from input.txt
rename to Test_files/input.txt
diff --git a/Test_files/short_expected_output.txt b/Test_files/short_expected_output.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a0778ebfc98ae2779aa5d573883fb4c932f307a6
--- /dev/null
+++ b/Test_files/short_expected_output.txt
@@ -0,0 +1 @@
+981518 113 101 43 2
diff --git a/Test_files/short_input.txt b/Test_files/short_input.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aec1a34deb029de383a74552885b885bb7bcc561
--- /dev/null
+++ b/Test_files/short_input.txt
@@ -0,0 +1 @@
+981518
diff --git a/run.c b/run.c
index c9b8a3240b284c6c51ca24d5e79dc8beafc0613e..d036ada30adb109fe0d02e4c7948a405e41f9790 100755
--- a/run.c
+++ b/run.c
@@ -11,7 +11,7 @@
 #define N 4
 //travailler avec des linkendList
 typedef struct node{ 
-    long value;
+    unsigned long long value;
     struct node *next;
 }node_t;
 
@@ -101,18 +101,18 @@ queue_t *get_from_buffer_2(struct buffer_cw *buf){ // trouver un element
 }
 
 
-int is_div(long number, long i) { // Vérifie si i est un diviseur de number.
+int is_div(unsigned long long number, unsigned long long 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(long number) { // Vérifie si number est un nombre premier. Return 1 si il est premier, 0 sinon
+int is_prime(unsigned long long number) { // Vérifie si number est un nombre premier. Return 1 si il est premier, 0 sinon
     if (number != 2) {
         if (number  % 2 == 0) {
             return 0 ;
         }
     }
-    for (long i = 3 ; i <= (number/2); i = i + 2) { //regarde les differents nombres pouvant etre diviser number
+    for (unsigned long long i = 3 ; i <= (number/2); i = i + 2) { //regarde les differents nombres pouvant etre diviser number
         if (is_div(number,i) != 0) { // si i peut diviser number
             return 0 ; //renvoi 0 => FAUX
         }
@@ -121,7 +121,7 @@ int is_prime(long number) { // Vérifie si number est un nombre premier. Return
 }
 
 
-void enqueue(queue_t* q, long val){ 
+void enqueue(queue_t* q, unsigned long long val){ 
 
     
     struct node *ptr;
@@ -148,7 +148,7 @@ void enqueue(queue_t* q, long val){
 }
 
 
-queue_t* prime_divs(long number){
+queue_t* prime_divs(unsigned long long number){
 
     struct queue new_queue;
     new_queue.size = 0;
@@ -163,7 +163,7 @@ queue_t* prime_divs(long number){
         return NULL;}
     *ptr = new_queue;
 
-    for (long i = 2; i <= number/2; i++){
+    for (unsigned long long i = 2; i <= number/2; i++){
         if (is_div(number, i) && is_prime(i) == 1){
             enqueue(ptr,i);
         }
@@ -206,9 +206,12 @@ void *writing(void *param){
             *current = *pr_divs->tail;
             current = current->next;
 
-            for (int i = 0; i < pr_divs->size; i++)
+            fprintf(file2,"%lld",current->value);
+            current = current->next;
+
+            for (int i = 1; i < pr_divs->size; i++)
             {
-                fprintf(file2," %ld",current->value);
+                fprintf(file2," %lld",current->value);
                 current = current->next;
             }
             fputc('\n',file2);
@@ -256,7 +259,7 @@ void *calculating(void *param){
         pr_divs = malloc(sizeof(queue_t));
         if (pr_divs == NULL){return NULL;}
 
-        pr_divs = prime_divs(strtol(chaine,NULL,0));
+        pr_divs = prime_divs(strtoll(chaine,NULL,0));
 
         sem_wait(&empty2);
         pthread_mutex_lock(&mutex2);
@@ -274,18 +277,18 @@ void *reading (void *param){
 
     struct buffer_rc *param1= (struct buffer_rc *) param;
     
-    char chaine[20];
+    char chaine[30];
 
     FILE *input;
     //input = malloc(sizeof(FILE*));
     input = param1->file1;
 
     
-    while (fgets(chaine,20,input) != NULL){
+    while (fgets(chaine,30,input) != NULL){
         
         sem_wait(&empty1);
         pthread_mutex_lock(&mutex1);
-
+        
         put_in_buffer_1(chaine,param1);            //put each line in the buffer #1
         
         pthread_mutex_unlock(&mutex1);
@@ -413,6 +416,9 @@ int run (char *input,char *output){
 
     fclose(file1);
     fclose(file2);
+    free(ptr1);
+    free(ptr2);
+    free(ptr3);
 
     return 0;
 
diff --git a/short_input.txt b/short_input.txt
deleted file mode 100644
index 2ddce3f230f43aca53555281298fdce8e0336e85..0000000000000000000000000000000000000000
--- a/short_input.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-666343
-463698
diff --git a/test.c b/test.c
index fc78776f54778177c0d3925a7da8eddc01fe2e17..bef6de0a1dd9236a1f3717ff2152809504f78f0b 100644
--- a/test.c
+++ b/test.c
@@ -17,12 +17,70 @@ void test_is_prime(void){
 void test_is_not_prime(void){
     CU_ASSERT_FALSE(is_prime(14));
 }
+void empty_file_test(void){
+    FILE *file1 = NULL;
+    
+    int err = run("Test_files/empty_input.txt","actual_output.txt");
+    if (err == -1){
+        CU_FAIL("method run failed");
+        return;
+    }
+
+    file1 = fopen("actual_output.txt","r");
+    if (file1 == NULL){
+    CU_FAIL("actual_output opening fail");
+    return;
+    }
+
+    char chaine1[20];
+    CU_ASSERT_EQUAL(fgets(chaine1,20,file1),NULL);
+
+    fclose(file1); 
+
+    
+}
+void short_file_test(void){
+    FILE *file1 = NULL;
+    FILE *file2 = NULL;
+
+    file1 = fopen("Test_files/short_expected_output.txt","r");
+    if (file1 == NULL){
+        CU_FAIL("short_expected_output opening fail");
+        return;
+    }
+
+    int err = run("Test_files/short_input.txt","actual_output.txt");
+    if (err == -1){
+        CU_FAIL("method run failed");
+        return;
+    }
+
+    file2 = fopen("actual_output.txt","r");
+    if (file2 == NULL){
+    CU_FAIL("actual_output opening fail");
+    return;
+    }
+
+    char chaine1[50];
+    char chaine2[50];
+
+    while (fgets(chaine1,50,file1) != NULL && fgets(chaine2,50,file2) != NULL)
+    {
+        //printf("%s\n",chaine1);
+        //printf("%s\n",chaine2);
+        CU_ASSERT_STRING_EQUAL(chaine1,chaine2);
+        
+    }
+
+    fclose(file1);
+    fclose(file2);
+}
 
 void file_test(void){
     FILE *file1 = NULL;
     FILE *file2 = NULL;
 
-    file1 = fopen("expected_output.txt","r");
+    file1 = fopen("Test_files/expected_output.txt","r");
     if (file1 == NULL){
         CU_FAIL("expected_output opening fail");
         return;
@@ -32,7 +90,7 @@ void file_test(void){
     double time;
     start = clock();
 
-    int err = run("input.txt","actual_output.txt");
+    int err = run("Test_files/input.txt","actual_output.txt");
 
     end = clock();
     time = (double) (end - start) / CLOCKS_PER_SEC;
@@ -60,7 +118,7 @@ void file_test(void){
         //CU_ASSERT_STRING_EQUAL(chaine1,chaine2);
         n++;
     }
-    printf("%d",n);
+    //printf("%d",n);
     CU_ASSERT_EQUAL(n,100);
 
     fclose(file1);
@@ -97,9 +155,10 @@ int main(){
 
     if (NULL == CU_add_test(pSuite,"test_is_div",test_is_div) ||
         NULL == CU_add_test(pSuite, "test_is_prime",test_is_prime) ||
-        NULL == CU_add_test(pSuite, "test_is_not_prime",test_is_not_prime) 
-        || NULL == CU_add_test(pSuite,"file_test",file_test)
-    )
+        NULL == CU_add_test(pSuite, "test_is_not_prime",test_is_not_prime) || 
+        NULL == CU_add_test(pSuite,"empty_file_test",empty_file_test) ||
+        NULL == CU_add_test(pSuite,"short_file_test",short_file_test) ||
+        NULL == CU_add_test(pSuite,"file_test",file_test))
     {
         CU_cleanup_registry();
         return CU_get_error();