cf4984a3d4dd562ec7d642311cc039061d993e60
[gps-watch.git] / test / logger_test.rs
1 /*
2  * Copyright (c) 2020 Tilman Sauerbeck (tilman at code-monkey de)
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining
5  * a copy of this software and associated documentation files (the
6  * "Software"), to deal in the Software without restriction, including
7  * without limitation the rights to use, copy, modify, merge, publish,
8  * distribute, sublicense, and/or sell copies of the Software, and to
9  * permit persons to whom the Software is furnished to do so, subject to
10  * the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be
13  * included in all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
19  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
20  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
21  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22  */
23
24 use std::io::{Read, Write};
25 use std::os::unix::io::FromRawFd;
26 use common::buffer::{Buffer, BufferUserData};
27 use common::gps;
28 use common::storage::{Storage, Error};
29 use common::logger::{MEMORY_SIZE, Logger, Error as LoggerError};
30
31 struct FakeStorage {
32     expected: Box<[u8]>,
33     actual: Box<[u8]>,
34 }
35
36 impl FakeStorage {
37     fn new() -> FakeStorage {
38         FakeStorage {
39             expected: vec![0xff; MEMORY_SIZE].into_boxed_slice(),
40             actual: vec![0xff; MEMORY_SIZE].into_boxed_slice(),
41         }
42     }
43 }
44
45 impl Storage for FakeStorage {
46     fn size(&self) -> usize {
47         MEMORY_SIZE
48     }
49
50     fn read(&self, address: usize, buffer: &mut [u8]) {
51         for i in 0..buffer.len() {
52             buffer[i] = self.actual[address + i];
53         }
54     }
55
56     fn write(&mut self, address: usize, buffer: &[u8; 4096]) -> Result<(), Error> {
57         if (address & 4095) != 0 {
58             return Err(Error::UnalignedAddress);
59         }
60
61         for i in 0..buffer.len() {
62             self.actual[address + i] = buffer[i];
63         }
64
65         Ok(())
66     }
67
68     fn clear(&mut self) {
69         self.actual = vec![0xff; MEMORY_SIZE].into_boxed_slice();
70     }
71 }
72
73 struct Pipe {
74     pipe_fd: [i32; 2],
75 }
76
77 impl Pipe {
78     fn new() -> Pipe {
79         let mut pipe_fd = [-1i32; 2];
80
81         unsafe {
82             extern {
83                 fn pipe2(pipefd: *mut i32, flags: i32) -> i32;
84             }
85
86             const O_NONBLOCK : i32 = 0x800;
87
88             pipe2(pipe_fd.as_mut_ptr(), O_NONBLOCK);
89         }
90
91         Pipe {
92             pipe_fd: pipe_fd,
93         }
94     }
95
96     fn read_fd(&self) -> i32 {
97         self.pipe_fd[0]
98     }
99
100     fn write_fd(&self) -> i32 {
101         self.pipe_fd[1]
102     }
103 }
104
105 // Runs a couple of recordings on fully erased flash memory.
106 #[test]
107 fn first_recording() {
108     let mut fake_storage = FakeStorage::new();
109
110     let mut logger = Logger::new(&mut fake_storage);
111     logger.init();
112
113     let tap = gps::TimeAndPos {
114         system_time: 0,
115         unix_time: 1478026311,
116         latitude: 0x73234e,
117         longitude: 0x73234f,
118     };
119
120     let recording_id = logger.start_recording(&tap);
121     assert_eq!(1, recording_id);
122
123     let sectors_written = logger.stop_recording(&tap);
124     assert_eq!(1, sectors_written);
125
126     let expected = [
127         // Header:
128         0x01, 0x00, 0x01, 0x00,
129         0x47, 0xe4, 0x18, 0x58,
130
131         // First point:
132         0x03,
133         0x00,
134         0x9c, 0x8d, 0x99, 0x07,
135         0x9e, 0x8d, 0x99, 0x07,
136
137         // Sentinel:
138         0xff, 0xff, 0xff, 0xff, 0x0f,
139
140         // Footer:
141         0x00, 0x00
142     ];
143
144     let start = 0;
145     let end = start + expected.len();
146     fake_storage.expected[start..end].copy_from_slice(&expected);
147
148     assert_eq!(fake_storage.expected, fake_storage.actual);
149 }
150
151 #[test]
152 fn second_recording() {
153     let mut fake_storage = FakeStorage::new();
154
155     // Mark first sector as in use.
156     let recording0 = [
157         // Header:
158         0x01, 0x00, 0x01, 0x00,
159     ];
160
161     fake_storage.expected[0..recording0.len()].copy_from_slice(&recording0);
162     fake_storage.actual[0..recording0.len()].copy_from_slice(&recording0);
163
164     let mut logger = Logger::new(&mut fake_storage);
165     logger.init();
166
167     let tap = gps::TimeAndPos {
168         system_time: 0,
169         unix_time: 1478026312,
170         latitude: 0x73234e,
171         longitude: 0x73234f,
172     };
173
174     let recording_id = logger.start_recording(&tap);
175     assert_eq!(2, recording_id);
176
177     let sectors_written = logger.stop_recording(&tap);
178     assert_eq!(1, sectors_written);
179
180     let expected = [
181         // Header:
182         0x01, 0x00, 0x02, 0x00,
183         0x48, 0xe4, 0x18, 0x58,
184
185         // First point:
186         0x03,
187         0x00,
188         0x9c, 0x8d, 0x99, 0x07,
189         0x9e, 0x8d, 0x99, 0x07,
190
191         // Sentinel:
192         0xff, 0xff, 0xff, 0xff, 0x0f,
193
194         // Footer:
195         0x00, 0x00
196     ];
197
198     let start = 4096;
199     let end = start + expected.len();
200     fake_storage.expected[start..end].copy_from_slice(&expected);
201
202     assert_eq!(fake_storage.expected, fake_storage.actual);
203 }
204
205 #[test]
206 fn multi_sector_recording() {
207     let mut fake_storage = FakeStorage::new();
208
209     let mut logger = Logger::new(&mut fake_storage);
210     logger.init();
211
212     let tap = gps::TimeAndPos {
213         system_time: 0,
214         unix_time: 1578425250,
215         latitude: 0x73234e,
216         longitude: 0x73234f,
217     };
218
219     let recording_id = logger.start_recording(&tap);
220     assert_eq!(1, recording_id);
221
222     let mut prev_tap = tap;
223
224     for _ in 0..2048 {
225         let tap = gps::TimeAndPos {
226             system_time: 0,
227             unix_time: prev_tap.unix_time + 1,
228             latitude: prev_tap.latitude + 1,
229             longitude: prev_tap.longitude + 1,
230         };
231
232         logger.log(&prev_tap, &tap);
233
234         prev_tap = tap;
235     }
236
237     let sectors_written = logger.stop_recording(&tap);
238     assert_eq!(2, sectors_written);
239
240     let header0 = [
241         0x01, 0x00, 0x01, 0x00,
242     ];
243
244     let header1 = [
245         0x03, 0x00, 0x01, 0x00,
246     ];
247
248     assert_eq!(header0, fake_storage.actual[0..(0 + header0.len())]);
249     assert_eq!(header1, fake_storage.actual[4096..(4096 + header1.len())]);
250 }
251
252 extern "C" fn flush_write_buffer(user_data: *mut BufferUserData,
253                                  buf: *const u8,
254                                  _bufsiz: usize,
255                                  count: usize) -> isize {
256     let _file = user_data as *mut std::fs::File;
257
258     unsafe {
259         let file = &mut * _file;
260
261         file.write_all(std::slice::from_raw_parts(buf, count)).unwrap();
262     }
263
264     count as isize
265 }
266
267 // Verifies that Logger::get_recording() detects unknown recording IDs.
268 #[test]
269 fn get_recording_invalid() {
270     let pipe = Pipe::new();
271
272     let mut file = unsafe { std::fs::File::from_raw_fd(pipe.write_fd()) };
273
274     let mut yenc_buffer_space = [0u8; 8192];
275     let mut yenc_buffer = Buffer::alloc();
276
277     let user_data = (&mut file as *mut std::fs::File) as *mut BufferUserData;
278
279     yenc_buffer.init(yenc_buffer_space.as_mut_ptr(),
280                      yenc_buffer_space.len(),
281                      flush_write_buffer,
282                      user_data);
283
284     let mut fake_storage = FakeStorage::new();
285
286     let mut logger = Logger::new(&mut fake_storage);
287     logger.init();
288
289     // Zero is never a valid recording id.
290     let result = logger.get_recording(0, &mut yenc_buffer);
291     assert_eq!(LoggerError::NoSuchRecording, result.unwrap_err());
292
293     let result = logger.get_recording(1, &mut yenc_buffer);
294     assert_eq!(LoggerError::NoSuchRecording, result.unwrap_err());
295 }
296
297 // Verifies that Logger::get_recording() can retrieve finished recordings.
298 #[test]
299 fn get_recording_valid() {
300     let pipe = Pipe::new();
301
302     let mut file = unsafe { std::fs::File::from_raw_fd(pipe.write_fd()) };
303
304     let mut yenc_buffer_space = [0u8; 8192];
305     let mut yenc_buffer = Buffer::alloc();
306
307     let user_data = (&mut file as *mut std::fs::File) as *mut BufferUserData;
308
309     yenc_buffer.init(yenc_buffer_space.as_mut_ptr(),
310                      yenc_buffer_space.len(),
311                      flush_write_buffer,
312                      user_data);
313
314     let mut fake_storage = FakeStorage::new();
315
316     let mut logger = Logger::new(&mut fake_storage);
317     logger.init();
318
319     let result = logger.get_recording(1, &mut yenc_buffer);
320     assert_eq!(LoggerError::NoSuchRecording, result.unwrap_err());
321
322     let tap0 = gps::TimeAndPos {
323         system_time: 0,
324         unix_time: 1478026311,
325         latitude: 0x73234e,
326         longitude: 0x73234f,
327     };
328
329     logger.start_recording(&tap0);
330
331     let tap1 = gps::TimeAndPos {
332         system_time: 0,
333         unix_time: 1478026311 + 1,
334         latitude: 0x73234e + 5,
335         longitude: 0x73234f + 5,
336     };
337
338     logger.log(&tap0, &tap1);
339
340     let tap2 = gps::TimeAndPos {
341         system_time: 0,
342         unix_time: 1478026311 + 2,
343         latitude: 0x73234e + 10,
344         longitude: 0x73234f + 10,
345     };
346
347     logger.log(&tap1, &tap2);
348
349     logger.stop_recording(&tap2);
350
351     assert!(logger.get_recording(1, &mut yenc_buffer).is_ok());
352 }
353
354 // Verifies that Logger::list_recordings() shows an empty listing
355 // if there are no recordings.
356 #[test]
357 fn list_recordings0() {
358     let pipe = Pipe::new();
359
360     let mut file = unsafe { std::fs::File::from_raw_fd(pipe.write_fd()) };
361
362     let mut ls_buffer_space = [0u8; 4096];
363     let mut ls_buffer = Buffer::alloc();
364
365     let user_data = (&mut file as *mut std::fs::File) as *mut BufferUserData;
366
367     ls_buffer.init(ls_buffer_space.as_mut_ptr(),
368                    ls_buffer_space.len(),
369                    flush_write_buffer,
370                    user_data);
371
372     let mut fake_storage = FakeStorage::new();
373
374     let mut logger = Logger::new(&mut fake_storage);
375     logger.init();
376
377     logger.list_recordings(&mut ls_buffer);
378
379     let mut file = unsafe { std::fs::File::from_raw_fd(pipe.read_fd()) };
380
381     let mut listing_raw = [0u8; 256];
382
383     // There are no recordings, so there's no data in the pipe either.
384     assert!(file.read(&mut listing_raw).is_err());
385 }
386
387 // Verifies that Logger::list_recordings() shows a listing
388 // of a single recording in the very first sector.
389 #[test]
390 fn list_recordings1() {
391     let pipe = Pipe::new();
392
393     let mut file = unsafe { std::fs::File::from_raw_fd(pipe.write_fd()) };
394
395     let mut ls_buffer_space = [0u8; 4096];
396     let mut ls_buffer = Buffer::alloc();
397
398     let user_data = (&mut file as *mut std::fs::File) as *mut BufferUserData;
399
400     ls_buffer.init(ls_buffer_space.as_mut_ptr(),
401                    ls_buffer_space.len(),
402                    flush_write_buffer,
403                    user_data);
404
405     let mut fake_storage = FakeStorage::new();
406
407     // Mark first sector as in use.
408     let recording0 = [
409         // Header:
410         0x01, 0x00, 0x01, 0x00,
411         0xa2, 0xdb, 0x14, 0x5e,
412     ];
413
414     fake_storage.expected[0..recording0.len()].copy_from_slice(&recording0);
415     fake_storage.actual[0..recording0.len()].copy_from_slice(&recording0);
416
417     let mut logger = Logger::new(&mut fake_storage);
418     logger.init();
419
420     logger.list_recordings(&mut ls_buffer);
421
422     let mut file = unsafe { std::fs::File::from_raw_fd(pipe.read_fd()) };
423
424     let mut listing_raw = [0u8; 256];
425     let num_bytes_read = file.read(&mut listing_raw).unwrap();
426
427     let expected_bytes = b"\
428 2020-01-07 19:27:30       4K       1\n";
429
430     assert_eq!(String::from_utf8(expected_bytes.to_vec()).unwrap(),
431                String::from_utf8(listing_raw[0..num_bytes_read].to_vec()).unwrap());
432 }
433
434 // Verifies that Logger::list_recordings() handles sectors holding
435 // additional recording data.
436 #[test]
437 fn list_recording1_multi_sector() {
438     let pipe = Pipe::new();
439
440     let mut file = unsafe { std::fs::File::from_raw_fd(pipe.write_fd()) };
441
442     let mut ls_buffer_space = [0u8; 4096];
443     let mut ls_buffer = Buffer::alloc();
444
445     let user_data = (&mut file as *mut std::fs::File) as *mut BufferUserData;
446
447     ls_buffer.init(ls_buffer_space.as_mut_ptr(),
448                    ls_buffer_space.len(),
449                    flush_write_buffer,
450                    user_data);
451
452     let mut fake_storage = FakeStorage::new();
453
454     // The first sector starts recording 1.
455     let header0 = [
456         // Header:
457         0x01, 0x00, 0x01, 0x00,
458         0x75, 0x18, 0x17, 0x5e,
459     ];
460
461     // The second sector has additional data for recording 1.
462     let header1 = [
463         0x03, 0x00, 0x01, 0x00,
464     ];
465
466     fake_storage.actual[0..header0.len()].copy_from_slice(&header0);
467     fake_storage.actual[4096..4096 + header1.len()].copy_from_slice(&header1);
468
469     let mut logger = Logger::new(&mut fake_storage);
470     logger.init();
471
472     logger.list_recordings(&mut ls_buffer);
473
474     let mut file = unsafe { std::fs::File::from_raw_fd(pipe.read_fd()) };
475
476     let mut listing_raw = [0u8; 4096];
477     let num_bytes_read = file.read(&mut listing_raw).unwrap();
478
479     let expected_bytes = b"\
480 2020-01-09 12:11:33       8K       1\n";
481
482     assert_eq!(String::from_utf8(expected_bytes.to_vec()).unwrap(),
483                String::from_utf8(listing_raw[0..num_bytes_read].to_vec()).unwrap());
484 }