1 //===----------------------------------------------------------------------===//
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 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX26_REMOVED_CODECVT
10 // MSVC warning C4242: '+=': conversion from 'const _Ty' to 'size_t', possible loss of data
11 // MSVC warning C4244: 'argument': conversion from 'std::streamsize' to 'size_t', possible loss of data
12 // ADDITIONAL_COMPILE_FLAGS(cl-style-warnings): /wd4242 /wd4244
13 // UNSUPPORTED: c++03
14 
15 // <fstream>
16 
17 // This test checks the behavior of reading payloads of different sizes in different patterns.
18 // In particular, it was written to exercise code paths that deal with buffering inside the fstream
19 // implementation.
20 //
21 // For each test, we test various behaviors w.r.t. how the buffer is handled:
22 // - Provide a user-managed buffer to the library. In this case, we test the following corner-cases:
23 //    + A 0-sized buffer.
24 //    + A buffer size greater than and smaller than the payload size, which causes multiple buffer effects.
25 //      Important values are +/- 1 byte from the payload size.
26 // - Let the library manage a buffer of a user-provided size 'n'. In this case, we test the following corner-cases:
27 //    + A 0-sized buffer.
28 //    + A buffer size greater than and smaller than the payload size, which causes multiple buffer effects.
29 //      Important values are +/- 1 or 2 bytes from the payload size.
30 //    + A buffer size smaller than 8 bytes. If pubsetbuf() is called with less than 8 bytes, the library will
31 //      use __extbuf_min_ with 8 bytes instead of allocating anything.
32 // - Let the library manage a buffer, without specifying any size. In this case, the library will use the default
33 //   buffer size of 4096 bytes.
34 
35 #include <cassert>
36 #include <codecvt>
37 #include <fstream>
38 #include <locale>
39 #include <numeric>
40 #include <string>
41 #include <vector>
42 
43 #include "../types.h"
44 #include "assert_macros.h"
45 #include "platform_support.h"
46 #include "test_macros.h"
47 
48 template <class BufferPolicy>
test_read(BufferPolicy policy,const std::vector<std::streamsize> & payload_sizes)49 void test_read(BufferPolicy policy, const std::vector<std::streamsize>& payload_sizes) {
50   std::streamsize total_size = std::accumulate(payload_sizes.begin(), payload_sizes.end(), std::streamsize{0});
51   std::vector<char> data(total_size);
52   for (std::size_t i = 0; i < data.size(); ++i) {
53     data[i] = static_cast<char>(i % (1 << 8 * sizeof(char)));
54   }
55   std::string p = get_temp_file_name();
56   {
57     std::ofstream ofs;
58     ofs.open(p, std::ios::out | std::ios::binary);
59     assert(ofs.is_open());
60     ofs.write(data.data(), data.size());
61     assert(!ofs.fail());
62     // test that the user's out_buffer buffer was not modified by write()
63     for (std::streamsize j = 0; j < total_size; ++j) {
64       char exp = j % (1 << 8 * sizeof(char));
65       TEST_REQUIRE(data[j] == exp, [&] {
66         test_eprintf("failed after write() at offset %zu: got=%x, expected=%x\n", j, data[j], exp);
67       });
68     }
69     ofs.close();
70   }
71   {
72     std::ifstream ifs;
73     policy(ifs);
74     ifs.open(p, std::ios::ate | std::ios::binary);
75     assert(ifs.is_open());
76     const std::streamsize in_sz = ifs.tellg();
77     TEST_REQUIRE(in_sz == total_size, [&] { test_eprintf("out_sz = %zu, in_sz = %ld\n", total_size, in_sz); });
78     ifs.seekg(0, std::ios::beg);
79     std::size_t previously_read = 0;
80     std::vector<char> in_buffer(total_size);
81     for (const auto& payload_sz : payload_sizes) {
82       ifs.read(in_buffer.data() + previously_read, payload_sz);
83       assert(ifs);
84       for (std::streamsize j = 0; j < payload_sz; ++j) {
85         char exp = (previously_read + j) % (1 << 8 * sizeof(char));
86         TEST_REQUIRE(in_buffer[previously_read + j] == exp, [&] {
87           test_eprintf(
88               "failed after read() at offset %zu (offset %zu in chunk size %zu): got=%x, expected=%x\n",
89               previously_read + j,
90               j,
91               payload_sz,
92               in_buffer[previously_read + j],
93               exp);
94         });
95       }
96       previously_read += payload_sz;
97     }
98   }
99   std::remove(p.c_str());
100 }
101 
102 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
103 template <class BufferPolicy>
test_read_codecvt(BufferPolicy policy,const std::vector<std::streamsize> & payload_sizes)104 void test_read_codecvt(BufferPolicy policy, const std::vector<std::streamsize>& payload_sizes) {
105   std::streamsize total_size = std::accumulate(payload_sizes.begin(), payload_sizes.end(), std::streamsize{0});
106   std::vector<wchar_t> data(total_size);
107   for (std::size_t i = 0; i < data.size(); ++i) {
108     data[i] = static_cast<wchar_t>(i);
109   }
110   std::string p = get_temp_file_name();
111   {
112     std::wofstream ofs;
113     ofs.imbue(std::locale(std::locale::classic(), new std::codecvt_utf8<wchar_t>));
114     ofs.open(p, std::ios::out | std::ios::binary);
115     assert(ofs.is_open());
116     ofs.write(data.data(), data.size());
117     assert(!ofs.fail());
118     // test that the user's out_buffer buffer was not modified by write()
119     for (std::streamsize j = 0; j < total_size; ++j) {
120       wchar_t exp = static_cast<wchar_t>(j);
121       TEST_REQUIRE(data[j] == exp, [&] {
122         test_eprintf("failed after write() at offset %zu: got=%x, expected=%x\n", j, data[j], exp);
123       });
124     }
125     ofs.close();
126   }
127   {
128     std::wifstream ifs;
129     ifs.imbue(std::locale(std::locale::classic(), new std::codecvt_utf8<wchar_t>));
130     policy(ifs);
131     ifs.open(p, std::ios::in | std::ios::binary);
132     assert(ifs.is_open());
133     ifs.seekg(0, std::ios::beg);
134     std::size_t previously_read = 0;
135     std::vector<wchar_t> in_buffer(total_size);
136     for (const auto& payload_sz : payload_sizes) {
137       assert(ifs.read(in_buffer.data() + previously_read, payload_sz));
138       assert(ifs);
139       for (std::streamsize j = 0; j < payload_sz; ++j) {
140         wchar_t exp = static_cast<wchar_t>(j + previously_read);
141         TEST_REQUIRE(in_buffer[j + previously_read] == exp, [&] {
142           test_eprintf(
143               "failed after read() at offset %zu: got=%x, expected=%x\n", j, in_buffer[j + previously_read], exp);
144         });
145       }
146       previously_read += payload_sz;
147     }
148   }
149   std::remove(p.c_str());
150 }
151 #endif
152 
153 const std::vector<std::streamsize> buffer_sizes{0L, 3L, 8L, 9L, 11L};
154 const std::vector<std::streamsize> io_sizes{0L, 1L, 2L, 3L, 4L, 9L, 10L, 11L, 12L, 13L, 21L, 22L, 23L};
155 const std::vector<std::streamsize> io_sizes_default{
156     0L, 1L, 2L, 3L, 4L, 4094L, 4095L, 4096L, 4097L, 4098L, 8190L, 8191L, 8192L, 8193L, 8194L};
157 
158 // Test single read operations
test_1_read()159 void test_1_read() {
160   // with default library buffer size: 4096b
161   for (std::streamsize x : io_sizes_default) {
162     test_read(LibraryDefaultBuffer(), {x});
163 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
164     test_read_codecvt(LibraryDefaultBuffer(), {x});
165 #endif
166   }
167 
168   // with the library-managed buffer of given size
169   for (std::streamsize b : buffer_sizes) {
170     for (std::streamsize x : io_sizes) {
171       test_read(LibraryManagedBuffer(b), {x});
172 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
173       test_read_codecvt(LibraryManagedBuffer(b), {x});
174 #endif
175     }
176   }
177 
178   // with the user-managed buffer of given size
179   for (std::streamsize b : buffer_sizes) {
180     for (std::streamsize x : io_sizes) {
181       test_read(UserManagedBuffer(b), {x});
182 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
183       test_read_codecvt(UserManagedBuffer(b), {x});
184 #endif
185     }
186   }
187 }
188 
189 // Test two read operations
test_2_reads()190 void test_2_reads() {
191   // with default library buffer size: 4096b
192   for (std::streamsize a : io_sizes_default) {
193     for (std::streamsize b : io_sizes_default) {
194       test_read(LibraryDefaultBuffer(), {a, b});
195 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
196       test_read_codecvt(LibraryDefaultBuffer(), {a, b});
197 #endif
198     }
199   }
200 
201   // with the library-managed buffer of given size
202   for (std::streamsize buf : buffer_sizes) {
203     for (std::streamsize a : io_sizes) {
204       for (std::streamsize b : io_sizes) {
205         test_read(LibraryManagedBuffer(buf), {a, b});
206 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
207         test_read_codecvt(LibraryManagedBuffer(buf), {a, b});
208 #endif
209       }
210     }
211   }
212 
213   // with the user-managed buffer of given size
214   for (std::streamsize buf : buffer_sizes) {
215     for (std::streamsize a : io_sizes) {
216       for (std::streamsize b : io_sizes) {
217         test_read(UserManagedBuffer(buf), {a, b});
218 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
219         test_read_codecvt(UserManagedBuffer(buf), {a, b});
220 #endif
221       }
222     }
223   }
224 }
225 
main(int,char **)226 int main(int, char**) {
227   test_1_read();
228   test_2_reads();
229   return 0;
230 }
231