libc/test/src/stdio/fileop_test.cpp

   1 //===-- Unittests for file operations like fopen, flcose etc --------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "src/stdio/clearerr.h"
  10 #include "src/stdio/fclose.h"
  11 #include "src/stdio/feof.h"
  12 #include "src/stdio/ferror.h"
  13 #include "src/stdio/fflush.h"
  14 #include "src/stdio/fopen.h"
  15 #include "src/stdio/fputs.h"
  16 #include "src/stdio/fread.h"
  17 #include "src/stdio/fseek.h"
  18 #include "src/stdio/fwrite.h"
  19 #include "test/UnitTest/ErrnoSetterMatcher.h"
  20 #include "test/UnitTest/Test.h"
  21
  22 #include "src/errno/libc_errno.h"
  23 #include <stdio.h>
  24
  25 using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::EQ;
  26 using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::NE;
  27 using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::returns;
  28
  29 TEST(LlvmLibcFILETest, SimpleFileOperations) {
  30   constexpr char FILENAME[] = "testdata/simple_operations.test";
  31   ::FILE *file = LIBC_NAMESPACE::fopen(FILENAME, "w");
  32   ASSERT_FALSE(file == nullptr);
  33   constexpr char CONTENT[] = "1234567890987654321";
  34   ASSERT_EQ(sizeof(CONTENT) - 1,
  35             LIBC_NAMESPACE::fwrite(CONTENT, 1, sizeof(CONTENT) - 1, file));
  36
  37   // This is not a readable file.
  38   char read_data[sizeof(CONTENT)];
  39   ASSERT_THAT(LIBC_NAMESPACE::fread(read_data, 1, sizeof(CONTENT), file),
  40               returns(EQ(size_t(0))).with_errno(NE(0)));
  41   ASSERT_NE(LIBC_NAMESPACE::ferror(file), 0);
  42   libc_errno = 0;
  43
  44   LIBC_NAMESPACE::clearerr(file);
  45   ASSERT_EQ(LIBC_NAMESPACE::ferror(file), 0);
  46
  47   ASSERT_EQ(0, LIBC_NAMESPACE::fclose(file));
  48
  49   file = LIBC_NAMESPACE::fopen(FILENAME, "r");
  50   ASSERT_FALSE(file == nullptr);
  51
  52   constexpr size_t READ_SIZE = 5;
  53   char data[READ_SIZE];
  54   data[READ_SIZE - 1] = '\0';
  55   ASSERT_EQ(LIBC_NAMESPACE::fread(data, 1, READ_SIZE - 1, file), READ_SIZE - 1);
  56   ASSERT_STREQ(data, "1234");
  57   ASSERT_EQ(LIBC_NAMESPACE::fseek(file, 5, SEEK_CUR), 0);
  58   ASSERT_EQ(LIBC_NAMESPACE::fread(data, 1, READ_SIZE - 1, file), READ_SIZE - 1);
  59   ASSERT_STREQ(data, "0987");
  60   ASSERT_EQ(LIBC_NAMESPACE::fseek(file, -5, SEEK_CUR), 0);
  61   ASSERT_EQ(LIBC_NAMESPACE::fread(data, 1, READ_SIZE - 1, file), READ_SIZE - 1);
  62   ASSERT_STREQ(data, "9098");
  63
  64   // Reading another time should trigger eof.
  65   ASSERT_NE(sizeof(CONTENT),
  66             LIBC_NAMESPACE::fread(read_data, 1, sizeof(CONTENT), file));
  67   ASSERT_NE(LIBC_NAMESPACE::feof(file), 0);
  68
  69   // Should be an error to write.
  70   ASSERT_THAT(LIBC_NAMESPACE::fwrite(CONTENT, 1, sizeof(CONTENT), file),
  71               returns(EQ(size_t(0))).with_errno(NE(0)));
  72   ASSERT_NE(LIBC_NAMESPACE::ferror(file), 0);
  73   libc_errno = 0;
  74
  75   LIBC_NAMESPACE::clearerr(file);
  76
  77   // Should be an error to puts.
  78   ASSERT_THAT(LIBC_NAMESPACE::fputs(CONTENT, file),
  79               returns(EQ(EOF)).with_errno(NE(0)));
  80   ASSERT_NE(LIBC_NAMESPACE::ferror(file), 0);
  81   libc_errno = 0;
  82
  83   LIBC_NAMESPACE::clearerr(file);
  84   ASSERT_EQ(LIBC_NAMESPACE::ferror(file), 0);
  85
  86   libc_errno = 0;
  87   ASSERT_THAT(LIBC_NAMESPACE::fwrite("nothing", 1, 1, file),
  88               returns(EQ(0)).with_errno(NE(0)));
  89   libc_errno = 0;
  90
  91   ASSERT_EQ(LIBC_NAMESPACE::fclose(file), 0);
  92
  93   // Now try puts.
  94   file = LIBC_NAMESPACE::fopen(FILENAME, "w");
  95   ASSERT_FALSE(file == nullptr);
  96   // fputs returns a negative value on error (EOF) or any non-negative value on
  97   // success. This assert checks that the return value is non-negative.
  98   ASSERT_GE(LIBC_NAMESPACE::fputs(CONTENT, file), 0);
  99
 100   LIBC_NAMESPACE::clearerr(file);
 101   ASSERT_EQ(LIBC_NAMESPACE::ferror(file), 0);
 102
 103   // This is not a readable file.
 104   libc_errno = 0;
 105   ASSERT_THAT(LIBC_NAMESPACE::fread(data, 1, 1, file),
 106               returns(EQ(0)).with_errno(NE(0)));
 107   libc_errno = 0;
 108
 109   ASSERT_EQ(0, LIBC_NAMESPACE::fclose(file));
 110
 111   file = LIBC_NAMESPACE::fopen(FILENAME, "r");
 112   ASSERT_FALSE(file == nullptr);
 113
 114   ASSERT_EQ(LIBC_NAMESPACE::fread(read_data, 1, sizeof(CONTENT) - 1, file),
 115             sizeof(CONTENT) - 1);
 116   read_data[sizeof(CONTENT) - 1] = '\0';
 117   ASSERT_STREQ(read_data, CONTENT);
 118   ASSERT_EQ(LIBC_NAMESPACE::fclose(file), 0);
 119
 120   // Check that the other functions correctly set libc_errno.
 121
 122   // libc_errno = 0;
 123   // ASSERT_NE(LIBC_NAMESPACE::fseek(file, 0, SEEK_SET), 0);
 124   // EXPECT_NE(libc_errno, 0);
 125
 126   // libc_errno = 0;
 127   // ASSERT_NE(LIBC_NAMESPACE::fclose(file), 0);
 128   // EXPECT_NE(libc_errno, 0);
 129
 130   // libc_errno = 0;
 131   // ASSERT_EQ(LIBC_NAMESPACE::fopen("INVALID FILE NAME", "r"),
 132   //           static_cast<FILE *>(nullptr));
 133   // EXPECT_NE(libc_errno, 0);
 134 }
 135
 136 TEST(LlvmLibcFILETest, FFlush) {
 137   constexpr char FILENAME[] = "testdata/fflush.test";
 138   ::FILE *file = LIBC_NAMESPACE::fopen(FILENAME, "w+");
 139   ASSERT_FALSE(file == nullptr);
 140   constexpr char CONTENT[] = "1234567890987654321";
 141   ASSERT_EQ(sizeof(CONTENT),
 142             LIBC_NAMESPACE::fwrite(CONTENT, 1, sizeof(CONTENT), file));
 143
 144   // Flushing at this point should write the data to disk. So, we should be
 145   // able to read it back.
 146   ASSERT_EQ(0, LIBC_NAMESPACE::fflush(file));
 147
 148   char data[sizeof(CONTENT)];
 149   ASSERT_EQ(LIBC_NAMESPACE::fseek(file, 0, SEEK_SET), 0);
 150   ASSERT_EQ(LIBC_NAMESPACE::fread(data, 1, sizeof(CONTENT), file),
 151             sizeof(CONTENT));
 152   ASSERT_STREQ(data, CONTENT);
 153
 154   ASSERT_EQ(LIBC_NAMESPACE::fclose(file), 0);
 155 }
 156
 157 TEST(LlvmLibcFILETest, FOpenFWriteSizeGreaterThanOne) {
 158   using MyStruct = struct {
 159     char c;
 160     unsigned long long i;
 161   };
 162   constexpr MyStruct WRITE_DATA[] = {{'a', 1}, {'b', 2}, {'c', 3}};
 163   constexpr size_t WRITE_NMEMB = sizeof(WRITE_DATA) / sizeof(MyStruct);
 164   constexpr char FILENAME[] = "testdata/fread_fwrite.test";
 165
 166   libc_errno = 0;
 167   FILE *file = LIBC_NAMESPACE::fopen(FILENAME, "w");
 168   ASSERT_FALSE(file == nullptr);
 169   ASSERT_EQ(size_t(0), LIBC_NAMESPACE::fwrite(WRITE_DATA, 0, 1, file));
 170   ASSERT_THAT(
 171       LIBC_NAMESPACE::fwrite(WRITE_DATA, sizeof(MyStruct), WRITE_NMEMB, file),
 172       returns(EQ(WRITE_NMEMB)).with_errno(EQ(0)));
 173   ASSERT_EQ(LIBC_NAMESPACE::fclose(file), 0);
 174
 175   file = LIBC_NAMESPACE::fopen(FILENAME, "r");
 176   ASSERT_FALSE(file == nullptr);
 177   MyStruct read_data[WRITE_NMEMB];
 178   ASSERT_EQ(size_t(0), LIBC_NAMESPACE::fread(read_data, 0, 1, file));
 179   ASSERT_THAT(
 180       LIBC_NAMESPACE::fread(read_data, sizeof(MyStruct), WRITE_NMEMB, file),
 181       returns(EQ(WRITE_NMEMB)).with_errno(EQ(0)));
 182   // Trying to read more should fetch nothing.
 183   ASSERT_THAT(
 184       LIBC_NAMESPACE::fread(read_data, sizeof(MyStruct), WRITE_NMEMB, file),
 185       returns(EQ(0)).with_errno(EQ(0)));
 186   EXPECT_NE(LIBC_NAMESPACE::feof(file), 0);
 187   EXPECT_EQ(LIBC_NAMESPACE::ferror(file), 0);
 188   ASSERT_EQ(LIBC_NAMESPACE::fclose(file), 0);
 189   // Verify that the data which was read is correct.
 190   for (size_t i = 0; i < WRITE_NMEMB; ++i) {
 191     ASSERT_EQ(read_data[i].c, WRITE_DATA[i].c);
 192     ASSERT_EQ(read_data[i].i, WRITE_DATA[i].i);
 193   }
 194 }