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