GCC Code Coverage Report

Directory: ./
File: Os/File.cpp
Date: 2026-09-03 21:13:48
Exec Total Coverage
Lines: 182 211 86.3%
Functions: 25 27 92.6%
Branches: 88 129 68.2%
Line Branch Exec Source
1 // ======================================================================
2 // \title Os/File.cpp
3 // \brief common function implementation for Os::File
4 // ======================================================================
5 #include <Fw/Types/Assert.hpp>
6 #include <Fw/Types/StringUtils.hpp>
7 #include <Os/File.hpp>
8 #include <algorithm>
9 #include <config/FppConstantsAc.hpp>
10
11 namespace Os {
12
13
6/6
✓ Branch 14 taken 44614 times.
✓ Branch 20 taken 22842368 times.
✓ Branch 21 taken 44614 times.
✓ Branch 27 taken 713824 times.
✓ Branch 28 taken 44614 times.
✓ Branch 34 taken 44614 times.
 23600806 File::File() : m_crc_buffer(), m_handle_storage(), m_delegate(*FileInterface::getDelegate(m_handle_storage)) {
14 44614 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
15 44614 }
16
17 179230 File::~File() {
18 89614 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
19
3/4
✗ Branch 3 not taken.
✓ Branch 4 taken 44807 times.
✓ Branch 5 taken 8450 times.
✓ Branch 6 taken 36357 times.
 89614 if (this->m_mode != OPEN_NO_MODE) {
20 16900 this->close();
21 }
22 89614 m_delegate.~FileInterface();
23 89616 }
24
25 291 File::File(const File& other)
26
1/2
✗ Branch 4 not taken.
✓ Branch 5 taken 291 times.
 291 : m_mode(other.m_mode),
27 291 m_hash(other.m_hash),
28
2/2
✓ Branch 4 taken 148992 times.
✓ Branch 5 taken 291 times.
 149283 m_crc_buffer(),
29
2/2
✓ Branch 4 taken 4656 times.
✓ Branch 5 taken 291 times.
 4947 m_handle_storage(),
30
1/1
✓ Branch 14 taken 291 times.
 582 m_delegate(*FileInterface::getDelegate(m_handle_storage, &other.m_delegate)) {
31 291 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
32 291 }
33
34 95 File& File::operator=(const File& other) {
35
1/2
✓ Branch 0 taken 95 times.
✗ Branch 1 not taken.
 95 if (this != &other) {
36 // The delegate below is constructed over the storage of the existing one. Any file this
37 // object currently holds must be closed first or its handle is orphaned permanently.
38
3/4
✗ Branch 3 not taken.
✓ Branch 4 taken 95 times.
✓ Branch 5 taken 73 times.
✓ Branch 6 taken 22 times.
 95 if (this->m_mode != OPEN_NO_MODE) {
39 73 this->close();
40 }
41 95 this->m_delegate.~FileInterface();
42
1/2
✗ Branch 5 not taken.
✓ Branch 6 taken 95 times.
 95 this->m_mode = other.m_mode;
43 95 this->m_hash = other.m_hash;
44 95 (void)FileInterface::getDelegate(m_handle_storage, &other.m_delegate);
45 95 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
46 }
47 95 return *this;
48 }
49
50 28768 File::Status File::open(const CHAR* filepath, File::Mode requested_mode) {
51 28768 return this->open(filepath, requested_mode, OverwriteType::NO_OVERWRITE);
52 }
53
54 32125 File::Status File::open(const CHAR* filepath, File::Mode requested_mode, File::OverwriteType overwrite) {
55 32125 FW_ASSERT(nullptr != filepath);
56 32125 return this->open(filepath, static_cast<FwSizeType>(FileNameStringSize + 1), requested_mode, overwrite);
57 }
58
59 ✗ File::Status File::open(const CHAR* filepath, FwSizeType length, File::Mode requested_mode) {
60 ✗ return this->open(filepath, length, requested_mode, OverwriteType::NO_OVERWRITE);
61 }
62
63 32142 File::Status File::open(const CHAR* filepath,
64 FwSizeType length,
65 File::Mode requested_mode,
66 File::OverwriteType overwrite) {
67 32142 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
68 32142 FW_ASSERT(nullptr != filepath);
69 32142 const FwSizeType string_len = static_cast<FwSizeType>(Fw::StringUtils::string_length(filepath, length));
70 32142 FW_ASSERT(string_len < length, static_cast<FwAssertArgType>(string_len), static_cast<FwAssertArgType>(length));
71 32142 FW_ASSERT(File::Mode::OPEN_NO_MODE < requested_mode && File::Mode::MAX_OPEN_MODE > requested_mode);
72 32142 FW_ASSERT((0 <= this->m_mode) && (this->m_mode < Mode::MAX_OPEN_MODE));
73 32142 FW_ASSERT((0 <= overwrite) && (overwrite < OverwriteType::MAX_OVERWRITE_TYPE));
74 // Check for already opened file
75
2/2
✓ Branch 4 taken 87 times.
✓ Branch 5 taken 32055 times.
 32142 if (this->isOpen()) {
76 87 return File::Status::INVALID_MODE;
77 }
78 32055 File::Status status = this->m_delegate.open(filepath, requested_mode, overwrite);
79
2/2
✓ Branch 0 taken 22475 times.
✓ Branch 1 taken 9580 times.
 32055 if (status == File::Status::OP_OK) {
80 22475 this->m_mode = requested_mode;
81 // Reset any open CRC calculations
82 22475 this->m_hash.init();
83 }
84
85 32055 return status;
86 }
87
88 ✗ File::Status File::open(const Fw::ConstStringBase& path, File::Mode requested_mode) {
89 ✗ return this->open(path.toChar(), static_cast<FwSizeType>(path.getCapacity()), requested_mode,
90 ✗ OverwriteType::NO_OVERWRITE);
91 }
92
93 12 File::Status File::open(const Fw::ConstStringBase& path, File::Mode requested_mode, File::OverwriteType overwrite) {
94 12 return this->open(path.toChar(), static_cast<FwSizeType>(path.getCapacity()), requested_mode, overwrite);
95 }
96
97 22718 void File::close() {
98 22718 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
99 22718 FW_ASSERT(this->m_mode < Mode::MAX_OPEN_MODE);
100 22718 FW_ASSERT((0 <= this->m_mode) && (this->m_mode < Mode::MAX_OPEN_MODE));
101 22718 this->m_delegate.close();
102 22718 this->m_mode = Mode::OPEN_NO_MODE;
103 22718 }
104
105 46242 bool File::isOpen() const {
106 46242 FW_ASSERT(&this->m_delegate == reinterpret_cast<const FileInterface*>(&this->m_handle_storage[0]));
107 46242 FW_ASSERT((0 <= this->m_mode) && (this->m_mode < Mode::MAX_OPEN_MODE));
108
1/2
✗ Branch 3 not taken.
✓ Branch 4 taken 46242 times.
 46242 return this->m_mode != Mode::OPEN_NO_MODE;
109 }
110
111 10452 File::Status File::size(FwSizeType& size_result) {
112 10452 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
113 10452 FW_ASSERT((0 <= this->m_mode) && (this->m_mode < Mode::MAX_OPEN_MODE));
114
2/4
✗ Branch 3 not taken.
✓ Branch 4 taken 10452 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 10452 times.
 10452 if (OPEN_NO_MODE == this->m_mode) {
115 ✗ return File::Status::NOT_OPENED;
116 }
117 10452 return this->m_delegate.size(size_result);
118 }
119
120 4904 File::Status File::position(FwSizeType& position_result) {
121 4904 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
122 4904 FW_ASSERT((0 <= this->m_mode) && (this->m_mode < Mode::MAX_OPEN_MODE));
123 // Check that the file is open before attempting operation
124
3/4
✗ Branch 3 not taken.
✓ Branch 4 taken 4904 times.
✓ Branch 5 taken 10 times.
✓ Branch 6 taken 4894 times.
 4904 if (OPEN_NO_MODE == this->m_mode) {
125 10 return File::Status::NOT_OPENED;
126 }
127 4894 return this->m_delegate.position(position_result);
128 }
129
130 79 File::Status File::preallocate(FwSizeType offset, FwSizeType length) {
131 79 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
132 79 FW_ASSERT((0 <= this->m_mode) && (this->m_mode < Mode::MAX_OPEN_MODE));
133 // Check that the file is open before attempting operation
134
3/4
✗ Branch 3 not taken.
✓ Branch 4 taken 79 times.
✓ Branch 5 taken 15 times.
✓ Branch 6 taken 64 times.
 79 if (OPEN_NO_MODE == this->m_mode) {
135 15 return File::Status::NOT_OPENED;
136
2/4
✗ Branch 3 not taken.
✓ Branch 4 taken 64 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 64 times.
 64 } else if (OPEN_READ == this->m_mode) {
137 ✗ return File::Status::INVALID_MODE;
138 }
139 64 return this->m_delegate.preallocate(offset, length);
140 }
141
142 279 File::Status File::seek(FwSignedSizeType offset, File::SeekType seekType) {
143 279 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
144 279 FW_ASSERT((0 <= seekType) && (seekType < SeekType::MAX_SEEK_TYPE));
145 // Cannot do a seek with a negative offset in absolute mode
146 279 FW_ASSERT((seekType == File::SeekType::RELATIVE) || (offset >= 0));
147 279 FW_ASSERT((0 <= this->m_mode) && (this->m_mode < Mode::MAX_OPEN_MODE));
148 // Check that the file is open before attempting operation
149
3/4
✗ Branch 3 not taken.
✓ Branch 4 taken 279 times.
✓ Branch 5 taken 26 times.
✓ Branch 6 taken 253 times.
 279 if (OPEN_NO_MODE == this->m_mode) {
150 26 return File::Status::NOT_OPENED;
151 }
152 253 return this->m_delegate.seek(offset, seekType);
153 }
154
155 42 File::Status File::seek_absolute(FwSizeType offset) {
156 42 Os::File::Status status = File::Status::OTHER_ERROR;
157 // If the offset can be represented by a signed value, then we can perform a single seek
158
1/2
✓ Branch 1 taken 42 times.
✗ Branch 2 not taken.
 42 if (static_cast<FwSizeType>(std::numeric_limits<FwSignedSizeType>::max()) >= offset) {
159 // Check that the bounding above is correct
160 42 FW_ASSERT(static_cast<FwSignedSizeType>(offset) >= 0);
161 42 status = this->seek(static_cast<FwSignedSizeType>(offset), File::SeekType::ABSOLUTE);
162 }
163 // Otherwise, a full seek to any value represented by FwSizeType can be performed
164 // by at most 3 seeks of a FwSignedSizeType. Two half seeks (rounded down) that are
165 // strictly bounded by std::numeric_limits<FwSignedSizeType>::max() and one seek of
166 // a possibile "odd" byte to ensure odds offsets do not introduce an off-by-one-error.
167 // Thus we perform 3 seeks to guarantee that we can reach any position.
168 else {
169 ✗ FwSignedSizeType half_offset = static_cast<FwSignedSizeType>(offset >> 1);
170 ✗ bool is_odd = (offset % 2) == 1;
171 ✗ status = this->seek(half_offset, File::SeekType::ABSOLUTE);
172 ✗ if (status == File::Status::OP_OK) {
173 ✗ status = this->seek(half_offset, File::SeekType::RELATIVE);
174 }
175 ✗ if (status == File::Status::OP_OK) {
176 ✗ status = this->seek((is_odd) ? 1 : 0, File::SeekType::RELATIVE);
177 }
178 }
179 42 return status;
180 }
181
182 92 File::Status File::flush() {
183 92 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
184 92 FW_ASSERT(this->m_mode < Mode::MAX_OPEN_MODE);
185 // Check that the file is open before attempting operation
186
3/4
✗ Branch 3 not taken.
✓ Branch 4 taken 92 times.
✓ Branch 5 taken 24 times.
✓ Branch 6 taken 68 times.
 92 if (OPEN_NO_MODE == this->m_mode) {
187 24 return File::Status::NOT_OPENED;
188
3/4
✗ Branch 3 not taken.
✓ Branch 4 taken 68 times.
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 66 times.
 68 } else if (OPEN_READ == this->m_mode) {
189 2 return File::Status::INVALID_MODE;
190 }
191 66 return this->m_delegate.flush();
192 }
193
194 8519 File::Status File::read(U8* buffer, FwSizeType& size) {
195 8519 return this->read(buffer, size, WaitType::WAIT);
196 }
197
198 253646 File::Status File::read(U8* buffer, FwSizeType& size, File::WaitType wait) {
199 253646 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
200 253646 FW_ASSERT(buffer != nullptr);
201 253646 FW_ASSERT(this->m_mode < Mode::MAX_OPEN_MODE);
202 // Check that the file is open before attempting operation
203
3/4
✗ Branch 3 not taken.
✓ Branch 4 taken 253646 times.
✓ Branch 5 taken 22 times.
✓ Branch 6 taken 253624 times.
 253646 if (OPEN_NO_MODE == this->m_mode) {
204 22 size = 0;
205 22 return File::Status::NOT_OPENED;
206
3/4
✗ Branch 3 not taken.
✓ Branch 4 taken 253624 times.
✓ Branch 5 taken 81 times.
✓ Branch 6 taken 253543 times.
 253624 } else if (OPEN_READ != this->m_mode) {
207 81 size = 0;
208 81 return File::Status::INVALID_MODE;
209 }
210 253543 return this->m_delegate.read(buffer, size, wait);
211 }
212
213 8017 File::Status File::write(const U8* buffer, FwSizeType& size) {
214 8017 return this->write(buffer, size, WaitType::WAIT);
215 }
216
217 8761 File::Status File::write(const U8* buffer, FwSizeType& size, File::WaitType wait) {
218 8761 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
219 8761 FW_ASSERT(buffer != nullptr);
220 8761 FW_ASSERT(this->m_mode < Mode::MAX_OPEN_MODE);
221 // Check that the file is open before attempting operation
222
3/4
✗ Branch 3 not taken.
✓ Branch 4 taken 8761 times.
✓ Branch 5 taken 30 times.
✓ Branch 6 taken 8731 times.
 8761 if (OPEN_NO_MODE == this->m_mode) {
223 30 size = 0;
224 30 return File::Status::NOT_OPENED;
225
3/4
✗ Branch 3 not taken.
✓ Branch 4 taken 8731 times.
✓ Branch 5 taken 3 times.
✓ Branch 6 taken 8728 times.
 8731 } else if (OPEN_READ == this->m_mode) {
226 3 size = 0;
227 3 return File::Status::INVALID_MODE;
228 }
229 8728 return this->m_delegate.write(buffer, size, wait);
230 }
231
232 2 FileHandle* File::getHandle() {
233 2 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
234 2 return this->m_delegate.getHandle();
235 }
236
237 108 File::Status File::calculateCrc(U32& crc) {
238 108 File::Status status = File::Status::OP_OK;
239 108 FwSizeType size = FW_FILE_CHUNK_SIZE;
240 108 crc = 0;
241
1/2
✓ Branch 1 taken 117 times.
✗ Branch 2 not taken.
 117 for (FwSizeType i = 0; i < std::numeric_limits<FwSizeType>::max(); i++) {
242
1/1
✓ Branch 4 taken 117 times.
 117 status = this->incrementalCrc(size);
243 // Break on eof or error
244
4/4
✓ Branch 0 taken 91 times.
✓ Branch 1 taken 26 times.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 82 times.
 117 if ((size != FW_FILE_CHUNK_SIZE) || (status != File::OP_OK)) {
245 break;
246 }
247 }
248 // When successful, finalize the CRC
249
2/2
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 84 times.
 108 if (status == File::OP_OK) {
250
1/1
✓ Branch 4 taken 24 times.
 24 status = this->finalizeCrc(crc);
251 }
252 108 return status;
253 }
254
255 214 File::Status File::incrementalCrc(FwSizeType& size) {
256 214 File::Status status = File::Status::OP_OK;
257 214 FW_ASSERT(size <= FW_FILE_CHUNK_SIZE, FwAssertArgType(size));
258
3/4
✗ Branch 3 not taken.
✓ Branch 4 taken 214 times.
✓ Branch 5 taken 41 times.
✓ Branch 6 taken 173 times.
 214 if (OPEN_NO_MODE == this->m_mode) {
259 41 status = File::Status::NOT_OPENED;
260
3/4
✗ Branch 3 not taken.
✓ Branch 4 taken 173 times.
✓ Branch 5 taken 135 times.
✓ Branch 6 taken 38 times.
 173 } else if (OPEN_READ != this->m_mode) {
261 135 status = File::Status::INVALID_MODE;
262 } else {
263 // Read data without waiting for additional data to be available
264 38 status = this->read(this->m_crc_buffer, size, File::WaitType::NO_WAIT);
265
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 2 times.
 38 if (OP_OK == status) {
266 36 FW_ASSERT(size <= FW_FILE_CHUNK_SIZE, FwAssertArgType(size));
267 36 this->m_hash.update(this->m_crc_buffer, size);
268 }
269 }
270 214 return status;
271 }
272
273 88 File::Status File::finalizeCrc(U32& crc) {
274 88 File::Status status = File::Status::OP_OK;
275 88 this->m_hash.finalize(crc);
276 // Historically, the CRC calculation in File omitted the final 1's complement step. Utils::Hash performs that step
277 // and as such, we must undo it before returning the value to ensure backwards compatibility.
278 88 crc = ~crc;
279 88 this->m_hash.init();
280 88 return status;
281 }
282
283 42 File::Status File::readline(U8* buffer, FwSizeType& size, File::WaitType wait) {
284 42 const FwSizeType requested_size = size;
285 42 FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
286 42 FW_ASSERT(buffer != nullptr);
287 42 FW_ASSERT(this->m_mode < Mode::MAX_OPEN_MODE);
288 // Check that the file is open before attempting operation
289
2/4
✗ Branch 3 not taken.
✓ Branch 4 taken 42 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 42 times.
 42 if (OPEN_NO_MODE == this->m_mode) {
290 ✗ size = 0;
291 ✗ return File::Status::NOT_OPENED;
292
2/4
✗ Branch 3 not taken.
✓ Branch 4 taken 42 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 42 times.
 42 } else if (OPEN_READ != this->m_mode) {
293 ✗ size = 0;
294 ✗ return File::Status::INVALID_MODE;
295 }
296 42 FwSizeType original_location = 0;
297
1/1
✓ Branch 4 taken 42 times.
 42 File::Status status = this->position(original_location);
298
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
 42 if (status != Os::File::Status::OP_OK) {
299 ✗ size = 0;
300 ✗ (void)this->seek_absolute(original_location);
301 ✗ return status;
302 }
303 42 FwSizeType read = 0;
304 // Loop reading chunk by chunk
305
1/2
✓ Branch 1 taken 42 times.
✗ Branch 2 not taken.
 42 for (FwSizeType i = 0; i < size; i += read) {
306 // read in chunks to avoid large buffer allocations
307 42 FwSizeType current_chunk_size = std::min(size - i, static_cast<FwSizeType>(FW_FILE_CHUNK_SIZE));
308 42 read = current_chunk_size;
309
1/1
✓ Branch 5 taken 42 times.
 42 status = this->read(buffer + i, read, wait);
310
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
 42 if (status != File::Status::OP_OK) {
311 // Contract: on error, seek back to the original location
312 ✗ size = 0;
313 ✗ (void)this->seek_absolute(original_location);
314 ✗ return status;
315 }
316 // EOF break out now
317
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
 42 if (read == 0) {
318 ✗ size = i;
319 ✗ return Os::File::Status::OP_OK;
320 }
321 // Loop from i to i + current_chunk_size looking for `\n`
322 42 const FwSizeType chunk_end = i + read;
323
1/2
✓ Branch 0 taken 1745 times.
✗ Branch 1 not taken.
 1745 for (FwSizeType j = i; j < chunk_end; j++) {
324 // Newline seek back to after it, return the size read
325
2/2
✓ Branch 2 taken 42 times.
✓ Branch 3 taken 1703 times.
 1745 if (buffer[j] == '\n') {
326 42 size = j + 1;
327 // Ensure that the computation worked and there is not overflow
328 42 FW_ASSERT(size <= requested_size);
329 42 FW_ASSERT(std::numeric_limits<FwSizeType>::max() - size >= original_location);
330
1/1
✓ Branch 4 taken 42 times.
 42 (void)this->seek_absolute(original_location + j + 1);
331 42 return Os::File::Status::OP_OK;
332 }
333 }
334 }
335 // Failed to find newline within data available
336 // Contract: on error, seek back to the original location
337 ✗ size = 0;
338 ✗ (void)this->seek_absolute(original_location);
339 ✗ return Os::File::Status::OTHER_ERROR;
340 }
341 } // namespace Os
342