direct/timothy_tests/quick_tests/test_yaffs_read_EINVAL.c

   1 /*
   2  * YAFFS: Yet another FFS. A NAND-flash specific file system.
   3  *
   4  * Copyright (C) 2002-2010 Aleph One Ltd.
   5  *   for Toby Churchill Ltd and Brightstar Engineering
   6  *
   7  * Created by Timothy Manning <timothy@yaffs.net>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13
  14 #include "test_yaffs_read_EINVAL.h"
  15
  16 static int handle = -1;
  17 static char *file_name = NULL;
  18
  19 int test_yaffs_read_EINVAL(void)
  20 {
  21         int error_code = 0;
  22         handle=yaffs_open(FILE_PATH,O_CREAT | O_RDWR, FILE_MODE);
  23         char text[2000000]="\0";
  24         int output=0;
  25
  26         if (handle<0){
  27                 print_message("could not open file\n",2);
  28                 return -1;
  29         }
  30
  31         /*there needs a large amout of test in the file in order to trigger EINVAL */
  32         output=test_yaffs_read_EINVAL_init();
  33         if (output<0){
  34                 print_message("could not write text to the file\n",2);
  35                 return -1;
  36         }
  37
  38         if (handle>=0){
  39                 output=yaffs_read(handle, text, -1);
  40                 if (output<0){
  41                         error_code=yaffs_get_error();
  42                         if (abs(error_code)== EINVAL){
  43                                 return 1;
  44                         } else {
  45                                 print_message("different error than expected\n",2);
  46                                 return -1;
  47                         }
  48                 } else{
  49                         print_message("read a negative number of bytes (which is a bad thing)\n",2);
  50                         return -1;
  51                 }
  52         } else {
  53                 print_message("error opening file\n",2);
  54                 return -1;
  55         }
  56 }
  57
  58 int test_yaffs_read_EINVAL_clean(void)
  59 {
  60         int output=0;
  61         if (handle>=0){
  62                 if(file_name){
  63                         free(file_name);
  64                         file_name = NULL;
  65                 }
  66
  67
  68                 output= yaffs_truncate(FILE_PATH,FILE_SIZE );
  69                 if (output>=0){
  70                         output=test_yaffs_write();
  71                         if (output<0){
  72                                 print_message("failed to write to file\n",2);
  73                                 return -1;
  74                         } else {
  75                                 output=test_yaffs_write_clean();
  76                                 if (output<0){
  77                                         print_message("failed to clean the write_to_file function\n",2);
  78                                 }
  79                         }
  80                 } else {
  81                         print_message("failed to truncate file\n",2);
  82                         return -1;
  83                 }
  84
  85                 if(output>=0){
  86                         output=yaffs_close(handle);
  87                         if (output>=0){
  88                                 return 1;
  89                         } else {
  90                                 print_message("could not close the handle\n",2);
  91                                 return -1;
  92                         }
  93                 } else {
  94                         print_message("failed to fix the file\n",2);
  95                         return -1;
  96                 }
  97         } else {
  98                 print_message("no open handle\n",2);
  99                 return -1;
 100         }
 101 }
 102
 103 int test_yaffs_read_EINVAL_init(void)
 104 {
 105         int output=0;
 106         int x=0;
 107
 108         int file_name_length=1000000;
 109
 110         file_name = malloc(file_name_length);
 111         if(!file_name){
 112                 print_message("unable to create file text\n",2);
 113                 return -1;
 114         }
 115
 116         strcat(file_name,YAFFS_MOUNT_POINT);
 117         for (x=strlen(YAFFS_MOUNT_POINT); x<file_name_length -1; x++){
 118                 file_name[x]='a';
 119         }
 120         file_name[file_name_length-2]='\0';
 121
 122
 123
 124         if (handle>=0){
 125                 output= yaffs_write(handle, file_name, file_name_length-1);
 126                 if (output<0){
 127                         print_message("could not write text to file\n",2);
 128                         return -1;
 129                 } else {
 130
 131                         return 1;
 132                 }
 133
 134         } else {
 135                 print_message("error opening file\n",2);
 136                 return -1;
 137         }
 138
 139 }
 140
 141