From fa51fe8f096b5d9c3505ec681394be831aa07924 Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Mon, 22 Aug 2022 03:10:09 +0200 Subject: [PATCH 01/29] tail: improve performance of piped stdin Rewrite handling of stdin when it is piped and read input in chunks. Fixes https://github.com/uutils/coreutils/issues/3842 --- Cargo.lock | 1 + src/uu/tail/Cargo.toml | 9 +- src/uu/tail/src/chunks.rs | 430 ++++++++++++++++- src/uu/tail/src/tail.rs | 123 +++-- tests/by-util/test_tail.rs | 446 ++++++++++++++++++ .../random_ascii_24576_bytes_304_lines.txt | 304 ++++++++++++ ...ii_24576_bytes_304_lines_c_+16385.expected | 105 +++++ ...ii_24576_bytes_304_lines_c_+16386.expected | 105 +++++ ...cii_24576_bytes_304_lines_c_+8193.expected | 205 ++++++++ ...cii_24576_bytes_304_lines_c_+8194.expected | 205 ++++++++ ...ii_24576_bytes_304_lines_c_-16384.expected | 205 ++++++++ ...ii_24576_bytes_304_lines_c_-16385.expected | 205 ++++++++ ...cii_24576_bytes_304_lines_c_-8192.expected | 105 +++++ ...cii_24576_bytes_304_lines_c_-8193.expected | 105 +++++ .../random_ascii_8192_bytes_103_lines.txt | 103 ++++ ...m_ascii_8192_bytes_103_lines_c_+2.expected | 103 ++++ ...m_ascii_8192_bytes_103_lines_c_-1.expected | 1 + ...scii_8192_bytes_103_lines_c_-8191.expected | 103 ++++ ...m_ascii_8192_bytes_103_lines_n_+2.expected | 102 ++++ ...m_ascii_8192_bytes_103_lines_n_-1.expected | 1 + ...ascii_8192_bytes_103_lines_n_-102.expected | 102 ++++ .../random_ascii_8193_bytes_103_lines.txt | 103 ++++ ...m_ascii_8193_bytes_103_lines_c_+2.expected | 103 ++++ ...m_ascii_8193_bytes_103_lines_c_-1.expected | 1 + ...scii_8193_bytes_103_lines_c_-8192.expected | 103 ++++ ...m_ascii_8193_bytes_103_lines_n_+2.expected | 102 ++++ ...m_ascii_8193_bytes_103_lines_n_-1.expected | 1 + ...ascii_8193_bytes_103_lines_n_-102.expected | 102 ++++ 28 files changed, 3512 insertions(+), 71 deletions(-) create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines.txt create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16385.expected create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16386.expected create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8193.expected create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8194.expected create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16384.expected create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16385.expected create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8192.expected create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8193.expected create mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines.txt create mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_+2.expected create mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-1.expected create mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-8191.expected create mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_+2.expected create mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-1.expected create mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-102.expected create mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines.txt create mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_+2.expected create mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-1.expected create mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-8192.expected create mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_+2.expected create mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-1.expected create mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-102.expected diff --git a/Cargo.lock b/Cargo.lock index 394b9b8cd38..87c13c407aa 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2814,6 +2814,7 @@ version = "0.0.15" dependencies = [ "clap 3.2.17", "libc", + "memchr", "nix", "notify", "uucore", diff --git a/src/uu/tail/Cargo.toml b/src/uu/tail/Cargo.toml index 98ab9314dfe..0f744b1ed67 100644 --- a/src/uu/tail/Cargo.toml +++ b/src/uu/tail/Cargo.toml @@ -18,12 +18,13 @@ path = "src/tail.rs" [dependencies] clap = { version = "3.2", features = ["wrap_help", "cargo"] } libc = "0.2.132" -notify = { version = "=5.0.0-pre.16", features=["macos_kqueue"]} -uucore = { version=">=0.0.15", package="uucore", path="../../uucore", features=["ringbuffer", "lines"] } +memchr = "2.5.0" +notify = { version = "=5.0.0-pre.16", features = ["macos_kqueue"] } +uucore = { version = ">=0.0.15", package = "uucore", path = "../../uucore", features = ["ringbuffer", "lines"] } [target.'cfg(windows)'.dependencies] -winapi = { version="0.3", features=["fileapi", "handleapi", "processthreadsapi", "synchapi", "winbase"] } -winapi-util = { version="0.1.5" } +winapi = { version = "0.3", features = ["fileapi", "handleapi", "processthreadsapi", "synchapi", "winbase"] } +winapi-util = { version = "0.1.5" } [target.'cfg(unix)'.dependencies] nix = { version = "0.25", features = ["fs"] } diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs index 2704930935f..1da065a95b7 100644 --- a/src/uu/tail/src/chunks.rs +++ b/src/uu/tail/src/chunks.rs @@ -1,14 +1,23 @@ -//! Iterating over a file by chunks, starting at the end of the file. +//! Iterating over a file by chunks, either starting at the end of the file with [`ReverseChunks`] +//! or at the end of piped stdin with [`LinesChunk`] or [`BytesChunk`]. //! -//! Use [`ReverseChunks::new`] to create a new iterator over chunks of -//! bytes from the file. +//! Use [`ReverseChunks::new`] to create a new iterator over chunks of bytes from the file. +use std::collections::vec_deque::Iter; +use std::collections::VecDeque; use std::fs::File; -use std::io::{Read, Seek, SeekFrom}; +use std::io::{BufReader, Read, Seek, SeekFrom, Write}; +use uucore::error::UResult; /// When reading files in reverse in `bounded_tail`, this is the size of each /// block read at a time. pub const BLOCK_SIZE: u64 = 1 << 16; +/// The size of the backing buffer of a LinesChunk or BytesChunk. Some calculations concerning the +/// buffer assume that the target system's usize is greater than this BUFFER_SIZE, and therefore +/// convert from u64 to usize as long as it is known, that the value resides somewhere between 0 +/// and the BUFFER_SIZE. +pub const BUFFER_SIZE: usize = 8192; + /// An iterator over a file in non-overlapping chunks from the end of the file. /// /// Each chunk is a [`Vec`]<[`u8`]> of size [`BLOCK_SIZE`] (except @@ -81,3 +90,416 @@ impl<'a> Iterator for ReverseChunks<'a> { Some(buf[0..(block_size as usize)].to_vec()) } } + +/// The type of the backing buffer of the BytesChunk and LinesChunk structs. +type ChunkBuffer = [u8; BUFFER_SIZE]; + +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct BytesChunk { + buffer: ChunkBuffer, + bytes: usize, +} + +impl BytesChunk { + pub(crate) fn new() -> Self { + Self { + buffer: [0; BUFFER_SIZE], + bytes: 0, + } + } + + fn from(chunk: &Self, offset: usize) -> Self { + assert!( + offset <= chunk.bytes, + "offset may not be larger than the chunk size" + ); + + let mut buffer: ChunkBuffer = [0; BUFFER_SIZE]; + let slice = chunk.get_buffer_with(offset); + buffer[..slice.len()].copy_from_slice(slice); + Self { + buffer, + bytes: chunk.bytes - offset, + } + } + + pub(crate) fn get_buffer(&self) -> &[u8] { + &self.buffer[..self.bytes] + } + + pub(crate) fn get_buffer_with(&self, offset: usize) -> &[u8] { + &self.buffer[offset..self.bytes] + } + + pub(crate) fn fill(&mut self, filehandle: &mut BufReader) -> UResult> { + let num_bytes = filehandle.read(&mut self.buffer)?; + self.bytes = num_bytes; + if num_bytes == 0 { + return Ok(None); + } + + Ok(Some(self.bytes)) + } +} + +pub(crate) struct BytesChunkBuffer { + num_print: u64, + bytes: u64, + chunks: VecDeque>, +} + +impl BytesChunkBuffer { + pub(crate) fn new(num_print: u64) -> Self { + Self { + bytes: 0, + num_print, + chunks: VecDeque::new(), + } + } + + /// Fills the chunks collection with chunks and consumes the reader completely. This method + /// ensures that there are exactly as many chunks as needed to match `self.num_print` bytes, so + /// there are in sum exactly `self.num_print` bytes stored in all chunks. The method returns + /// an iterator over these chunks. If there are no chunks, for example because the piped stdin + /// contained no bytes, or `num_print = 0` then `iterator.next` returns None. + /// + /// # Arguments + /// + /// * `reader`: A buffered reader with an inner element implementing the [`Read`] trait. + /// + /// returns: Result>, Box> + /// + /// # Examples + /// + /// ```rust,ignore + /// use std::io::{BufReader, Cursor}; + /// + /// let mut reader = BufReader::new(Cursor::new("")); + /// let num_print = 0; + /// let mut chunks = BytesChunkBuffer::new(num_print); + /// let mut iter = chunks.fill(&mut reader).unwrap(); + /// + /// let chunk = iter.next(); + /// assert!(chunk.is_none()); + /// + /// let mut reader = BufReader::new(Cursor::new("a")); + /// let num_print = 1; + /// let mut chunks = BytesChunkBuffer::new(num_print); + /// let mut iter = chunks.fill(&mut reader).unwrap(); + /// + /// let chunk = iter.next(); + /// assert!(chunk.is_some()); + /// assert_eq!(&[b'a'], chunk.unwrap().get_buffer()); + /// assert_eq!(None, iter.next()); + /// ``` + pub(crate) fn fill( + &mut self, + reader: &mut BufReader, + ) -> UResult>> { + let mut chunk = Box::new(BytesChunk::new()); + + // fill chunks with all bytes from reader and reuse already instantiated chunks if possible + while (chunk.fill(reader)?).is_some() { + self.bytes += chunk.bytes as u64; + self.chunks.push_back(chunk); + + let first = &self.chunks[0]; + if self.bytes - first.bytes as u64 > self.num_print { + chunk = self.chunks.pop_front().unwrap(); + self.bytes -= chunk.bytes as u64; + } else { + chunk = Box::new(BytesChunk::new()); + } + } + + // quit early if there are no chunks for example in case the pipe was empty + if self.chunks.is_empty() { + return Ok(self.chunks.iter()); + } + + let chunk = self.chunks.pop_front().unwrap(); + // calculate the offset in the first chunk and put the calculated chunk as first element in + // the self.chunks collection. + let offset = if self.num_print >= self.bytes { + // ignore a passed in value exceeding the number of actually read bytes and treat it + // like a value equal to the number of bytes. + 0 + } else { + // the calculated offset must be in the range 0 to BUFFER_SIZE and is therefore safely + // convertable to a usize without losses. + (self.bytes - self.num_print) as usize + }; + + self.chunks + .push_front(Box::new(BytesChunk::from(&chunk, offset))); + + Ok(self.chunks.iter()) + } +} + +pub(crate) struct LinesChunk { + buffer: ChunkBuffer, + bytes: usize, + lines: usize, + delimiter: u8, +} + +impl LinesChunk { + pub(crate) fn new(delimiter: u8) -> Self { + Self { + buffer: [0; BUFFER_SIZE], + bytes: 0, + lines: 0, + delimiter, + } + } + + fn count_lines(&self) -> usize { + memchr::memchr_iter(self.delimiter, self.get_buffer()).count() + } + + /// Creates a new [`LinesChunk`] from an existing one with an offset in lines. The new chunk + /// contains exactly `chunk.lines - offset` lines. The offset in bytes is calculated and applied + /// to the new chunk, so the new chunk contains only the bytes encountered after the offset in + /// number of lines and the `delimiter`. If the offset is larger or equal to `chunk.lines` then + /// a new empty `LinesChunk` is returned. + /// + /// # Arguments + /// + /// * `chunk`: The chunk to create the new chunk from + /// * `offset`: The offset in number of lines (not bytes) + /// + /// returns: LinesChunk + /// + /// # Examples + /// + /// ```rust,ignore + /// let mut chunk = LinesChunk::new(b'\n'); + /// // manually filling the buffer and setting the correct values for bytes and lines + /// chunk.buffer[0..12].copy_from_slice("hello\nworld\n".as_bytes()); + /// chunk.bytes = 12; + /// chunk.lines = 2; + /// + /// let offset = 1; // offset in number of lines + /// let new_chunk = LinesChunk::from(&chunk, offset); + /// assert_eq!("world\n".as_bytes(), new_chunk.get_buffer()); + /// assert_eq!(6, new_chunk.bytes); + /// assert_eq!(1, new_chunk.lines); + /// ``` + fn from_chunk(chunk: &Self, offset: usize) -> Self { + if offset >= chunk.lines { + Self::new(chunk.delimiter); + } + + let mut buffer: ChunkBuffer = [0; BUFFER_SIZE]; + + let bytes_offset = chunk.calculate_bytes_offset_from(offset); + let slice = chunk.get_buffer_with(bytes_offset); + buffer[..slice.len()].copy_from_slice(slice); + + Self { + buffer, + lines: chunk.lines - offset, + bytes: chunk.bytes - bytes_offset, + delimiter: chunk.delimiter, + } + } + + pub(crate) fn has_data(&self) -> bool { + self.bytes > 0 + } + + pub(crate) fn get_buffer(&self) -> &[u8] { + &self.buffer[..self.bytes] + } + + pub(crate) fn get_buffer_with(&self, offset: usize) -> &[u8] { + &self.buffer[offset..self.bytes] + } + + pub(crate) fn get_lines(&self) -> usize { + self.lines + } + + pub(crate) fn increment_lines(&mut self) -> usize { + self.lines += 1; + self.lines + } + + pub(crate) fn fill(&mut self, filehandle: &mut BufReader) -> UResult> { + let num_bytes = filehandle.read(&mut self.buffer)?; + self.bytes = num_bytes; + + if num_bytes == 0 { + self.lines = 0; + return Ok(None); + } + + self.lines = self.count_lines(); + Ok(Some(self.bytes)) + } + + fn calculate_bytes_offset_from(&self, offset: usize) -> usize { + let mut lines_offset = offset; + let mut bytes_offset = 0; + for byte in self.get_buffer().iter() { + if lines_offset == 0 { + break; + } + if byte == &self.delimiter { + lines_offset -= 1; + } + bytes_offset += 1; + } + bytes_offset + } + + pub(crate) fn print_lines(&self, writer: &mut impl Write, offset: usize) -> UResult<()> { + self.print_bytes(writer, self.calculate_bytes_offset_from(offset)) + } + + pub(crate) fn print_bytes(&self, writer: &mut impl Write, offset: usize) -> UResult<()> { + writer.write_all(&self.buffer[offset..self.bytes])?; + Ok(()) + } +} + +pub struct LinesChunkBuffer { + delimiter: u8, + lines: u64, + num_print: u64, + chunks: VecDeque>, +} + +impl LinesChunkBuffer { + pub(crate) fn new(delimiter: u8, num_print: u64) -> Self { + Self { + delimiter, + num_print, + lines: 0, + chunks: VecDeque::new(), + } + } + + pub(crate) fn fill( + &mut self, + reader: &mut BufReader, + ) -> UResult>> { + let mut chunk = Box::new(LinesChunk::new(self.delimiter)); + + while (chunk.fill(reader)?).is_some() { + self.lines += chunk.lines as u64; + self.chunks.push_back(chunk); + + let first = &self.chunks[0]; + if self.lines - first.lines as u64 > self.num_print { + chunk = self.chunks.pop_front().unwrap(); + + self.lines -= chunk.lines as u64; + } else { + chunk = Box::new(LinesChunk::new(self.delimiter)); + } + } + + if !&self.chunks.is_empty() { + let length = &self.chunks.len(); + let last = &mut self.chunks[length - 1]; + if !last.buffer[..last.bytes].ends_with(&[self.delimiter]) { + last.lines += 1; + self.lines += 1; + } + } else { + // chunks is empty when a file is empty so quitting early here + return Ok(self.chunks.iter()); + } + + // skip unnecessary chunks and save the first chunk which may hold some lines we have to + // print + let chunk = loop { + // it's safe to call unwrap here because there is at least one chunk and sorting out + // more chunks than exist shouldn't be possible. + let chunk = self.chunks.pop_front().unwrap(); + + // skip is true as long there are enough lines left in the other stored chunks. + let skip = self.lines - chunk.lines as u64 > self.num_print; + if skip { + self.lines -= chunk.lines as u64; + } else { + break chunk; + } + }; + + // calculate the number of lines to skip in the chunk + let skip_lines = if self.num_print >= self.lines { + 0 + } else { + (self.lines - self.num_print) as usize + }; + + let chunk = LinesChunk::from_chunk(&chunk, skip_lines); + self.chunks.push_front(Box::new(chunk)); + + Ok(self.chunks.iter()) + } +} + +#[cfg(test)] +mod tests { + use crate::chunks::{BytesChunk, BUFFER_SIZE}; + + #[test] + fn test_bytes_chunk_from_when_offset_is_zero() { + let mut chunk = BytesChunk::new(); + chunk.bytes = BUFFER_SIZE; + chunk.buffer[1] = 1; + let other = BytesChunk::from(&chunk, 0); + assert_eq!(other, chunk); + + chunk.bytes = 2; + let other = BytesChunk::from(&chunk, 0); + assert_eq!(other, chunk); + + chunk.bytes = 1; + let other = BytesChunk::from(&chunk, 0); + assert_eq!(other.buffer, [0; BUFFER_SIZE]); + assert_eq!(other.bytes, chunk.bytes); + + chunk.bytes = BUFFER_SIZE; + let other = BytesChunk::from(&chunk, 2); + assert_eq!(other.buffer, [0; BUFFER_SIZE]); + assert_eq!(other.bytes, BUFFER_SIZE - 2); + } + + #[test] + fn test_bytes_chunk_from_when_offset_is_not_zero() { + let mut chunk = BytesChunk::new(); + chunk.bytes = BUFFER_SIZE; + chunk.buffer[1] = 1; + + let other = BytesChunk::from(&chunk, 1); + let mut expected_buffer = [0; BUFFER_SIZE]; + expected_buffer[0] = 1; + assert_eq!(other.buffer, expected_buffer); + assert_eq!(other.bytes, BUFFER_SIZE - 1); + + let other = BytesChunk::from(&chunk, 2); + assert_eq!(other.buffer, [0; BUFFER_SIZE]); + assert_eq!(other.bytes, BUFFER_SIZE - 2); + } + + #[test] + fn test_bytes_chunk_from_when_offset_is_larger_than_chunk_size_then_panics() { + let mut chunk = BytesChunk::new(); + chunk.bytes = BUFFER_SIZE; + let result = std::panic::catch_unwind(|| BytesChunk::from(&chunk, BUFFER_SIZE + 1)); + assert!(result.is_err()); + + chunk.bytes = 0; + let result = std::panic::catch_unwind(|| BytesChunk::from(&chunk, 1)); + assert!(result.is_err()); + + chunk.bytes = 1; + let result = std::panic::catch_unwind(|| BytesChunk::from(&chunk, 2)); + assert!(result.is_err()); + } +} diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs index 32ebb21b06f..40505c16dae 100644 --- a/src/uu/tail/src/tail.rs +++ b/src/uu/tail/src/tail.rs @@ -21,6 +21,7 @@ extern crate clap; #[macro_use] extern crate uucore; +extern crate core; mod chunks; mod parse; @@ -30,11 +31,12 @@ use chunks::ReverseChunks; use clap::{Arg, Command}; use notify::{RecommendedWatcher, RecursiveMode, Watcher, WatcherKind}; +use std::cmp::Ordering; use std::collections::{HashMap, VecDeque}; use std::ffi::OsString; -use std::fmt; use std::fs::{File, Metadata}; -use std::io::{stdin, stdout, BufRead, BufReader, Read, Seek, SeekFrom, Write}; +use std::io; +use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Seek, SeekFrom, Write}; use std::path::{Path, PathBuf}; use std::sync::mpsc::{self, channel, Receiver}; use std::time::Duration; @@ -43,9 +45,7 @@ use uucore::error::{ get_exit_code, set_exit_code, FromIo, UError, UResult, USimpleError, UUsageError, }; use uucore::format_usage; -use uucore::lines::lines; use uucore::parse_size::{parse_size, ParseSizeError}; -use uucore::ringbuffer::RingBuffer; #[cfg(unix)] use std::os::unix::fs::MetadataExt; @@ -1427,70 +1427,67 @@ fn bounded_tail(file: &mut File, settings: &Settings) { std::io::copy(file, &mut stdout).unwrap(); } -/// An alternative to [`Iterator::skip`] with u64 instead of usize. This is -/// necessary because the usize limit doesn't make sense when iterating over -/// something that's not in memory. For example, a very large file. This allows -/// us to skip data larger than 4 GiB even on 32-bit platforms. -fn skip_u64(iter: &mut impl Iterator, num: u64) { - for _ in 0..num { - if iter.next().is_none() { - break; - } - } -} - -/// Collect the last elements of an iterator into a `VecDeque`. -/// -/// This function returns a [`VecDeque`] containing either the last -/// `count` elements of `iter`, an [`Iterator`] over [`Result`] -/// instances, or all but the first `count` elements of `iter`. If -/// `beginning` is `true`, then all but the first `count` elements are -/// returned. -/// -/// # Panics -/// -/// If any element of `iter` is an [`Err`], then this function panics. -fn unbounded_tail_collect( - mut iter: impl Iterator>, - count: u64, - beginning: bool, -) -> UResult> -where - E: fmt::Debug, -{ - if beginning { - // GNU `tail` seems to index bytes and lines starting at 1, not - // at 0. It seems to treat `+0` and `+1` as the same thing. - let i = count.max(1) - 1; - skip_u64(&mut iter, i); - Ok(iter.map(|r| r.unwrap()).collect()) - } else { - let count: usize = count - .try_into() - .map_err(|_| USimpleError::new(1, "Insufficient addressable memory"))?; - Ok(RingBuffer::from_iter(iter.map(|r| r.unwrap()), count).data) - } -} - fn unbounded_tail(reader: &mut BufReader, settings: &Settings) -> UResult<()> { - // Read through each line/char and store them in a ringbuffer that always - // contains count lines/chars. When reaching the end of file, output the - // data in the ringbuf. - match settings.mode { - FilterMode::Lines(count, sep) => { - let mut stdout = stdout(); - for line in unbounded_tail_collect(lines(reader, sep), count, settings.beginning)? { - stdout - .write_all(&line) - .map_err_context(|| String::from("IO error"))?; + match (&settings.mode, settings.beginning) { + (FilterMode::Lines(count, sep), false) => { + let mut chunks = chunks::LinesChunkBuffer::new(*sep, *count); + let mut writer = BufWriter::new(stdout().lock()); + for chunk in chunks.fill(reader)? { + writer.write_all(chunk.get_buffer())?; + } + } + (FilterMode::Lines(count, sep), true) => { + let mut num_skip = (*count).max(1) - 1; + let mut writer = BufWriter::new(stdout().lock()); + let mut chunk = chunks::LinesChunk::new(*sep); + while chunk.fill(reader)?.is_some() { + let lines = chunk.get_lines() as u64; + match lines.cmp(&num_skip) { + Ordering::Less => { + num_skip -= lines; + } + Ordering::Equal | Ordering::Greater => { + break; + } + } + } + if chunk.has_data() { + if !chunk.get_buffer().ends_with(&[*sep]) { + chunk.increment_lines(); + } + chunk.print_lines(&mut writer, num_skip as usize)?; + io::copy(reader, &mut writer)?; } } - FilterMode::Bytes(count) => { - for byte in unbounded_tail_collect(reader.bytes(), count, settings.beginning)? { - if let Err(err) = stdout().write(&[byte]) { - return Err(USimpleError::new(1, err.to_string())); + (FilterMode::Bytes(count), false) => { + let mut chunks = chunks::BytesChunkBuffer::new(*count); + let mut writer = BufWriter::new(stdout().lock()); + for chunk in chunks.fill(reader)? { + writer.write_all(chunk.get_buffer())?; + } + } + (FilterMode::Bytes(count), true) => { + let mut num_skip = (*count).max(1) - 1; + let mut writer = BufWriter::new(stdout().lock()); + let mut chunk = chunks::BytesChunk::new(); + loop { + if let Some(bytes) = chunk.fill(reader)? { + let bytes: u64 = bytes as u64; + match bytes.cmp(&num_skip) { + Ordering::Less => num_skip -= bytes, + Ordering::Equal => { + break; + } + Ordering::Greater => { + writer.write_all(chunk.get_buffer_with(num_skip as usize))?; + break; + } + } + } else { + return Ok(()); } } + io::copy(reader, &mut writer)?; } } Ok(()) diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs index d4755a48832..d78795d62fa 100644 --- a/tests/by-util/test_tail.rs +++ b/tests/by-util/test_tail.rs @@ -30,6 +30,10 @@ static FOLLOW_NAME_SHORT_EXP: &str = "follow_name_short.expected"; #[cfg(target_os = "linux")] static FOLLOW_NAME_EXP: &str = "follow_name.expected"; +static RANDOM_TEXT_BUFFER_SIZE: &str = "random_ascii_8192_bytes_103_lines.txt"; +static RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE: &str = "random_ascii_8193_bytes_103_lines.txt"; +static RANDOM_TEXT_BUFFER_SIZE_MULT_THREE: &str = "random_ascii_24576_bytes_304_lines.txt"; + #[test] #[cfg(all(unix, not(target_os = "android")))] // FIXME: fix this test for Android fn test_stdin_default() { @@ -2435,3 +2439,445 @@ fn test_illegal_seek() { ); assert_eq!(p.wait().unwrap().code().unwrap(), 1); } + +#[test] +fn test_pipe_when_lines_option_value_is_higher_than_contained_lines() { + let test_string = "a\nb\n"; + new_ucmd!() + .args(&["-n", "3"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-n", "4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-n", "999"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-n", "+3"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-n", "+4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-n", "+999"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); +} + +#[test] +fn test_pipe_when_negative_lines_option_given_no_newline_at_eof() { + let test_string = "a\nb"; + new_ucmd!() + .args(&["-n", "0"]) + .pipe_in(test_string) + .succeeds() + .no_stdout() + .no_stderr(); + new_ucmd!() + .args(&["-n", "1"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("b"); + new_ucmd!() + .args(&["-n", "2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a\nb"); +} + +#[test] +fn test_pipe_when_positive_lines_option_given_no_newline_at_eof() { + let test_string = "a\nb"; + new_ucmd!() + .args(&["-n", "+0"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a\nb"); + new_ucmd!() + .args(&["-n", "+1"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a\nb"); + new_ucmd!() + .args(&["-n", "+2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("b"); +} + +#[test] +fn test_pipe_when_lines_option_given_multibyte_utf8_characters() { + // the test string consists of from left to right a 4-byte,3-byte,2-byte,1-byte utf-8 character + let test_string = "𝅘𝅥𝅮\n⏻\nƒ\na"; + new_ucmd!() + .args(&["-n", "+0"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-n", "+2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("⏻\nƒ\na"); + new_ucmd!() + .args(&["-n", "+3"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("ƒ\na"); + new_ucmd!() + .args(&["-n", "+4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a"); + new_ucmd!() + .args(&["-n", "+5"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-n", "-4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-n", "-3"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("⏻\nƒ\na"); + new_ucmd!() + .args(&["-n", "-2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("ƒ\na"); + new_ucmd!() + .args(&["-n", "-1"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a"); + new_ucmd!() + .args(&["-n", "-0"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); +} + +#[test] +fn test_pipe_when_lines_option_given_input_size_is_equal_to_buffer_size() { + new_ucmd!() + .args(&["-n", "+0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE); + new_ucmd!() + .args(&["-n", "+2"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture("random_ascii_8192_bytes_103_lines_n_+2.expected"); + new_ucmd!() + .args(&["-n", "-0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-n", "-1"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture("random_ascii_8192_bytes_103_lines_n_-1.expected"); + new_ucmd!() + .args(&["-n", "-102"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture("random_ascii_8192_bytes_103_lines_n_-102.expected"); + new_ucmd!() + .args(&["-n", "-103"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE); +} + +#[test] +fn test_pipe_when_lines_option_given_input_size_is_one_byte_greater_than_buffer_size() { + new_ucmd!() + .args(&["-n", "+0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE); + + new_ucmd!() + .args(&["-n", "-1"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture("random_ascii_8193_bytes_103_lines_n_-1.expected"); + + new_ucmd!() + .args(&["-n", "+2"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture("random_ascii_8193_bytes_103_lines_n_+2.expected"); + + new_ucmd!() + .args(&["-n", "-102"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture("random_ascii_8193_bytes_103_lines_n_-102.expected"); +} + +#[test] +fn test_pipe_when_bytes_option_value_is_higher_than_contained_bytes() { + let test_string = "a\nb"; + new_ucmd!() + .args(&["-c", "4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-c", "5"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-c", "999"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-c", "+4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-c", "+5"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-c", "+999"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); +} + +#[test] +fn test_pipe_when_bytes_option_given_multibyte_utf8_characters() { + // the test string consists of from left to right a 4-byte,3-byte,2-byte,1-byte utf-8 character + let test_string = "𝅘𝅥𝅮⏻ƒa"; + new_ucmd!() + .args(&["-c", "+0"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-c", "+2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only_bytes(&test_string.as_bytes()[1..]); + new_ucmd!() + .args(&["-c", "+5"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("⏻ƒa"); + new_ucmd!() + .args(&["-c", "+8"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("ƒa"); + new_ucmd!() + .args(&["-c", "+10"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a"); + new_ucmd!() + .args(&["-c", "+11"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-c", "-1"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a"); + new_ucmd!() + .args(&["-c", "-2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only_bytes(&"ƒa".as_bytes()[1..]); + new_ucmd!() + .args(&["-c", "-3"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("ƒa"); + new_ucmd!() + .args(&["-c", "-6"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("⏻ƒa"); + new_ucmd!() + .args(&["-c", "-10"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); +} + +#[test] +fn test_pipe_when_bytes_option_given_input_size_is_equal_to_buffer_size() { + new_ucmd!() + .args(&["-c", "+0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE); + + new_ucmd!() + .args(&["-c", "+2"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture("random_ascii_8192_bytes_103_lines_c_+2.expected"); + + new_ucmd!() + .args(&["-c", "-0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_only(""); + + new_ucmd!() + .args(&["-c", "-8191"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture("random_ascii_8192_bytes_103_lines_c_-8191.expected"); + + new_ucmd!() + .args(&["-c", "-8192"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE); + + new_ucmd!() + .args(&["-c", "-8193"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE); + + new_ucmd!() + .args(&["-c", "-1"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture("random_ascii_8192_bytes_103_lines_c_-1.expected"); +} + +#[test] +fn test_pipe_when_bytes_option_given_input_size_is_one_byte_greater_than_buffer_size() { + new_ucmd!() + .args(&["-c", "+0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE); + + new_ucmd!() + .args(&["-c", "+2"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture("random_ascii_8193_bytes_103_lines_c_+2.expected"); + + new_ucmd!() + .args(&["-c", "-0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_only(""); + + new_ucmd!() + .args(&["-c", "-1"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture("random_ascii_8193_bytes_103_lines_c_-1.expected"); + + new_ucmd!() + .args(&["-c", "-8192"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture("random_ascii_8193_bytes_103_lines_c_-8192.expected"); + + new_ucmd!() + .args(&["-c", "-8193"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE); +} + +#[test] +fn test_pipe_when_bytes_option_given_input_size_has_multiple_size_of_buffer_size() { + new_ucmd!() + .args(&["-c", "+0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE); + + new_ucmd!() + .args(&["-c", "-0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_only(""); + + new_ucmd!() + .args(&["-c", "+8193"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_+8193.expected"); + + new_ucmd!() + .args(&["-c", "+8194"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_+8194.expected"); + + new_ucmd!() + .args(&["-c", "+16385"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_+16385.expected"); + + new_ucmd!() + .args(&["-c", "+16386"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_+16386.expected"); + + new_ucmd!() + .args(&["-c", "-8192"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_-8192.expected"); + + new_ucmd!() + .args(&["-c", "-8193"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_-8193.expected"); + + new_ucmd!() + .args(&["-c", "-16384"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_-16384.expected"); + + new_ucmd!() + .args(&["-c", "-16385"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_-16385.expected"); + + new_ucmd!() + .args(&["-c", "-24576"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE); +} diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines.txt b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines.txt new file mode 100644 index 00000000000..d8f4feecb07 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines.txt @@ -0,0 +1,304 @@ +J4oQ6fxiqTHDbuEkMmoaSGaIUsZEOOdQOyvYnZ1YLQpWlV7r31y2xe68plK5I1xR12wTDdoE7rxe2eUKMPCBTVxVNH8bY228GJHp +lR6GhgHuxsMvcYvSabj9kCB4PqGcvfazUkm3MW2271kJu7LhYRjMpsSlzN7WrQJQqiEgtTItHnsxiSqp1P1gd4MDveEtePk7Draw +IdV9Cf7MCJK09ndDt1aJH2GFHDnzopgemQVEdD +bDAGoTWu0fMT9siH61yKIz2II1oVyBx9g2prC8U9AlGuf15WcVK95NMxLmZrmyDtA +LwOtKZ4nVn3g7xmPVTN2Kg5n6O9Yl76O3T22Q9mVqZt4YpFrK1xGzpqjxBNUdJDsvawSCNSNEA7AMTzYSrYpPpPt2P9iyx2MvpNR +X8tlk4pRgQjuoXKEp5TuFF3OuIFY5XXYJQymjWLIDGcxSjjI6xEqdU8CMN +YMJJs74SPsjiOwNAK2VpinYb1QtwXPqVdGfbGg8VQ5o9QnOcVCGvQyVbRpWBo or0F9E e9xo7i8l5UM4Azm Tq8uMIWI9 +9XfvyGGMs DP7COeWrqdFQNTo8Pbv7XadRB2LcvQ6SlR6gwd8VUN7dyMdOkZLV4Jb7VT f4NIFMiRwVecGp +WQXKXeThT2qAGMsXSXefIvXqpoVjbjeexj79h9Mj9xoBfRASf3nYHB0icQAg9RfpzAAh34ozWgmUjqLF4MF00he5EGIOHsRTeoEu +nSeUSahCLkcHJ3ESVXjLIUCG1p5QSNM1RECulAEcMfMuUuSRwO5iVVDXLSkHPzHPg07HhsLhfVjuinFhZNvmb8xI5D2 +6MW8GNggwEDB2bX9epFvZNPx47GvVINAs +UJhLmBGjBGb6PsbrvKKY0GXeVVaMCUMIK8qlCpWRnmTUkjJ0SwQ4KxZb4fdOKCEH0QZDZOikYWMvc8Y9IJq3t +ljByUTerOapn3UbSsaqaLl12SwePUY1Cle2EZUfXmvjcO8bVvUg7LB4v06ai7QFZxpVvUrbxlnzVXInk0T62JJ23qxWrCwiWgRa3 +5DEXGaWwwuWOlPyzNBslkiaqPxWRL4zHeyqjO3A +JcHL0yolKdeNza8LtNCqzstf6t2YD24p24nHQNT4fU3WnjYZkWQIjCZQuZEXJG65p4Rxa9iMHTiiLxO +r6TD0TobCVWvsOvbuewX6457GdS4RO2JnlDckEeqxkCofrXZxbUN29IixwTTS5sQOQnbkoIbd9m8dO63WaxBNl97zQxhcvYqy7kk +u9qI168NZSKAsNDiY93nqPoOdzlsFaadHvBRBcW1XCmM6b6xhd7BXA33arsomRHBrybN2tqHtmSUMdU0f64N4AQDRg7yxgf2Qkgn +9RLYDwmrW6SwTqMSUBV8Xh09mnwOYInEIfnIQxBZhBQlIW7QmFBqWdDlNt3tQC3ji +4bZjdOzgqIIDLrbjEnrTFXOkyKvgC84WPul0mzVhZiZoV5xANWeXgsA4dwbiM 6WIVegaAxtVWnfdOmukoEhWGH +4DdaktQoh7HHi4g7Q7X8bEm9I6eOLhrXRqn7NWkX +mKUEW0CUTDGrCR4dEmW8PbGveLR70d0gD45mwoR8ivpQrGHBiBKFKjhTZosG4RCN7GJInO4JnMSlO935SX8qoXIEVcCtjdTvTWZb +oaj8njqe1WTCkfnZX0J7FfxH3g1V2vdw7uqAkP7YmUzx7Gie5432XuxwKzzGu50BwJre5AJ9GHl8r2BMuv77IdBNlp7hnafTlIva +Nh8pWJwSEXwrg +yVATXJX68rwMo41rPisbRexAvKfsyizVJwVt5g32b4q03NHEVEpHmQCUgJUMUze26EIU5aCy1ZurtFXWLOSNNxs2SOOEoFdN6KKc +08q2nhdrQ oovQsOCZk1wd7k +5p6hXKZ3ACq6Cu4Ad8MnKSlMOilFbNOhCqUST2YKY6ET0GvX2UuXaXlMEkimrLAomnPMvlJctZPAygx1X7pDe +sMOQOGnRNucYeICZKh2Zv1ecg6IA93VKY36QLoEhWkoE3gIoQFonh6PNs701K1eH8mL5qnlENaWexVJTd9bHVvSM8iEfUY2Bg7gc +amGTM2iiiefj8A2JjjDgHcMzW0kGnmLG3q5gPJF6D9RJV8kw35CBkKv1L4AZMUMtVKzNjKE4Q61l3HBfNUPqLDlF1aa97yB464MX +lzvXIpc1mWceFWPLzziai5Pqw1 tbtY8jyxC29pMCW2pzY1o2hK3zfHm3pQP7kG +TdlJ468GKpqfR7ALEyL3UgIiM88LI9A0RjXouOEZ6ZIPl2iFYU8CuT9O 9han5ROjXOOO7qiu6WgAIXi +BYwTfRSnCi1R4k8RIgfEx4DRcSXiygBf0xHPzm7iGG 4h NSXoSaV1R4nF3fT8hScc3dYl +iJoFdbYJXf6yL6cg8hVynqs1m7lGNUMrw8a2pgnCHAy +ojqFHZzc6scJsLtAcPkpa3OUR6JdHABOk40OdBm704VuLg05TbMC8daDKY0Xb6MdHdNoHjby4jLCEsU4ZOpqluwiGlEoCEhS +lvXn0B1wr0EMN2V3gLr f9m6b45r952K450PA0G1D +SrwHLTw9r3fmJWBhuJptCBXFTh5ogT4l3WiaIAEvmTyc742DgsB8qvx9SFSKGwS8EQtrEzIOEuDycNmQkY2HSjvhod5kdAnAharQ +DgHDpB XwbHpgkF6GnevICk9CzeicW7ejE34MyG7Zls99d2MhUlaIsEsUH9DOMVdTdrQpd3AmZAktNF66e1 +Tuk0IVg2Ydv97QrO958rC4KzRsqS29n0SHiD85UouIaQKdE1L7mVBUghMr70XlqMLw9tINkjS75mLYA +dMjrvrXlvJAwTPMe49SlitQLRol06OWC ojS b00IJOoIJJKgbN ufw7IKkMsphU0MdPfuU wGbH0Nfymwhy6udv h2deKFxbV +DYUQ84zpLDThoBClPqMnaKTcRHT1zWL1hv0ir4PjF8FUGHKAAe9Ol35y5XiaDY6vyowmusm29fkS1IgESiDJivRE89KthOeSPDGS +4dmxKagasI05Ny6qzslXkPqoTlsHnN56val EvvPdEZe79MpnPj6iAyvobUDcn0W4NyhwQNTD5hoPBhL7215mpK +8FBvhjbWvFEhPpLMv70txCIZ38uu0qg UZILFGPlXatAu29fiILbA32ojP8dyop7EkMLVMK9IgcLsPBTw6tm8Ic87y71 +fIED6GWYNYozuCAHlL6z0LMj0eidbRsIX3Jy4Mz1m4MtPWOXmjgZXbkhL +Ev0ERzawuimBTeFKlXvSlTjMP3sOUj9caZowuFLX4noZKXPMVVgMXvnMBl1xwbCg7E2yvbWaH3ruqJH7RMXff9FYeIji8yF4sTDB +ujeDyqJqySTpbNkJ8ByDbyabqc5uutUhwpTbaljn8ss9QzGJYD2JrQTDZW4xcCIduGBufY862WbgE7HiL4cGBDYnKfhzox59VCtG +LyengubNpNecXP6u5hjQpY1idKdqCYC3jRU0HcAqk590hsxMwW4YKzgUvdTjPUkHHbi04Hns9272wYsDzYhXtTCLs40F3XKTka0e +K47uiWwlm4SDXUpoVupwCnBBDCUx1s7mraSePlHrEtreDBJD6DlbVfOYoWHzVWUW7XwczOd9UwU7wNyZxApKvoR89oYXaBtGEJ4C +5GI9j3GHcR 2BLyoumh3nGLQy2oUeasWAOCyFGzm0RscKRWYvTav8jQOjSgxWTjTxXG +4XoElg0rkiQ3HCW7GgCSDvcGDKS8Npu5sOIihppBRnIyx4OZDpwLhmzJfxbMJbnIPRNuk6GfBvgS hZ8MBxHhVW OhMLWGV +FtlDbZKyiaN1dwljcS5NKLTwL1xCBi3WkZ11 yatKBBwUTJits0PzR8V7UlDUXKzPqpefTQuw7B99JwUrQPDz2Bn03e05NXx31 +eB0qzoAVO470hDHa6G17fBenDm9YAvVMJaeqXqZUZNAOtbsddPo4EJRE9GPbgeRGaUzpmjL2DS0SgLrT1Bb0k Y +76nNUndzbxAz0WpPVRebZb61UKAaVRQm +K5gb71TkqSE7TNYyP1erCTv9dHhzgI2i6omHU5Oad4IwWMQZbwHRQOo1NSwqHG9qhjSiDUNb +7a0JNBLotxxAuny1qnnNE6eJUnWuqApL73j6qzXuaGlSzhm5R7qPjqHHSOeOsLX3uET9JLBQQfHoYC6t81WFaYj4UhrsA3WNiW2D +1ehCPHReFTNDtCPNH9gTBtd40vC3S6b3w7nXec3fE1ZDYT8ry5YeZYqPDz9DIJniEyqRr76gxeduHvhwC +TZwOS1bZr32TItefc4dG9bVG2VpfgD7zVM20SPxWlIdkTXxEDFAvg agcz8LIfBqz4jHr6p +wtG0JEtXMWWIfLvVML7DT8NluPzBey9QyhtTgYyxYGx93truoReslHMjtLpKyFxDWz30m8MEL1D4Ch86ltjybsARupZif3IyV6MA +teM1Um2wASkZZpRBcYWFxmsTah57OJMq9zWyyC2iFx1jshAhXeBqg8bkUV5EO5PAxGZ8evXWsREZ +51fl3ymZu0fra6sbTrJCjXFfTYFM0g8Foamoe N3 l2IXbNFOxpSm2QVFxuaV WJT0JlW +qkLc3j5HCGdOibkCJVz2orsQ7AEr1IHFb9oK4CFWjxPDtOxIuQQHmiyHaIlfiwDIx6AJcKrNRWcB1qGupUhQeE0dY9QZD3O +L66YuALn2YJ8Sdwhsaqm9hh8yN9cTh0AYU9Fm9qLOEczlxCzPMUAHVXSAZpnbkEjZAJKiIHA5hi4unZ90mwreQDX1SilFYOVTY0M +kPEWphf1U6UugF8RYwS0cU0ESLuQnxpQbKsbNI90qWJsMOToRXa49J0YKWuRppuZDsXAucO9tD8xHgXnq824FYQvKdBTdUCTc59H +In33xgNgQtWsUFrIt4436zfjiZSlgHMcOm7311i9b1kZLYG0hdr8 aydTC gPtNj4kKxojwdxZk81OVFHjNYtkrs8K5KW +bKUyv0a7x2hY52ebafP3qIDqkDneehvtVzdKDNiZeePw BHyh6ZCzVY 1WqvYSTIwBXFQ D5dJuScKJuByAkHtrAc2RNMD +LEDQVgwv9xBdRqiWa8Z6UmG4sdDj EmidDdlPFdmNKE0FaVOrZV 2MmhEcTmUgFIKCxw2DYbKpQcn1whTxEC z4FRFnxk8toL +4Btu8k9QJbxyzpKquJkfIL4agcyu1SiyTtM +ecOHStkGkwMjOfnmhUGEL85COIEZFEl6DkiHs5iTNvYNXNYz0LEEEq9QdkSlfo4Q5eEVeboxqbsaSs5JnA9XhZm6GdeYptnHfLwZ +7C vSMNUDAMDGHBjYh0GwBsA RBnQqKDSC3gOlvyLMYCevdUjK3yA84EmLvZ68wg9HHjWiOE8u05zr +dJkz5eTDH1iBUxOFKBlL0HBFvKVota5opnuDTCg +s1EGHPHtVjZqnBupfDU2gCZa5X6ETHTd1IDxh1OKgVPNpxHOU1u06snilMkxJRO9C6vWJcTzqCf7kMY2jaQqI9L2J8yVVpSqjW0s +eadd5TQmhmX SqcyX8qdUQCn5FgsOXRGY9DoQUEnKS9jh8CdcwPN M5Jg4QFG +6Zu0I3PUuVKNxkpK9GTYmF6tDmk0PDjituCuuFv9T5CPtACYNxR4Lla +TAlDA4b4e10AIwKjNJOB3UpjDhcZmVZQjUg5wc2s348W0kNIVFKNQ9ZeJWLbG9nPg0Oi2GShGk7Inzm0RccECTtXTfcvFCsux6N4 +0RIo7ZMEENN3rKNcQRNQewI9M0eU4FKC vdEV3dXcKHGIvWESC2hA2OIOSO3hfGKR7Qatkws1EAXXD +pOPlJgz853NtQMFI1vJ87A8GHpYIm xtoBxOqXvqgasg1k0lvawezzO5cvfJcbuJmNCdERJxP5WC8zngTEX1 +6DwSQuV8mhwQtPT0iERyQYeE cdbqJOTGEuwnUlBwKUa78EwKZf3kw gR1Ss4BHQhHXd 2kPkD +4MDk8puPDmibPcZtPcu541Y9BEbyiaNI7E6g98mK btVAKSrqvocNEBTh6XYHJbgee8 +pdntzVjwk4BSXSNZpzBKnKFa9bSWGTDbzKYIXl0iBsn625EgQaIlhxrCamcaHfkMPEjb0izMw2fExA7PRHjZ4tiijDMpCMbocWWY +o274WWap1jLtgpEVaMRPOeJ1bHGrquBWN2YPfQCk6NeXShgC4D5fZ12hofJ6ScIh0NRNjl7wgQX4rSdc3NeWgXABb4Tv1PBPIjy4 +AugAqkt0p2iF3WzehKNCU53csmeH8Bzn5db92GyrYEdJPeDGLuBvp2J0tGQfPqCWKQdbvFwQMpK iJRB56byKSd9M +QNRzCxGNkgdswpe1jexXQD0anS9euxN 78Qw9ENQuSUNsp15xW xkdfQNnrtdYUYYQ +Msc15WA42U1flB8uVVMENsnAUkIoAV5kW7DsQ0pXae rJNYuG6XIAKCtY2G697KaDoV03nPSTIwdMgLZJPRGEipkIWyKVmellIe +QWxOUw6m0vHkZKGnp5qyinKZz1xBtbM7HUQdPb0BSc6jRXDpTutxuhHM0WHQTejBhdQeOtzZ bc zxnKthkXH +x33H1hITTDUD44IBoKyEK8W4HGS4ClbABxhDg38qZnS4CynfLcQumOIuytArK5PUq2zJg1Z90AqkYCNVe52uCdbVomFjIiTdI3ww +5 L gMqFFwZlcln0htEcUE2exoUxT2bGbwhWHXH2gFjDnXiTv6yIBapBNoC cE1i4ZOWMM4P +XEzMFgRy0Sk91KNkUbqOcKZ8ilL7kkpp9xJvNU4NMOpJvicNXaD9vGewLQrHlmi7GAklQwgxxtGg1F7HOs3iDAiuxA4NvYNfit +Xu9hw9kzDId7fhbdQwnByNzoGQMb4JXpj3HKJV6zCji2ZSjd4z2r9CGyoSvIL9ModwzkTEsU3JoSPNR +an0Bjr3kKxmF6TFLV3hQFUEzjuZ +EbgntoQdcxa5ejRRj5RaL5xQh4DS58Y5WD5mdO51mO9r6OeEDlvh8XD9WJrczTKaFmL9kyFSFJiBywZhWbtqICPIX5A86jt3RanX +ioEBdOhAAyCJdZPWQc9A01IHnnXxduRyIXUj6mPUMEozF4D3pmwNL6 hNPhGkKKm5KeDEPv7 +vQmixtzVX75oXcrDzh5f0x2rz5lvRB63xIOyF0WW761yT82gtrb +KcQ79Ai1FMUPNtrlNaEtU1CS9XXVXz4KKnScAUOJ0dpeqq4b2peKB39gAxANIXETCbZUrgHUPdyPOJcBsU1BxnyvnZ14nieQbur1 +5PtE1YSPHbUoH7jPYxMrnh7RkyeR4gtlUcxCrXsDIS3VBb9smAyAK9MKVryybIjZ8EotfSLo1jMbxAGeqEo34VA5ds aiGo7s +E37V0nnm1itRo2uBCKAJBxOhRSEZL0QZIRD3zPsgbXdE9N7gZjOGbMZQ00k2FiBKxTh5FsJ1GEZSnKuCyoTbGUUghHXzb9ZlqZ0n +75T3rJaFjNt66s6kJiC060rAshKtI5VvQPfiI5uL4n6EprWwGKBWpI1jM1HziuDR2rYNVJaQq +brR80YVAbPzrU3hIggLw0gIqM5WNfknHMZRjtjHzYQ0LGw5qAkUYSn0LQOYpbTbzvLB81tpqb43l8C5 +7HPL1RjflbxJRpltWxTjRQayzTVcp3No3qXSe4PhKJVQ9Iull0OZzVSdgRwpjN5CS48iuSePdWl5Dz9zheDm2pQ +1Bd8zOlDyrKNbQrjaKTA9wjuQ0qSrbp4YuFwiZ8boLk40vVbdLRab6ufV7lTd7rVuemEJJE +RLmjOiiXfaXN8wjfOusp0CtXw3TUGvH3Ps68 BbL0RuC6Bg9ZmXxhyUySy8kSt EJeiVLDIcGqCx6wYbqZhSkq6gRW +qCrA7LNdy1RqE6FyTIR3fN9A2Y1K95k5CKzdeas +g4LylIj3P1DEn07KlkKA2MLEcRhipcJsk4hwSIwvDOIkOjlRwwmK7HjBjYzeS7aOGq9mEhb5PbevpDVgBBKNIYEb4HhrrfixUC8j +J2 PNukXTyPowk2P490ZRC hjIqTv3QZxI7 wrsa0rJ8ixaNmZ3Za evP5y6eRvwSwJng787yQzpVi3wCDBw XrEPBJ0 +t2BMpq3evy3ELNduHoifzv6jkN0gJy9o +99sUZ34ro19oJd3UTlLLvi8h8vwToC3ijOEXhY8abO4dCMZUhwj8QlYdDC0JmtAXLO9CEZ0dWZXAMvXgDaorn7CDVBks2Qa7aMkN +1JClm9DlcPR65EKgtPeh +wdteBwA8oEHKRttRIEGI8IstPh2s75Sc9mg0LFG4tn256bBycdcJu4yj6bjBYN13U2dsKkrsJuonekqCOaTTtKudcIwAqRFnZYSa +eXQuRchTkAoQQdZMOejbLczo975o4h0rnt0UvAgU53n +8BYujbW5W2X50yUfshDCtEra20Nx9rJnMAtCkw8QgfECDM988y4A5FGw1sOSyaNch4 +Y47fv7VGVhfl9NG9ByImguZRrYZ3En0DYy2P0G1ufy7xplzshenzxNEjwTe3UR9G83VUs6obeSVCYBAo7pBmaQxH 9f5f9Mv +4oC5X0WDLvadtlM0NNmyDKYfzgw3JTGXDzPGVl7WkL5hsec6MbwS6l0Q7ruX0WtU1WVD8vyCBmVcr2q9DtmgHqclSbMoHXokGFkY +knfOZFLg9DrRkWp3VZfVLYKgsi6pCv 9J7JUWTWxRXLpSszJpKvQbbLa1BYpw0hI3LwgEbX +6ttL77Ak2kox3W9QqdzwQLmTh45n1rwe2daWBRpzwOq33LEBG1nwOlPY5tve0iH5z4T2Vs7cBj6BrOFc8OgS1RXygUURmkmZvYC9 +7XuL HJk8TMOkeCLMZzoJZ9EZVAJXQO9lHftsvw05CwmcscDV7QuRmuwQBD6f4qAnr35io +xNyNC60pDHAKQOV4sIbyoUra8u78PMofY52BjsfFySGZenDGkc4joegzKdogbeQeEjRRD3pPX1CjGu +NtxYCePWXkwgYoxasuDn0ULgaJ9rTD BjglBpG3kpRBB84GwJzfjh8dEmRmKMxsPA8K KpGfjhm +EEVeLcH2t16Se4FZkLSFzADooDijqm60lvxSOpe2LGGhXa94dQmMTESl6FPVqchzKKQuMg77ulrF7GSUosvw4Ry5oLJEQGPqHuxs +jCcE238RM7JOGHwDomNGHoyY0LIYO2dqIcxNOMqvVcFLqCwxnWnX6N zWqHH4ACm1EbtXCACZAOtGsPsM4DdXw +DyqJiYYqBZZAZ0jyvwF2Rzm7DDpWtphJFvKaCvi1n4lf3lBQe FRzakzcOm1sP3q5BMwWDQjcKIhKCsTR4KsqAQWM2cef1 +CTOu64tjU65CzlCmns0QSG8PpqeXLZGo32GbMz1dsSU3byFdXvUfLInNPWTQIGj9tmeGnDzeBihPKIwOQzeB +4oyVwRjiyn0pyMWZ0ChczKOLO57DxwNd4v38dZ 1nIVIVSxlVl0GH4v4tt9judjPKvsMxrAxJq7cDbK bVlc9EcVvTR +ikVAsOiY5ZQT7Y88wh4clEB7lV 8kTSte3RXOTA +1bVCT7yBXD3Es6yezJWm7hdz6vZPaIIOX2l0fTUXB8RfxTq3Kaj6lmQJnuItDJncz6AaYbjXe95W3Vmp0PS3ATEzdG9mEZwSymjd +egkKfFTdY4kx6EnInnegVUFBDalZa5z9ubx3eu6nHD7zfYkjFWUMaLSgwVKjJpsYcw3DtHlfhLWo1nwC9hTX89vCEShI4bcsnlJ7 +3jyOhJSBOym5T55E8F154bYhF4dnwt6q2DRPnenggO1d04bJbVhRbfTgbhGPen3mO5VaU2Z63Rs7q9kp8CsJwPtO5Bp0LC0sTh4Q + +0fJLwkEdB9cY9rVMHpMpRq30e3X1YdchhB8mOkKBXCCaS9WhoBXZYV4zS0R1LOCC5OqHu8TxDJ6p3rOoGxM2s1KzJMZlweexZzSa +ovcwhSG UZ2TTYIan8vFvreBtkSyxmlnQsUyfZnajIPFZeNE +IGu8JRG1yuZuCq0xNPJ19G1ysunyc3X57fORpykArVk2TVQhsBlvsqsloPMMd9FKOSTc0jZsnJf2nLujBuHP5vwqrytGCZMh3mI1 +rZz f5h5RW4JYTtZbd8yeqAF6Hxmze5KaG0jLI7XWIA2ZbVzKLJRydDZu7tiRyNSNjXdw5MuFDgSudZcav3WHJyO OXQ +S4KSuD4dKkPL2hDwuHVwVf6L7hNvyLC5EuqZN1JIgbYiozbhmhU6CKqDLoOdsxFZsr5Uy5F4j3GruUTukaxxIXV9THGDm3E35XGy +OYLvjv2YQWsT5eiWnm5AFuGUBI8pdDSVdnvLPW1Gm9Blb3lQU6xwJsUIWw11NWLmCSf2Aj9olkGXtxWXhji1ypQhQd2GKZUodWyH +gLRGD6QucBcQI5VI8fjoQGWPAgtoWhgsKDGbG6ZH2x9YoFWgWJc OsB1rt7pUWu3vyBueDujMduUejf7RdLO +KqnRyHahI19I5jLVHLKGyNWrbvb9sxEhKPyZEKop +uRCHEXbWRYGZhPks3Q3Wcjvaea8oeuguFZqZVkd0fVpgX8WDleCk8ZqWU1eQbVWjgzaxTNJB23qqMYl6YJFczQb4TkE3GGgDYS3J +cSP1D3qqirQASr42pWt2PBOF7OaRzjD6HUn8MtGF1wyPPWrORXAx3pWPtl4KqVXdsDDFD 6RgMB +ekLwEfmUgQsMsCwBvzkO6H2sJyVJnJ1lpwcsXvJj5skReQdBulviH1NLUIx6KnpIquID2WoY7BoAajF5I evPqde68gP9jb7B +FEawPc OpvimjyZAes9sdECf3B2JF fIChuOk8iDpcneQ1bwseUKjXr7pON6pOc9UaU87Iu +NHD2joerAZTwSMPBAPMRRXNzNLaSIbIrwbzMBNHJrevadSa nY2CfcuuQw5 C0cTEl1ahv6B94v61xTdPXlwMGVYY +7I8Mg2wvMqGLUAbpJtwN2HSFlutq4L2hIF1K08MyKpvI20e0IegHjIHyTuZ1uzZFtQ86Euh1uyI +r6rBVKxfnFihxTPfBBMLo9UXER 4tHUGvLZLPATCdaV4rfT6RmUowQ09KGFxiRdUC +EOEroqWa4gLkFgDHDYEUdYAA2OYGrMPqzilN7OLJqaWmFudOHTRFB6MSSpOCeGLNbGAkT7adB4J9ucX035wU3YTSPAehBbzIe5Aq +vmHRBFC6l FLY2MdW2qGIGjAgQwZMND42REPfVmFmn7HrDo Eoxwjaxzutvua xfqbd1w70 +G43CnoGLCkxmHCiJ1CBHtFA3ytIX5aXiaZkFL47OcLC3u46Lv0TnQdjnGtew5I9YCSq7Y4342RtnQae6dsSfrwaqa2WtYASIDDuW +3PCri8Hd07miGhuRrwrwZCi7NN1q6cGvsCjgQCDzbwlnXd3lrB1ilFX2pAw24 20rp6tW78 7Csmtkjhu2oPIwSO2A +r7m47cYIDK +hpJ7OVfU98IYdwXAy230328Hwyn5bLldYAdvWDnkthFsWxi7wXROx08xhSDRn4i232OY0Jpl2PkSbX5mK3aEjbamS8tpp8gKnF +JjR2XpPFzk7BmeHedc5KSFQl1AFH 3DzxlnyQd5ebjS3Bqd8qHc2LbSTcnqDkVrRvRBLmkhtWCTbpHm05COf 52nO1gcPe +8THe9oE8LrkF0uZKgXLsSkCIq82PFhsv7WaR1CcwXIKToOe8OeFWjUORkmYw4EfKEwVoK6786bf9H3Zv5EMCpWthC8c2mREEdIdj +AQ2ZE7YmIhqJvtby7q vkf2t7hWc6K8Bz9TG8U0XZxRfq0m Ci9joyI3Wfen +dZinbVG6q5PHjKv8ImrXM5D6u3fXCacFyYG8KJoe01bfyD1vw9foYMPCEL1aGo6Uph6bQRNvVsImOd2r5Zvg8staHtt7IsAwiKou +KNuIH7UyLjCH +ABkyySlH5b2e8lZxpQKkHqIChY5xe3uzK1cVwwjrk38LLmKpXlv5GqcHZLEmM31ZaJ9nJ1dAOoqVGw2xjNuqgDi62NgLdyN8bnqD +CSH5kvYfOkxVgN9H196mcpJF2E1IVzjqJeTeJfuBKrE +iUaFSINIPMmYTqMWEtJBestMGF9RQKEtQCPCbIiqwl3kA8EXMkgU9dQSZvJR0DymlBBQ6MUfVqFbblexcUaZIRclnogDPfawyphL +2HXcmB7py2qyWWqbiUBFQCkg3Ic41tpFy7I58BZ46XVhw07jio W7v8PoqvgG1wOV7f8fuiuXvPlQoC2lY07wm0 nQgRok +w3JrHmwWyKmRLhJrrk9jjHhoiTGuLE3j4tsciZlwfhQprtYIkKVez2pr4YlNNYcRvLq0kWQDFo3BohylWpPaO5 +i7lLo7pmeACCHzh4jXoNuBBSOCTRKRi1KEdeWqPH1BUHlhzHKzrXJFL1gmcspqNO2h6dmEwHSlKIowLeaZUyCXMZC4iz8BckLNE0 +feeyDvyILnsWK8ysQZ7WrV1BlJpVxkeULrT5TaKUC8BcNnPWQZeIGC9eOROCmoBmRhnyoXBSWEkOIBgl0MqJ5uub6kdxMGSh76D1 +3NQkbCAHJeCDltw5P8ivcicJZIKiqZ PzAZQItATtQWTyX5zJkFjYG1iQb0N4ssd +O7oMoWi3eKwNRJFMt0ipSs3eaI5W06ncBWdiFWIb4sg6onYSSrwlGkhe8W6fSBHWf PowV2RJb1hlYV88oaCdvFv21SPC8nJQ +U1iITVNuOAw6zhEZOc8z MpFsl4q9kulMJ8cjvW7EI1FfikBXDThfFxPHWu +G1DV05xMQIxLgG5NFmJnSXBmKi2pkZNii303wKIqmL4Qz0xi9MznIBbKob56ZSH01lB9zgll7C9W8gwlDxpfduiQ4pkANDmDSgns +pn4yak7rgCezcCP46lIRVFcZr6HM9JwP3ejcLoLLdAm0GM0ovbrwFIBnZRbzXNjWqfdTYiTCqyYxr4TzXFGgxv3 +VzPVnagOAzhzpbJSAf8arLn7ZCL9Nt7EXYX8OL3S2ocutTJ3snzyVbaxoAX9cefUMaM6JWcR2s8pB6pVFTjGl7p6aN11DiBXmXb4 +V VcleLQyNYWYQv3z8grpAWYsSlMFGu3KRa7dWaiiH2t +q3jSX6ZY7929tTGA0YP8lDhro5X83MKFjL4201yatzDb4HaTjuQLRpXVAZy5lqHQyMJmdQqn1 Si2 D NYRhpHl5VKr +6JMzwA00ZRVy1Z2hI1WxV7wSyIXR +MNm2hwXasuvK2pjoihAkXzoUtuYDhqBFFqWsYRW3njSteQPb9srNSBNE4UM9tR8Fp3lmLB6jJpFu3OQnVCiLEUHkUBBWeUNna0S8 +S5ETB5w8Z8pxy55mrppkTE4x85VRzhErGFeRAUBfuJtManvRtMpTBpsjuro27yLjyGWwUTnhUh7Ga2MIu4aTIHpgU7mk Rc qAv +22xdHaKlod6f4Gbpk8SRo1WlkqYDWw0kLXCXeNCZ3Azu8M0nRtOQLx9zGyHizMClckRWFFZqFYKOPrGdMuTCUdHELsSMWEgl6Daj +sDWuyiHvPzaQrq1NM0Ryy4VUwwgKOi c2Elp6skrC4kLgg7qyIO5HOke 1LRoZc6eIL5DPSc +Jiukkxl5yUueJOUvd3Y3e0bxnQqwPjnYvBta8p7HUGF2Fs8cHMfGBuCsvjqf2pqs4BVcgdZb4xnvVJUvTIlnCckgHs8yXlWtMtgv +nNJ34AkMxBSzWanNsWWHtE7Pnn5Ea3D80CIVB9Ld85aSNWrfWLp0Pe5mOw7VQ5YBak4TPHjmQDX1KyEbdYvCkVBdymSxDP8NUBa8 +WnCCYghXUFDHEccoqmPlFwRREV7KwuXqI0UnaLQYDE7U9H5qcRIi1hX2vjs02KYYDykGBYYfXrtSXg2JBCtXkeogKaOQPTpVUv2c +zs CbrnVrA7i5oiDDAsglO0Ta sa5f6mXYUgIN64m3zpmqsLQbCRKLkKYfQ8sbH7Sdcd3oDnp70dbSg0JtuAD64hucNRE h +JRrn4fzfDz35Ho8yuRDN4Fn0JZKbJBamM7Ugn9nSldmMwIqsWIIQG5JAomGveR7XZFal2XIotpPujUmQ1G8D4aFtwUn3j6n6olgW +hiaOzdzuBXFPGPZOhjshexl5jGUxTRIZl1jCWCMW1fyKtEDReYhhfjEdeV8Os9OwgZP73TmuyG8Pw1XbMWkxt25I9JWF0DLYaUwx +8hOKeNzko QDzJL97X O5wI5k0OSrUDjxA97lYNGCTyGww0neGp RW1DUaJTfaWsMXsR1SzkQ4NqNgraLRgZJYm +NSEeFJ8CpEsK5MHx2rHGSGQamJl5bhOEpTa5gghVl0Vi3q +l77M6H27VVICru1xXUgoQ8iahSjrJTWdofNKswdORFLTn5QGGrHX0XnN2ubp9E38B6wsswuzLOlPswu93RGDw pTFk65uWoc +4XANAZojJHgREiWaG5T4GvW4y0vhUrrmjjFEQGPfwBMeDXNFji5v +KLATcQroa5yJ4XTZtqTAfy316iCSJ1Ea8KestkkNfpBpuwbD1b0JN7gQkqRz0FAcWg5XqeRGXfPA6psmiSs8uuVlF6 +a4xF24lzDQTr7DWloSLJWhCuwNkK9acMYh06NUXVwnA0MVqkqyjNnShsWl8H4oQv5Nsf3Kbcg7R7AYwqbIyyvoi1L0OMG2icFaTU +veRNQRxoXZ0TwV0BDeNUWpOTgf9BBSXrpU9gHePT88AzPlGDTAawY6kCoekbUMntEaXY0vAVVHp R362Ou LOObMUiodtscmyL5 +cdTV6u6EWPl01fTH0FUZ2H0V4W8z44F4Gh2ydhSgI5uRlGZWCpidd2ZQPPSU44nGR59YGAbBGs3g8yFVmh3S2ZDiAoHPRdGUUVbD +O6yXceTzh0ax9buiGdvRVS6KsykYClnlACuhL3B3cZXletNklhYjd4iM10VIfUqmsd1O1eFmRa0awYKiLYWyXq6jKYA61uQlyj1D +i4k0S00cPzV8xAzE1ytC4 E4oQkbgweEF1R lPKNmluEfUFGioa6Rah2KecZ7d1Lh6uQdNNgD0s eUS5ySCPMxouDK8 +0HgjteGUDEcipVohCCBKBOiZUciFI6DvSAiuPJ7sfXEN8wOnmf1REzGhvvctZOgXVTBLlwrNFxR5iCGxGJ6vj8aCaGdAiHusVcHV +62LhpLay021xMEDPxkFKIcucN3tMmAeY75U3aPMPWhE42jEGZb9xsl2WuqH1MHpybhKP207Xva8KpgDmh36bFjN2AKSvtRYEBT9l +LWkQ1I2k3mRg5AUHmufZuRLFl8mK9PlfswEE9kK5KpOWQdULt0PbAuxG35WTQpGuIwMiMiGQhRqJdoYpyqsp5IChwrTHpdoR8vuZ +GruCxRwK5X8s2E0mwJ6NpC5DOEcNKbU2NU3a4fAsfMfCr2ENRbe6SwrihPx2n3GojnoQjoSA5t9nVk6ZT +tyCDw51m6ycbu37bPuiuoz76Zh +pgRi400F8WY82Qj8ze2OyWRrtAmgdSPhaTTfrsMne6Ug5S0CI72XWpcrTLq3IMe1RaaPujHLRbt6TeUSjcvDLizBMAHLXl5K5GS5 +B2NzwHeRY32toI78mq +aQQgMWn70ZyPCXIoMBRB72AwaVkatE5BhYxNuhX9hZBu8oCQuVoLF4IOeTkGHK2gckjFZBkOiRDsKg3B7YYN3NtT2Xfr +0Ty0o3QOim0BeJsaaR8rhFISxPf1iX8IfroC2dj8Yc QT06CFy5oeLhFTdjQoYrHUWpgupG9G4pXHLpG5tk03TFDBa6ExHnvRx +uggfzWdjjrC4hple6IJmJfAZmtXXHXzLJE9VDxquA +Xv1ABk8D8GBAXFc78pUQbC9TVoyQAHI0R3GUSkoJyoql8lRc2fI9BmAYl61BGAxG7r5jre14oQNxqN5JHj6guic9EqsYVoUNbQZX +ogqLoERowSmByIgpTZSQOaIrNwy3PtWpcSOR7QgNZCAFcv7h4bm4vcRJOknBhMouP6jAHyrRnxAK7jSnUOG9cMZecHhQgbzGSMJw +Oj +iJu1iZRbPgiO4LldaJwpEHGKk3DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16385.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16385.expected new file mode 100644 index 00000000000..a30c8ea3471 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16385.expected @@ -0,0 +1,105 @@ +ESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16386.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16386.expected new file mode 100644 index 00000000000..e4d11d8b6bf --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16386.expected @@ -0,0 +1,105 @@ +SvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8193.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8193.expected new file mode 100644 index 00000000000..88d4bdf6c0e --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8193.expected @@ -0,0 +1,205 @@ +IYEb4HhrrfixUC8j +J2 PNukXTyPowk2P490ZRC hjIqTv3QZxI7 wrsa0rJ8ixaNmZ3Za evP5y6eRvwSwJng787yQzpVi3wCDBw XrEPBJ0 +t2BMpq3evy3ELNduHoifzv6jkN0gJy9o +99sUZ34ro19oJd3UTlLLvi8h8vwToC3ijOEXhY8abO4dCMZUhwj8QlYdDC0JmtAXLO9CEZ0dWZXAMvXgDaorn7CDVBks2Qa7aMkN +1JClm9DlcPR65EKgtPeh +wdteBwA8oEHKRttRIEGI8IstPh2s75Sc9mg0LFG4tn256bBycdcJu4yj6bjBYN13U2dsKkrsJuonekqCOaTTtKudcIwAqRFnZYSa +eXQuRchTkAoQQdZMOejbLczo975o4h0rnt0UvAgU53n +8BYujbW5W2X50yUfshDCtEra20Nx9rJnMAtCkw8QgfECDM988y4A5FGw1sOSyaNch4 +Y47fv7VGVhfl9NG9ByImguZRrYZ3En0DYy2P0G1ufy7xplzshenzxNEjwTe3UR9G83VUs6obeSVCYBAo7pBmaQxH 9f5f9Mv +4oC5X0WDLvadtlM0NNmyDKYfzgw3JTGXDzPGVl7WkL5hsec6MbwS6l0Q7ruX0WtU1WVD8vyCBmVcr2q9DtmgHqclSbMoHXokGFkY +knfOZFLg9DrRkWp3VZfVLYKgsi6pCv 9J7JUWTWxRXLpSszJpKvQbbLa1BYpw0hI3LwgEbX +6ttL77Ak2kox3W9QqdzwQLmTh45n1rwe2daWBRpzwOq33LEBG1nwOlPY5tve0iH5z4T2Vs7cBj6BrOFc8OgS1RXygUURmkmZvYC9 +7XuL HJk8TMOkeCLMZzoJZ9EZVAJXQO9lHftsvw05CwmcscDV7QuRmuwQBD6f4qAnr35io +xNyNC60pDHAKQOV4sIbyoUra8u78PMofY52BjsfFySGZenDGkc4joegzKdogbeQeEjRRD3pPX1CjGu +NtxYCePWXkwgYoxasuDn0ULgaJ9rTD BjglBpG3kpRBB84GwJzfjh8dEmRmKMxsPA8K KpGfjhm +EEVeLcH2t16Se4FZkLSFzADooDijqm60lvxSOpe2LGGhXa94dQmMTESl6FPVqchzKKQuMg77ulrF7GSUosvw4Ry5oLJEQGPqHuxs +jCcE238RM7JOGHwDomNGHoyY0LIYO2dqIcxNOMqvVcFLqCwxnWnX6N zWqHH4ACm1EbtXCACZAOtGsPsM4DdXw +DyqJiYYqBZZAZ0jyvwF2Rzm7DDpWtphJFvKaCvi1n4lf3lBQe FRzakzcOm1sP3q5BMwWDQjcKIhKCsTR4KsqAQWM2cef1 +CTOu64tjU65CzlCmns0QSG8PpqeXLZGo32GbMz1dsSU3byFdXvUfLInNPWTQIGj9tmeGnDzeBihPKIwOQzeB +4oyVwRjiyn0pyMWZ0ChczKOLO57DxwNd4v38dZ 1nIVIVSxlVl0GH4v4tt9judjPKvsMxrAxJq7cDbK bVlc9EcVvTR +ikVAsOiY5ZQT7Y88wh4clEB7lV 8kTSte3RXOTA +1bVCT7yBXD3Es6yezJWm7hdz6vZPaIIOX2l0fTUXB8RfxTq3Kaj6lmQJnuItDJncz6AaYbjXe95W3Vmp0PS3ATEzdG9mEZwSymjd +egkKfFTdY4kx6EnInnegVUFBDalZa5z9ubx3eu6nHD7zfYkjFWUMaLSgwVKjJpsYcw3DtHlfhLWo1nwC9hTX89vCEShI4bcsnlJ7 +3jyOhJSBOym5T55E8F154bYhF4dnwt6q2DRPnenggO1d04bJbVhRbfTgbhGPen3mO5VaU2Z63Rs7q9kp8CsJwPtO5Bp0LC0sTh4Q + +0fJLwkEdB9cY9rVMHpMpRq30e3X1YdchhB8mOkKBXCCaS9WhoBXZYV4zS0R1LOCC5OqHu8TxDJ6p3rOoGxM2s1KzJMZlweexZzSa +ovcwhSG UZ2TTYIan8vFvreBtkSyxmlnQsUyfZnajIPFZeNE +IGu8JRG1yuZuCq0xNPJ19G1ysunyc3X57fORpykArVk2TVQhsBlvsqsloPMMd9FKOSTc0jZsnJf2nLujBuHP5vwqrytGCZMh3mI1 +rZz f5h5RW4JYTtZbd8yeqAF6Hxmze5KaG0jLI7XWIA2ZbVzKLJRydDZu7tiRyNSNjXdw5MuFDgSudZcav3WHJyO OXQ +S4KSuD4dKkPL2hDwuHVwVf6L7hNvyLC5EuqZN1JIgbYiozbhmhU6CKqDLoOdsxFZsr5Uy5F4j3GruUTukaxxIXV9THGDm3E35XGy +OYLvjv2YQWsT5eiWnm5AFuGUBI8pdDSVdnvLPW1Gm9Blb3lQU6xwJsUIWw11NWLmCSf2Aj9olkGXtxWXhji1ypQhQd2GKZUodWyH +gLRGD6QucBcQI5VI8fjoQGWPAgtoWhgsKDGbG6ZH2x9YoFWgWJc OsB1rt7pUWu3vyBueDujMduUejf7RdLO +KqnRyHahI19I5jLVHLKGyNWrbvb9sxEhKPyZEKop +uRCHEXbWRYGZhPks3Q3Wcjvaea8oeuguFZqZVkd0fVpgX8WDleCk8ZqWU1eQbVWjgzaxTNJB23qqMYl6YJFczQb4TkE3GGgDYS3J +cSP1D3qqirQASr42pWt2PBOF7OaRzjD6HUn8MtGF1wyPPWrORXAx3pWPtl4KqVXdsDDFD 6RgMB +ekLwEfmUgQsMsCwBvzkO6H2sJyVJnJ1lpwcsXvJj5skReQdBulviH1NLUIx6KnpIquID2WoY7BoAajF5I evPqde68gP9jb7B +FEawPc OpvimjyZAes9sdECf3B2JF fIChuOk8iDpcneQ1bwseUKjXr7pON6pOc9UaU87Iu +NHD2joerAZTwSMPBAPMRRXNzNLaSIbIrwbzMBNHJrevadSa nY2CfcuuQw5 C0cTEl1ahv6B94v61xTdPXlwMGVYY +7I8Mg2wvMqGLUAbpJtwN2HSFlutq4L2hIF1K08MyKpvI20e0IegHjIHyTuZ1uzZFtQ86Euh1uyI +r6rBVKxfnFihxTPfBBMLo9UXER 4tHUGvLZLPATCdaV4rfT6RmUowQ09KGFxiRdUC +EOEroqWa4gLkFgDHDYEUdYAA2OYGrMPqzilN7OLJqaWmFudOHTRFB6MSSpOCeGLNbGAkT7adB4J9ucX035wU3YTSPAehBbzIe5Aq +vmHRBFC6l FLY2MdW2qGIGjAgQwZMND42REPfVmFmn7HrDo Eoxwjaxzutvua xfqbd1w70 +G43CnoGLCkxmHCiJ1CBHtFA3ytIX5aXiaZkFL47OcLC3u46Lv0TnQdjnGtew5I9YCSq7Y4342RtnQae6dsSfrwaqa2WtYASIDDuW +3PCri8Hd07miGhuRrwrwZCi7NN1q6cGvsCjgQCDzbwlnXd3lrB1ilFX2pAw24 20rp6tW78 7Csmtkjhu2oPIwSO2A +r7m47cYIDK +hpJ7OVfU98IYdwXAy230328Hwyn5bLldYAdvWDnkthFsWxi7wXROx08xhSDRn4i232OY0Jpl2PkSbX5mK3aEjbamS8tpp8gKnF +JjR2XpPFzk7BmeHedc5KSFQl1AFH 3DzxlnyQd5ebjS3Bqd8qHc2LbSTcnqDkVrRvRBLmkhtWCTbpHm05COf 52nO1gcPe +8THe9oE8LrkF0uZKgXLsSkCIq82PFhsv7WaR1CcwXIKToOe8OeFWjUORkmYw4EfKEwVoK6786bf9H3Zv5EMCpWthC8c2mREEdIdj +AQ2ZE7YmIhqJvtby7q vkf2t7hWc6K8Bz9TG8U0XZxRfq0m Ci9joyI3Wfen +dZinbVG6q5PHjKv8ImrXM5D6u3fXCacFyYG8KJoe01bfyD1vw9foYMPCEL1aGo6Uph6bQRNvVsImOd2r5Zvg8staHtt7IsAwiKou +KNuIH7UyLjCH +ABkyySlH5b2e8lZxpQKkHqIChY5xe3uzK1cVwwjrk38LLmKpXlv5GqcHZLEmM31ZaJ9nJ1dAOoqVGw2xjNuqgDi62NgLdyN8bnqD +CSH5kvYfOkxVgN9H196mcpJF2E1IVzjqJeTeJfuBKrE +iUaFSINIPMmYTqMWEtJBestMGF9RQKEtQCPCbIiqwl3kA8EXMkgU9dQSZvJR0DymlBBQ6MUfVqFbblexcUaZIRclnogDPfawyphL +2HXcmB7py2qyWWqbiUBFQCkg3Ic41tpFy7I58BZ46XVhw07jio W7v8PoqvgG1wOV7f8fuiuXvPlQoC2lY07wm0 nQgRok +w3JrHmwWyKmRLhJrrk9jjHhoiTGuLE3j4tsciZlwfhQprtYIkKVez2pr4YlNNYcRvLq0kWQDFo3BohylWpPaO5 +i7lLo7pmeACCHzh4jXoNuBBSOCTRKRi1KEdeWqPH1BUHlhzHKzrXJFL1gmcspqNO2h6dmEwHSlKIowLeaZUyCXMZC4iz8BckLNE0 +feeyDvyILnsWK8ysQZ7WrV1BlJpVxkeULrT5TaKUC8BcNnPWQZeIGC9eOROCmoBmRhnyoXBSWEkOIBgl0MqJ5uub6kdxMGSh76D1 +3NQkbCAHJeCDltw5P8ivcicJZIKiqZ PzAZQItATtQWTyX5zJkFjYG1iQb0N4ssd +O7oMoWi3eKwNRJFMt0ipSs3eaI5W06ncBWdiFWIb4sg6onYSSrwlGkhe8W6fSBHWf PowV2RJb1hlYV88oaCdvFv21SPC8nJQ +U1iITVNuOAw6zhEZOc8z MpFsl4q9kulMJ8cjvW7EI1FfikBXDThfFxPHWu +G1DV05xMQIxLgG5NFmJnSXBmKi2pkZNii303wKIqmL4Qz0xi9MznIBbKob56ZSH01lB9zgll7C9W8gwlDxpfduiQ4pkANDmDSgns +pn4yak7rgCezcCP46lIRVFcZr6HM9JwP3ejcLoLLdAm0GM0ovbrwFIBnZRbzXNjWqfdTYiTCqyYxr4TzXFGgxv3 +VzPVnagOAzhzpbJSAf8arLn7ZCL9Nt7EXYX8OL3S2ocutTJ3snzyVbaxoAX9cefUMaM6JWcR2s8pB6pVFTjGl7p6aN11DiBXmXb4 +V VcleLQyNYWYQv3z8grpAWYsSlMFGu3KRa7dWaiiH2t +q3jSX6ZY7929tTGA0YP8lDhro5X83MKFjL4201yatzDb4HaTjuQLRpXVAZy5lqHQyMJmdQqn1 Si2 D NYRhpHl5VKr +6JMzwA00ZRVy1Z2hI1WxV7wSyIXR +MNm2hwXasuvK2pjoihAkXzoUtuYDhqBFFqWsYRW3njSteQPb9srNSBNE4UM9tR8Fp3lmLB6jJpFu3OQnVCiLEUHkUBBWeUNna0S8 +S5ETB5w8Z8pxy55mrppkTE4x85VRzhErGFeRAUBfuJtManvRtMpTBpsjuro27yLjyGWwUTnhUh7Ga2MIu4aTIHpgU7mk Rc qAv +22xdHaKlod6f4Gbpk8SRo1WlkqYDWw0kLXCXeNCZ3Azu8M0nRtOQLx9zGyHizMClckRWFFZqFYKOPrGdMuTCUdHELsSMWEgl6Daj +sDWuyiHvPzaQrq1NM0Ryy4VUwwgKOi c2Elp6skrC4kLgg7qyIO5HOke 1LRoZc6eIL5DPSc +Jiukkxl5yUueJOUvd3Y3e0bxnQqwPjnYvBta8p7HUGF2Fs8cHMfGBuCsvjqf2pqs4BVcgdZb4xnvVJUvTIlnCckgHs8yXlWtMtgv +nNJ34AkMxBSzWanNsWWHtE7Pnn5Ea3D80CIVB9Ld85aSNWrfWLp0Pe5mOw7VQ5YBak4TPHjmQDX1KyEbdYvCkVBdymSxDP8NUBa8 +WnCCYghXUFDHEccoqmPlFwRREV7KwuXqI0UnaLQYDE7U9H5qcRIi1hX2vjs02KYYDykGBYYfXrtSXg2JBCtXkeogKaOQPTpVUv2c +zs CbrnVrA7i5oiDDAsglO0Ta sa5f6mXYUgIN64m3zpmqsLQbCRKLkKYfQ8sbH7Sdcd3oDnp70dbSg0JtuAD64hucNRE h +JRrn4fzfDz35Ho8yuRDN4Fn0JZKbJBamM7Ugn9nSldmMwIqsWIIQG5JAomGveR7XZFal2XIotpPujUmQ1G8D4aFtwUn3j6n6olgW +hiaOzdzuBXFPGPZOhjshexl5jGUxTRIZl1jCWCMW1fyKtEDReYhhfjEdeV8Os9OwgZP73TmuyG8Pw1XbMWkxt25I9JWF0DLYaUwx +8hOKeNzko QDzJL97X O5wI5k0OSrUDjxA97lYNGCTyGww0neGp RW1DUaJTfaWsMXsR1SzkQ4NqNgraLRgZJYm +NSEeFJ8CpEsK5MHx2rHGSGQamJl5bhOEpTa5gghVl0Vi3q +l77M6H27VVICru1xXUgoQ8iahSjrJTWdofNKswdORFLTn5QGGrHX0XnN2ubp9E38B6wsswuzLOlPswu93RGDw pTFk65uWoc +4XANAZojJHgREiWaG5T4GvW4y0vhUrrmjjFEQGPfwBMeDXNFji5v +KLATcQroa5yJ4XTZtqTAfy316iCSJ1Ea8KestkkNfpBpuwbD1b0JN7gQkqRz0FAcWg5XqeRGXfPA6psmiSs8uuVlF6 +a4xF24lzDQTr7DWloSLJWhCuwNkK9acMYh06NUXVwnA0MVqkqyjNnShsWl8H4oQv5Nsf3Kbcg7R7AYwqbIyyvoi1L0OMG2icFaTU +veRNQRxoXZ0TwV0BDeNUWpOTgf9BBSXrpU9gHePT88AzPlGDTAawY6kCoekbUMntEaXY0vAVVHp R362Ou LOObMUiodtscmyL5 +cdTV6u6EWPl01fTH0FUZ2H0V4W8z44F4Gh2ydhSgI5uRlGZWCpidd2ZQPPSU44nGR59YGAbBGs3g8yFVmh3S2ZDiAoHPRdGUUVbD +O6yXceTzh0ax9buiGdvRVS6KsykYClnlACuhL3B3cZXletNklhYjd4iM10VIfUqmsd1O1eFmRa0awYKiLYWyXq6jKYA61uQlyj1D +i4k0S00cPzV8xAzE1ytC4 E4oQkbgweEF1R lPKNmluEfUFGioa6Rah2KecZ7d1Lh6uQdNNgD0s eUS5ySCPMxouDK8 +0HgjteGUDEcipVohCCBKBOiZUciFI6DvSAiuPJ7sfXEN8wOnmf1REzGhvvctZOgXVTBLlwrNFxR5iCGxGJ6vj8aCaGdAiHusVcHV +62LhpLay021xMEDPxkFKIcucN3tMmAeY75U3aPMPWhE42jEGZb9xsl2WuqH1MHpybhKP207Xva8KpgDmh36bFjN2AKSvtRYEBT9l +LWkQ1I2k3mRg5AUHmufZuRLFl8mK9PlfswEE9kK5KpOWQdULt0PbAuxG35WTQpGuIwMiMiGQhRqJdoYpyqsp5IChwrTHpdoR8vuZ +GruCxRwK5X8s2E0mwJ6NpC5DOEcNKbU2NU3a4fAsfMfCr2ENRbe6SwrihPx2n3GojnoQjoSA5t9nVk6ZT +tyCDw51m6ycbu37bPuiuoz76Zh +pgRi400F8WY82Qj8ze2OyWRrtAmgdSPhaTTfrsMne6Ug5S0CI72XWpcrTLq3IMe1RaaPujHLRbt6TeUSjcvDLizBMAHLXl5K5GS5 +B2NzwHeRY32toI78mq +aQQgMWn70ZyPCXIoMBRB72AwaVkatE5BhYxNuhX9hZBu8oCQuVoLF4IOeTkGHK2gckjFZBkOiRDsKg3B7YYN3NtT2Xfr +0Ty0o3QOim0BeJsaaR8rhFISxPf1iX8IfroC2dj8Yc QT06CFy5oeLhFTdjQoYrHUWpgupG9G4pXHLpG5tk03TFDBa6ExHnvRx +uggfzWdjjrC4hple6IJmJfAZmtXXHXzLJE9VDxquA +Xv1ABk8D8GBAXFc78pUQbC9TVoyQAHI0R3GUSkoJyoql8lRc2fI9BmAYl61BGAxG7r5jre14oQNxqN5JHj6guic9EqsYVoUNbQZX +ogqLoERowSmByIgpTZSQOaIrNwy3PtWpcSOR7QgNZCAFcv7h4bm4vcRJOknBhMouP6jAHyrRnxAK7jSnUOG9cMZecHhQgbzGSMJw +Oj +iJu1iZRbPgiO4LldaJwpEHGKk3DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8194.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8194.expected new file mode 100644 index 00000000000..c6fe21e9470 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8194.expected @@ -0,0 +1,205 @@ +YEb4HhrrfixUC8j +J2 PNukXTyPowk2P490ZRC hjIqTv3QZxI7 wrsa0rJ8ixaNmZ3Za evP5y6eRvwSwJng787yQzpVi3wCDBw XrEPBJ0 +t2BMpq3evy3ELNduHoifzv6jkN0gJy9o +99sUZ34ro19oJd3UTlLLvi8h8vwToC3ijOEXhY8abO4dCMZUhwj8QlYdDC0JmtAXLO9CEZ0dWZXAMvXgDaorn7CDVBks2Qa7aMkN +1JClm9DlcPR65EKgtPeh +wdteBwA8oEHKRttRIEGI8IstPh2s75Sc9mg0LFG4tn256bBycdcJu4yj6bjBYN13U2dsKkrsJuonekqCOaTTtKudcIwAqRFnZYSa +eXQuRchTkAoQQdZMOejbLczo975o4h0rnt0UvAgU53n +8BYujbW5W2X50yUfshDCtEra20Nx9rJnMAtCkw8QgfECDM988y4A5FGw1sOSyaNch4 +Y47fv7VGVhfl9NG9ByImguZRrYZ3En0DYy2P0G1ufy7xplzshenzxNEjwTe3UR9G83VUs6obeSVCYBAo7pBmaQxH 9f5f9Mv +4oC5X0WDLvadtlM0NNmyDKYfzgw3JTGXDzPGVl7WkL5hsec6MbwS6l0Q7ruX0WtU1WVD8vyCBmVcr2q9DtmgHqclSbMoHXokGFkY +knfOZFLg9DrRkWp3VZfVLYKgsi6pCv 9J7JUWTWxRXLpSszJpKvQbbLa1BYpw0hI3LwgEbX +6ttL77Ak2kox3W9QqdzwQLmTh45n1rwe2daWBRpzwOq33LEBG1nwOlPY5tve0iH5z4T2Vs7cBj6BrOFc8OgS1RXygUURmkmZvYC9 +7XuL HJk8TMOkeCLMZzoJZ9EZVAJXQO9lHftsvw05CwmcscDV7QuRmuwQBD6f4qAnr35io +xNyNC60pDHAKQOV4sIbyoUra8u78PMofY52BjsfFySGZenDGkc4joegzKdogbeQeEjRRD3pPX1CjGu +NtxYCePWXkwgYoxasuDn0ULgaJ9rTD BjglBpG3kpRBB84GwJzfjh8dEmRmKMxsPA8K KpGfjhm +EEVeLcH2t16Se4FZkLSFzADooDijqm60lvxSOpe2LGGhXa94dQmMTESl6FPVqchzKKQuMg77ulrF7GSUosvw4Ry5oLJEQGPqHuxs +jCcE238RM7JOGHwDomNGHoyY0LIYO2dqIcxNOMqvVcFLqCwxnWnX6N zWqHH4ACm1EbtXCACZAOtGsPsM4DdXw +DyqJiYYqBZZAZ0jyvwF2Rzm7DDpWtphJFvKaCvi1n4lf3lBQe FRzakzcOm1sP3q5BMwWDQjcKIhKCsTR4KsqAQWM2cef1 +CTOu64tjU65CzlCmns0QSG8PpqeXLZGo32GbMz1dsSU3byFdXvUfLInNPWTQIGj9tmeGnDzeBihPKIwOQzeB +4oyVwRjiyn0pyMWZ0ChczKOLO57DxwNd4v38dZ 1nIVIVSxlVl0GH4v4tt9judjPKvsMxrAxJq7cDbK bVlc9EcVvTR +ikVAsOiY5ZQT7Y88wh4clEB7lV 8kTSte3RXOTA +1bVCT7yBXD3Es6yezJWm7hdz6vZPaIIOX2l0fTUXB8RfxTq3Kaj6lmQJnuItDJncz6AaYbjXe95W3Vmp0PS3ATEzdG9mEZwSymjd +egkKfFTdY4kx6EnInnegVUFBDalZa5z9ubx3eu6nHD7zfYkjFWUMaLSgwVKjJpsYcw3DtHlfhLWo1nwC9hTX89vCEShI4bcsnlJ7 +3jyOhJSBOym5T55E8F154bYhF4dnwt6q2DRPnenggO1d04bJbVhRbfTgbhGPen3mO5VaU2Z63Rs7q9kp8CsJwPtO5Bp0LC0sTh4Q + +0fJLwkEdB9cY9rVMHpMpRq30e3X1YdchhB8mOkKBXCCaS9WhoBXZYV4zS0R1LOCC5OqHu8TxDJ6p3rOoGxM2s1KzJMZlweexZzSa +ovcwhSG UZ2TTYIan8vFvreBtkSyxmlnQsUyfZnajIPFZeNE +IGu8JRG1yuZuCq0xNPJ19G1ysunyc3X57fORpykArVk2TVQhsBlvsqsloPMMd9FKOSTc0jZsnJf2nLujBuHP5vwqrytGCZMh3mI1 +rZz f5h5RW4JYTtZbd8yeqAF6Hxmze5KaG0jLI7XWIA2ZbVzKLJRydDZu7tiRyNSNjXdw5MuFDgSudZcav3WHJyO OXQ +S4KSuD4dKkPL2hDwuHVwVf6L7hNvyLC5EuqZN1JIgbYiozbhmhU6CKqDLoOdsxFZsr5Uy5F4j3GruUTukaxxIXV9THGDm3E35XGy +OYLvjv2YQWsT5eiWnm5AFuGUBI8pdDSVdnvLPW1Gm9Blb3lQU6xwJsUIWw11NWLmCSf2Aj9olkGXtxWXhji1ypQhQd2GKZUodWyH +gLRGD6QucBcQI5VI8fjoQGWPAgtoWhgsKDGbG6ZH2x9YoFWgWJc OsB1rt7pUWu3vyBueDujMduUejf7RdLO +KqnRyHahI19I5jLVHLKGyNWrbvb9sxEhKPyZEKop +uRCHEXbWRYGZhPks3Q3Wcjvaea8oeuguFZqZVkd0fVpgX8WDleCk8ZqWU1eQbVWjgzaxTNJB23qqMYl6YJFczQb4TkE3GGgDYS3J +cSP1D3qqirQASr42pWt2PBOF7OaRzjD6HUn8MtGF1wyPPWrORXAx3pWPtl4KqVXdsDDFD 6RgMB +ekLwEfmUgQsMsCwBvzkO6H2sJyVJnJ1lpwcsXvJj5skReQdBulviH1NLUIx6KnpIquID2WoY7BoAajF5I evPqde68gP9jb7B +FEawPc OpvimjyZAes9sdECf3B2JF fIChuOk8iDpcneQ1bwseUKjXr7pON6pOc9UaU87Iu +NHD2joerAZTwSMPBAPMRRXNzNLaSIbIrwbzMBNHJrevadSa nY2CfcuuQw5 C0cTEl1ahv6B94v61xTdPXlwMGVYY +7I8Mg2wvMqGLUAbpJtwN2HSFlutq4L2hIF1K08MyKpvI20e0IegHjIHyTuZ1uzZFtQ86Euh1uyI +r6rBVKxfnFihxTPfBBMLo9UXER 4tHUGvLZLPATCdaV4rfT6RmUowQ09KGFxiRdUC +EOEroqWa4gLkFgDHDYEUdYAA2OYGrMPqzilN7OLJqaWmFudOHTRFB6MSSpOCeGLNbGAkT7adB4J9ucX035wU3YTSPAehBbzIe5Aq +vmHRBFC6l FLY2MdW2qGIGjAgQwZMND42REPfVmFmn7HrDo Eoxwjaxzutvua xfqbd1w70 +G43CnoGLCkxmHCiJ1CBHtFA3ytIX5aXiaZkFL47OcLC3u46Lv0TnQdjnGtew5I9YCSq7Y4342RtnQae6dsSfrwaqa2WtYASIDDuW +3PCri8Hd07miGhuRrwrwZCi7NN1q6cGvsCjgQCDzbwlnXd3lrB1ilFX2pAw24 20rp6tW78 7Csmtkjhu2oPIwSO2A +r7m47cYIDK +hpJ7OVfU98IYdwXAy230328Hwyn5bLldYAdvWDnkthFsWxi7wXROx08xhSDRn4i232OY0Jpl2PkSbX5mK3aEjbamS8tpp8gKnF +JjR2XpPFzk7BmeHedc5KSFQl1AFH 3DzxlnyQd5ebjS3Bqd8qHc2LbSTcnqDkVrRvRBLmkhtWCTbpHm05COf 52nO1gcPe +8THe9oE8LrkF0uZKgXLsSkCIq82PFhsv7WaR1CcwXIKToOe8OeFWjUORkmYw4EfKEwVoK6786bf9H3Zv5EMCpWthC8c2mREEdIdj +AQ2ZE7YmIhqJvtby7q vkf2t7hWc6K8Bz9TG8U0XZxRfq0m Ci9joyI3Wfen +dZinbVG6q5PHjKv8ImrXM5D6u3fXCacFyYG8KJoe01bfyD1vw9foYMPCEL1aGo6Uph6bQRNvVsImOd2r5Zvg8staHtt7IsAwiKou +KNuIH7UyLjCH +ABkyySlH5b2e8lZxpQKkHqIChY5xe3uzK1cVwwjrk38LLmKpXlv5GqcHZLEmM31ZaJ9nJ1dAOoqVGw2xjNuqgDi62NgLdyN8bnqD +CSH5kvYfOkxVgN9H196mcpJF2E1IVzjqJeTeJfuBKrE +iUaFSINIPMmYTqMWEtJBestMGF9RQKEtQCPCbIiqwl3kA8EXMkgU9dQSZvJR0DymlBBQ6MUfVqFbblexcUaZIRclnogDPfawyphL +2HXcmB7py2qyWWqbiUBFQCkg3Ic41tpFy7I58BZ46XVhw07jio W7v8PoqvgG1wOV7f8fuiuXvPlQoC2lY07wm0 nQgRok +w3JrHmwWyKmRLhJrrk9jjHhoiTGuLE3j4tsciZlwfhQprtYIkKVez2pr4YlNNYcRvLq0kWQDFo3BohylWpPaO5 +i7lLo7pmeACCHzh4jXoNuBBSOCTRKRi1KEdeWqPH1BUHlhzHKzrXJFL1gmcspqNO2h6dmEwHSlKIowLeaZUyCXMZC4iz8BckLNE0 +feeyDvyILnsWK8ysQZ7WrV1BlJpVxkeULrT5TaKUC8BcNnPWQZeIGC9eOROCmoBmRhnyoXBSWEkOIBgl0MqJ5uub6kdxMGSh76D1 +3NQkbCAHJeCDltw5P8ivcicJZIKiqZ PzAZQItATtQWTyX5zJkFjYG1iQb0N4ssd +O7oMoWi3eKwNRJFMt0ipSs3eaI5W06ncBWdiFWIb4sg6onYSSrwlGkhe8W6fSBHWf PowV2RJb1hlYV88oaCdvFv21SPC8nJQ +U1iITVNuOAw6zhEZOc8z MpFsl4q9kulMJ8cjvW7EI1FfikBXDThfFxPHWu +G1DV05xMQIxLgG5NFmJnSXBmKi2pkZNii303wKIqmL4Qz0xi9MznIBbKob56ZSH01lB9zgll7C9W8gwlDxpfduiQ4pkANDmDSgns +pn4yak7rgCezcCP46lIRVFcZr6HM9JwP3ejcLoLLdAm0GM0ovbrwFIBnZRbzXNjWqfdTYiTCqyYxr4TzXFGgxv3 +VzPVnagOAzhzpbJSAf8arLn7ZCL9Nt7EXYX8OL3S2ocutTJ3snzyVbaxoAX9cefUMaM6JWcR2s8pB6pVFTjGl7p6aN11DiBXmXb4 +V VcleLQyNYWYQv3z8grpAWYsSlMFGu3KRa7dWaiiH2t +q3jSX6ZY7929tTGA0YP8lDhro5X83MKFjL4201yatzDb4HaTjuQLRpXVAZy5lqHQyMJmdQqn1 Si2 D NYRhpHl5VKr +6JMzwA00ZRVy1Z2hI1WxV7wSyIXR +MNm2hwXasuvK2pjoihAkXzoUtuYDhqBFFqWsYRW3njSteQPb9srNSBNE4UM9tR8Fp3lmLB6jJpFu3OQnVCiLEUHkUBBWeUNna0S8 +S5ETB5w8Z8pxy55mrppkTE4x85VRzhErGFeRAUBfuJtManvRtMpTBpsjuro27yLjyGWwUTnhUh7Ga2MIu4aTIHpgU7mk Rc qAv +22xdHaKlod6f4Gbpk8SRo1WlkqYDWw0kLXCXeNCZ3Azu8M0nRtOQLx9zGyHizMClckRWFFZqFYKOPrGdMuTCUdHELsSMWEgl6Daj +sDWuyiHvPzaQrq1NM0Ryy4VUwwgKOi c2Elp6skrC4kLgg7qyIO5HOke 1LRoZc6eIL5DPSc +Jiukkxl5yUueJOUvd3Y3e0bxnQqwPjnYvBta8p7HUGF2Fs8cHMfGBuCsvjqf2pqs4BVcgdZb4xnvVJUvTIlnCckgHs8yXlWtMtgv +nNJ34AkMxBSzWanNsWWHtE7Pnn5Ea3D80CIVB9Ld85aSNWrfWLp0Pe5mOw7VQ5YBak4TPHjmQDX1KyEbdYvCkVBdymSxDP8NUBa8 +WnCCYghXUFDHEccoqmPlFwRREV7KwuXqI0UnaLQYDE7U9H5qcRIi1hX2vjs02KYYDykGBYYfXrtSXg2JBCtXkeogKaOQPTpVUv2c +zs CbrnVrA7i5oiDDAsglO0Ta sa5f6mXYUgIN64m3zpmqsLQbCRKLkKYfQ8sbH7Sdcd3oDnp70dbSg0JtuAD64hucNRE h +JRrn4fzfDz35Ho8yuRDN4Fn0JZKbJBamM7Ugn9nSldmMwIqsWIIQG5JAomGveR7XZFal2XIotpPujUmQ1G8D4aFtwUn3j6n6olgW +hiaOzdzuBXFPGPZOhjshexl5jGUxTRIZl1jCWCMW1fyKtEDReYhhfjEdeV8Os9OwgZP73TmuyG8Pw1XbMWkxt25I9JWF0DLYaUwx +8hOKeNzko QDzJL97X O5wI5k0OSrUDjxA97lYNGCTyGww0neGp RW1DUaJTfaWsMXsR1SzkQ4NqNgraLRgZJYm +NSEeFJ8CpEsK5MHx2rHGSGQamJl5bhOEpTa5gghVl0Vi3q +l77M6H27VVICru1xXUgoQ8iahSjrJTWdofNKswdORFLTn5QGGrHX0XnN2ubp9E38B6wsswuzLOlPswu93RGDw pTFk65uWoc +4XANAZojJHgREiWaG5T4GvW4y0vhUrrmjjFEQGPfwBMeDXNFji5v +KLATcQroa5yJ4XTZtqTAfy316iCSJ1Ea8KestkkNfpBpuwbD1b0JN7gQkqRz0FAcWg5XqeRGXfPA6psmiSs8uuVlF6 +a4xF24lzDQTr7DWloSLJWhCuwNkK9acMYh06NUXVwnA0MVqkqyjNnShsWl8H4oQv5Nsf3Kbcg7R7AYwqbIyyvoi1L0OMG2icFaTU +veRNQRxoXZ0TwV0BDeNUWpOTgf9BBSXrpU9gHePT88AzPlGDTAawY6kCoekbUMntEaXY0vAVVHp R362Ou LOObMUiodtscmyL5 +cdTV6u6EWPl01fTH0FUZ2H0V4W8z44F4Gh2ydhSgI5uRlGZWCpidd2ZQPPSU44nGR59YGAbBGs3g8yFVmh3S2ZDiAoHPRdGUUVbD +O6yXceTzh0ax9buiGdvRVS6KsykYClnlACuhL3B3cZXletNklhYjd4iM10VIfUqmsd1O1eFmRa0awYKiLYWyXq6jKYA61uQlyj1D +i4k0S00cPzV8xAzE1ytC4 E4oQkbgweEF1R lPKNmluEfUFGioa6Rah2KecZ7d1Lh6uQdNNgD0s eUS5ySCPMxouDK8 +0HgjteGUDEcipVohCCBKBOiZUciFI6DvSAiuPJ7sfXEN8wOnmf1REzGhvvctZOgXVTBLlwrNFxR5iCGxGJ6vj8aCaGdAiHusVcHV +62LhpLay021xMEDPxkFKIcucN3tMmAeY75U3aPMPWhE42jEGZb9xsl2WuqH1MHpybhKP207Xva8KpgDmh36bFjN2AKSvtRYEBT9l +LWkQ1I2k3mRg5AUHmufZuRLFl8mK9PlfswEE9kK5KpOWQdULt0PbAuxG35WTQpGuIwMiMiGQhRqJdoYpyqsp5IChwrTHpdoR8vuZ +GruCxRwK5X8s2E0mwJ6NpC5DOEcNKbU2NU3a4fAsfMfCr2ENRbe6SwrihPx2n3GojnoQjoSA5t9nVk6ZT +tyCDw51m6ycbu37bPuiuoz76Zh +pgRi400F8WY82Qj8ze2OyWRrtAmgdSPhaTTfrsMne6Ug5S0CI72XWpcrTLq3IMe1RaaPujHLRbt6TeUSjcvDLizBMAHLXl5K5GS5 +B2NzwHeRY32toI78mq +aQQgMWn70ZyPCXIoMBRB72AwaVkatE5BhYxNuhX9hZBu8oCQuVoLF4IOeTkGHK2gckjFZBkOiRDsKg3B7YYN3NtT2Xfr +0Ty0o3QOim0BeJsaaR8rhFISxPf1iX8IfroC2dj8Yc QT06CFy5oeLhFTdjQoYrHUWpgupG9G4pXHLpG5tk03TFDBa6ExHnvRx +uggfzWdjjrC4hple6IJmJfAZmtXXHXzLJE9VDxquA +Xv1ABk8D8GBAXFc78pUQbC9TVoyQAHI0R3GUSkoJyoql8lRc2fI9BmAYl61BGAxG7r5jre14oQNxqN5JHj6guic9EqsYVoUNbQZX +ogqLoERowSmByIgpTZSQOaIrNwy3PtWpcSOR7QgNZCAFcv7h4bm4vcRJOknBhMouP6jAHyrRnxAK7jSnUOG9cMZecHhQgbzGSMJw +Oj +iJu1iZRbPgiO4LldaJwpEHGKk3DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16384.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16384.expected new file mode 100644 index 00000000000..88d4bdf6c0e --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16384.expected @@ -0,0 +1,205 @@ +IYEb4HhrrfixUC8j +J2 PNukXTyPowk2P490ZRC hjIqTv3QZxI7 wrsa0rJ8ixaNmZ3Za evP5y6eRvwSwJng787yQzpVi3wCDBw XrEPBJ0 +t2BMpq3evy3ELNduHoifzv6jkN0gJy9o +99sUZ34ro19oJd3UTlLLvi8h8vwToC3ijOEXhY8abO4dCMZUhwj8QlYdDC0JmtAXLO9CEZ0dWZXAMvXgDaorn7CDVBks2Qa7aMkN +1JClm9DlcPR65EKgtPeh +wdteBwA8oEHKRttRIEGI8IstPh2s75Sc9mg0LFG4tn256bBycdcJu4yj6bjBYN13U2dsKkrsJuonekqCOaTTtKudcIwAqRFnZYSa +eXQuRchTkAoQQdZMOejbLczo975o4h0rnt0UvAgU53n +8BYujbW5W2X50yUfshDCtEra20Nx9rJnMAtCkw8QgfECDM988y4A5FGw1sOSyaNch4 +Y47fv7VGVhfl9NG9ByImguZRrYZ3En0DYy2P0G1ufy7xplzshenzxNEjwTe3UR9G83VUs6obeSVCYBAo7pBmaQxH 9f5f9Mv +4oC5X0WDLvadtlM0NNmyDKYfzgw3JTGXDzPGVl7WkL5hsec6MbwS6l0Q7ruX0WtU1WVD8vyCBmVcr2q9DtmgHqclSbMoHXokGFkY +knfOZFLg9DrRkWp3VZfVLYKgsi6pCv 9J7JUWTWxRXLpSszJpKvQbbLa1BYpw0hI3LwgEbX +6ttL77Ak2kox3W9QqdzwQLmTh45n1rwe2daWBRpzwOq33LEBG1nwOlPY5tve0iH5z4T2Vs7cBj6BrOFc8OgS1RXygUURmkmZvYC9 +7XuL HJk8TMOkeCLMZzoJZ9EZVAJXQO9lHftsvw05CwmcscDV7QuRmuwQBD6f4qAnr35io +xNyNC60pDHAKQOV4sIbyoUra8u78PMofY52BjsfFySGZenDGkc4joegzKdogbeQeEjRRD3pPX1CjGu +NtxYCePWXkwgYoxasuDn0ULgaJ9rTD BjglBpG3kpRBB84GwJzfjh8dEmRmKMxsPA8K KpGfjhm +EEVeLcH2t16Se4FZkLSFzADooDijqm60lvxSOpe2LGGhXa94dQmMTESl6FPVqchzKKQuMg77ulrF7GSUosvw4Ry5oLJEQGPqHuxs +jCcE238RM7JOGHwDomNGHoyY0LIYO2dqIcxNOMqvVcFLqCwxnWnX6N zWqHH4ACm1EbtXCACZAOtGsPsM4DdXw +DyqJiYYqBZZAZ0jyvwF2Rzm7DDpWtphJFvKaCvi1n4lf3lBQe FRzakzcOm1sP3q5BMwWDQjcKIhKCsTR4KsqAQWM2cef1 +CTOu64tjU65CzlCmns0QSG8PpqeXLZGo32GbMz1dsSU3byFdXvUfLInNPWTQIGj9tmeGnDzeBihPKIwOQzeB +4oyVwRjiyn0pyMWZ0ChczKOLO57DxwNd4v38dZ 1nIVIVSxlVl0GH4v4tt9judjPKvsMxrAxJq7cDbK bVlc9EcVvTR +ikVAsOiY5ZQT7Y88wh4clEB7lV 8kTSte3RXOTA +1bVCT7yBXD3Es6yezJWm7hdz6vZPaIIOX2l0fTUXB8RfxTq3Kaj6lmQJnuItDJncz6AaYbjXe95W3Vmp0PS3ATEzdG9mEZwSymjd +egkKfFTdY4kx6EnInnegVUFBDalZa5z9ubx3eu6nHD7zfYkjFWUMaLSgwVKjJpsYcw3DtHlfhLWo1nwC9hTX89vCEShI4bcsnlJ7 +3jyOhJSBOym5T55E8F154bYhF4dnwt6q2DRPnenggO1d04bJbVhRbfTgbhGPen3mO5VaU2Z63Rs7q9kp8CsJwPtO5Bp0LC0sTh4Q + +0fJLwkEdB9cY9rVMHpMpRq30e3X1YdchhB8mOkKBXCCaS9WhoBXZYV4zS0R1LOCC5OqHu8TxDJ6p3rOoGxM2s1KzJMZlweexZzSa +ovcwhSG UZ2TTYIan8vFvreBtkSyxmlnQsUyfZnajIPFZeNE +IGu8JRG1yuZuCq0xNPJ19G1ysunyc3X57fORpykArVk2TVQhsBlvsqsloPMMd9FKOSTc0jZsnJf2nLujBuHP5vwqrytGCZMh3mI1 +rZz f5h5RW4JYTtZbd8yeqAF6Hxmze5KaG0jLI7XWIA2ZbVzKLJRydDZu7tiRyNSNjXdw5MuFDgSudZcav3WHJyO OXQ +S4KSuD4dKkPL2hDwuHVwVf6L7hNvyLC5EuqZN1JIgbYiozbhmhU6CKqDLoOdsxFZsr5Uy5F4j3GruUTukaxxIXV9THGDm3E35XGy +OYLvjv2YQWsT5eiWnm5AFuGUBI8pdDSVdnvLPW1Gm9Blb3lQU6xwJsUIWw11NWLmCSf2Aj9olkGXtxWXhji1ypQhQd2GKZUodWyH +gLRGD6QucBcQI5VI8fjoQGWPAgtoWhgsKDGbG6ZH2x9YoFWgWJc OsB1rt7pUWu3vyBueDujMduUejf7RdLO +KqnRyHahI19I5jLVHLKGyNWrbvb9sxEhKPyZEKop +uRCHEXbWRYGZhPks3Q3Wcjvaea8oeuguFZqZVkd0fVpgX8WDleCk8ZqWU1eQbVWjgzaxTNJB23qqMYl6YJFczQb4TkE3GGgDYS3J +cSP1D3qqirQASr42pWt2PBOF7OaRzjD6HUn8MtGF1wyPPWrORXAx3pWPtl4KqVXdsDDFD 6RgMB +ekLwEfmUgQsMsCwBvzkO6H2sJyVJnJ1lpwcsXvJj5skReQdBulviH1NLUIx6KnpIquID2WoY7BoAajF5I evPqde68gP9jb7B +FEawPc OpvimjyZAes9sdECf3B2JF fIChuOk8iDpcneQ1bwseUKjXr7pON6pOc9UaU87Iu +NHD2joerAZTwSMPBAPMRRXNzNLaSIbIrwbzMBNHJrevadSa nY2CfcuuQw5 C0cTEl1ahv6B94v61xTdPXlwMGVYY +7I8Mg2wvMqGLUAbpJtwN2HSFlutq4L2hIF1K08MyKpvI20e0IegHjIHyTuZ1uzZFtQ86Euh1uyI +r6rBVKxfnFihxTPfBBMLo9UXER 4tHUGvLZLPATCdaV4rfT6RmUowQ09KGFxiRdUC +EOEroqWa4gLkFgDHDYEUdYAA2OYGrMPqzilN7OLJqaWmFudOHTRFB6MSSpOCeGLNbGAkT7adB4J9ucX035wU3YTSPAehBbzIe5Aq +vmHRBFC6l FLY2MdW2qGIGjAgQwZMND42REPfVmFmn7HrDo Eoxwjaxzutvua xfqbd1w70 +G43CnoGLCkxmHCiJ1CBHtFA3ytIX5aXiaZkFL47OcLC3u46Lv0TnQdjnGtew5I9YCSq7Y4342RtnQae6dsSfrwaqa2WtYASIDDuW +3PCri8Hd07miGhuRrwrwZCi7NN1q6cGvsCjgQCDzbwlnXd3lrB1ilFX2pAw24 20rp6tW78 7Csmtkjhu2oPIwSO2A +r7m47cYIDK +hpJ7OVfU98IYdwXAy230328Hwyn5bLldYAdvWDnkthFsWxi7wXROx08xhSDRn4i232OY0Jpl2PkSbX5mK3aEjbamS8tpp8gKnF +JjR2XpPFzk7BmeHedc5KSFQl1AFH 3DzxlnyQd5ebjS3Bqd8qHc2LbSTcnqDkVrRvRBLmkhtWCTbpHm05COf 52nO1gcPe +8THe9oE8LrkF0uZKgXLsSkCIq82PFhsv7WaR1CcwXIKToOe8OeFWjUORkmYw4EfKEwVoK6786bf9H3Zv5EMCpWthC8c2mREEdIdj +AQ2ZE7YmIhqJvtby7q vkf2t7hWc6K8Bz9TG8U0XZxRfq0m Ci9joyI3Wfen +dZinbVG6q5PHjKv8ImrXM5D6u3fXCacFyYG8KJoe01bfyD1vw9foYMPCEL1aGo6Uph6bQRNvVsImOd2r5Zvg8staHtt7IsAwiKou +KNuIH7UyLjCH +ABkyySlH5b2e8lZxpQKkHqIChY5xe3uzK1cVwwjrk38LLmKpXlv5GqcHZLEmM31ZaJ9nJ1dAOoqVGw2xjNuqgDi62NgLdyN8bnqD +CSH5kvYfOkxVgN9H196mcpJF2E1IVzjqJeTeJfuBKrE +iUaFSINIPMmYTqMWEtJBestMGF9RQKEtQCPCbIiqwl3kA8EXMkgU9dQSZvJR0DymlBBQ6MUfVqFbblexcUaZIRclnogDPfawyphL +2HXcmB7py2qyWWqbiUBFQCkg3Ic41tpFy7I58BZ46XVhw07jio W7v8PoqvgG1wOV7f8fuiuXvPlQoC2lY07wm0 nQgRok +w3JrHmwWyKmRLhJrrk9jjHhoiTGuLE3j4tsciZlwfhQprtYIkKVez2pr4YlNNYcRvLq0kWQDFo3BohylWpPaO5 +i7lLo7pmeACCHzh4jXoNuBBSOCTRKRi1KEdeWqPH1BUHlhzHKzrXJFL1gmcspqNO2h6dmEwHSlKIowLeaZUyCXMZC4iz8BckLNE0 +feeyDvyILnsWK8ysQZ7WrV1BlJpVxkeULrT5TaKUC8BcNnPWQZeIGC9eOROCmoBmRhnyoXBSWEkOIBgl0MqJ5uub6kdxMGSh76D1 +3NQkbCAHJeCDltw5P8ivcicJZIKiqZ PzAZQItATtQWTyX5zJkFjYG1iQb0N4ssd +O7oMoWi3eKwNRJFMt0ipSs3eaI5W06ncBWdiFWIb4sg6onYSSrwlGkhe8W6fSBHWf PowV2RJb1hlYV88oaCdvFv21SPC8nJQ +U1iITVNuOAw6zhEZOc8z MpFsl4q9kulMJ8cjvW7EI1FfikBXDThfFxPHWu +G1DV05xMQIxLgG5NFmJnSXBmKi2pkZNii303wKIqmL4Qz0xi9MznIBbKob56ZSH01lB9zgll7C9W8gwlDxpfduiQ4pkANDmDSgns +pn4yak7rgCezcCP46lIRVFcZr6HM9JwP3ejcLoLLdAm0GM0ovbrwFIBnZRbzXNjWqfdTYiTCqyYxr4TzXFGgxv3 +VzPVnagOAzhzpbJSAf8arLn7ZCL9Nt7EXYX8OL3S2ocutTJ3snzyVbaxoAX9cefUMaM6JWcR2s8pB6pVFTjGl7p6aN11DiBXmXb4 +V VcleLQyNYWYQv3z8grpAWYsSlMFGu3KRa7dWaiiH2t +q3jSX6ZY7929tTGA0YP8lDhro5X83MKFjL4201yatzDb4HaTjuQLRpXVAZy5lqHQyMJmdQqn1 Si2 D NYRhpHl5VKr +6JMzwA00ZRVy1Z2hI1WxV7wSyIXR +MNm2hwXasuvK2pjoihAkXzoUtuYDhqBFFqWsYRW3njSteQPb9srNSBNE4UM9tR8Fp3lmLB6jJpFu3OQnVCiLEUHkUBBWeUNna0S8 +S5ETB5w8Z8pxy55mrppkTE4x85VRzhErGFeRAUBfuJtManvRtMpTBpsjuro27yLjyGWwUTnhUh7Ga2MIu4aTIHpgU7mk Rc qAv +22xdHaKlod6f4Gbpk8SRo1WlkqYDWw0kLXCXeNCZ3Azu8M0nRtOQLx9zGyHizMClckRWFFZqFYKOPrGdMuTCUdHELsSMWEgl6Daj +sDWuyiHvPzaQrq1NM0Ryy4VUwwgKOi c2Elp6skrC4kLgg7qyIO5HOke 1LRoZc6eIL5DPSc +Jiukkxl5yUueJOUvd3Y3e0bxnQqwPjnYvBta8p7HUGF2Fs8cHMfGBuCsvjqf2pqs4BVcgdZb4xnvVJUvTIlnCckgHs8yXlWtMtgv +nNJ34AkMxBSzWanNsWWHtE7Pnn5Ea3D80CIVB9Ld85aSNWrfWLp0Pe5mOw7VQ5YBak4TPHjmQDX1KyEbdYvCkVBdymSxDP8NUBa8 +WnCCYghXUFDHEccoqmPlFwRREV7KwuXqI0UnaLQYDE7U9H5qcRIi1hX2vjs02KYYDykGBYYfXrtSXg2JBCtXkeogKaOQPTpVUv2c +zs CbrnVrA7i5oiDDAsglO0Ta sa5f6mXYUgIN64m3zpmqsLQbCRKLkKYfQ8sbH7Sdcd3oDnp70dbSg0JtuAD64hucNRE h +JRrn4fzfDz35Ho8yuRDN4Fn0JZKbJBamM7Ugn9nSldmMwIqsWIIQG5JAomGveR7XZFal2XIotpPujUmQ1G8D4aFtwUn3j6n6olgW +hiaOzdzuBXFPGPZOhjshexl5jGUxTRIZl1jCWCMW1fyKtEDReYhhfjEdeV8Os9OwgZP73TmuyG8Pw1XbMWkxt25I9JWF0DLYaUwx +8hOKeNzko QDzJL97X O5wI5k0OSrUDjxA97lYNGCTyGww0neGp RW1DUaJTfaWsMXsR1SzkQ4NqNgraLRgZJYm +NSEeFJ8CpEsK5MHx2rHGSGQamJl5bhOEpTa5gghVl0Vi3q +l77M6H27VVICru1xXUgoQ8iahSjrJTWdofNKswdORFLTn5QGGrHX0XnN2ubp9E38B6wsswuzLOlPswu93RGDw pTFk65uWoc +4XANAZojJHgREiWaG5T4GvW4y0vhUrrmjjFEQGPfwBMeDXNFji5v +KLATcQroa5yJ4XTZtqTAfy316iCSJ1Ea8KestkkNfpBpuwbD1b0JN7gQkqRz0FAcWg5XqeRGXfPA6psmiSs8uuVlF6 +a4xF24lzDQTr7DWloSLJWhCuwNkK9acMYh06NUXVwnA0MVqkqyjNnShsWl8H4oQv5Nsf3Kbcg7R7AYwqbIyyvoi1L0OMG2icFaTU +veRNQRxoXZ0TwV0BDeNUWpOTgf9BBSXrpU9gHePT88AzPlGDTAawY6kCoekbUMntEaXY0vAVVHp R362Ou LOObMUiodtscmyL5 +cdTV6u6EWPl01fTH0FUZ2H0V4W8z44F4Gh2ydhSgI5uRlGZWCpidd2ZQPPSU44nGR59YGAbBGs3g8yFVmh3S2ZDiAoHPRdGUUVbD +O6yXceTzh0ax9buiGdvRVS6KsykYClnlACuhL3B3cZXletNklhYjd4iM10VIfUqmsd1O1eFmRa0awYKiLYWyXq6jKYA61uQlyj1D +i4k0S00cPzV8xAzE1ytC4 E4oQkbgweEF1R lPKNmluEfUFGioa6Rah2KecZ7d1Lh6uQdNNgD0s eUS5ySCPMxouDK8 +0HgjteGUDEcipVohCCBKBOiZUciFI6DvSAiuPJ7sfXEN8wOnmf1REzGhvvctZOgXVTBLlwrNFxR5iCGxGJ6vj8aCaGdAiHusVcHV +62LhpLay021xMEDPxkFKIcucN3tMmAeY75U3aPMPWhE42jEGZb9xsl2WuqH1MHpybhKP207Xva8KpgDmh36bFjN2AKSvtRYEBT9l +LWkQ1I2k3mRg5AUHmufZuRLFl8mK9PlfswEE9kK5KpOWQdULt0PbAuxG35WTQpGuIwMiMiGQhRqJdoYpyqsp5IChwrTHpdoR8vuZ +GruCxRwK5X8s2E0mwJ6NpC5DOEcNKbU2NU3a4fAsfMfCr2ENRbe6SwrihPx2n3GojnoQjoSA5t9nVk6ZT +tyCDw51m6ycbu37bPuiuoz76Zh +pgRi400F8WY82Qj8ze2OyWRrtAmgdSPhaTTfrsMne6Ug5S0CI72XWpcrTLq3IMe1RaaPujHLRbt6TeUSjcvDLizBMAHLXl5K5GS5 +B2NzwHeRY32toI78mq +aQQgMWn70ZyPCXIoMBRB72AwaVkatE5BhYxNuhX9hZBu8oCQuVoLF4IOeTkGHK2gckjFZBkOiRDsKg3B7YYN3NtT2Xfr +0Ty0o3QOim0BeJsaaR8rhFISxPf1iX8IfroC2dj8Yc QT06CFy5oeLhFTdjQoYrHUWpgupG9G4pXHLpG5tk03TFDBa6ExHnvRx +uggfzWdjjrC4hple6IJmJfAZmtXXHXzLJE9VDxquA +Xv1ABk8D8GBAXFc78pUQbC9TVoyQAHI0R3GUSkoJyoql8lRc2fI9BmAYl61BGAxG7r5jre14oQNxqN5JHj6guic9EqsYVoUNbQZX +ogqLoERowSmByIgpTZSQOaIrNwy3PtWpcSOR7QgNZCAFcv7h4bm4vcRJOknBhMouP6jAHyrRnxAK7jSnUOG9cMZecHhQgbzGSMJw +Oj +iJu1iZRbPgiO4LldaJwpEHGKk3DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16385.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16385.expected new file mode 100644 index 00000000000..32b6b3dc600 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16385.expected @@ -0,0 +1,205 @@ +NIYEb4HhrrfixUC8j +J2 PNukXTyPowk2P490ZRC hjIqTv3QZxI7 wrsa0rJ8ixaNmZ3Za evP5y6eRvwSwJng787yQzpVi3wCDBw XrEPBJ0 +t2BMpq3evy3ELNduHoifzv6jkN0gJy9o +99sUZ34ro19oJd3UTlLLvi8h8vwToC3ijOEXhY8abO4dCMZUhwj8QlYdDC0JmtAXLO9CEZ0dWZXAMvXgDaorn7CDVBks2Qa7aMkN +1JClm9DlcPR65EKgtPeh +wdteBwA8oEHKRttRIEGI8IstPh2s75Sc9mg0LFG4tn256bBycdcJu4yj6bjBYN13U2dsKkrsJuonekqCOaTTtKudcIwAqRFnZYSa +eXQuRchTkAoQQdZMOejbLczo975o4h0rnt0UvAgU53n +8BYujbW5W2X50yUfshDCtEra20Nx9rJnMAtCkw8QgfECDM988y4A5FGw1sOSyaNch4 +Y47fv7VGVhfl9NG9ByImguZRrYZ3En0DYy2P0G1ufy7xplzshenzxNEjwTe3UR9G83VUs6obeSVCYBAo7pBmaQxH 9f5f9Mv +4oC5X0WDLvadtlM0NNmyDKYfzgw3JTGXDzPGVl7WkL5hsec6MbwS6l0Q7ruX0WtU1WVD8vyCBmVcr2q9DtmgHqclSbMoHXokGFkY +knfOZFLg9DrRkWp3VZfVLYKgsi6pCv 9J7JUWTWxRXLpSszJpKvQbbLa1BYpw0hI3LwgEbX +6ttL77Ak2kox3W9QqdzwQLmTh45n1rwe2daWBRpzwOq33LEBG1nwOlPY5tve0iH5z4T2Vs7cBj6BrOFc8OgS1RXygUURmkmZvYC9 +7XuL HJk8TMOkeCLMZzoJZ9EZVAJXQO9lHftsvw05CwmcscDV7QuRmuwQBD6f4qAnr35io +xNyNC60pDHAKQOV4sIbyoUra8u78PMofY52BjsfFySGZenDGkc4joegzKdogbeQeEjRRD3pPX1CjGu +NtxYCePWXkwgYoxasuDn0ULgaJ9rTD BjglBpG3kpRBB84GwJzfjh8dEmRmKMxsPA8K KpGfjhm +EEVeLcH2t16Se4FZkLSFzADooDijqm60lvxSOpe2LGGhXa94dQmMTESl6FPVqchzKKQuMg77ulrF7GSUosvw4Ry5oLJEQGPqHuxs +jCcE238RM7JOGHwDomNGHoyY0LIYO2dqIcxNOMqvVcFLqCwxnWnX6N zWqHH4ACm1EbtXCACZAOtGsPsM4DdXw +DyqJiYYqBZZAZ0jyvwF2Rzm7DDpWtphJFvKaCvi1n4lf3lBQe FRzakzcOm1sP3q5BMwWDQjcKIhKCsTR4KsqAQWM2cef1 +CTOu64tjU65CzlCmns0QSG8PpqeXLZGo32GbMz1dsSU3byFdXvUfLInNPWTQIGj9tmeGnDzeBihPKIwOQzeB +4oyVwRjiyn0pyMWZ0ChczKOLO57DxwNd4v38dZ 1nIVIVSxlVl0GH4v4tt9judjPKvsMxrAxJq7cDbK bVlc9EcVvTR +ikVAsOiY5ZQT7Y88wh4clEB7lV 8kTSte3RXOTA +1bVCT7yBXD3Es6yezJWm7hdz6vZPaIIOX2l0fTUXB8RfxTq3Kaj6lmQJnuItDJncz6AaYbjXe95W3Vmp0PS3ATEzdG9mEZwSymjd +egkKfFTdY4kx6EnInnegVUFBDalZa5z9ubx3eu6nHD7zfYkjFWUMaLSgwVKjJpsYcw3DtHlfhLWo1nwC9hTX89vCEShI4bcsnlJ7 +3jyOhJSBOym5T55E8F154bYhF4dnwt6q2DRPnenggO1d04bJbVhRbfTgbhGPen3mO5VaU2Z63Rs7q9kp8CsJwPtO5Bp0LC0sTh4Q + +0fJLwkEdB9cY9rVMHpMpRq30e3X1YdchhB8mOkKBXCCaS9WhoBXZYV4zS0R1LOCC5OqHu8TxDJ6p3rOoGxM2s1KzJMZlweexZzSa +ovcwhSG UZ2TTYIan8vFvreBtkSyxmlnQsUyfZnajIPFZeNE +IGu8JRG1yuZuCq0xNPJ19G1ysunyc3X57fORpykArVk2TVQhsBlvsqsloPMMd9FKOSTc0jZsnJf2nLujBuHP5vwqrytGCZMh3mI1 +rZz f5h5RW4JYTtZbd8yeqAF6Hxmze5KaG0jLI7XWIA2ZbVzKLJRydDZu7tiRyNSNjXdw5MuFDgSudZcav3WHJyO OXQ +S4KSuD4dKkPL2hDwuHVwVf6L7hNvyLC5EuqZN1JIgbYiozbhmhU6CKqDLoOdsxFZsr5Uy5F4j3GruUTukaxxIXV9THGDm3E35XGy +OYLvjv2YQWsT5eiWnm5AFuGUBI8pdDSVdnvLPW1Gm9Blb3lQU6xwJsUIWw11NWLmCSf2Aj9olkGXtxWXhji1ypQhQd2GKZUodWyH +gLRGD6QucBcQI5VI8fjoQGWPAgtoWhgsKDGbG6ZH2x9YoFWgWJc OsB1rt7pUWu3vyBueDujMduUejf7RdLO +KqnRyHahI19I5jLVHLKGyNWrbvb9sxEhKPyZEKop +uRCHEXbWRYGZhPks3Q3Wcjvaea8oeuguFZqZVkd0fVpgX8WDleCk8ZqWU1eQbVWjgzaxTNJB23qqMYl6YJFczQb4TkE3GGgDYS3J +cSP1D3qqirQASr42pWt2PBOF7OaRzjD6HUn8MtGF1wyPPWrORXAx3pWPtl4KqVXdsDDFD 6RgMB +ekLwEfmUgQsMsCwBvzkO6H2sJyVJnJ1lpwcsXvJj5skReQdBulviH1NLUIx6KnpIquID2WoY7BoAajF5I evPqde68gP9jb7B +FEawPc OpvimjyZAes9sdECf3B2JF fIChuOk8iDpcneQ1bwseUKjXr7pON6pOc9UaU87Iu +NHD2joerAZTwSMPBAPMRRXNzNLaSIbIrwbzMBNHJrevadSa nY2CfcuuQw5 C0cTEl1ahv6B94v61xTdPXlwMGVYY +7I8Mg2wvMqGLUAbpJtwN2HSFlutq4L2hIF1K08MyKpvI20e0IegHjIHyTuZ1uzZFtQ86Euh1uyI +r6rBVKxfnFihxTPfBBMLo9UXER 4tHUGvLZLPATCdaV4rfT6RmUowQ09KGFxiRdUC +EOEroqWa4gLkFgDHDYEUdYAA2OYGrMPqzilN7OLJqaWmFudOHTRFB6MSSpOCeGLNbGAkT7adB4J9ucX035wU3YTSPAehBbzIe5Aq +vmHRBFC6l FLY2MdW2qGIGjAgQwZMND42REPfVmFmn7HrDo Eoxwjaxzutvua xfqbd1w70 +G43CnoGLCkxmHCiJ1CBHtFA3ytIX5aXiaZkFL47OcLC3u46Lv0TnQdjnGtew5I9YCSq7Y4342RtnQae6dsSfrwaqa2WtYASIDDuW +3PCri8Hd07miGhuRrwrwZCi7NN1q6cGvsCjgQCDzbwlnXd3lrB1ilFX2pAw24 20rp6tW78 7Csmtkjhu2oPIwSO2A +r7m47cYIDK +hpJ7OVfU98IYdwXAy230328Hwyn5bLldYAdvWDnkthFsWxi7wXROx08xhSDRn4i232OY0Jpl2PkSbX5mK3aEjbamS8tpp8gKnF +JjR2XpPFzk7BmeHedc5KSFQl1AFH 3DzxlnyQd5ebjS3Bqd8qHc2LbSTcnqDkVrRvRBLmkhtWCTbpHm05COf 52nO1gcPe +8THe9oE8LrkF0uZKgXLsSkCIq82PFhsv7WaR1CcwXIKToOe8OeFWjUORkmYw4EfKEwVoK6786bf9H3Zv5EMCpWthC8c2mREEdIdj +AQ2ZE7YmIhqJvtby7q vkf2t7hWc6K8Bz9TG8U0XZxRfq0m Ci9joyI3Wfen +dZinbVG6q5PHjKv8ImrXM5D6u3fXCacFyYG8KJoe01bfyD1vw9foYMPCEL1aGo6Uph6bQRNvVsImOd2r5Zvg8staHtt7IsAwiKou +KNuIH7UyLjCH +ABkyySlH5b2e8lZxpQKkHqIChY5xe3uzK1cVwwjrk38LLmKpXlv5GqcHZLEmM31ZaJ9nJ1dAOoqVGw2xjNuqgDi62NgLdyN8bnqD +CSH5kvYfOkxVgN9H196mcpJF2E1IVzjqJeTeJfuBKrE +iUaFSINIPMmYTqMWEtJBestMGF9RQKEtQCPCbIiqwl3kA8EXMkgU9dQSZvJR0DymlBBQ6MUfVqFbblexcUaZIRclnogDPfawyphL +2HXcmB7py2qyWWqbiUBFQCkg3Ic41tpFy7I58BZ46XVhw07jio W7v8PoqvgG1wOV7f8fuiuXvPlQoC2lY07wm0 nQgRok +w3JrHmwWyKmRLhJrrk9jjHhoiTGuLE3j4tsciZlwfhQprtYIkKVez2pr4YlNNYcRvLq0kWQDFo3BohylWpPaO5 +i7lLo7pmeACCHzh4jXoNuBBSOCTRKRi1KEdeWqPH1BUHlhzHKzrXJFL1gmcspqNO2h6dmEwHSlKIowLeaZUyCXMZC4iz8BckLNE0 +feeyDvyILnsWK8ysQZ7WrV1BlJpVxkeULrT5TaKUC8BcNnPWQZeIGC9eOROCmoBmRhnyoXBSWEkOIBgl0MqJ5uub6kdxMGSh76D1 +3NQkbCAHJeCDltw5P8ivcicJZIKiqZ PzAZQItATtQWTyX5zJkFjYG1iQb0N4ssd +O7oMoWi3eKwNRJFMt0ipSs3eaI5W06ncBWdiFWIb4sg6onYSSrwlGkhe8W6fSBHWf PowV2RJb1hlYV88oaCdvFv21SPC8nJQ +U1iITVNuOAw6zhEZOc8z MpFsl4q9kulMJ8cjvW7EI1FfikBXDThfFxPHWu +G1DV05xMQIxLgG5NFmJnSXBmKi2pkZNii303wKIqmL4Qz0xi9MznIBbKob56ZSH01lB9zgll7C9W8gwlDxpfduiQ4pkANDmDSgns +pn4yak7rgCezcCP46lIRVFcZr6HM9JwP3ejcLoLLdAm0GM0ovbrwFIBnZRbzXNjWqfdTYiTCqyYxr4TzXFGgxv3 +VzPVnagOAzhzpbJSAf8arLn7ZCL9Nt7EXYX8OL3S2ocutTJ3snzyVbaxoAX9cefUMaM6JWcR2s8pB6pVFTjGl7p6aN11DiBXmXb4 +V VcleLQyNYWYQv3z8grpAWYsSlMFGu3KRa7dWaiiH2t +q3jSX6ZY7929tTGA0YP8lDhro5X83MKFjL4201yatzDb4HaTjuQLRpXVAZy5lqHQyMJmdQqn1 Si2 D NYRhpHl5VKr +6JMzwA00ZRVy1Z2hI1WxV7wSyIXR +MNm2hwXasuvK2pjoihAkXzoUtuYDhqBFFqWsYRW3njSteQPb9srNSBNE4UM9tR8Fp3lmLB6jJpFu3OQnVCiLEUHkUBBWeUNna0S8 +S5ETB5w8Z8pxy55mrppkTE4x85VRzhErGFeRAUBfuJtManvRtMpTBpsjuro27yLjyGWwUTnhUh7Ga2MIu4aTIHpgU7mk Rc qAv +22xdHaKlod6f4Gbpk8SRo1WlkqYDWw0kLXCXeNCZ3Azu8M0nRtOQLx9zGyHizMClckRWFFZqFYKOPrGdMuTCUdHELsSMWEgl6Daj +sDWuyiHvPzaQrq1NM0Ryy4VUwwgKOi c2Elp6skrC4kLgg7qyIO5HOke 1LRoZc6eIL5DPSc +Jiukkxl5yUueJOUvd3Y3e0bxnQqwPjnYvBta8p7HUGF2Fs8cHMfGBuCsvjqf2pqs4BVcgdZb4xnvVJUvTIlnCckgHs8yXlWtMtgv +nNJ34AkMxBSzWanNsWWHtE7Pnn5Ea3D80CIVB9Ld85aSNWrfWLp0Pe5mOw7VQ5YBak4TPHjmQDX1KyEbdYvCkVBdymSxDP8NUBa8 +WnCCYghXUFDHEccoqmPlFwRREV7KwuXqI0UnaLQYDE7U9H5qcRIi1hX2vjs02KYYDykGBYYfXrtSXg2JBCtXkeogKaOQPTpVUv2c +zs CbrnVrA7i5oiDDAsglO0Ta sa5f6mXYUgIN64m3zpmqsLQbCRKLkKYfQ8sbH7Sdcd3oDnp70dbSg0JtuAD64hucNRE h +JRrn4fzfDz35Ho8yuRDN4Fn0JZKbJBamM7Ugn9nSldmMwIqsWIIQG5JAomGveR7XZFal2XIotpPujUmQ1G8D4aFtwUn3j6n6olgW +hiaOzdzuBXFPGPZOhjshexl5jGUxTRIZl1jCWCMW1fyKtEDReYhhfjEdeV8Os9OwgZP73TmuyG8Pw1XbMWkxt25I9JWF0DLYaUwx +8hOKeNzko QDzJL97X O5wI5k0OSrUDjxA97lYNGCTyGww0neGp RW1DUaJTfaWsMXsR1SzkQ4NqNgraLRgZJYm +NSEeFJ8CpEsK5MHx2rHGSGQamJl5bhOEpTa5gghVl0Vi3q +l77M6H27VVICru1xXUgoQ8iahSjrJTWdofNKswdORFLTn5QGGrHX0XnN2ubp9E38B6wsswuzLOlPswu93RGDw pTFk65uWoc +4XANAZojJHgREiWaG5T4GvW4y0vhUrrmjjFEQGPfwBMeDXNFji5v +KLATcQroa5yJ4XTZtqTAfy316iCSJ1Ea8KestkkNfpBpuwbD1b0JN7gQkqRz0FAcWg5XqeRGXfPA6psmiSs8uuVlF6 +a4xF24lzDQTr7DWloSLJWhCuwNkK9acMYh06NUXVwnA0MVqkqyjNnShsWl8H4oQv5Nsf3Kbcg7R7AYwqbIyyvoi1L0OMG2icFaTU +veRNQRxoXZ0TwV0BDeNUWpOTgf9BBSXrpU9gHePT88AzPlGDTAawY6kCoekbUMntEaXY0vAVVHp R362Ou LOObMUiodtscmyL5 +cdTV6u6EWPl01fTH0FUZ2H0V4W8z44F4Gh2ydhSgI5uRlGZWCpidd2ZQPPSU44nGR59YGAbBGs3g8yFVmh3S2ZDiAoHPRdGUUVbD +O6yXceTzh0ax9buiGdvRVS6KsykYClnlACuhL3B3cZXletNklhYjd4iM10VIfUqmsd1O1eFmRa0awYKiLYWyXq6jKYA61uQlyj1D +i4k0S00cPzV8xAzE1ytC4 E4oQkbgweEF1R lPKNmluEfUFGioa6Rah2KecZ7d1Lh6uQdNNgD0s eUS5ySCPMxouDK8 +0HgjteGUDEcipVohCCBKBOiZUciFI6DvSAiuPJ7sfXEN8wOnmf1REzGhvvctZOgXVTBLlwrNFxR5iCGxGJ6vj8aCaGdAiHusVcHV +62LhpLay021xMEDPxkFKIcucN3tMmAeY75U3aPMPWhE42jEGZb9xsl2WuqH1MHpybhKP207Xva8KpgDmh36bFjN2AKSvtRYEBT9l +LWkQ1I2k3mRg5AUHmufZuRLFl8mK9PlfswEE9kK5KpOWQdULt0PbAuxG35WTQpGuIwMiMiGQhRqJdoYpyqsp5IChwrTHpdoR8vuZ +GruCxRwK5X8s2E0mwJ6NpC5DOEcNKbU2NU3a4fAsfMfCr2ENRbe6SwrihPx2n3GojnoQjoSA5t9nVk6ZT +tyCDw51m6ycbu37bPuiuoz76Zh +pgRi400F8WY82Qj8ze2OyWRrtAmgdSPhaTTfrsMne6Ug5S0CI72XWpcrTLq3IMe1RaaPujHLRbt6TeUSjcvDLizBMAHLXl5K5GS5 +B2NzwHeRY32toI78mq +aQQgMWn70ZyPCXIoMBRB72AwaVkatE5BhYxNuhX9hZBu8oCQuVoLF4IOeTkGHK2gckjFZBkOiRDsKg3B7YYN3NtT2Xfr +0Ty0o3QOim0BeJsaaR8rhFISxPf1iX8IfroC2dj8Yc QT06CFy5oeLhFTdjQoYrHUWpgupG9G4pXHLpG5tk03TFDBa6ExHnvRx +uggfzWdjjrC4hple6IJmJfAZmtXXHXzLJE9VDxquA +Xv1ABk8D8GBAXFc78pUQbC9TVoyQAHI0R3GUSkoJyoql8lRc2fI9BmAYl61BGAxG7r5jre14oQNxqN5JHj6guic9EqsYVoUNbQZX +ogqLoERowSmByIgpTZSQOaIrNwy3PtWpcSOR7QgNZCAFcv7h4bm4vcRJOknBhMouP6jAHyrRnxAK7jSnUOG9cMZecHhQgbzGSMJw +Oj +iJu1iZRbPgiO4LldaJwpEHGKk3DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8192.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8192.expected new file mode 100644 index 00000000000..a30c8ea3471 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8192.expected @@ -0,0 +1,105 @@ +ESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8193.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8193.expected new file mode 100644 index 00000000000..b1e55dd70d7 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8193.expected @@ -0,0 +1,105 @@ +DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines.txt b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines.txt new file mode 100644 index 00000000000..4ec2c6700c2 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines.txt @@ -0,0 +1,103 @@ +xxSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_+2.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_+2.expected new file mode 100644 index 00000000000..e6c5768c7fd --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_+2.expected @@ -0,0 +1,103 @@ +xSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-1.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-1.expected new file mode 100644 index 00000000000..8b137891791 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-1.expected @@ -0,0 +1 @@ + diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-8191.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-8191.expected new file mode 100644 index 00000000000..e6c5768c7fd --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-8191.expected @@ -0,0 +1,103 @@ +xSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_+2.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_+2.expected new file mode 100644 index 00000000000..b78a76687d4 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_+2.expected @@ -0,0 +1,102 @@ +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-1.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-1.expected new file mode 100644 index 00000000000..30b643a88e9 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-1.expected @@ -0,0 +1 @@ +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-102.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-102.expected new file mode 100644 index 00000000000..b78a76687d4 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-102.expected @@ -0,0 +1,102 @@ +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines.txt b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines.txt new file mode 100644 index 00000000000..d6fb16fa7f0 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines.txt @@ -0,0 +1,103 @@ +xxSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_+2.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_+2.expected new file mode 100644 index 00000000000..b7cf0e1ac78 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_+2.expected @@ -0,0 +1,103 @@ +xSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-1.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-1.expected new file mode 100644 index 00000000000..8b137891791 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-1.expected @@ -0,0 +1 @@ + diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-8192.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-8192.expected new file mode 100644 index 00000000000..b7cf0e1ac78 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-8192.expected @@ -0,0 +1,103 @@ +xSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_+2.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_+2.expected new file mode 100644 index 00000000000..3797bf0301e --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_+2.expected @@ -0,0 +1,102 @@ +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-1.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-1.expected new file mode 100644 index 00000000000..e9e28bd1608 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-1.expected @@ -0,0 +1 @@ +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-102.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-102.expected new file mode 100644 index 00000000000..3797bf0301e --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-102.expected @@ -0,0 +1,102 @@ +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX From fc1b94021087ddabe00c41bd483ff88dabaff2cc Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Tue, 23 Aug 2022 22:32:45 +0200 Subject: [PATCH 02/29] gitignore: ignore big test fixtures which are used only locally --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index 77e8f717e5e..9589b855d61 100644 --- a/.gitignore +++ b/.gitignore @@ -15,3 +15,5 @@ lib*.a *.iml ### macOS ### .DS_Store + +**/*.BIG From 68e013193f1f36a87cf4295c31667c8b53eac7fd Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Wed, 24 Aug 2022 00:10:46 +0200 Subject: [PATCH 03/29] tail: Fix spelling and imports --- src/uu/tail/src/chunks.rs | 8 +++++--- src/uu/tail/src/tail.rs | 5 +++-- tests/by-util/test_tail.rs | 2 +- 3 files changed, 9 insertions(+), 6 deletions(-) diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs index 1da065a95b7..ef8fdffcf3c 100644 --- a/src/uu/tail/src/chunks.rs +++ b/src/uu/tail/src/chunks.rs @@ -2,8 +2,10 @@ //! or at the end of piped stdin with [`LinesChunk`] or [`BytesChunk`]. //! //! Use [`ReverseChunks::new`] to create a new iterator over chunks of bytes from the file. -use std::collections::vec_deque::Iter; -use std::collections::VecDeque; + +// spell-checker:ignore (ToDO) filehandle + +use std::collections::vec_deque::{Iter, VecDeque}; use std::fs::File; use std::io::{BufReader, Read, Seek, SeekFrom, Write}; use uucore::error::UResult; @@ -226,7 +228,7 @@ impl BytesChunkBuffer { 0 } else { // the calculated offset must be in the range 0 to BUFFER_SIZE and is therefore safely - // convertable to a usize without losses. + // convertible to a usize without losses. (self.bytes - self.num_print) as usize }; diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs index 40505c16dae..9fcee00ce66 100644 --- a/src/uu/tail/src/tail.rs +++ b/src/uu/tail/src/tail.rs @@ -7,7 +7,7 @@ // * For the full copyright and license information, please view the LICENSE // * file that was distributed with this source code. -// spell-checker:ignore (ToDO) seekable seek'd tail'ing ringbuffer ringbuf unwatch Uncategorized +// spell-checker:ignore (ToDO) seekable seek'd tail'ing ringbuffer ringbuf unwatch Uncategorized filehandle // spell-checker:ignore (libs) kqueue // spell-checker:ignore (acronyms) // spell-checker:ignore (env/flags) @@ -32,7 +32,8 @@ use chunks::ReverseChunks; use clap::{Arg, Command}; use notify::{RecommendedWatcher, RecursiveMode, Watcher, WatcherKind}; use std::cmp::Ordering; -use std::collections::{HashMap, VecDeque}; +use std::collections::vec_deque::VecDeque; +use std::collections::HashMap; use std::ffi::OsString; use std::fs::{File, Metadata}; use std::io; diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs index d78795d62fa..b36c6c52268 100644 --- a/tests/by-util/test_tail.rs +++ b/tests/by-util/test_tail.rs @@ -3,7 +3,7 @@ // * For the full copyright and license information, please view the LICENSE // * file that was distributed with this source code. -// spell-checker:ignore (ToDO) abcdefghijklmnopqrstuvwxyz efghijklmnopqrstuvwxyz vwxyz emptyfile file siette ocho nueve diez +// spell-checker:ignore (ToDO) abcdefghijklmnopqrstuvwxyz efghijklmnopqrstuvwxyz vwxyz emptyfile file siette ocho nueve diez MULT // spell-checker:ignore (libs) kqueue // spell-checker:ignore (jargon) tailable untailable From 247fd8712099bd93f8b77654c90e61e316c8593a Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Wed, 24 Aug 2022 00:41:55 +0200 Subject: [PATCH 04/29] tail: Fix incompatibilities with rust 1.56.1 Fixes temporary value dropped while borrowed --- src/uu/tail/src/tail.rs | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs index 9fcee00ce66..c5f202632ac 100644 --- a/src/uu/tail/src/tail.rs +++ b/src/uu/tail/src/tail.rs @@ -1429,17 +1429,18 @@ fn bounded_tail(file: &mut File, settings: &Settings) { } fn unbounded_tail(reader: &mut BufReader, settings: &Settings) -> UResult<()> { + let stdout = stdout(); match (&settings.mode, settings.beginning) { (FilterMode::Lines(count, sep), false) => { let mut chunks = chunks::LinesChunkBuffer::new(*sep, *count); - let mut writer = BufWriter::new(stdout().lock()); + let mut writer = BufWriter::new(stdout.lock()); for chunk in chunks.fill(reader)? { writer.write_all(chunk.get_buffer())?; } } (FilterMode::Lines(count, sep), true) => { let mut num_skip = (*count).max(1) - 1; - let mut writer = BufWriter::new(stdout().lock()); + let mut writer = BufWriter::new(stdout.lock()); let mut chunk = chunks::LinesChunk::new(*sep); while chunk.fill(reader)?.is_some() { let lines = chunk.get_lines() as u64; @@ -1462,14 +1463,14 @@ fn unbounded_tail(reader: &mut BufReader, settings: &Settings) -> UR } (FilterMode::Bytes(count), false) => { let mut chunks = chunks::BytesChunkBuffer::new(*count); - let mut writer = BufWriter::new(stdout().lock()); + let mut writer = BufWriter::new(stdout.lock()); for chunk in chunks.fill(reader)? { writer.write_all(chunk.get_buffer())?; } } (FilterMode::Bytes(count), true) => { let mut num_skip = (*count).max(1) - 1; - let mut writer = BufWriter::new(stdout().lock()); + let mut writer = BufWriter::new(stdout.lock()); let mut chunk = chunks::BytesChunk::new(); loop { if let Some(bytes) = chunk.fill(reader)? { From a6c64359f81aec064f0753b78dbee102c9bc6a73 Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Wed, 24 Aug 2022 15:13:56 +0200 Subject: [PATCH 05/29] tail: Revert changes to spacing around "=" in Cargo.toml --- src/uu/tail/Cargo.toml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/uu/tail/Cargo.toml b/src/uu/tail/Cargo.toml index 0f744b1ed67..a4063c6eb61 100644 --- a/src/uu/tail/Cargo.toml +++ b/src/uu/tail/Cargo.toml @@ -19,12 +19,12 @@ path = "src/tail.rs" clap = { version = "3.2", features = ["wrap_help", "cargo"] } libc = "0.2.132" memchr = "2.5.0" -notify = { version = "=5.0.0-pre.16", features = ["macos_kqueue"] } -uucore = { version = ">=0.0.15", package = "uucore", path = "../../uucore", features = ["ringbuffer", "lines"] } +notify = { version = "=5.0.0-pre.16", features=["macos_kqueue"]} +uucore = { version=">=0.0.15", package="uucore", path="../../uucore", features=["ringbuffer", "lines"] } [target.'cfg(windows)'.dependencies] -winapi = { version = "0.3", features = ["fileapi", "handleapi", "processthreadsapi", "synchapi", "winbase"] } -winapi-util = { version = "0.1.5" } +winapi = { version="0.3", features=["fileapi", "handleapi", "processthreadsapi", "synchapi", "winbase"] } +winapi-util = { version="0.1.5" } [target.'cfg(unix)'.dependencies] nix = { version = "0.25", features = ["fs"] } From 6cbccee43a3a7c53d051de78a31b2976fc117cfb Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Wed, 24 Aug 2022 20:48:23 +0200 Subject: [PATCH 06/29] tests/common: Add library "random.rs" to generate random strings --- tests/common/mod.rs | 1 + tests/common/random.rs | 97 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 98 insertions(+) create mode 100644 tests/common/random.rs diff --git a/tests/common/mod.rs b/tests/common/mod.rs index 3fcd9044197..f73cd42af24 100644 --- a/tests/common/mod.rs +++ b/tests/common/mod.rs @@ -1,3 +1,4 @@ #[macro_use] pub mod macros; +pub mod random; pub mod util; diff --git a/tests/common/random.rs b/tests/common/random.rs new file mode 100644 index 00000000000..b1f0b73e0f7 --- /dev/null +++ b/tests/common/random.rs @@ -0,0 +1,97 @@ +// * This file is part of the uutils coreutils package. +// * +// * For the full copyright and license information, please view the LICENSE +// * file that was distributed with this source code. + +#![allow(dead_code)] + +use rand::distributions::Distribution; +use rand::Rng; + +#[derive(Clone, Copy, Debug)] +#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))] +pub struct AlphanumericNewline; + +impl AlphanumericNewline { + const CHARSET: &'static [u8] = + b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\n"; + fn random_char(rng: &mut R) -> char + where + R: Rng + ?Sized, + { + Self::random(rng) as char + } + + fn random(rng: &mut R) -> u8 + where + R: Rng + ?Sized, + { + let idx = rng.gen_range(0..Self::CHARSET.len()); + Self::CHARSET[idx] + } +} + +impl Distribution for AlphanumericNewline { + fn sample(&self, rng: &mut R) -> u8 { + Self::random(rng) + } +} + +pub struct RandomString; + +impl RandomString { + pub fn generate(dist: D, length: usize) -> String + where + D: Distribution, + { + rand::thread_rng() + .sample_iter(dist) + .take(length) + .map(|b| b as char) + .collect() + } + + pub fn generate_with_delimiter( + dist: D, + delimiter: u8, + num_delimiter: usize, + end_with_delimiter: bool, + length: usize, + ) -> String + where + D: Distribution, + { + if length == 0 { + return String::from(""); + } + let mut result = String::from(""); + let mut samples = if end_with_delimiter { + num_delimiter.max(1) + } else { + num_delimiter + 1 + }; + let characters_per_sample = length / samples; + while samples != 0 { + result.extend( + rand::thread_rng() + .sample_iter(&dist) + .take(characters_per_sample) + .map(|b| b as char), + ); + result.push(delimiter as char); + samples -= 1; + } + + if end_with_delimiter { + let mut string = result + .bytes() + .take(length - 1) + .map(|b| b as char) + .collect::(); + string.push(delimiter as char); + string + } else { + result.bytes().take(length).map(|b| b as char).collect() + } + } +} From e07198cdc7625a5fde499501c04177f4ff9c1be4 Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Wed, 24 Aug 2022 20:51:17 +0200 Subject: [PATCH 07/29] tests/tail: Restructure tests to use the new random.rs library --- tests/by-util/test_tail.rs | 196 ++++++++++++++++++++++++------------- 1 file changed, 126 insertions(+), 70 deletions(-) diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs index b36c6c52268..55eb4bef920 100644 --- a/tests/by-util/test_tail.rs +++ b/tests/by-util/test_tail.rs @@ -9,7 +9,9 @@ extern crate tail; +use crate::common::random::*; use crate::common::util::*; +use rand::distributions::Alphanumeric; use std::char::from_digit; #[cfg(unix)] use std::io::Read; @@ -30,9 +32,7 @@ static FOLLOW_NAME_SHORT_EXP: &str = "follow_name_short.expected"; #[cfg(target_os = "linux")] static FOLLOW_NAME_EXP: &str = "follow_name.expected"; -static RANDOM_TEXT_BUFFER_SIZE: &str = "random_ascii_8192_bytes_103_lines.txt"; -static RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE: &str = "random_ascii_8193_bytes_103_lines.txt"; -static RANDOM_TEXT_BUFFER_SIZE_MULT_THREE: &str = "random_ascii_24576_bytes_304_lines.txt"; +const CHUNK_BUFFER_SIZE: usize = 8192; #[test] #[cfg(all(unix, not(target_os = "android")))] // FIXME: fix this test for Android @@ -2574,63 +2574,96 @@ fn test_pipe_when_lines_option_given_multibyte_utf8_characters() { #[test] fn test_pipe_when_lines_option_given_input_size_is_equal_to_buffer_size() { + let total_lines = 100; + let random_string = RandomString::generate_with_delimiter( + Alphanumeric, + b'\n', + total_lines, + true, + CHUNK_BUFFER_SIZE, + ); + let random_string = random_string.as_str(); + let lines = random_string.split_inclusive('\n'); + new_ucmd!() .args(&["-n", "+0"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE); + .stdout_only(random_string); + + let expected = lines.clone().skip(1).collect::(); new_ucmd!() .args(&["-n", "+2"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_8192_bytes_103_lines_n_+2.expected"); + .stdout_only(expected); + new_ucmd!() .args(&["-n", "-0"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .pipe_in(random_string) .succeeds() .stdout_only(""); + + let expected = lines.clone().skip(total_lines - 1).collect::(); new_ucmd!() .args(&["-n", "-1"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_8192_bytes_103_lines_n_-1.expected"); + .stdout_only(expected); + + let expected = lines.clone().skip(1).collect::(); new_ucmd!() - .args(&["-n", "-102"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .args(&["-n", "-99"]) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_8192_bytes_103_lines_n_-102.expected"); + .stdout_only(expected); + new_ucmd!() - .args(&["-n", "-103"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .args(&["-n", "-100"]) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE); + .stdout_only(random_string); } #[test] fn test_pipe_when_lines_option_given_input_size_is_one_byte_greater_than_buffer_size() { + let total_lines = 100; + let random_string = RandomString::generate_with_delimiter( + Alphanumeric, + b'\n', + total_lines, + true, + CHUNK_BUFFER_SIZE + 1, + ); + let random_string = random_string.as_str(); + let lines = random_string.split_inclusive('\n'); + new_ucmd!() .args(&["-n", "+0"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE); + .stdout_only(random_string); + let expected = lines.clone().skip(total_lines - 1).collect::(); new_ucmd!() .args(&["-n", "-1"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_8193_bytes_103_lines_n_-1.expected"); + .stdout_only(expected); + let expected = lines.clone().skip(1).collect::(); new_ucmd!() .args(&["-n", "+2"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_8193_bytes_103_lines_n_+2.expected"); + .stdout_only(expected); + let expected = lines.clone().skip(1).collect::(); new_ucmd!() - .args(&["-n", "-102"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .args(&["-n", "-99"]) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_8193_bytes_103_lines_n_-102.expected"); + .stdout_only(expected); } #[test] @@ -2731,153 +2764,176 @@ fn test_pipe_when_bytes_option_given_multibyte_utf8_characters() { #[test] fn test_pipe_when_bytes_option_given_input_size_is_equal_to_buffer_size() { + let random_string = RandomString::generate(AlphanumericNewline, CHUNK_BUFFER_SIZE); + let random_string = random_string.as_str(); + new_ucmd!() .args(&["-c", "+0"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE); + .stdout_only(random_string); + let expected = &random_string.as_bytes()[1..]; new_ucmd!() .args(&["-c", "+2"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_8192_bytes_103_lines_c_+2.expected"); + .stdout_only_bytes(expected); new_ucmd!() .args(&["-c", "-0"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .pipe_in(random_string) .succeeds() .stdout_only(""); + let expected = &random_string.as_bytes()[1..]; new_ucmd!() .args(&["-c", "-8191"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_8192_bytes_103_lines_c_-8191.expected"); + .stdout_only_bytes(expected); new_ucmd!() .args(&["-c", "-8192"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE); + .stdout_only_bytes(random_string); new_ucmd!() .args(&["-c", "-8193"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE); + .stdout_only_bytes(random_string); + let expected = &random_string.as_bytes()[CHUNK_BUFFER_SIZE - 1..]; new_ucmd!() .args(&["-c", "-1"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_8192_bytes_103_lines_c_-1.expected"); + .stdout_only_bytes(expected); } #[test] fn test_pipe_when_bytes_option_given_input_size_is_one_byte_greater_than_buffer_size() { + let random_string = RandomString::generate(AlphanumericNewline, CHUNK_BUFFER_SIZE + 1); + let random_string = random_string.as_str(); + new_ucmd!() .args(&["-c", "+0"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE); + .stdout_only(random_string); + let expected = &random_string.as_bytes()[1..]; new_ucmd!() .args(&["-c", "+2"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_8193_bytes_103_lines_c_+2.expected"); + .stdout_only_bytes(expected); new_ucmd!() .args(&["-c", "-0"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .pipe_in(random_string) .succeeds() .stdout_only(""); + let expected = &random_string.as_bytes()[CHUNK_BUFFER_SIZE..]; new_ucmd!() .args(&["-c", "-1"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_8193_bytes_103_lines_c_-1.expected"); + .stdout_only_bytes(expected); + let expected = &random_string.as_bytes()[1..]; new_ucmd!() .args(&["-c", "-8192"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_8193_bytes_103_lines_c_-8192.expected"); + .stdout_only_bytes(expected); new_ucmd!() .args(&["-c", "-8193"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE); + .stdout_only(random_string); } #[test] fn test_pipe_when_bytes_option_given_input_size_has_multiple_size_of_buffer_size() { + let random_string = RandomString::generate(AlphanumericNewline, CHUNK_BUFFER_SIZE * 3); + let random_string = random_string.as_str(); + new_ucmd!() .args(&["-c", "+0"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE); + .stdout_only(random_string); new_ucmd!() .args(&["-c", "-0"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .pipe_in(random_string) .succeeds() .stdout_only(""); + let expected = &random_string.as_bytes()[8192..]; new_ucmd!() .args(&["-c", "+8193"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_+8193.expected"); + .stdout_only_bytes(expected); + let expected = &random_string.as_bytes()[8193..]; new_ucmd!() .args(&["-c", "+8194"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_+8194.expected"); + .stdout_only_bytes(expected); + let expected = &random_string.as_bytes()[16384..]; new_ucmd!() .args(&["-c", "+16385"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_+16385.expected"); + .stdout_only_bytes(expected); + let expected = &random_string.as_bytes()[16385..]; new_ucmd!() .args(&["-c", "+16386"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_+16386.expected"); + .stdout_only_bytes(expected); + let expected = &random_string.as_bytes()[16384..]; new_ucmd!() .args(&["-c", "-8192"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_-8192.expected"); + .stdout_only_bytes(expected); + let expected = &random_string.as_bytes()[16383..]; new_ucmd!() .args(&["-c", "-8193"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_-8193.expected"); + .stdout_only_bytes(expected); + let expected = &random_string.as_bytes()[8192..]; new_ucmd!() .args(&["-c", "-16384"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_-16384.expected"); + .stdout_only_bytes(expected); + let expected = &random_string.as_bytes()[8191..]; new_ucmd!() .args(&["-c", "-16385"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_-16385.expected"); + .stdout_only_bytes(expected); new_ucmd!() .args(&["-c", "-24576"]) - .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .pipe_in(random_string) .succeeds() - .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE); + .stdout_only(random_string); } From d63b98c54b1a60cbe8d08f4e87f1a8350bc46f9a Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Wed, 24 Aug 2022 20:52:05 +0200 Subject: [PATCH 08/29] fixtures/tail: Remove random_ascii_* test fixtures --- .../random_ascii_24576_bytes_304_lines.txt | 304 ------------------ ...ii_24576_bytes_304_lines_c_+16385.expected | 105 ------ ...ii_24576_bytes_304_lines_c_+16386.expected | 105 ------ ...cii_24576_bytes_304_lines_c_+8193.expected | 205 ------------ ...cii_24576_bytes_304_lines_c_+8194.expected | 205 ------------ ...ii_24576_bytes_304_lines_c_-16384.expected | 205 ------------ ...ii_24576_bytes_304_lines_c_-16385.expected | 205 ------------ ...cii_24576_bytes_304_lines_c_-8192.expected | 105 ------ ...cii_24576_bytes_304_lines_c_-8193.expected | 105 ------ .../random_ascii_8192_bytes_103_lines.txt | 103 ------ ...m_ascii_8192_bytes_103_lines_c_+2.expected | 103 ------ ...m_ascii_8192_bytes_103_lines_c_-1.expected | 1 - ...scii_8192_bytes_103_lines_c_-8191.expected | 103 ------ ...m_ascii_8192_bytes_103_lines_n_+2.expected | 102 ------ ...m_ascii_8192_bytes_103_lines_n_-1.expected | 1 - ...ascii_8192_bytes_103_lines_n_-102.expected | 102 ------ .../random_ascii_8193_bytes_103_lines.txt | 103 ------ ...m_ascii_8193_bytes_103_lines_c_+2.expected | 103 ------ ...m_ascii_8193_bytes_103_lines_c_-1.expected | 1 - ...scii_8193_bytes_103_lines_c_-8192.expected | 103 ------ ...m_ascii_8193_bytes_103_lines_n_+2.expected | 102 ------ ...m_ascii_8193_bytes_103_lines_n_-1.expected | 1 - ...ascii_8193_bytes_103_lines_n_-102.expected | 102 ------ 23 files changed, 2574 deletions(-) delete mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines.txt delete mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16385.expected delete mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16386.expected delete mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8193.expected delete mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8194.expected delete mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16384.expected delete mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16385.expected delete mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8192.expected delete mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8193.expected delete mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines.txt delete mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_+2.expected delete mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-1.expected delete mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-8191.expected delete mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_+2.expected delete mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-1.expected delete mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-102.expected delete mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines.txt delete mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_+2.expected delete mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-1.expected delete mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-8192.expected delete mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_+2.expected delete mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-1.expected delete mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-102.expected diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines.txt b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines.txt deleted file mode 100644 index d8f4feecb07..00000000000 --- a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines.txt +++ /dev/null @@ -1,304 +0,0 @@ -J4oQ6fxiqTHDbuEkMmoaSGaIUsZEOOdQOyvYnZ1YLQpWlV7r31y2xe68plK5I1xR12wTDdoE7rxe2eUKMPCBTVxVNH8bY228GJHp -lR6GhgHuxsMvcYvSabj9kCB4PqGcvfazUkm3MW2271kJu7LhYRjMpsSlzN7WrQJQqiEgtTItHnsxiSqp1P1gd4MDveEtePk7Draw -IdV9Cf7MCJK09ndDt1aJH2GFHDnzopgemQVEdD -bDAGoTWu0fMT9siH61yKIz2II1oVyBx9g2prC8U9AlGuf15WcVK95NMxLmZrmyDtA -LwOtKZ4nVn3g7xmPVTN2Kg5n6O9Yl76O3T22Q9mVqZt4YpFrK1xGzpqjxBNUdJDsvawSCNSNEA7AMTzYSrYpPpPt2P9iyx2MvpNR -X8tlk4pRgQjuoXKEp5TuFF3OuIFY5XXYJQymjWLIDGcxSjjI6xEqdU8CMN -YMJJs74SPsjiOwNAK2VpinYb1QtwXPqVdGfbGg8VQ5o9QnOcVCGvQyVbRpWBo or0F9E e9xo7i8l5UM4Azm Tq8uMIWI9 -9XfvyGGMs DP7COeWrqdFQNTo8Pbv7XadRB2LcvQ6SlR6gwd8VUN7dyMdOkZLV4Jb7VT f4NIFMiRwVecGp -WQXKXeThT2qAGMsXSXefIvXqpoVjbjeexj79h9Mj9xoBfRASf3nYHB0icQAg9RfpzAAh34ozWgmUjqLF4MF00he5EGIOHsRTeoEu -nSeUSahCLkcHJ3ESVXjLIUCG1p5QSNM1RECulAEcMfMuUuSRwO5iVVDXLSkHPzHPg07HhsLhfVjuinFhZNvmb8xI5D2 -6MW8GNggwEDB2bX9epFvZNPx47GvVINAs -UJhLmBGjBGb6PsbrvKKY0GXeVVaMCUMIK8qlCpWRnmTUkjJ0SwQ4KxZb4fdOKCEH0QZDZOikYWMvc8Y9IJq3t -ljByUTerOapn3UbSsaqaLl12SwePUY1Cle2EZUfXmvjcO8bVvUg7LB4v06ai7QFZxpVvUrbxlnzVXInk0T62JJ23qxWrCwiWgRa3 -5DEXGaWwwuWOlPyzNBslkiaqPxWRL4zHeyqjO3A -JcHL0yolKdeNza8LtNCqzstf6t2YD24p24nHQNT4fU3WnjYZkWQIjCZQuZEXJG65p4Rxa9iMHTiiLxO -r6TD0TobCVWvsOvbuewX6457GdS4RO2JnlDckEeqxkCofrXZxbUN29IixwTTS5sQOQnbkoIbd9m8dO63WaxBNl97zQxhcvYqy7kk -u9qI168NZSKAsNDiY93nqPoOdzlsFaadHvBRBcW1XCmM6b6xhd7BXA33arsomRHBrybN2tqHtmSUMdU0f64N4AQDRg7yxgf2Qkgn -9RLYDwmrW6SwTqMSUBV8Xh09mnwOYInEIfnIQxBZhBQlIW7QmFBqWdDlNt3tQC3ji -4bZjdOzgqIIDLrbjEnrTFXOkyKvgC84WPul0mzVhZiZoV5xANWeXgsA4dwbiM 6WIVegaAxtVWnfdOmukoEhWGH -4DdaktQoh7HHi4g7Q7X8bEm9I6eOLhrXRqn7NWkX -mKUEW0CUTDGrCR4dEmW8PbGveLR70d0gD45mwoR8ivpQrGHBiBKFKjhTZosG4RCN7GJInO4JnMSlO935SX8qoXIEVcCtjdTvTWZb -oaj8njqe1WTCkfnZX0J7FfxH3g1V2vdw7uqAkP7YmUzx7Gie5432XuxwKzzGu50BwJre5AJ9GHl8r2BMuv77IdBNlp7hnafTlIva -Nh8pWJwSEXwrg -yVATXJX68rwMo41rPisbRexAvKfsyizVJwVt5g32b4q03NHEVEpHmQCUgJUMUze26EIU5aCy1ZurtFXWLOSNNxs2SOOEoFdN6KKc -08q2nhdrQ oovQsOCZk1wd7k -5p6hXKZ3ACq6Cu4Ad8MnKSlMOilFbNOhCqUST2YKY6ET0GvX2UuXaXlMEkimrLAomnPMvlJctZPAygx1X7pDe -sMOQOGnRNucYeICZKh2Zv1ecg6IA93VKY36QLoEhWkoE3gIoQFonh6PNs701K1eH8mL5qnlENaWexVJTd9bHVvSM8iEfUY2Bg7gc -amGTM2iiiefj8A2JjjDgHcMzW0kGnmLG3q5gPJF6D9RJV8kw35CBkKv1L4AZMUMtVKzNjKE4Q61l3HBfNUPqLDlF1aa97yB464MX -lzvXIpc1mWceFWPLzziai5Pqw1 tbtY8jyxC29pMCW2pzY1o2hK3zfHm3pQP7kG -TdlJ468GKpqfR7ALEyL3UgIiM88LI9A0RjXouOEZ6ZIPl2iFYU8CuT9O 9han5ROjXOOO7qiu6WgAIXi -BYwTfRSnCi1R4k8RIgfEx4DRcSXiygBf0xHPzm7iGG 4h NSXoSaV1R4nF3fT8hScc3dYl -iJoFdbYJXf6yL6cg8hVynqs1m7lGNUMrw8a2pgnCHAy -ojqFHZzc6scJsLtAcPkpa3OUR6JdHABOk40OdBm704VuLg05TbMC8daDKY0Xb6MdHdNoHjby4jLCEsU4ZOpqluwiGlEoCEhS -lvXn0B1wr0EMN2V3gLr f9m6b45r952K450PA0G1D -SrwHLTw9r3fmJWBhuJptCBXFTh5ogT4l3WiaIAEvmTyc742DgsB8qvx9SFSKGwS8EQtrEzIOEuDycNmQkY2HSjvhod5kdAnAharQ -DgHDpB XwbHpgkF6GnevICk9CzeicW7ejE34MyG7Zls99d2MhUlaIsEsUH9DOMVdTdrQpd3AmZAktNF66e1 -Tuk0IVg2Ydv97QrO958rC4KzRsqS29n0SHiD85UouIaQKdE1L7mVBUghMr70XlqMLw9tINkjS75mLYA -dMjrvrXlvJAwTPMe49SlitQLRol06OWC ojS b00IJOoIJJKgbN ufw7IKkMsphU0MdPfuU wGbH0Nfymwhy6udv h2deKFxbV -DYUQ84zpLDThoBClPqMnaKTcRHT1zWL1hv0ir4PjF8FUGHKAAe9Ol35y5XiaDY6vyowmusm29fkS1IgESiDJivRE89KthOeSPDGS -4dmxKagasI05Ny6qzslXkPqoTlsHnN56val EvvPdEZe79MpnPj6iAyvobUDcn0W4NyhwQNTD5hoPBhL7215mpK -8FBvhjbWvFEhPpLMv70txCIZ38uu0qg UZILFGPlXatAu29fiILbA32ojP8dyop7EkMLVMK9IgcLsPBTw6tm8Ic87y71 -fIED6GWYNYozuCAHlL6z0LMj0eidbRsIX3Jy4Mz1m4MtPWOXmjgZXbkhL -Ev0ERzawuimBTeFKlXvSlTjMP3sOUj9caZowuFLX4noZKXPMVVgMXvnMBl1xwbCg7E2yvbWaH3ruqJH7RMXff9FYeIji8yF4sTDB -ujeDyqJqySTpbNkJ8ByDbyabqc5uutUhwpTbaljn8ss9QzGJYD2JrQTDZW4xcCIduGBufY862WbgE7HiL4cGBDYnKfhzox59VCtG -LyengubNpNecXP6u5hjQpY1idKdqCYC3jRU0HcAqk590hsxMwW4YKzgUvdTjPUkHHbi04Hns9272wYsDzYhXtTCLs40F3XKTka0e -K47uiWwlm4SDXUpoVupwCnBBDCUx1s7mraSePlHrEtreDBJD6DlbVfOYoWHzVWUW7XwczOd9UwU7wNyZxApKvoR89oYXaBtGEJ4C -5GI9j3GHcR 2BLyoumh3nGLQy2oUeasWAOCyFGzm0RscKRWYvTav8jQOjSgxWTjTxXG -4XoElg0rkiQ3HCW7GgCSDvcGDKS8Npu5sOIihppBRnIyx4OZDpwLhmzJfxbMJbnIPRNuk6GfBvgS hZ8MBxHhVW OhMLWGV -FtlDbZKyiaN1dwljcS5NKLTwL1xCBi3WkZ11 yatKBBwUTJits0PzR8V7UlDUXKzPqpefTQuw7B99JwUrQPDz2Bn03e05NXx31 -eB0qzoAVO470hDHa6G17fBenDm9YAvVMJaeqXqZUZNAOtbsddPo4EJRE9GPbgeRGaUzpmjL2DS0SgLrT1Bb0k Y -76nNUndzbxAz0WpPVRebZb61UKAaVRQm -K5gb71TkqSE7TNYyP1erCTv9dHhzgI2i6omHU5Oad4IwWMQZbwHRQOo1NSwqHG9qhjSiDUNb -7a0JNBLotxxAuny1qnnNE6eJUnWuqApL73j6qzXuaGlSzhm5R7qPjqHHSOeOsLX3uET9JLBQQfHoYC6t81WFaYj4UhrsA3WNiW2D -1ehCPHReFTNDtCPNH9gTBtd40vC3S6b3w7nXec3fE1ZDYT8ry5YeZYqPDz9DIJniEyqRr76gxeduHvhwC -TZwOS1bZr32TItefc4dG9bVG2VpfgD7zVM20SPxWlIdkTXxEDFAvg agcz8LIfBqz4jHr6p -wtG0JEtXMWWIfLvVML7DT8NluPzBey9QyhtTgYyxYGx93truoReslHMjtLpKyFxDWz30m8MEL1D4Ch86ltjybsARupZif3IyV6MA -teM1Um2wASkZZpRBcYWFxmsTah57OJMq9zWyyC2iFx1jshAhXeBqg8bkUV5EO5PAxGZ8evXWsREZ -51fl3ymZu0fra6sbTrJCjXFfTYFM0g8Foamoe N3 l2IXbNFOxpSm2QVFxuaV WJT0JlW -qkLc3j5HCGdOibkCJVz2orsQ7AEr1IHFb9oK4CFWjxPDtOxIuQQHmiyHaIlfiwDIx6AJcKrNRWcB1qGupUhQeE0dY9QZD3O -L66YuALn2YJ8Sdwhsaqm9hh8yN9cTh0AYU9Fm9qLOEczlxCzPMUAHVXSAZpnbkEjZAJKiIHA5hi4unZ90mwreQDX1SilFYOVTY0M -kPEWphf1U6UugF8RYwS0cU0ESLuQnxpQbKsbNI90qWJsMOToRXa49J0YKWuRppuZDsXAucO9tD8xHgXnq824FYQvKdBTdUCTc59H -In33xgNgQtWsUFrIt4436zfjiZSlgHMcOm7311i9b1kZLYG0hdr8 aydTC gPtNj4kKxojwdxZk81OVFHjNYtkrs8K5KW -bKUyv0a7x2hY52ebafP3qIDqkDneehvtVzdKDNiZeePw BHyh6ZCzVY 1WqvYSTIwBXFQ D5dJuScKJuByAkHtrAc2RNMD -LEDQVgwv9xBdRqiWa8Z6UmG4sdDj EmidDdlPFdmNKE0FaVOrZV 2MmhEcTmUgFIKCxw2DYbKpQcn1whTxEC z4FRFnxk8toL -4Btu8k9QJbxyzpKquJkfIL4agcyu1SiyTtM -ecOHStkGkwMjOfnmhUGEL85COIEZFEl6DkiHs5iTNvYNXNYz0LEEEq9QdkSlfo4Q5eEVeboxqbsaSs5JnA9XhZm6GdeYptnHfLwZ -7C vSMNUDAMDGHBjYh0GwBsA RBnQqKDSC3gOlvyLMYCevdUjK3yA84EmLvZ68wg9HHjWiOE8u05zr -dJkz5eTDH1iBUxOFKBlL0HBFvKVota5opnuDTCg -s1EGHPHtVjZqnBupfDU2gCZa5X6ETHTd1IDxh1OKgVPNpxHOU1u06snilMkxJRO9C6vWJcTzqCf7kMY2jaQqI9L2J8yVVpSqjW0s -eadd5TQmhmX SqcyX8qdUQCn5FgsOXRGY9DoQUEnKS9jh8CdcwPN M5Jg4QFG -6Zu0I3PUuVKNxkpK9GTYmF6tDmk0PDjituCuuFv9T5CPtACYNxR4Lla -TAlDA4b4e10AIwKjNJOB3UpjDhcZmVZQjUg5wc2s348W0kNIVFKNQ9ZeJWLbG9nPg0Oi2GShGk7Inzm0RccECTtXTfcvFCsux6N4 -0RIo7ZMEENN3rKNcQRNQewI9M0eU4FKC vdEV3dXcKHGIvWESC2hA2OIOSO3hfGKR7Qatkws1EAXXD -pOPlJgz853NtQMFI1vJ87A8GHpYIm xtoBxOqXvqgasg1k0lvawezzO5cvfJcbuJmNCdERJxP5WC8zngTEX1 -6DwSQuV8mhwQtPT0iERyQYeE cdbqJOTGEuwnUlBwKUa78EwKZf3kw gR1Ss4BHQhHXd 2kPkD -4MDk8puPDmibPcZtPcu541Y9BEbyiaNI7E6g98mK btVAKSrqvocNEBTh6XYHJbgee8 -pdntzVjwk4BSXSNZpzBKnKFa9bSWGTDbzKYIXl0iBsn625EgQaIlhxrCamcaHfkMPEjb0izMw2fExA7PRHjZ4tiijDMpCMbocWWY -o274WWap1jLtgpEVaMRPOeJ1bHGrquBWN2YPfQCk6NeXShgC4D5fZ12hofJ6ScIh0NRNjl7wgQX4rSdc3NeWgXABb4Tv1PBPIjy4 -AugAqkt0p2iF3WzehKNCU53csmeH8Bzn5db92GyrYEdJPeDGLuBvp2J0tGQfPqCWKQdbvFwQMpK iJRB56byKSd9M -QNRzCxGNkgdswpe1jexXQD0anS9euxN 78Qw9ENQuSUNsp15xW xkdfQNnrtdYUYYQ -Msc15WA42U1flB8uVVMENsnAUkIoAV5kW7DsQ0pXae rJNYuG6XIAKCtY2G697KaDoV03nPSTIwdMgLZJPRGEipkIWyKVmellIe -QWxOUw6m0vHkZKGnp5qyinKZz1xBtbM7HUQdPb0BSc6jRXDpTutxuhHM0WHQTejBhdQeOtzZ bc zxnKthkXH -x33H1hITTDUD44IBoKyEK8W4HGS4ClbABxhDg38qZnS4CynfLcQumOIuytArK5PUq2zJg1Z90AqkYCNVe52uCdbVomFjIiTdI3ww -5 L gMqFFwZlcln0htEcUE2exoUxT2bGbwhWHXH2gFjDnXiTv6yIBapBNoC cE1i4ZOWMM4P -XEzMFgRy0Sk91KNkUbqOcKZ8ilL7kkpp9xJvNU4NMOpJvicNXaD9vGewLQrHlmi7GAklQwgxxtGg1F7HOs3iDAiuxA4NvYNfit -Xu9hw9kzDId7fhbdQwnByNzoGQMb4JXpj3HKJV6zCji2ZSjd4z2r9CGyoSvIL9ModwzkTEsU3JoSPNR -an0Bjr3kKxmF6TFLV3hQFUEzjuZ -EbgntoQdcxa5ejRRj5RaL5xQh4DS58Y5WD5mdO51mO9r6OeEDlvh8XD9WJrczTKaFmL9kyFSFJiBywZhWbtqICPIX5A86jt3RanX -ioEBdOhAAyCJdZPWQc9A01IHnnXxduRyIXUj6mPUMEozF4D3pmwNL6 hNPhGkKKm5KeDEPv7 -vQmixtzVX75oXcrDzh5f0x2rz5lvRB63xIOyF0WW761yT82gtrb -KcQ79Ai1FMUPNtrlNaEtU1CS9XXVXz4KKnScAUOJ0dpeqq4b2peKB39gAxANIXETCbZUrgHUPdyPOJcBsU1BxnyvnZ14nieQbur1 -5PtE1YSPHbUoH7jPYxMrnh7RkyeR4gtlUcxCrXsDIS3VBb9smAyAK9MKVryybIjZ8EotfSLo1jMbxAGeqEo34VA5ds aiGo7s -E37V0nnm1itRo2uBCKAJBxOhRSEZL0QZIRD3zPsgbXdE9N7gZjOGbMZQ00k2FiBKxTh5FsJ1GEZSnKuCyoTbGUUghHXzb9ZlqZ0n -75T3rJaFjNt66s6kJiC060rAshKtI5VvQPfiI5uL4n6EprWwGKBWpI1jM1HziuDR2rYNVJaQq -brR80YVAbPzrU3hIggLw0gIqM5WNfknHMZRjtjHzYQ0LGw5qAkUYSn0LQOYpbTbzvLB81tpqb43l8C5 -7HPL1RjflbxJRpltWxTjRQayzTVcp3No3qXSe4PhKJVQ9Iull0OZzVSdgRwpjN5CS48iuSePdWl5Dz9zheDm2pQ -1Bd8zOlDyrKNbQrjaKTA9wjuQ0qSrbp4YuFwiZ8boLk40vVbdLRab6ufV7lTd7rVuemEJJE -RLmjOiiXfaXN8wjfOusp0CtXw3TUGvH3Ps68 BbL0RuC6Bg9ZmXxhyUySy8kSt EJeiVLDIcGqCx6wYbqZhSkq6gRW -qCrA7LNdy1RqE6FyTIR3fN9A2Y1K95k5CKzdeas -g4LylIj3P1DEn07KlkKA2MLEcRhipcJsk4hwSIwvDOIkOjlRwwmK7HjBjYzeS7aOGq9mEhb5PbevpDVgBBKNIYEb4HhrrfixUC8j -J2 PNukXTyPowk2P490ZRC hjIqTv3QZxI7 wrsa0rJ8ixaNmZ3Za evP5y6eRvwSwJng787yQzpVi3wCDBw XrEPBJ0 -t2BMpq3evy3ELNduHoifzv6jkN0gJy9o -99sUZ34ro19oJd3UTlLLvi8h8vwToC3ijOEXhY8abO4dCMZUhwj8QlYdDC0JmtAXLO9CEZ0dWZXAMvXgDaorn7CDVBks2Qa7aMkN -1JClm9DlcPR65EKgtPeh -wdteBwA8oEHKRttRIEGI8IstPh2s75Sc9mg0LFG4tn256bBycdcJu4yj6bjBYN13U2dsKkrsJuonekqCOaTTtKudcIwAqRFnZYSa -eXQuRchTkAoQQdZMOejbLczo975o4h0rnt0UvAgU53n -8BYujbW5W2X50yUfshDCtEra20Nx9rJnMAtCkw8QgfECDM988y4A5FGw1sOSyaNch4 -Y47fv7VGVhfl9NG9ByImguZRrYZ3En0DYy2P0G1ufy7xplzshenzxNEjwTe3UR9G83VUs6obeSVCYBAo7pBmaQxH 9f5f9Mv -4oC5X0WDLvadtlM0NNmyDKYfzgw3JTGXDzPGVl7WkL5hsec6MbwS6l0Q7ruX0WtU1WVD8vyCBmVcr2q9DtmgHqclSbMoHXokGFkY -knfOZFLg9DrRkWp3VZfVLYKgsi6pCv 9J7JUWTWxRXLpSszJpKvQbbLa1BYpw0hI3LwgEbX -6ttL77Ak2kox3W9QqdzwQLmTh45n1rwe2daWBRpzwOq33LEBG1nwOlPY5tve0iH5z4T2Vs7cBj6BrOFc8OgS1RXygUURmkmZvYC9 -7XuL HJk8TMOkeCLMZzoJZ9EZVAJXQO9lHftsvw05CwmcscDV7QuRmuwQBD6f4qAnr35io -xNyNC60pDHAKQOV4sIbyoUra8u78PMofY52BjsfFySGZenDGkc4joegzKdogbeQeEjRRD3pPX1CjGu -NtxYCePWXkwgYoxasuDn0ULgaJ9rTD BjglBpG3kpRBB84GwJzfjh8dEmRmKMxsPA8K KpGfjhm -EEVeLcH2t16Se4FZkLSFzADooDijqm60lvxSOpe2LGGhXa94dQmMTESl6FPVqchzKKQuMg77ulrF7GSUosvw4Ry5oLJEQGPqHuxs -jCcE238RM7JOGHwDomNGHoyY0LIYO2dqIcxNOMqvVcFLqCwxnWnX6N zWqHH4ACm1EbtXCACZAOtGsPsM4DdXw -DyqJiYYqBZZAZ0jyvwF2Rzm7DDpWtphJFvKaCvi1n4lf3lBQe FRzakzcOm1sP3q5BMwWDQjcKIhKCsTR4KsqAQWM2cef1 -CTOu64tjU65CzlCmns0QSG8PpqeXLZGo32GbMz1dsSU3byFdXvUfLInNPWTQIGj9tmeGnDzeBihPKIwOQzeB -4oyVwRjiyn0pyMWZ0ChczKOLO57DxwNd4v38dZ 1nIVIVSxlVl0GH4v4tt9judjPKvsMxrAxJq7cDbK bVlc9EcVvTR -ikVAsOiY5ZQT7Y88wh4clEB7lV 8kTSte3RXOTA -1bVCT7yBXD3Es6yezJWm7hdz6vZPaIIOX2l0fTUXB8RfxTq3Kaj6lmQJnuItDJncz6AaYbjXe95W3Vmp0PS3ATEzdG9mEZwSymjd -egkKfFTdY4kx6EnInnegVUFBDalZa5z9ubx3eu6nHD7zfYkjFWUMaLSgwVKjJpsYcw3DtHlfhLWo1nwC9hTX89vCEShI4bcsnlJ7 -3jyOhJSBOym5T55E8F154bYhF4dnwt6q2DRPnenggO1d04bJbVhRbfTgbhGPen3mO5VaU2Z63Rs7q9kp8CsJwPtO5Bp0LC0sTh4Q - -0fJLwkEdB9cY9rVMHpMpRq30e3X1YdchhB8mOkKBXCCaS9WhoBXZYV4zS0R1LOCC5OqHu8TxDJ6p3rOoGxM2s1KzJMZlweexZzSa -ovcwhSG UZ2TTYIan8vFvreBtkSyxmlnQsUyfZnajIPFZeNE -IGu8JRG1yuZuCq0xNPJ19G1ysunyc3X57fORpykArVk2TVQhsBlvsqsloPMMd9FKOSTc0jZsnJf2nLujBuHP5vwqrytGCZMh3mI1 -rZz f5h5RW4JYTtZbd8yeqAF6Hxmze5KaG0jLI7XWIA2ZbVzKLJRydDZu7tiRyNSNjXdw5MuFDgSudZcav3WHJyO OXQ -S4KSuD4dKkPL2hDwuHVwVf6L7hNvyLC5EuqZN1JIgbYiozbhmhU6CKqDLoOdsxFZsr5Uy5F4j3GruUTukaxxIXV9THGDm3E35XGy -OYLvjv2YQWsT5eiWnm5AFuGUBI8pdDSVdnvLPW1Gm9Blb3lQU6xwJsUIWw11NWLmCSf2Aj9olkGXtxWXhji1ypQhQd2GKZUodWyH -gLRGD6QucBcQI5VI8fjoQGWPAgtoWhgsKDGbG6ZH2x9YoFWgWJc OsB1rt7pUWu3vyBueDujMduUejf7RdLO -KqnRyHahI19I5jLVHLKGyNWrbvb9sxEhKPyZEKop -uRCHEXbWRYGZhPks3Q3Wcjvaea8oeuguFZqZVkd0fVpgX8WDleCk8ZqWU1eQbVWjgzaxTNJB23qqMYl6YJFczQb4TkE3GGgDYS3J -cSP1D3qqirQASr42pWt2PBOF7OaRzjD6HUn8MtGF1wyPPWrORXAx3pWPtl4KqVXdsDDFD 6RgMB -ekLwEfmUgQsMsCwBvzkO6H2sJyVJnJ1lpwcsXvJj5skReQdBulviH1NLUIx6KnpIquID2WoY7BoAajF5I evPqde68gP9jb7B -FEawPc OpvimjyZAes9sdECf3B2JF fIChuOk8iDpcneQ1bwseUKjXr7pON6pOc9UaU87Iu -NHD2joerAZTwSMPBAPMRRXNzNLaSIbIrwbzMBNHJrevadSa nY2CfcuuQw5 C0cTEl1ahv6B94v61xTdPXlwMGVYY -7I8Mg2wvMqGLUAbpJtwN2HSFlutq4L2hIF1K08MyKpvI20e0IegHjIHyTuZ1uzZFtQ86Euh1uyI -r6rBVKxfnFihxTPfBBMLo9UXER 4tHUGvLZLPATCdaV4rfT6RmUowQ09KGFxiRdUC -EOEroqWa4gLkFgDHDYEUdYAA2OYGrMPqzilN7OLJqaWmFudOHTRFB6MSSpOCeGLNbGAkT7adB4J9ucX035wU3YTSPAehBbzIe5Aq -vmHRBFC6l FLY2MdW2qGIGjAgQwZMND42REPfVmFmn7HrDo Eoxwjaxzutvua xfqbd1w70 -G43CnoGLCkxmHCiJ1CBHtFA3ytIX5aXiaZkFL47OcLC3u46Lv0TnQdjnGtew5I9YCSq7Y4342RtnQae6dsSfrwaqa2WtYASIDDuW -3PCri8Hd07miGhuRrwrwZCi7NN1q6cGvsCjgQCDzbwlnXd3lrB1ilFX2pAw24 20rp6tW78 7Csmtkjhu2oPIwSO2A -r7m47cYIDK -hpJ7OVfU98IYdwXAy230328Hwyn5bLldYAdvWDnkthFsWxi7wXROx08xhSDRn4i232OY0Jpl2PkSbX5mK3aEjbamS8tpp8gKnF -JjR2XpPFzk7BmeHedc5KSFQl1AFH 3DzxlnyQd5ebjS3Bqd8qHc2LbSTcnqDkVrRvRBLmkhtWCTbpHm05COf 52nO1gcPe -8THe9oE8LrkF0uZKgXLsSkCIq82PFhsv7WaR1CcwXIKToOe8OeFWjUORkmYw4EfKEwVoK6786bf9H3Zv5EMCpWthC8c2mREEdIdj -AQ2ZE7YmIhqJvtby7q vkf2t7hWc6K8Bz9TG8U0XZxRfq0m Ci9joyI3Wfen -dZinbVG6q5PHjKv8ImrXM5D6u3fXCacFyYG8KJoe01bfyD1vw9foYMPCEL1aGo6Uph6bQRNvVsImOd2r5Zvg8staHtt7IsAwiKou -KNuIH7UyLjCH -ABkyySlH5b2e8lZxpQKkHqIChY5xe3uzK1cVwwjrk38LLmKpXlv5GqcHZLEmM31ZaJ9nJ1dAOoqVGw2xjNuqgDi62NgLdyN8bnqD -CSH5kvYfOkxVgN9H196mcpJF2E1IVzjqJeTeJfuBKrE -iUaFSINIPMmYTqMWEtJBestMGF9RQKEtQCPCbIiqwl3kA8EXMkgU9dQSZvJR0DymlBBQ6MUfVqFbblexcUaZIRclnogDPfawyphL -2HXcmB7py2qyWWqbiUBFQCkg3Ic41tpFy7I58BZ46XVhw07jio W7v8PoqvgG1wOV7f8fuiuXvPlQoC2lY07wm0 nQgRok -w3JrHmwWyKmRLhJrrk9jjHhoiTGuLE3j4tsciZlwfhQprtYIkKVez2pr4YlNNYcRvLq0kWQDFo3BohylWpPaO5 -i7lLo7pmeACCHzh4jXoNuBBSOCTRKRi1KEdeWqPH1BUHlhzHKzrXJFL1gmcspqNO2h6dmEwHSlKIowLeaZUyCXMZC4iz8BckLNE0 -feeyDvyILnsWK8ysQZ7WrV1BlJpVxkeULrT5TaKUC8BcNnPWQZeIGC9eOROCmoBmRhnyoXBSWEkOIBgl0MqJ5uub6kdxMGSh76D1 -3NQkbCAHJeCDltw5P8ivcicJZIKiqZ PzAZQItATtQWTyX5zJkFjYG1iQb0N4ssd -O7oMoWi3eKwNRJFMt0ipSs3eaI5W06ncBWdiFWIb4sg6onYSSrwlGkhe8W6fSBHWf PowV2RJb1hlYV88oaCdvFv21SPC8nJQ -U1iITVNuOAw6zhEZOc8z MpFsl4q9kulMJ8cjvW7EI1FfikBXDThfFxPHWu -G1DV05xMQIxLgG5NFmJnSXBmKi2pkZNii303wKIqmL4Qz0xi9MznIBbKob56ZSH01lB9zgll7C9W8gwlDxpfduiQ4pkANDmDSgns -pn4yak7rgCezcCP46lIRVFcZr6HM9JwP3ejcLoLLdAm0GM0ovbrwFIBnZRbzXNjWqfdTYiTCqyYxr4TzXFGgxv3 -VzPVnagOAzhzpbJSAf8arLn7ZCL9Nt7EXYX8OL3S2ocutTJ3snzyVbaxoAX9cefUMaM6JWcR2s8pB6pVFTjGl7p6aN11DiBXmXb4 -V VcleLQyNYWYQv3z8grpAWYsSlMFGu3KRa7dWaiiH2t -q3jSX6ZY7929tTGA0YP8lDhro5X83MKFjL4201yatzDb4HaTjuQLRpXVAZy5lqHQyMJmdQqn1 Si2 D NYRhpHl5VKr -6JMzwA00ZRVy1Z2hI1WxV7wSyIXR -MNm2hwXasuvK2pjoihAkXzoUtuYDhqBFFqWsYRW3njSteQPb9srNSBNE4UM9tR8Fp3lmLB6jJpFu3OQnVCiLEUHkUBBWeUNna0S8 -S5ETB5w8Z8pxy55mrppkTE4x85VRzhErGFeRAUBfuJtManvRtMpTBpsjuro27yLjyGWwUTnhUh7Ga2MIu4aTIHpgU7mk Rc qAv -22xdHaKlod6f4Gbpk8SRo1WlkqYDWw0kLXCXeNCZ3Azu8M0nRtOQLx9zGyHizMClckRWFFZqFYKOPrGdMuTCUdHELsSMWEgl6Daj -sDWuyiHvPzaQrq1NM0Ryy4VUwwgKOi c2Elp6skrC4kLgg7qyIO5HOke 1LRoZc6eIL5DPSc -Jiukkxl5yUueJOUvd3Y3e0bxnQqwPjnYvBta8p7HUGF2Fs8cHMfGBuCsvjqf2pqs4BVcgdZb4xnvVJUvTIlnCckgHs8yXlWtMtgv -nNJ34AkMxBSzWanNsWWHtE7Pnn5Ea3D80CIVB9Ld85aSNWrfWLp0Pe5mOw7VQ5YBak4TPHjmQDX1KyEbdYvCkVBdymSxDP8NUBa8 -WnCCYghXUFDHEccoqmPlFwRREV7KwuXqI0UnaLQYDE7U9H5qcRIi1hX2vjs02KYYDykGBYYfXrtSXg2JBCtXkeogKaOQPTpVUv2c -zs CbrnVrA7i5oiDDAsglO0Ta sa5f6mXYUgIN64m3zpmqsLQbCRKLkKYfQ8sbH7Sdcd3oDnp70dbSg0JtuAD64hucNRE h -JRrn4fzfDz35Ho8yuRDN4Fn0JZKbJBamM7Ugn9nSldmMwIqsWIIQG5JAomGveR7XZFal2XIotpPujUmQ1G8D4aFtwUn3j6n6olgW -hiaOzdzuBXFPGPZOhjshexl5jGUxTRIZl1jCWCMW1fyKtEDReYhhfjEdeV8Os9OwgZP73TmuyG8Pw1XbMWkxt25I9JWF0DLYaUwx -8hOKeNzko QDzJL97X O5wI5k0OSrUDjxA97lYNGCTyGww0neGp RW1DUaJTfaWsMXsR1SzkQ4NqNgraLRgZJYm -NSEeFJ8CpEsK5MHx2rHGSGQamJl5bhOEpTa5gghVl0Vi3q -l77M6H27VVICru1xXUgoQ8iahSjrJTWdofNKswdORFLTn5QGGrHX0XnN2ubp9E38B6wsswuzLOlPswu93RGDw pTFk65uWoc -4XANAZojJHgREiWaG5T4GvW4y0vhUrrmjjFEQGPfwBMeDXNFji5v -KLATcQroa5yJ4XTZtqTAfy316iCSJ1Ea8KestkkNfpBpuwbD1b0JN7gQkqRz0FAcWg5XqeRGXfPA6psmiSs8uuVlF6 -a4xF24lzDQTr7DWloSLJWhCuwNkK9acMYh06NUXVwnA0MVqkqyjNnShsWl8H4oQv5Nsf3Kbcg7R7AYwqbIyyvoi1L0OMG2icFaTU -veRNQRxoXZ0TwV0BDeNUWpOTgf9BBSXrpU9gHePT88AzPlGDTAawY6kCoekbUMntEaXY0vAVVHp R362Ou LOObMUiodtscmyL5 -cdTV6u6EWPl01fTH0FUZ2H0V4W8z44F4Gh2ydhSgI5uRlGZWCpidd2ZQPPSU44nGR59YGAbBGs3g8yFVmh3S2ZDiAoHPRdGUUVbD -O6yXceTzh0ax9buiGdvRVS6KsykYClnlACuhL3B3cZXletNklhYjd4iM10VIfUqmsd1O1eFmRa0awYKiLYWyXq6jKYA61uQlyj1D -i4k0S00cPzV8xAzE1ytC4 E4oQkbgweEF1R lPKNmluEfUFGioa6Rah2KecZ7d1Lh6uQdNNgD0s eUS5ySCPMxouDK8 -0HgjteGUDEcipVohCCBKBOiZUciFI6DvSAiuPJ7sfXEN8wOnmf1REzGhvvctZOgXVTBLlwrNFxR5iCGxGJ6vj8aCaGdAiHusVcHV -62LhpLay021xMEDPxkFKIcucN3tMmAeY75U3aPMPWhE42jEGZb9xsl2WuqH1MHpybhKP207Xva8KpgDmh36bFjN2AKSvtRYEBT9l -LWkQ1I2k3mRg5AUHmufZuRLFl8mK9PlfswEE9kK5KpOWQdULt0PbAuxG35WTQpGuIwMiMiGQhRqJdoYpyqsp5IChwrTHpdoR8vuZ -GruCxRwK5X8s2E0mwJ6NpC5DOEcNKbU2NU3a4fAsfMfCr2ENRbe6SwrihPx2n3GojnoQjoSA5t9nVk6ZT -tyCDw51m6ycbu37bPuiuoz76Zh -pgRi400F8WY82Qj8ze2OyWRrtAmgdSPhaTTfrsMne6Ug5S0CI72XWpcrTLq3IMe1RaaPujHLRbt6TeUSjcvDLizBMAHLXl5K5GS5 -B2NzwHeRY32toI78mq -aQQgMWn70ZyPCXIoMBRB72AwaVkatE5BhYxNuhX9hZBu8oCQuVoLF4IOeTkGHK2gckjFZBkOiRDsKg3B7YYN3NtT2Xfr -0Ty0o3QOim0BeJsaaR8rhFISxPf1iX8IfroC2dj8Yc QT06CFy5oeLhFTdjQoYrHUWpgupG9G4pXHLpG5tk03TFDBa6ExHnvRx -uggfzWdjjrC4hple6IJmJfAZmtXXHXzLJE9VDxquA -Xv1ABk8D8GBAXFc78pUQbC9TVoyQAHI0R3GUSkoJyoql8lRc2fI9BmAYl61BGAxG7r5jre14oQNxqN5JHj6guic9EqsYVoUNbQZX -ogqLoERowSmByIgpTZSQOaIrNwy3PtWpcSOR7QgNZCAFcv7h4bm4vcRJOknBhMouP6jAHyrRnxAK7jSnUOG9cMZecHhQgbzGSMJw -Oj -iJu1iZRbPgiO4LldaJwpEHGKk3DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr -mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw -J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF -NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u - F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP -tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 -VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO -5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ -JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 -g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R -m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H -xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH -IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI -iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH -BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz -yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l -3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg -ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 -7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH -Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY -aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC -WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy -LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP -tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL -tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 -lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf -D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q -Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA -W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp -bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ -pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 -gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr -LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r -WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 -oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh -FNP0Y6IqX49F35bfD7kjoSWsjkyk -Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni -OeinspAF -MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC -ONwZExY64x17zX6bYpevYFprSMqe2nc6 -YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f -kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp -4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A -wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw -9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 -Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 -NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne -MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 -tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac -LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k -1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G -faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW -Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC -uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m -TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd -NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh -sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev -G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 -a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx -50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid -YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU -5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM -0RlsNFegAijnXAGnyIJzrA0nQbatU9 -ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 -s0YehjVFmDt2rClB -9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST -bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR -D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv -r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj -U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon -HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF -MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp -6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy -32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg -nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd -uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN -fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 -J8 -xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ -Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV -uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 -lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ -pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 -24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq -GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ -fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI -HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc -lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M -yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m -gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH -L5TiMCvyJYVmFNjZr9MtsvqdJ3u -a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS -Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh -MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 -mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv -TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn -6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv -YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o -Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd -oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed -tkDZE9F6vRoLXUuQAK0EZCDLKH -qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC -2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE -uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp -o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16385.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16385.expected deleted file mode 100644 index a30c8ea3471..00000000000 --- a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16385.expected +++ /dev/null @@ -1,105 +0,0 @@ -ESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr -mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw -J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF -NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u - F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP -tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 -VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO -5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ -JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 -g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R -m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H -xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH -IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI -iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH -BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz -yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l -3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg -ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 -7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH -Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY -aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC -WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy -LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP -tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL -tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 -lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf -D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q -Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA -W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp -bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ -pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 -gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr -LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r -WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 -oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh -FNP0Y6IqX49F35bfD7kjoSWsjkyk -Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni -OeinspAF -MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC -ONwZExY64x17zX6bYpevYFprSMqe2nc6 -YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f -kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp -4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A -wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw -9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 -Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 -NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne -MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 -tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac -LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k -1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G -faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW -Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC -uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m -TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd -NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh -sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev -G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 -a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx -50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid -YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU -5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM -0RlsNFegAijnXAGnyIJzrA0nQbatU9 -ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 -s0YehjVFmDt2rClB -9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST -bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR -D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv -r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj -U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon -HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF -MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp -6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy -32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg -nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd -uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN -fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 -J8 -xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ -Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV -uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 -lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ -pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 -24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq -GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ -fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI -HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc -lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M -yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m -gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH -L5TiMCvyJYVmFNjZr9MtsvqdJ3u -a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS -Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh -MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 -mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv -TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn -6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv -YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o -Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd -oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed -tkDZE9F6vRoLXUuQAK0EZCDLKH -qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC -2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE -uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp -o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16386.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16386.expected deleted file mode 100644 index e4d11d8b6bf..00000000000 --- a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16386.expected +++ /dev/null @@ -1,105 +0,0 @@ -SvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr -mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw -J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF -NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u - F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP -tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 -VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO -5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ -JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 -g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R -m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H -xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH -IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI -iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH -BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz -yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l -3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg -ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 -7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH -Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY -aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC -WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy -LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP -tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL -tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 -lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf -D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q -Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA -W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp -bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ -pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 -gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr -LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r -WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 -oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh -FNP0Y6IqX49F35bfD7kjoSWsjkyk -Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni -OeinspAF -MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC -ONwZExY64x17zX6bYpevYFprSMqe2nc6 -YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f -kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp -4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A -wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw -9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 -Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 -NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne -MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 -tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac -LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k -1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G -faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW -Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC -uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m -TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd -NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh -sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev -G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 -a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx -50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid -YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU -5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM -0RlsNFegAijnXAGnyIJzrA0nQbatU9 -ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 -s0YehjVFmDt2rClB -9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST -bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR -D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv -r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj -U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon -HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF -MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp -6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy -32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg -nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd -uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN -fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 -J8 -xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ -Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV -uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 -lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ -pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 -24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq -GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ -fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI -HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc -lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M -yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m -gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH -L5TiMCvyJYVmFNjZr9MtsvqdJ3u -a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS -Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh -MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 -mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv -TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn -6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv -YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o -Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd -oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed -tkDZE9F6vRoLXUuQAK0EZCDLKH -qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC -2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE -uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp -o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8193.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8193.expected deleted file mode 100644 index 88d4bdf6c0e..00000000000 --- a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8193.expected +++ /dev/null @@ -1,205 +0,0 @@ -IYEb4HhrrfixUC8j -J2 PNukXTyPowk2P490ZRC hjIqTv3QZxI7 wrsa0rJ8ixaNmZ3Za evP5y6eRvwSwJng787yQzpVi3wCDBw XrEPBJ0 -t2BMpq3evy3ELNduHoifzv6jkN0gJy9o -99sUZ34ro19oJd3UTlLLvi8h8vwToC3ijOEXhY8abO4dCMZUhwj8QlYdDC0JmtAXLO9CEZ0dWZXAMvXgDaorn7CDVBks2Qa7aMkN -1JClm9DlcPR65EKgtPeh -wdteBwA8oEHKRttRIEGI8IstPh2s75Sc9mg0LFG4tn256bBycdcJu4yj6bjBYN13U2dsKkrsJuonekqCOaTTtKudcIwAqRFnZYSa -eXQuRchTkAoQQdZMOejbLczo975o4h0rnt0UvAgU53n -8BYujbW5W2X50yUfshDCtEra20Nx9rJnMAtCkw8QgfECDM988y4A5FGw1sOSyaNch4 -Y47fv7VGVhfl9NG9ByImguZRrYZ3En0DYy2P0G1ufy7xplzshenzxNEjwTe3UR9G83VUs6obeSVCYBAo7pBmaQxH 9f5f9Mv -4oC5X0WDLvadtlM0NNmyDKYfzgw3JTGXDzPGVl7WkL5hsec6MbwS6l0Q7ruX0WtU1WVD8vyCBmVcr2q9DtmgHqclSbMoHXokGFkY -knfOZFLg9DrRkWp3VZfVLYKgsi6pCv 9J7JUWTWxRXLpSszJpKvQbbLa1BYpw0hI3LwgEbX -6ttL77Ak2kox3W9QqdzwQLmTh45n1rwe2daWBRpzwOq33LEBG1nwOlPY5tve0iH5z4T2Vs7cBj6BrOFc8OgS1RXygUURmkmZvYC9 -7XuL HJk8TMOkeCLMZzoJZ9EZVAJXQO9lHftsvw05CwmcscDV7QuRmuwQBD6f4qAnr35io -xNyNC60pDHAKQOV4sIbyoUra8u78PMofY52BjsfFySGZenDGkc4joegzKdogbeQeEjRRD3pPX1CjGu -NtxYCePWXkwgYoxasuDn0ULgaJ9rTD BjglBpG3kpRBB84GwJzfjh8dEmRmKMxsPA8K KpGfjhm -EEVeLcH2t16Se4FZkLSFzADooDijqm60lvxSOpe2LGGhXa94dQmMTESl6FPVqchzKKQuMg77ulrF7GSUosvw4Ry5oLJEQGPqHuxs -jCcE238RM7JOGHwDomNGHoyY0LIYO2dqIcxNOMqvVcFLqCwxnWnX6N zWqHH4ACm1EbtXCACZAOtGsPsM4DdXw -DyqJiYYqBZZAZ0jyvwF2Rzm7DDpWtphJFvKaCvi1n4lf3lBQe FRzakzcOm1sP3q5BMwWDQjcKIhKCsTR4KsqAQWM2cef1 -CTOu64tjU65CzlCmns0QSG8PpqeXLZGo32GbMz1dsSU3byFdXvUfLInNPWTQIGj9tmeGnDzeBihPKIwOQzeB -4oyVwRjiyn0pyMWZ0ChczKOLO57DxwNd4v38dZ 1nIVIVSxlVl0GH4v4tt9judjPKvsMxrAxJq7cDbK bVlc9EcVvTR -ikVAsOiY5ZQT7Y88wh4clEB7lV 8kTSte3RXOTA -1bVCT7yBXD3Es6yezJWm7hdz6vZPaIIOX2l0fTUXB8RfxTq3Kaj6lmQJnuItDJncz6AaYbjXe95W3Vmp0PS3ATEzdG9mEZwSymjd -egkKfFTdY4kx6EnInnegVUFBDalZa5z9ubx3eu6nHD7zfYkjFWUMaLSgwVKjJpsYcw3DtHlfhLWo1nwC9hTX89vCEShI4bcsnlJ7 -3jyOhJSBOym5T55E8F154bYhF4dnwt6q2DRPnenggO1d04bJbVhRbfTgbhGPen3mO5VaU2Z63Rs7q9kp8CsJwPtO5Bp0LC0sTh4Q - -0fJLwkEdB9cY9rVMHpMpRq30e3X1YdchhB8mOkKBXCCaS9WhoBXZYV4zS0R1LOCC5OqHu8TxDJ6p3rOoGxM2s1KzJMZlweexZzSa -ovcwhSG UZ2TTYIan8vFvreBtkSyxmlnQsUyfZnajIPFZeNE -IGu8JRG1yuZuCq0xNPJ19G1ysunyc3X57fORpykArVk2TVQhsBlvsqsloPMMd9FKOSTc0jZsnJf2nLujBuHP5vwqrytGCZMh3mI1 -rZz f5h5RW4JYTtZbd8yeqAF6Hxmze5KaG0jLI7XWIA2ZbVzKLJRydDZu7tiRyNSNjXdw5MuFDgSudZcav3WHJyO OXQ -S4KSuD4dKkPL2hDwuHVwVf6L7hNvyLC5EuqZN1JIgbYiozbhmhU6CKqDLoOdsxFZsr5Uy5F4j3GruUTukaxxIXV9THGDm3E35XGy -OYLvjv2YQWsT5eiWnm5AFuGUBI8pdDSVdnvLPW1Gm9Blb3lQU6xwJsUIWw11NWLmCSf2Aj9olkGXtxWXhji1ypQhQd2GKZUodWyH -gLRGD6QucBcQI5VI8fjoQGWPAgtoWhgsKDGbG6ZH2x9YoFWgWJc OsB1rt7pUWu3vyBueDujMduUejf7RdLO -KqnRyHahI19I5jLVHLKGyNWrbvb9sxEhKPyZEKop -uRCHEXbWRYGZhPks3Q3Wcjvaea8oeuguFZqZVkd0fVpgX8WDleCk8ZqWU1eQbVWjgzaxTNJB23qqMYl6YJFczQb4TkE3GGgDYS3J -cSP1D3qqirQASr42pWt2PBOF7OaRzjD6HUn8MtGF1wyPPWrORXAx3pWPtl4KqVXdsDDFD 6RgMB -ekLwEfmUgQsMsCwBvzkO6H2sJyVJnJ1lpwcsXvJj5skReQdBulviH1NLUIx6KnpIquID2WoY7BoAajF5I evPqde68gP9jb7B -FEawPc OpvimjyZAes9sdECf3B2JF fIChuOk8iDpcneQ1bwseUKjXr7pON6pOc9UaU87Iu -NHD2joerAZTwSMPBAPMRRXNzNLaSIbIrwbzMBNHJrevadSa nY2CfcuuQw5 C0cTEl1ahv6B94v61xTdPXlwMGVYY -7I8Mg2wvMqGLUAbpJtwN2HSFlutq4L2hIF1K08MyKpvI20e0IegHjIHyTuZ1uzZFtQ86Euh1uyI -r6rBVKxfnFihxTPfBBMLo9UXER 4tHUGvLZLPATCdaV4rfT6RmUowQ09KGFxiRdUC -EOEroqWa4gLkFgDHDYEUdYAA2OYGrMPqzilN7OLJqaWmFudOHTRFB6MSSpOCeGLNbGAkT7adB4J9ucX035wU3YTSPAehBbzIe5Aq -vmHRBFC6l FLY2MdW2qGIGjAgQwZMND42REPfVmFmn7HrDo Eoxwjaxzutvua xfqbd1w70 -G43CnoGLCkxmHCiJ1CBHtFA3ytIX5aXiaZkFL47OcLC3u46Lv0TnQdjnGtew5I9YCSq7Y4342RtnQae6dsSfrwaqa2WtYASIDDuW -3PCri8Hd07miGhuRrwrwZCi7NN1q6cGvsCjgQCDzbwlnXd3lrB1ilFX2pAw24 20rp6tW78 7Csmtkjhu2oPIwSO2A -r7m47cYIDK -hpJ7OVfU98IYdwXAy230328Hwyn5bLldYAdvWDnkthFsWxi7wXROx08xhSDRn4i232OY0Jpl2PkSbX5mK3aEjbamS8tpp8gKnF -JjR2XpPFzk7BmeHedc5KSFQl1AFH 3DzxlnyQd5ebjS3Bqd8qHc2LbSTcnqDkVrRvRBLmkhtWCTbpHm05COf 52nO1gcPe -8THe9oE8LrkF0uZKgXLsSkCIq82PFhsv7WaR1CcwXIKToOe8OeFWjUORkmYw4EfKEwVoK6786bf9H3Zv5EMCpWthC8c2mREEdIdj -AQ2ZE7YmIhqJvtby7q vkf2t7hWc6K8Bz9TG8U0XZxRfq0m Ci9joyI3Wfen -dZinbVG6q5PHjKv8ImrXM5D6u3fXCacFyYG8KJoe01bfyD1vw9foYMPCEL1aGo6Uph6bQRNvVsImOd2r5Zvg8staHtt7IsAwiKou -KNuIH7UyLjCH -ABkyySlH5b2e8lZxpQKkHqIChY5xe3uzK1cVwwjrk38LLmKpXlv5GqcHZLEmM31ZaJ9nJ1dAOoqVGw2xjNuqgDi62NgLdyN8bnqD -CSH5kvYfOkxVgN9H196mcpJF2E1IVzjqJeTeJfuBKrE -iUaFSINIPMmYTqMWEtJBestMGF9RQKEtQCPCbIiqwl3kA8EXMkgU9dQSZvJR0DymlBBQ6MUfVqFbblexcUaZIRclnogDPfawyphL -2HXcmB7py2qyWWqbiUBFQCkg3Ic41tpFy7I58BZ46XVhw07jio W7v8PoqvgG1wOV7f8fuiuXvPlQoC2lY07wm0 nQgRok -w3JrHmwWyKmRLhJrrk9jjHhoiTGuLE3j4tsciZlwfhQprtYIkKVez2pr4YlNNYcRvLq0kWQDFo3BohylWpPaO5 -i7lLo7pmeACCHzh4jXoNuBBSOCTRKRi1KEdeWqPH1BUHlhzHKzrXJFL1gmcspqNO2h6dmEwHSlKIowLeaZUyCXMZC4iz8BckLNE0 -feeyDvyILnsWK8ysQZ7WrV1BlJpVxkeULrT5TaKUC8BcNnPWQZeIGC9eOROCmoBmRhnyoXBSWEkOIBgl0MqJ5uub6kdxMGSh76D1 -3NQkbCAHJeCDltw5P8ivcicJZIKiqZ PzAZQItATtQWTyX5zJkFjYG1iQb0N4ssd -O7oMoWi3eKwNRJFMt0ipSs3eaI5W06ncBWdiFWIb4sg6onYSSrwlGkhe8W6fSBHWf PowV2RJb1hlYV88oaCdvFv21SPC8nJQ -U1iITVNuOAw6zhEZOc8z MpFsl4q9kulMJ8cjvW7EI1FfikBXDThfFxPHWu -G1DV05xMQIxLgG5NFmJnSXBmKi2pkZNii303wKIqmL4Qz0xi9MznIBbKob56ZSH01lB9zgll7C9W8gwlDxpfduiQ4pkANDmDSgns -pn4yak7rgCezcCP46lIRVFcZr6HM9JwP3ejcLoLLdAm0GM0ovbrwFIBnZRbzXNjWqfdTYiTCqyYxr4TzXFGgxv3 -VzPVnagOAzhzpbJSAf8arLn7ZCL9Nt7EXYX8OL3S2ocutTJ3snzyVbaxoAX9cefUMaM6JWcR2s8pB6pVFTjGl7p6aN11DiBXmXb4 -V VcleLQyNYWYQv3z8grpAWYsSlMFGu3KRa7dWaiiH2t -q3jSX6ZY7929tTGA0YP8lDhro5X83MKFjL4201yatzDb4HaTjuQLRpXVAZy5lqHQyMJmdQqn1 Si2 D NYRhpHl5VKr -6JMzwA00ZRVy1Z2hI1WxV7wSyIXR -MNm2hwXasuvK2pjoihAkXzoUtuYDhqBFFqWsYRW3njSteQPb9srNSBNE4UM9tR8Fp3lmLB6jJpFu3OQnVCiLEUHkUBBWeUNna0S8 -S5ETB5w8Z8pxy55mrppkTE4x85VRzhErGFeRAUBfuJtManvRtMpTBpsjuro27yLjyGWwUTnhUh7Ga2MIu4aTIHpgU7mk Rc qAv -22xdHaKlod6f4Gbpk8SRo1WlkqYDWw0kLXCXeNCZ3Azu8M0nRtOQLx9zGyHizMClckRWFFZqFYKOPrGdMuTCUdHELsSMWEgl6Daj -sDWuyiHvPzaQrq1NM0Ryy4VUwwgKOi c2Elp6skrC4kLgg7qyIO5HOke 1LRoZc6eIL5DPSc -Jiukkxl5yUueJOUvd3Y3e0bxnQqwPjnYvBta8p7HUGF2Fs8cHMfGBuCsvjqf2pqs4BVcgdZb4xnvVJUvTIlnCckgHs8yXlWtMtgv -nNJ34AkMxBSzWanNsWWHtE7Pnn5Ea3D80CIVB9Ld85aSNWrfWLp0Pe5mOw7VQ5YBak4TPHjmQDX1KyEbdYvCkVBdymSxDP8NUBa8 -WnCCYghXUFDHEccoqmPlFwRREV7KwuXqI0UnaLQYDE7U9H5qcRIi1hX2vjs02KYYDykGBYYfXrtSXg2JBCtXkeogKaOQPTpVUv2c -zs CbrnVrA7i5oiDDAsglO0Ta sa5f6mXYUgIN64m3zpmqsLQbCRKLkKYfQ8sbH7Sdcd3oDnp70dbSg0JtuAD64hucNRE h -JRrn4fzfDz35Ho8yuRDN4Fn0JZKbJBamM7Ugn9nSldmMwIqsWIIQG5JAomGveR7XZFal2XIotpPujUmQ1G8D4aFtwUn3j6n6olgW -hiaOzdzuBXFPGPZOhjshexl5jGUxTRIZl1jCWCMW1fyKtEDReYhhfjEdeV8Os9OwgZP73TmuyG8Pw1XbMWkxt25I9JWF0DLYaUwx -8hOKeNzko QDzJL97X O5wI5k0OSrUDjxA97lYNGCTyGww0neGp RW1DUaJTfaWsMXsR1SzkQ4NqNgraLRgZJYm -NSEeFJ8CpEsK5MHx2rHGSGQamJl5bhOEpTa5gghVl0Vi3q -l77M6H27VVICru1xXUgoQ8iahSjrJTWdofNKswdORFLTn5QGGrHX0XnN2ubp9E38B6wsswuzLOlPswu93RGDw pTFk65uWoc -4XANAZojJHgREiWaG5T4GvW4y0vhUrrmjjFEQGPfwBMeDXNFji5v -KLATcQroa5yJ4XTZtqTAfy316iCSJ1Ea8KestkkNfpBpuwbD1b0JN7gQkqRz0FAcWg5XqeRGXfPA6psmiSs8uuVlF6 -a4xF24lzDQTr7DWloSLJWhCuwNkK9acMYh06NUXVwnA0MVqkqyjNnShsWl8H4oQv5Nsf3Kbcg7R7AYwqbIyyvoi1L0OMG2icFaTU -veRNQRxoXZ0TwV0BDeNUWpOTgf9BBSXrpU9gHePT88AzPlGDTAawY6kCoekbUMntEaXY0vAVVHp R362Ou LOObMUiodtscmyL5 -cdTV6u6EWPl01fTH0FUZ2H0V4W8z44F4Gh2ydhSgI5uRlGZWCpidd2ZQPPSU44nGR59YGAbBGs3g8yFVmh3S2ZDiAoHPRdGUUVbD -O6yXceTzh0ax9buiGdvRVS6KsykYClnlACuhL3B3cZXletNklhYjd4iM10VIfUqmsd1O1eFmRa0awYKiLYWyXq6jKYA61uQlyj1D -i4k0S00cPzV8xAzE1ytC4 E4oQkbgweEF1R lPKNmluEfUFGioa6Rah2KecZ7d1Lh6uQdNNgD0s eUS5ySCPMxouDK8 -0HgjteGUDEcipVohCCBKBOiZUciFI6DvSAiuPJ7sfXEN8wOnmf1REzGhvvctZOgXVTBLlwrNFxR5iCGxGJ6vj8aCaGdAiHusVcHV -62LhpLay021xMEDPxkFKIcucN3tMmAeY75U3aPMPWhE42jEGZb9xsl2WuqH1MHpybhKP207Xva8KpgDmh36bFjN2AKSvtRYEBT9l -LWkQ1I2k3mRg5AUHmufZuRLFl8mK9PlfswEE9kK5KpOWQdULt0PbAuxG35WTQpGuIwMiMiGQhRqJdoYpyqsp5IChwrTHpdoR8vuZ -GruCxRwK5X8s2E0mwJ6NpC5DOEcNKbU2NU3a4fAsfMfCr2ENRbe6SwrihPx2n3GojnoQjoSA5t9nVk6ZT -tyCDw51m6ycbu37bPuiuoz76Zh -pgRi400F8WY82Qj8ze2OyWRrtAmgdSPhaTTfrsMne6Ug5S0CI72XWpcrTLq3IMe1RaaPujHLRbt6TeUSjcvDLizBMAHLXl5K5GS5 -B2NzwHeRY32toI78mq -aQQgMWn70ZyPCXIoMBRB72AwaVkatE5BhYxNuhX9hZBu8oCQuVoLF4IOeTkGHK2gckjFZBkOiRDsKg3B7YYN3NtT2Xfr -0Ty0o3QOim0BeJsaaR8rhFISxPf1iX8IfroC2dj8Yc QT06CFy5oeLhFTdjQoYrHUWpgupG9G4pXHLpG5tk03TFDBa6ExHnvRx -uggfzWdjjrC4hple6IJmJfAZmtXXHXzLJE9VDxquA -Xv1ABk8D8GBAXFc78pUQbC9TVoyQAHI0R3GUSkoJyoql8lRc2fI9BmAYl61BGAxG7r5jre14oQNxqN5JHj6guic9EqsYVoUNbQZX -ogqLoERowSmByIgpTZSQOaIrNwy3PtWpcSOR7QgNZCAFcv7h4bm4vcRJOknBhMouP6jAHyrRnxAK7jSnUOG9cMZecHhQgbzGSMJw -Oj -iJu1iZRbPgiO4LldaJwpEHGKk3DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr -mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw -J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF -NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u - F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP -tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 -VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO -5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ -JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 -g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R -m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H -xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH -IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI -iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH -BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz -yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l -3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg -ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 -7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH -Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY -aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC -WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy -LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP -tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL -tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 -lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf -D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q -Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA -W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp -bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ -pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 -gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr -LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r -WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 -oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh -FNP0Y6IqX49F35bfD7kjoSWsjkyk -Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni -OeinspAF -MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC -ONwZExY64x17zX6bYpevYFprSMqe2nc6 -YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f -kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp -4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A -wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw -9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 -Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 -NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne -MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 -tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac -LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k -1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G -faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW -Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC -uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m -TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd -NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh -sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev -G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 -a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx -50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid -YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU -5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM -0RlsNFegAijnXAGnyIJzrA0nQbatU9 -ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 -s0YehjVFmDt2rClB -9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST -bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR -D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv -r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj -U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon -HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF -MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp -6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy -32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg -nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd -uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN -fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 -J8 -xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ -Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV -uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 -lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ -pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 -24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq -GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ -fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI -HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc -lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M -yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m -gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH -L5TiMCvyJYVmFNjZr9MtsvqdJ3u -a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS -Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh -MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 -mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv -TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn -6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv -YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o -Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd -oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed -tkDZE9F6vRoLXUuQAK0EZCDLKH -qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC -2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE -uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp -o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8194.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8194.expected deleted file mode 100644 index c6fe21e9470..00000000000 --- a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8194.expected +++ /dev/null @@ -1,205 +0,0 @@ -YEb4HhrrfixUC8j -J2 PNukXTyPowk2P490ZRC hjIqTv3QZxI7 wrsa0rJ8ixaNmZ3Za evP5y6eRvwSwJng787yQzpVi3wCDBw XrEPBJ0 -t2BMpq3evy3ELNduHoifzv6jkN0gJy9o -99sUZ34ro19oJd3UTlLLvi8h8vwToC3ijOEXhY8abO4dCMZUhwj8QlYdDC0JmtAXLO9CEZ0dWZXAMvXgDaorn7CDVBks2Qa7aMkN -1JClm9DlcPR65EKgtPeh -wdteBwA8oEHKRttRIEGI8IstPh2s75Sc9mg0LFG4tn256bBycdcJu4yj6bjBYN13U2dsKkrsJuonekqCOaTTtKudcIwAqRFnZYSa -eXQuRchTkAoQQdZMOejbLczo975o4h0rnt0UvAgU53n -8BYujbW5W2X50yUfshDCtEra20Nx9rJnMAtCkw8QgfECDM988y4A5FGw1sOSyaNch4 -Y47fv7VGVhfl9NG9ByImguZRrYZ3En0DYy2P0G1ufy7xplzshenzxNEjwTe3UR9G83VUs6obeSVCYBAo7pBmaQxH 9f5f9Mv -4oC5X0WDLvadtlM0NNmyDKYfzgw3JTGXDzPGVl7WkL5hsec6MbwS6l0Q7ruX0WtU1WVD8vyCBmVcr2q9DtmgHqclSbMoHXokGFkY -knfOZFLg9DrRkWp3VZfVLYKgsi6pCv 9J7JUWTWxRXLpSszJpKvQbbLa1BYpw0hI3LwgEbX -6ttL77Ak2kox3W9QqdzwQLmTh45n1rwe2daWBRpzwOq33LEBG1nwOlPY5tve0iH5z4T2Vs7cBj6BrOFc8OgS1RXygUURmkmZvYC9 -7XuL HJk8TMOkeCLMZzoJZ9EZVAJXQO9lHftsvw05CwmcscDV7QuRmuwQBD6f4qAnr35io -xNyNC60pDHAKQOV4sIbyoUra8u78PMofY52BjsfFySGZenDGkc4joegzKdogbeQeEjRRD3pPX1CjGu -NtxYCePWXkwgYoxasuDn0ULgaJ9rTD BjglBpG3kpRBB84GwJzfjh8dEmRmKMxsPA8K KpGfjhm -EEVeLcH2t16Se4FZkLSFzADooDijqm60lvxSOpe2LGGhXa94dQmMTESl6FPVqchzKKQuMg77ulrF7GSUosvw4Ry5oLJEQGPqHuxs -jCcE238RM7JOGHwDomNGHoyY0LIYO2dqIcxNOMqvVcFLqCwxnWnX6N zWqHH4ACm1EbtXCACZAOtGsPsM4DdXw -DyqJiYYqBZZAZ0jyvwF2Rzm7DDpWtphJFvKaCvi1n4lf3lBQe FRzakzcOm1sP3q5BMwWDQjcKIhKCsTR4KsqAQWM2cef1 -CTOu64tjU65CzlCmns0QSG8PpqeXLZGo32GbMz1dsSU3byFdXvUfLInNPWTQIGj9tmeGnDzeBihPKIwOQzeB -4oyVwRjiyn0pyMWZ0ChczKOLO57DxwNd4v38dZ 1nIVIVSxlVl0GH4v4tt9judjPKvsMxrAxJq7cDbK bVlc9EcVvTR -ikVAsOiY5ZQT7Y88wh4clEB7lV 8kTSte3RXOTA -1bVCT7yBXD3Es6yezJWm7hdz6vZPaIIOX2l0fTUXB8RfxTq3Kaj6lmQJnuItDJncz6AaYbjXe95W3Vmp0PS3ATEzdG9mEZwSymjd -egkKfFTdY4kx6EnInnegVUFBDalZa5z9ubx3eu6nHD7zfYkjFWUMaLSgwVKjJpsYcw3DtHlfhLWo1nwC9hTX89vCEShI4bcsnlJ7 -3jyOhJSBOym5T55E8F154bYhF4dnwt6q2DRPnenggO1d04bJbVhRbfTgbhGPen3mO5VaU2Z63Rs7q9kp8CsJwPtO5Bp0LC0sTh4Q - -0fJLwkEdB9cY9rVMHpMpRq30e3X1YdchhB8mOkKBXCCaS9WhoBXZYV4zS0R1LOCC5OqHu8TxDJ6p3rOoGxM2s1KzJMZlweexZzSa -ovcwhSG UZ2TTYIan8vFvreBtkSyxmlnQsUyfZnajIPFZeNE -IGu8JRG1yuZuCq0xNPJ19G1ysunyc3X57fORpykArVk2TVQhsBlvsqsloPMMd9FKOSTc0jZsnJf2nLujBuHP5vwqrytGCZMh3mI1 -rZz f5h5RW4JYTtZbd8yeqAF6Hxmze5KaG0jLI7XWIA2ZbVzKLJRydDZu7tiRyNSNjXdw5MuFDgSudZcav3WHJyO OXQ -S4KSuD4dKkPL2hDwuHVwVf6L7hNvyLC5EuqZN1JIgbYiozbhmhU6CKqDLoOdsxFZsr5Uy5F4j3GruUTukaxxIXV9THGDm3E35XGy -OYLvjv2YQWsT5eiWnm5AFuGUBI8pdDSVdnvLPW1Gm9Blb3lQU6xwJsUIWw11NWLmCSf2Aj9olkGXtxWXhji1ypQhQd2GKZUodWyH -gLRGD6QucBcQI5VI8fjoQGWPAgtoWhgsKDGbG6ZH2x9YoFWgWJc OsB1rt7pUWu3vyBueDujMduUejf7RdLO -KqnRyHahI19I5jLVHLKGyNWrbvb9sxEhKPyZEKop -uRCHEXbWRYGZhPks3Q3Wcjvaea8oeuguFZqZVkd0fVpgX8WDleCk8ZqWU1eQbVWjgzaxTNJB23qqMYl6YJFczQb4TkE3GGgDYS3J -cSP1D3qqirQASr42pWt2PBOF7OaRzjD6HUn8MtGF1wyPPWrORXAx3pWPtl4KqVXdsDDFD 6RgMB -ekLwEfmUgQsMsCwBvzkO6H2sJyVJnJ1lpwcsXvJj5skReQdBulviH1NLUIx6KnpIquID2WoY7BoAajF5I evPqde68gP9jb7B -FEawPc OpvimjyZAes9sdECf3B2JF fIChuOk8iDpcneQ1bwseUKjXr7pON6pOc9UaU87Iu -NHD2joerAZTwSMPBAPMRRXNzNLaSIbIrwbzMBNHJrevadSa nY2CfcuuQw5 C0cTEl1ahv6B94v61xTdPXlwMGVYY -7I8Mg2wvMqGLUAbpJtwN2HSFlutq4L2hIF1K08MyKpvI20e0IegHjIHyTuZ1uzZFtQ86Euh1uyI -r6rBVKxfnFihxTPfBBMLo9UXER 4tHUGvLZLPATCdaV4rfT6RmUowQ09KGFxiRdUC -EOEroqWa4gLkFgDHDYEUdYAA2OYGrMPqzilN7OLJqaWmFudOHTRFB6MSSpOCeGLNbGAkT7adB4J9ucX035wU3YTSPAehBbzIe5Aq -vmHRBFC6l FLY2MdW2qGIGjAgQwZMND42REPfVmFmn7HrDo Eoxwjaxzutvua xfqbd1w70 -G43CnoGLCkxmHCiJ1CBHtFA3ytIX5aXiaZkFL47OcLC3u46Lv0TnQdjnGtew5I9YCSq7Y4342RtnQae6dsSfrwaqa2WtYASIDDuW -3PCri8Hd07miGhuRrwrwZCi7NN1q6cGvsCjgQCDzbwlnXd3lrB1ilFX2pAw24 20rp6tW78 7Csmtkjhu2oPIwSO2A -r7m47cYIDK -hpJ7OVfU98IYdwXAy230328Hwyn5bLldYAdvWDnkthFsWxi7wXROx08xhSDRn4i232OY0Jpl2PkSbX5mK3aEjbamS8tpp8gKnF -JjR2XpPFzk7BmeHedc5KSFQl1AFH 3DzxlnyQd5ebjS3Bqd8qHc2LbSTcnqDkVrRvRBLmkhtWCTbpHm05COf 52nO1gcPe -8THe9oE8LrkF0uZKgXLsSkCIq82PFhsv7WaR1CcwXIKToOe8OeFWjUORkmYw4EfKEwVoK6786bf9H3Zv5EMCpWthC8c2mREEdIdj -AQ2ZE7YmIhqJvtby7q vkf2t7hWc6K8Bz9TG8U0XZxRfq0m Ci9joyI3Wfen -dZinbVG6q5PHjKv8ImrXM5D6u3fXCacFyYG8KJoe01bfyD1vw9foYMPCEL1aGo6Uph6bQRNvVsImOd2r5Zvg8staHtt7IsAwiKou -KNuIH7UyLjCH -ABkyySlH5b2e8lZxpQKkHqIChY5xe3uzK1cVwwjrk38LLmKpXlv5GqcHZLEmM31ZaJ9nJ1dAOoqVGw2xjNuqgDi62NgLdyN8bnqD -CSH5kvYfOkxVgN9H196mcpJF2E1IVzjqJeTeJfuBKrE -iUaFSINIPMmYTqMWEtJBestMGF9RQKEtQCPCbIiqwl3kA8EXMkgU9dQSZvJR0DymlBBQ6MUfVqFbblexcUaZIRclnogDPfawyphL -2HXcmB7py2qyWWqbiUBFQCkg3Ic41tpFy7I58BZ46XVhw07jio W7v8PoqvgG1wOV7f8fuiuXvPlQoC2lY07wm0 nQgRok -w3JrHmwWyKmRLhJrrk9jjHhoiTGuLE3j4tsciZlwfhQprtYIkKVez2pr4YlNNYcRvLq0kWQDFo3BohylWpPaO5 -i7lLo7pmeACCHzh4jXoNuBBSOCTRKRi1KEdeWqPH1BUHlhzHKzrXJFL1gmcspqNO2h6dmEwHSlKIowLeaZUyCXMZC4iz8BckLNE0 -feeyDvyILnsWK8ysQZ7WrV1BlJpVxkeULrT5TaKUC8BcNnPWQZeIGC9eOROCmoBmRhnyoXBSWEkOIBgl0MqJ5uub6kdxMGSh76D1 -3NQkbCAHJeCDltw5P8ivcicJZIKiqZ PzAZQItATtQWTyX5zJkFjYG1iQb0N4ssd -O7oMoWi3eKwNRJFMt0ipSs3eaI5W06ncBWdiFWIb4sg6onYSSrwlGkhe8W6fSBHWf PowV2RJb1hlYV88oaCdvFv21SPC8nJQ -U1iITVNuOAw6zhEZOc8z MpFsl4q9kulMJ8cjvW7EI1FfikBXDThfFxPHWu -G1DV05xMQIxLgG5NFmJnSXBmKi2pkZNii303wKIqmL4Qz0xi9MznIBbKob56ZSH01lB9zgll7C9W8gwlDxpfduiQ4pkANDmDSgns -pn4yak7rgCezcCP46lIRVFcZr6HM9JwP3ejcLoLLdAm0GM0ovbrwFIBnZRbzXNjWqfdTYiTCqyYxr4TzXFGgxv3 -VzPVnagOAzhzpbJSAf8arLn7ZCL9Nt7EXYX8OL3S2ocutTJ3snzyVbaxoAX9cefUMaM6JWcR2s8pB6pVFTjGl7p6aN11DiBXmXb4 -V VcleLQyNYWYQv3z8grpAWYsSlMFGu3KRa7dWaiiH2t -q3jSX6ZY7929tTGA0YP8lDhro5X83MKFjL4201yatzDb4HaTjuQLRpXVAZy5lqHQyMJmdQqn1 Si2 D NYRhpHl5VKr -6JMzwA00ZRVy1Z2hI1WxV7wSyIXR -MNm2hwXasuvK2pjoihAkXzoUtuYDhqBFFqWsYRW3njSteQPb9srNSBNE4UM9tR8Fp3lmLB6jJpFu3OQnVCiLEUHkUBBWeUNna0S8 -S5ETB5w8Z8pxy55mrppkTE4x85VRzhErGFeRAUBfuJtManvRtMpTBpsjuro27yLjyGWwUTnhUh7Ga2MIu4aTIHpgU7mk Rc qAv -22xdHaKlod6f4Gbpk8SRo1WlkqYDWw0kLXCXeNCZ3Azu8M0nRtOQLx9zGyHizMClckRWFFZqFYKOPrGdMuTCUdHELsSMWEgl6Daj -sDWuyiHvPzaQrq1NM0Ryy4VUwwgKOi c2Elp6skrC4kLgg7qyIO5HOke 1LRoZc6eIL5DPSc -Jiukkxl5yUueJOUvd3Y3e0bxnQqwPjnYvBta8p7HUGF2Fs8cHMfGBuCsvjqf2pqs4BVcgdZb4xnvVJUvTIlnCckgHs8yXlWtMtgv -nNJ34AkMxBSzWanNsWWHtE7Pnn5Ea3D80CIVB9Ld85aSNWrfWLp0Pe5mOw7VQ5YBak4TPHjmQDX1KyEbdYvCkVBdymSxDP8NUBa8 -WnCCYghXUFDHEccoqmPlFwRREV7KwuXqI0UnaLQYDE7U9H5qcRIi1hX2vjs02KYYDykGBYYfXrtSXg2JBCtXkeogKaOQPTpVUv2c -zs CbrnVrA7i5oiDDAsglO0Ta sa5f6mXYUgIN64m3zpmqsLQbCRKLkKYfQ8sbH7Sdcd3oDnp70dbSg0JtuAD64hucNRE h -JRrn4fzfDz35Ho8yuRDN4Fn0JZKbJBamM7Ugn9nSldmMwIqsWIIQG5JAomGveR7XZFal2XIotpPujUmQ1G8D4aFtwUn3j6n6olgW -hiaOzdzuBXFPGPZOhjshexl5jGUxTRIZl1jCWCMW1fyKtEDReYhhfjEdeV8Os9OwgZP73TmuyG8Pw1XbMWkxt25I9JWF0DLYaUwx -8hOKeNzko QDzJL97X O5wI5k0OSrUDjxA97lYNGCTyGww0neGp RW1DUaJTfaWsMXsR1SzkQ4NqNgraLRgZJYm -NSEeFJ8CpEsK5MHx2rHGSGQamJl5bhOEpTa5gghVl0Vi3q -l77M6H27VVICru1xXUgoQ8iahSjrJTWdofNKswdORFLTn5QGGrHX0XnN2ubp9E38B6wsswuzLOlPswu93RGDw pTFk65uWoc -4XANAZojJHgREiWaG5T4GvW4y0vhUrrmjjFEQGPfwBMeDXNFji5v -KLATcQroa5yJ4XTZtqTAfy316iCSJ1Ea8KestkkNfpBpuwbD1b0JN7gQkqRz0FAcWg5XqeRGXfPA6psmiSs8uuVlF6 -a4xF24lzDQTr7DWloSLJWhCuwNkK9acMYh06NUXVwnA0MVqkqyjNnShsWl8H4oQv5Nsf3Kbcg7R7AYwqbIyyvoi1L0OMG2icFaTU -veRNQRxoXZ0TwV0BDeNUWpOTgf9BBSXrpU9gHePT88AzPlGDTAawY6kCoekbUMntEaXY0vAVVHp R362Ou LOObMUiodtscmyL5 -cdTV6u6EWPl01fTH0FUZ2H0V4W8z44F4Gh2ydhSgI5uRlGZWCpidd2ZQPPSU44nGR59YGAbBGs3g8yFVmh3S2ZDiAoHPRdGUUVbD -O6yXceTzh0ax9buiGdvRVS6KsykYClnlACuhL3B3cZXletNklhYjd4iM10VIfUqmsd1O1eFmRa0awYKiLYWyXq6jKYA61uQlyj1D -i4k0S00cPzV8xAzE1ytC4 E4oQkbgweEF1R lPKNmluEfUFGioa6Rah2KecZ7d1Lh6uQdNNgD0s eUS5ySCPMxouDK8 -0HgjteGUDEcipVohCCBKBOiZUciFI6DvSAiuPJ7sfXEN8wOnmf1REzGhvvctZOgXVTBLlwrNFxR5iCGxGJ6vj8aCaGdAiHusVcHV -62LhpLay021xMEDPxkFKIcucN3tMmAeY75U3aPMPWhE42jEGZb9xsl2WuqH1MHpybhKP207Xva8KpgDmh36bFjN2AKSvtRYEBT9l -LWkQ1I2k3mRg5AUHmufZuRLFl8mK9PlfswEE9kK5KpOWQdULt0PbAuxG35WTQpGuIwMiMiGQhRqJdoYpyqsp5IChwrTHpdoR8vuZ -GruCxRwK5X8s2E0mwJ6NpC5DOEcNKbU2NU3a4fAsfMfCr2ENRbe6SwrihPx2n3GojnoQjoSA5t9nVk6ZT -tyCDw51m6ycbu37bPuiuoz76Zh -pgRi400F8WY82Qj8ze2OyWRrtAmgdSPhaTTfrsMne6Ug5S0CI72XWpcrTLq3IMe1RaaPujHLRbt6TeUSjcvDLizBMAHLXl5K5GS5 -B2NzwHeRY32toI78mq -aQQgMWn70ZyPCXIoMBRB72AwaVkatE5BhYxNuhX9hZBu8oCQuVoLF4IOeTkGHK2gckjFZBkOiRDsKg3B7YYN3NtT2Xfr -0Ty0o3QOim0BeJsaaR8rhFISxPf1iX8IfroC2dj8Yc QT06CFy5oeLhFTdjQoYrHUWpgupG9G4pXHLpG5tk03TFDBa6ExHnvRx -uggfzWdjjrC4hple6IJmJfAZmtXXHXzLJE9VDxquA -Xv1ABk8D8GBAXFc78pUQbC9TVoyQAHI0R3GUSkoJyoql8lRc2fI9BmAYl61BGAxG7r5jre14oQNxqN5JHj6guic9EqsYVoUNbQZX -ogqLoERowSmByIgpTZSQOaIrNwy3PtWpcSOR7QgNZCAFcv7h4bm4vcRJOknBhMouP6jAHyrRnxAK7jSnUOG9cMZecHhQgbzGSMJw -Oj -iJu1iZRbPgiO4LldaJwpEHGKk3DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr -mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw -J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF -NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u - F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP -tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 -VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO -5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ -JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 -g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R -m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H -xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH -IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI -iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH -BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz -yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l -3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg -ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 -7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH -Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY -aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC -WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy -LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP -tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL -tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 -lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf -D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q -Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA -W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp -bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ -pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 -gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr -LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r -WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 -oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh -FNP0Y6IqX49F35bfD7kjoSWsjkyk -Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni -OeinspAF -MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC -ONwZExY64x17zX6bYpevYFprSMqe2nc6 -YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f -kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp -4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A -wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw -9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 -Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 -NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne -MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 -tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac -LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k -1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G -faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW -Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC -uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m -TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd -NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh -sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev -G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 -a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx -50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid -YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU -5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM -0RlsNFegAijnXAGnyIJzrA0nQbatU9 -ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 -s0YehjVFmDt2rClB -9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST -bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR -D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv -r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj -U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon -HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF -MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp -6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy -32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg -nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd -uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN -fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 -J8 -xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ -Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV -uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 -lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ -pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 -24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq -GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ -fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI -HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc -lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M -yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m -gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH -L5TiMCvyJYVmFNjZr9MtsvqdJ3u -a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS -Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh -MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 -mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv -TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn -6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv -YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o -Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd -oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed -tkDZE9F6vRoLXUuQAK0EZCDLKH -qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC -2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE -uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp -o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16384.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16384.expected deleted file mode 100644 index 88d4bdf6c0e..00000000000 --- a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16384.expected +++ /dev/null @@ -1,205 +0,0 @@ -IYEb4HhrrfixUC8j -J2 PNukXTyPowk2P490ZRC hjIqTv3QZxI7 wrsa0rJ8ixaNmZ3Za evP5y6eRvwSwJng787yQzpVi3wCDBw XrEPBJ0 -t2BMpq3evy3ELNduHoifzv6jkN0gJy9o -99sUZ34ro19oJd3UTlLLvi8h8vwToC3ijOEXhY8abO4dCMZUhwj8QlYdDC0JmtAXLO9CEZ0dWZXAMvXgDaorn7CDVBks2Qa7aMkN -1JClm9DlcPR65EKgtPeh -wdteBwA8oEHKRttRIEGI8IstPh2s75Sc9mg0LFG4tn256bBycdcJu4yj6bjBYN13U2dsKkrsJuonekqCOaTTtKudcIwAqRFnZYSa -eXQuRchTkAoQQdZMOejbLczo975o4h0rnt0UvAgU53n -8BYujbW5W2X50yUfshDCtEra20Nx9rJnMAtCkw8QgfECDM988y4A5FGw1sOSyaNch4 -Y47fv7VGVhfl9NG9ByImguZRrYZ3En0DYy2P0G1ufy7xplzshenzxNEjwTe3UR9G83VUs6obeSVCYBAo7pBmaQxH 9f5f9Mv -4oC5X0WDLvadtlM0NNmyDKYfzgw3JTGXDzPGVl7WkL5hsec6MbwS6l0Q7ruX0WtU1WVD8vyCBmVcr2q9DtmgHqclSbMoHXokGFkY -knfOZFLg9DrRkWp3VZfVLYKgsi6pCv 9J7JUWTWxRXLpSszJpKvQbbLa1BYpw0hI3LwgEbX -6ttL77Ak2kox3W9QqdzwQLmTh45n1rwe2daWBRpzwOq33LEBG1nwOlPY5tve0iH5z4T2Vs7cBj6BrOFc8OgS1RXygUURmkmZvYC9 -7XuL HJk8TMOkeCLMZzoJZ9EZVAJXQO9lHftsvw05CwmcscDV7QuRmuwQBD6f4qAnr35io -xNyNC60pDHAKQOV4sIbyoUra8u78PMofY52BjsfFySGZenDGkc4joegzKdogbeQeEjRRD3pPX1CjGu -NtxYCePWXkwgYoxasuDn0ULgaJ9rTD BjglBpG3kpRBB84GwJzfjh8dEmRmKMxsPA8K KpGfjhm -EEVeLcH2t16Se4FZkLSFzADooDijqm60lvxSOpe2LGGhXa94dQmMTESl6FPVqchzKKQuMg77ulrF7GSUosvw4Ry5oLJEQGPqHuxs -jCcE238RM7JOGHwDomNGHoyY0LIYO2dqIcxNOMqvVcFLqCwxnWnX6N zWqHH4ACm1EbtXCACZAOtGsPsM4DdXw -DyqJiYYqBZZAZ0jyvwF2Rzm7DDpWtphJFvKaCvi1n4lf3lBQe FRzakzcOm1sP3q5BMwWDQjcKIhKCsTR4KsqAQWM2cef1 -CTOu64tjU65CzlCmns0QSG8PpqeXLZGo32GbMz1dsSU3byFdXvUfLInNPWTQIGj9tmeGnDzeBihPKIwOQzeB -4oyVwRjiyn0pyMWZ0ChczKOLO57DxwNd4v38dZ 1nIVIVSxlVl0GH4v4tt9judjPKvsMxrAxJq7cDbK bVlc9EcVvTR -ikVAsOiY5ZQT7Y88wh4clEB7lV 8kTSte3RXOTA -1bVCT7yBXD3Es6yezJWm7hdz6vZPaIIOX2l0fTUXB8RfxTq3Kaj6lmQJnuItDJncz6AaYbjXe95W3Vmp0PS3ATEzdG9mEZwSymjd -egkKfFTdY4kx6EnInnegVUFBDalZa5z9ubx3eu6nHD7zfYkjFWUMaLSgwVKjJpsYcw3DtHlfhLWo1nwC9hTX89vCEShI4bcsnlJ7 -3jyOhJSBOym5T55E8F154bYhF4dnwt6q2DRPnenggO1d04bJbVhRbfTgbhGPen3mO5VaU2Z63Rs7q9kp8CsJwPtO5Bp0LC0sTh4Q - -0fJLwkEdB9cY9rVMHpMpRq30e3X1YdchhB8mOkKBXCCaS9WhoBXZYV4zS0R1LOCC5OqHu8TxDJ6p3rOoGxM2s1KzJMZlweexZzSa -ovcwhSG UZ2TTYIan8vFvreBtkSyxmlnQsUyfZnajIPFZeNE -IGu8JRG1yuZuCq0xNPJ19G1ysunyc3X57fORpykArVk2TVQhsBlvsqsloPMMd9FKOSTc0jZsnJf2nLujBuHP5vwqrytGCZMh3mI1 -rZz f5h5RW4JYTtZbd8yeqAF6Hxmze5KaG0jLI7XWIA2ZbVzKLJRydDZu7tiRyNSNjXdw5MuFDgSudZcav3WHJyO OXQ -S4KSuD4dKkPL2hDwuHVwVf6L7hNvyLC5EuqZN1JIgbYiozbhmhU6CKqDLoOdsxFZsr5Uy5F4j3GruUTukaxxIXV9THGDm3E35XGy -OYLvjv2YQWsT5eiWnm5AFuGUBI8pdDSVdnvLPW1Gm9Blb3lQU6xwJsUIWw11NWLmCSf2Aj9olkGXtxWXhji1ypQhQd2GKZUodWyH -gLRGD6QucBcQI5VI8fjoQGWPAgtoWhgsKDGbG6ZH2x9YoFWgWJc OsB1rt7pUWu3vyBueDujMduUejf7RdLO -KqnRyHahI19I5jLVHLKGyNWrbvb9sxEhKPyZEKop -uRCHEXbWRYGZhPks3Q3Wcjvaea8oeuguFZqZVkd0fVpgX8WDleCk8ZqWU1eQbVWjgzaxTNJB23qqMYl6YJFczQb4TkE3GGgDYS3J -cSP1D3qqirQASr42pWt2PBOF7OaRzjD6HUn8MtGF1wyPPWrORXAx3pWPtl4KqVXdsDDFD 6RgMB -ekLwEfmUgQsMsCwBvzkO6H2sJyVJnJ1lpwcsXvJj5skReQdBulviH1NLUIx6KnpIquID2WoY7BoAajF5I evPqde68gP9jb7B -FEawPc OpvimjyZAes9sdECf3B2JF fIChuOk8iDpcneQ1bwseUKjXr7pON6pOc9UaU87Iu -NHD2joerAZTwSMPBAPMRRXNzNLaSIbIrwbzMBNHJrevadSa nY2CfcuuQw5 C0cTEl1ahv6B94v61xTdPXlwMGVYY -7I8Mg2wvMqGLUAbpJtwN2HSFlutq4L2hIF1K08MyKpvI20e0IegHjIHyTuZ1uzZFtQ86Euh1uyI -r6rBVKxfnFihxTPfBBMLo9UXER 4tHUGvLZLPATCdaV4rfT6RmUowQ09KGFxiRdUC -EOEroqWa4gLkFgDHDYEUdYAA2OYGrMPqzilN7OLJqaWmFudOHTRFB6MSSpOCeGLNbGAkT7adB4J9ucX035wU3YTSPAehBbzIe5Aq -vmHRBFC6l FLY2MdW2qGIGjAgQwZMND42REPfVmFmn7HrDo Eoxwjaxzutvua xfqbd1w70 -G43CnoGLCkxmHCiJ1CBHtFA3ytIX5aXiaZkFL47OcLC3u46Lv0TnQdjnGtew5I9YCSq7Y4342RtnQae6dsSfrwaqa2WtYASIDDuW -3PCri8Hd07miGhuRrwrwZCi7NN1q6cGvsCjgQCDzbwlnXd3lrB1ilFX2pAw24 20rp6tW78 7Csmtkjhu2oPIwSO2A -r7m47cYIDK -hpJ7OVfU98IYdwXAy230328Hwyn5bLldYAdvWDnkthFsWxi7wXROx08xhSDRn4i232OY0Jpl2PkSbX5mK3aEjbamS8tpp8gKnF -JjR2XpPFzk7BmeHedc5KSFQl1AFH 3DzxlnyQd5ebjS3Bqd8qHc2LbSTcnqDkVrRvRBLmkhtWCTbpHm05COf 52nO1gcPe -8THe9oE8LrkF0uZKgXLsSkCIq82PFhsv7WaR1CcwXIKToOe8OeFWjUORkmYw4EfKEwVoK6786bf9H3Zv5EMCpWthC8c2mREEdIdj -AQ2ZE7YmIhqJvtby7q vkf2t7hWc6K8Bz9TG8U0XZxRfq0m Ci9joyI3Wfen -dZinbVG6q5PHjKv8ImrXM5D6u3fXCacFyYG8KJoe01bfyD1vw9foYMPCEL1aGo6Uph6bQRNvVsImOd2r5Zvg8staHtt7IsAwiKou -KNuIH7UyLjCH -ABkyySlH5b2e8lZxpQKkHqIChY5xe3uzK1cVwwjrk38LLmKpXlv5GqcHZLEmM31ZaJ9nJ1dAOoqVGw2xjNuqgDi62NgLdyN8bnqD -CSH5kvYfOkxVgN9H196mcpJF2E1IVzjqJeTeJfuBKrE -iUaFSINIPMmYTqMWEtJBestMGF9RQKEtQCPCbIiqwl3kA8EXMkgU9dQSZvJR0DymlBBQ6MUfVqFbblexcUaZIRclnogDPfawyphL -2HXcmB7py2qyWWqbiUBFQCkg3Ic41tpFy7I58BZ46XVhw07jio W7v8PoqvgG1wOV7f8fuiuXvPlQoC2lY07wm0 nQgRok -w3JrHmwWyKmRLhJrrk9jjHhoiTGuLE3j4tsciZlwfhQprtYIkKVez2pr4YlNNYcRvLq0kWQDFo3BohylWpPaO5 -i7lLo7pmeACCHzh4jXoNuBBSOCTRKRi1KEdeWqPH1BUHlhzHKzrXJFL1gmcspqNO2h6dmEwHSlKIowLeaZUyCXMZC4iz8BckLNE0 -feeyDvyILnsWK8ysQZ7WrV1BlJpVxkeULrT5TaKUC8BcNnPWQZeIGC9eOROCmoBmRhnyoXBSWEkOIBgl0MqJ5uub6kdxMGSh76D1 -3NQkbCAHJeCDltw5P8ivcicJZIKiqZ PzAZQItATtQWTyX5zJkFjYG1iQb0N4ssd -O7oMoWi3eKwNRJFMt0ipSs3eaI5W06ncBWdiFWIb4sg6onYSSrwlGkhe8W6fSBHWf PowV2RJb1hlYV88oaCdvFv21SPC8nJQ -U1iITVNuOAw6zhEZOc8z MpFsl4q9kulMJ8cjvW7EI1FfikBXDThfFxPHWu -G1DV05xMQIxLgG5NFmJnSXBmKi2pkZNii303wKIqmL4Qz0xi9MznIBbKob56ZSH01lB9zgll7C9W8gwlDxpfduiQ4pkANDmDSgns -pn4yak7rgCezcCP46lIRVFcZr6HM9JwP3ejcLoLLdAm0GM0ovbrwFIBnZRbzXNjWqfdTYiTCqyYxr4TzXFGgxv3 -VzPVnagOAzhzpbJSAf8arLn7ZCL9Nt7EXYX8OL3S2ocutTJ3snzyVbaxoAX9cefUMaM6JWcR2s8pB6pVFTjGl7p6aN11DiBXmXb4 -V VcleLQyNYWYQv3z8grpAWYsSlMFGu3KRa7dWaiiH2t -q3jSX6ZY7929tTGA0YP8lDhro5X83MKFjL4201yatzDb4HaTjuQLRpXVAZy5lqHQyMJmdQqn1 Si2 D NYRhpHl5VKr -6JMzwA00ZRVy1Z2hI1WxV7wSyIXR -MNm2hwXasuvK2pjoihAkXzoUtuYDhqBFFqWsYRW3njSteQPb9srNSBNE4UM9tR8Fp3lmLB6jJpFu3OQnVCiLEUHkUBBWeUNna0S8 -S5ETB5w8Z8pxy55mrppkTE4x85VRzhErGFeRAUBfuJtManvRtMpTBpsjuro27yLjyGWwUTnhUh7Ga2MIu4aTIHpgU7mk Rc qAv -22xdHaKlod6f4Gbpk8SRo1WlkqYDWw0kLXCXeNCZ3Azu8M0nRtOQLx9zGyHizMClckRWFFZqFYKOPrGdMuTCUdHELsSMWEgl6Daj -sDWuyiHvPzaQrq1NM0Ryy4VUwwgKOi c2Elp6skrC4kLgg7qyIO5HOke 1LRoZc6eIL5DPSc -Jiukkxl5yUueJOUvd3Y3e0bxnQqwPjnYvBta8p7HUGF2Fs8cHMfGBuCsvjqf2pqs4BVcgdZb4xnvVJUvTIlnCckgHs8yXlWtMtgv -nNJ34AkMxBSzWanNsWWHtE7Pnn5Ea3D80CIVB9Ld85aSNWrfWLp0Pe5mOw7VQ5YBak4TPHjmQDX1KyEbdYvCkVBdymSxDP8NUBa8 -WnCCYghXUFDHEccoqmPlFwRREV7KwuXqI0UnaLQYDE7U9H5qcRIi1hX2vjs02KYYDykGBYYfXrtSXg2JBCtXkeogKaOQPTpVUv2c -zs CbrnVrA7i5oiDDAsglO0Ta sa5f6mXYUgIN64m3zpmqsLQbCRKLkKYfQ8sbH7Sdcd3oDnp70dbSg0JtuAD64hucNRE h -JRrn4fzfDz35Ho8yuRDN4Fn0JZKbJBamM7Ugn9nSldmMwIqsWIIQG5JAomGveR7XZFal2XIotpPujUmQ1G8D4aFtwUn3j6n6olgW -hiaOzdzuBXFPGPZOhjshexl5jGUxTRIZl1jCWCMW1fyKtEDReYhhfjEdeV8Os9OwgZP73TmuyG8Pw1XbMWkxt25I9JWF0DLYaUwx -8hOKeNzko QDzJL97X O5wI5k0OSrUDjxA97lYNGCTyGww0neGp RW1DUaJTfaWsMXsR1SzkQ4NqNgraLRgZJYm -NSEeFJ8CpEsK5MHx2rHGSGQamJl5bhOEpTa5gghVl0Vi3q -l77M6H27VVICru1xXUgoQ8iahSjrJTWdofNKswdORFLTn5QGGrHX0XnN2ubp9E38B6wsswuzLOlPswu93RGDw pTFk65uWoc -4XANAZojJHgREiWaG5T4GvW4y0vhUrrmjjFEQGPfwBMeDXNFji5v -KLATcQroa5yJ4XTZtqTAfy316iCSJ1Ea8KestkkNfpBpuwbD1b0JN7gQkqRz0FAcWg5XqeRGXfPA6psmiSs8uuVlF6 -a4xF24lzDQTr7DWloSLJWhCuwNkK9acMYh06NUXVwnA0MVqkqyjNnShsWl8H4oQv5Nsf3Kbcg7R7AYwqbIyyvoi1L0OMG2icFaTU -veRNQRxoXZ0TwV0BDeNUWpOTgf9BBSXrpU9gHePT88AzPlGDTAawY6kCoekbUMntEaXY0vAVVHp R362Ou LOObMUiodtscmyL5 -cdTV6u6EWPl01fTH0FUZ2H0V4W8z44F4Gh2ydhSgI5uRlGZWCpidd2ZQPPSU44nGR59YGAbBGs3g8yFVmh3S2ZDiAoHPRdGUUVbD -O6yXceTzh0ax9buiGdvRVS6KsykYClnlACuhL3B3cZXletNklhYjd4iM10VIfUqmsd1O1eFmRa0awYKiLYWyXq6jKYA61uQlyj1D -i4k0S00cPzV8xAzE1ytC4 E4oQkbgweEF1R lPKNmluEfUFGioa6Rah2KecZ7d1Lh6uQdNNgD0s eUS5ySCPMxouDK8 -0HgjteGUDEcipVohCCBKBOiZUciFI6DvSAiuPJ7sfXEN8wOnmf1REzGhvvctZOgXVTBLlwrNFxR5iCGxGJ6vj8aCaGdAiHusVcHV -62LhpLay021xMEDPxkFKIcucN3tMmAeY75U3aPMPWhE42jEGZb9xsl2WuqH1MHpybhKP207Xva8KpgDmh36bFjN2AKSvtRYEBT9l -LWkQ1I2k3mRg5AUHmufZuRLFl8mK9PlfswEE9kK5KpOWQdULt0PbAuxG35WTQpGuIwMiMiGQhRqJdoYpyqsp5IChwrTHpdoR8vuZ -GruCxRwK5X8s2E0mwJ6NpC5DOEcNKbU2NU3a4fAsfMfCr2ENRbe6SwrihPx2n3GojnoQjoSA5t9nVk6ZT -tyCDw51m6ycbu37bPuiuoz76Zh -pgRi400F8WY82Qj8ze2OyWRrtAmgdSPhaTTfrsMne6Ug5S0CI72XWpcrTLq3IMe1RaaPujHLRbt6TeUSjcvDLizBMAHLXl5K5GS5 -B2NzwHeRY32toI78mq -aQQgMWn70ZyPCXIoMBRB72AwaVkatE5BhYxNuhX9hZBu8oCQuVoLF4IOeTkGHK2gckjFZBkOiRDsKg3B7YYN3NtT2Xfr -0Ty0o3QOim0BeJsaaR8rhFISxPf1iX8IfroC2dj8Yc QT06CFy5oeLhFTdjQoYrHUWpgupG9G4pXHLpG5tk03TFDBa6ExHnvRx -uggfzWdjjrC4hple6IJmJfAZmtXXHXzLJE9VDxquA -Xv1ABk8D8GBAXFc78pUQbC9TVoyQAHI0R3GUSkoJyoql8lRc2fI9BmAYl61BGAxG7r5jre14oQNxqN5JHj6guic9EqsYVoUNbQZX -ogqLoERowSmByIgpTZSQOaIrNwy3PtWpcSOR7QgNZCAFcv7h4bm4vcRJOknBhMouP6jAHyrRnxAK7jSnUOG9cMZecHhQgbzGSMJw -Oj -iJu1iZRbPgiO4LldaJwpEHGKk3DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr -mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw -J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF -NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u - F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP -tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 -VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO -5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ -JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 -g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R -m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H -xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH -IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI -iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH -BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz -yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l -3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg -ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 -7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH -Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY -aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC -WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy -LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP -tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL -tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 -lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf -D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q -Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA -W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp -bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ -pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 -gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr -LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r -WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 -oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh -FNP0Y6IqX49F35bfD7kjoSWsjkyk -Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni -OeinspAF -MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC -ONwZExY64x17zX6bYpevYFprSMqe2nc6 -YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f -kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp -4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A -wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw -9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 -Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 -NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne -MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 -tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac -LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k -1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G -faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW -Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC -uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m -TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd -NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh -sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev -G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 -a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx -50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid -YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU -5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM -0RlsNFegAijnXAGnyIJzrA0nQbatU9 -ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 -s0YehjVFmDt2rClB -9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST -bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR -D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv -r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj -U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon -HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF -MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp -6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy -32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg -nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd -uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN -fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 -J8 -xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ -Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV -uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 -lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ -pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 -24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq -GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ -fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI -HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc -lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M -yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m -gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH -L5TiMCvyJYVmFNjZr9MtsvqdJ3u -a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS -Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh -MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 -mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv -TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn -6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv -YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o -Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd -oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed -tkDZE9F6vRoLXUuQAK0EZCDLKH -qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC -2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE -uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp -o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16385.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16385.expected deleted file mode 100644 index 32b6b3dc600..00000000000 --- a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16385.expected +++ /dev/null @@ -1,205 +0,0 @@ -NIYEb4HhrrfixUC8j -J2 PNukXTyPowk2P490ZRC hjIqTv3QZxI7 wrsa0rJ8ixaNmZ3Za evP5y6eRvwSwJng787yQzpVi3wCDBw XrEPBJ0 -t2BMpq3evy3ELNduHoifzv6jkN0gJy9o -99sUZ34ro19oJd3UTlLLvi8h8vwToC3ijOEXhY8abO4dCMZUhwj8QlYdDC0JmtAXLO9CEZ0dWZXAMvXgDaorn7CDVBks2Qa7aMkN -1JClm9DlcPR65EKgtPeh -wdteBwA8oEHKRttRIEGI8IstPh2s75Sc9mg0LFG4tn256bBycdcJu4yj6bjBYN13U2dsKkrsJuonekqCOaTTtKudcIwAqRFnZYSa -eXQuRchTkAoQQdZMOejbLczo975o4h0rnt0UvAgU53n -8BYujbW5W2X50yUfshDCtEra20Nx9rJnMAtCkw8QgfECDM988y4A5FGw1sOSyaNch4 -Y47fv7VGVhfl9NG9ByImguZRrYZ3En0DYy2P0G1ufy7xplzshenzxNEjwTe3UR9G83VUs6obeSVCYBAo7pBmaQxH 9f5f9Mv -4oC5X0WDLvadtlM0NNmyDKYfzgw3JTGXDzPGVl7WkL5hsec6MbwS6l0Q7ruX0WtU1WVD8vyCBmVcr2q9DtmgHqclSbMoHXokGFkY -knfOZFLg9DrRkWp3VZfVLYKgsi6pCv 9J7JUWTWxRXLpSszJpKvQbbLa1BYpw0hI3LwgEbX -6ttL77Ak2kox3W9QqdzwQLmTh45n1rwe2daWBRpzwOq33LEBG1nwOlPY5tve0iH5z4T2Vs7cBj6BrOFc8OgS1RXygUURmkmZvYC9 -7XuL HJk8TMOkeCLMZzoJZ9EZVAJXQO9lHftsvw05CwmcscDV7QuRmuwQBD6f4qAnr35io -xNyNC60pDHAKQOV4sIbyoUra8u78PMofY52BjsfFySGZenDGkc4joegzKdogbeQeEjRRD3pPX1CjGu -NtxYCePWXkwgYoxasuDn0ULgaJ9rTD BjglBpG3kpRBB84GwJzfjh8dEmRmKMxsPA8K KpGfjhm -EEVeLcH2t16Se4FZkLSFzADooDijqm60lvxSOpe2LGGhXa94dQmMTESl6FPVqchzKKQuMg77ulrF7GSUosvw4Ry5oLJEQGPqHuxs -jCcE238RM7JOGHwDomNGHoyY0LIYO2dqIcxNOMqvVcFLqCwxnWnX6N zWqHH4ACm1EbtXCACZAOtGsPsM4DdXw -DyqJiYYqBZZAZ0jyvwF2Rzm7DDpWtphJFvKaCvi1n4lf3lBQe FRzakzcOm1sP3q5BMwWDQjcKIhKCsTR4KsqAQWM2cef1 -CTOu64tjU65CzlCmns0QSG8PpqeXLZGo32GbMz1dsSU3byFdXvUfLInNPWTQIGj9tmeGnDzeBihPKIwOQzeB -4oyVwRjiyn0pyMWZ0ChczKOLO57DxwNd4v38dZ 1nIVIVSxlVl0GH4v4tt9judjPKvsMxrAxJq7cDbK bVlc9EcVvTR -ikVAsOiY5ZQT7Y88wh4clEB7lV 8kTSte3RXOTA -1bVCT7yBXD3Es6yezJWm7hdz6vZPaIIOX2l0fTUXB8RfxTq3Kaj6lmQJnuItDJncz6AaYbjXe95W3Vmp0PS3ATEzdG9mEZwSymjd -egkKfFTdY4kx6EnInnegVUFBDalZa5z9ubx3eu6nHD7zfYkjFWUMaLSgwVKjJpsYcw3DtHlfhLWo1nwC9hTX89vCEShI4bcsnlJ7 -3jyOhJSBOym5T55E8F154bYhF4dnwt6q2DRPnenggO1d04bJbVhRbfTgbhGPen3mO5VaU2Z63Rs7q9kp8CsJwPtO5Bp0LC0sTh4Q - -0fJLwkEdB9cY9rVMHpMpRq30e3X1YdchhB8mOkKBXCCaS9WhoBXZYV4zS0R1LOCC5OqHu8TxDJ6p3rOoGxM2s1KzJMZlweexZzSa -ovcwhSG UZ2TTYIan8vFvreBtkSyxmlnQsUyfZnajIPFZeNE -IGu8JRG1yuZuCq0xNPJ19G1ysunyc3X57fORpykArVk2TVQhsBlvsqsloPMMd9FKOSTc0jZsnJf2nLujBuHP5vwqrytGCZMh3mI1 -rZz f5h5RW4JYTtZbd8yeqAF6Hxmze5KaG0jLI7XWIA2ZbVzKLJRydDZu7tiRyNSNjXdw5MuFDgSudZcav3WHJyO OXQ -S4KSuD4dKkPL2hDwuHVwVf6L7hNvyLC5EuqZN1JIgbYiozbhmhU6CKqDLoOdsxFZsr5Uy5F4j3GruUTukaxxIXV9THGDm3E35XGy -OYLvjv2YQWsT5eiWnm5AFuGUBI8pdDSVdnvLPW1Gm9Blb3lQU6xwJsUIWw11NWLmCSf2Aj9olkGXtxWXhji1ypQhQd2GKZUodWyH -gLRGD6QucBcQI5VI8fjoQGWPAgtoWhgsKDGbG6ZH2x9YoFWgWJc OsB1rt7pUWu3vyBueDujMduUejf7RdLO -KqnRyHahI19I5jLVHLKGyNWrbvb9sxEhKPyZEKop -uRCHEXbWRYGZhPks3Q3Wcjvaea8oeuguFZqZVkd0fVpgX8WDleCk8ZqWU1eQbVWjgzaxTNJB23qqMYl6YJFczQb4TkE3GGgDYS3J -cSP1D3qqirQASr42pWt2PBOF7OaRzjD6HUn8MtGF1wyPPWrORXAx3pWPtl4KqVXdsDDFD 6RgMB -ekLwEfmUgQsMsCwBvzkO6H2sJyVJnJ1lpwcsXvJj5skReQdBulviH1NLUIx6KnpIquID2WoY7BoAajF5I evPqde68gP9jb7B -FEawPc OpvimjyZAes9sdECf3B2JF fIChuOk8iDpcneQ1bwseUKjXr7pON6pOc9UaU87Iu -NHD2joerAZTwSMPBAPMRRXNzNLaSIbIrwbzMBNHJrevadSa nY2CfcuuQw5 C0cTEl1ahv6B94v61xTdPXlwMGVYY -7I8Mg2wvMqGLUAbpJtwN2HSFlutq4L2hIF1K08MyKpvI20e0IegHjIHyTuZ1uzZFtQ86Euh1uyI -r6rBVKxfnFihxTPfBBMLo9UXER 4tHUGvLZLPATCdaV4rfT6RmUowQ09KGFxiRdUC -EOEroqWa4gLkFgDHDYEUdYAA2OYGrMPqzilN7OLJqaWmFudOHTRFB6MSSpOCeGLNbGAkT7adB4J9ucX035wU3YTSPAehBbzIe5Aq -vmHRBFC6l FLY2MdW2qGIGjAgQwZMND42REPfVmFmn7HrDo Eoxwjaxzutvua xfqbd1w70 -G43CnoGLCkxmHCiJ1CBHtFA3ytIX5aXiaZkFL47OcLC3u46Lv0TnQdjnGtew5I9YCSq7Y4342RtnQae6dsSfrwaqa2WtYASIDDuW -3PCri8Hd07miGhuRrwrwZCi7NN1q6cGvsCjgQCDzbwlnXd3lrB1ilFX2pAw24 20rp6tW78 7Csmtkjhu2oPIwSO2A -r7m47cYIDK -hpJ7OVfU98IYdwXAy230328Hwyn5bLldYAdvWDnkthFsWxi7wXROx08xhSDRn4i232OY0Jpl2PkSbX5mK3aEjbamS8tpp8gKnF -JjR2XpPFzk7BmeHedc5KSFQl1AFH 3DzxlnyQd5ebjS3Bqd8qHc2LbSTcnqDkVrRvRBLmkhtWCTbpHm05COf 52nO1gcPe -8THe9oE8LrkF0uZKgXLsSkCIq82PFhsv7WaR1CcwXIKToOe8OeFWjUORkmYw4EfKEwVoK6786bf9H3Zv5EMCpWthC8c2mREEdIdj -AQ2ZE7YmIhqJvtby7q vkf2t7hWc6K8Bz9TG8U0XZxRfq0m Ci9joyI3Wfen -dZinbVG6q5PHjKv8ImrXM5D6u3fXCacFyYG8KJoe01bfyD1vw9foYMPCEL1aGo6Uph6bQRNvVsImOd2r5Zvg8staHtt7IsAwiKou -KNuIH7UyLjCH -ABkyySlH5b2e8lZxpQKkHqIChY5xe3uzK1cVwwjrk38LLmKpXlv5GqcHZLEmM31ZaJ9nJ1dAOoqVGw2xjNuqgDi62NgLdyN8bnqD -CSH5kvYfOkxVgN9H196mcpJF2E1IVzjqJeTeJfuBKrE -iUaFSINIPMmYTqMWEtJBestMGF9RQKEtQCPCbIiqwl3kA8EXMkgU9dQSZvJR0DymlBBQ6MUfVqFbblexcUaZIRclnogDPfawyphL -2HXcmB7py2qyWWqbiUBFQCkg3Ic41tpFy7I58BZ46XVhw07jio W7v8PoqvgG1wOV7f8fuiuXvPlQoC2lY07wm0 nQgRok -w3JrHmwWyKmRLhJrrk9jjHhoiTGuLE3j4tsciZlwfhQprtYIkKVez2pr4YlNNYcRvLq0kWQDFo3BohylWpPaO5 -i7lLo7pmeACCHzh4jXoNuBBSOCTRKRi1KEdeWqPH1BUHlhzHKzrXJFL1gmcspqNO2h6dmEwHSlKIowLeaZUyCXMZC4iz8BckLNE0 -feeyDvyILnsWK8ysQZ7WrV1BlJpVxkeULrT5TaKUC8BcNnPWQZeIGC9eOROCmoBmRhnyoXBSWEkOIBgl0MqJ5uub6kdxMGSh76D1 -3NQkbCAHJeCDltw5P8ivcicJZIKiqZ PzAZQItATtQWTyX5zJkFjYG1iQb0N4ssd -O7oMoWi3eKwNRJFMt0ipSs3eaI5W06ncBWdiFWIb4sg6onYSSrwlGkhe8W6fSBHWf PowV2RJb1hlYV88oaCdvFv21SPC8nJQ -U1iITVNuOAw6zhEZOc8z MpFsl4q9kulMJ8cjvW7EI1FfikBXDThfFxPHWu -G1DV05xMQIxLgG5NFmJnSXBmKi2pkZNii303wKIqmL4Qz0xi9MznIBbKob56ZSH01lB9zgll7C9W8gwlDxpfduiQ4pkANDmDSgns -pn4yak7rgCezcCP46lIRVFcZr6HM9JwP3ejcLoLLdAm0GM0ovbrwFIBnZRbzXNjWqfdTYiTCqyYxr4TzXFGgxv3 -VzPVnagOAzhzpbJSAf8arLn7ZCL9Nt7EXYX8OL3S2ocutTJ3snzyVbaxoAX9cefUMaM6JWcR2s8pB6pVFTjGl7p6aN11DiBXmXb4 -V VcleLQyNYWYQv3z8grpAWYsSlMFGu3KRa7dWaiiH2t -q3jSX6ZY7929tTGA0YP8lDhro5X83MKFjL4201yatzDb4HaTjuQLRpXVAZy5lqHQyMJmdQqn1 Si2 D NYRhpHl5VKr -6JMzwA00ZRVy1Z2hI1WxV7wSyIXR -MNm2hwXasuvK2pjoihAkXzoUtuYDhqBFFqWsYRW3njSteQPb9srNSBNE4UM9tR8Fp3lmLB6jJpFu3OQnVCiLEUHkUBBWeUNna0S8 -S5ETB5w8Z8pxy55mrppkTE4x85VRzhErGFeRAUBfuJtManvRtMpTBpsjuro27yLjyGWwUTnhUh7Ga2MIu4aTIHpgU7mk Rc qAv -22xdHaKlod6f4Gbpk8SRo1WlkqYDWw0kLXCXeNCZ3Azu8M0nRtOQLx9zGyHizMClckRWFFZqFYKOPrGdMuTCUdHELsSMWEgl6Daj -sDWuyiHvPzaQrq1NM0Ryy4VUwwgKOi c2Elp6skrC4kLgg7qyIO5HOke 1LRoZc6eIL5DPSc -Jiukkxl5yUueJOUvd3Y3e0bxnQqwPjnYvBta8p7HUGF2Fs8cHMfGBuCsvjqf2pqs4BVcgdZb4xnvVJUvTIlnCckgHs8yXlWtMtgv -nNJ34AkMxBSzWanNsWWHtE7Pnn5Ea3D80CIVB9Ld85aSNWrfWLp0Pe5mOw7VQ5YBak4TPHjmQDX1KyEbdYvCkVBdymSxDP8NUBa8 -WnCCYghXUFDHEccoqmPlFwRREV7KwuXqI0UnaLQYDE7U9H5qcRIi1hX2vjs02KYYDykGBYYfXrtSXg2JBCtXkeogKaOQPTpVUv2c -zs CbrnVrA7i5oiDDAsglO0Ta sa5f6mXYUgIN64m3zpmqsLQbCRKLkKYfQ8sbH7Sdcd3oDnp70dbSg0JtuAD64hucNRE h -JRrn4fzfDz35Ho8yuRDN4Fn0JZKbJBamM7Ugn9nSldmMwIqsWIIQG5JAomGveR7XZFal2XIotpPujUmQ1G8D4aFtwUn3j6n6olgW -hiaOzdzuBXFPGPZOhjshexl5jGUxTRIZl1jCWCMW1fyKtEDReYhhfjEdeV8Os9OwgZP73TmuyG8Pw1XbMWkxt25I9JWF0DLYaUwx -8hOKeNzko QDzJL97X O5wI5k0OSrUDjxA97lYNGCTyGww0neGp RW1DUaJTfaWsMXsR1SzkQ4NqNgraLRgZJYm -NSEeFJ8CpEsK5MHx2rHGSGQamJl5bhOEpTa5gghVl0Vi3q -l77M6H27VVICru1xXUgoQ8iahSjrJTWdofNKswdORFLTn5QGGrHX0XnN2ubp9E38B6wsswuzLOlPswu93RGDw pTFk65uWoc -4XANAZojJHgREiWaG5T4GvW4y0vhUrrmjjFEQGPfwBMeDXNFji5v -KLATcQroa5yJ4XTZtqTAfy316iCSJ1Ea8KestkkNfpBpuwbD1b0JN7gQkqRz0FAcWg5XqeRGXfPA6psmiSs8uuVlF6 -a4xF24lzDQTr7DWloSLJWhCuwNkK9acMYh06NUXVwnA0MVqkqyjNnShsWl8H4oQv5Nsf3Kbcg7R7AYwqbIyyvoi1L0OMG2icFaTU -veRNQRxoXZ0TwV0BDeNUWpOTgf9BBSXrpU9gHePT88AzPlGDTAawY6kCoekbUMntEaXY0vAVVHp R362Ou LOObMUiodtscmyL5 -cdTV6u6EWPl01fTH0FUZ2H0V4W8z44F4Gh2ydhSgI5uRlGZWCpidd2ZQPPSU44nGR59YGAbBGs3g8yFVmh3S2ZDiAoHPRdGUUVbD -O6yXceTzh0ax9buiGdvRVS6KsykYClnlACuhL3B3cZXletNklhYjd4iM10VIfUqmsd1O1eFmRa0awYKiLYWyXq6jKYA61uQlyj1D -i4k0S00cPzV8xAzE1ytC4 E4oQkbgweEF1R lPKNmluEfUFGioa6Rah2KecZ7d1Lh6uQdNNgD0s eUS5ySCPMxouDK8 -0HgjteGUDEcipVohCCBKBOiZUciFI6DvSAiuPJ7sfXEN8wOnmf1REzGhvvctZOgXVTBLlwrNFxR5iCGxGJ6vj8aCaGdAiHusVcHV -62LhpLay021xMEDPxkFKIcucN3tMmAeY75U3aPMPWhE42jEGZb9xsl2WuqH1MHpybhKP207Xva8KpgDmh36bFjN2AKSvtRYEBT9l -LWkQ1I2k3mRg5AUHmufZuRLFl8mK9PlfswEE9kK5KpOWQdULt0PbAuxG35WTQpGuIwMiMiGQhRqJdoYpyqsp5IChwrTHpdoR8vuZ -GruCxRwK5X8s2E0mwJ6NpC5DOEcNKbU2NU3a4fAsfMfCr2ENRbe6SwrihPx2n3GojnoQjoSA5t9nVk6ZT -tyCDw51m6ycbu37bPuiuoz76Zh -pgRi400F8WY82Qj8ze2OyWRrtAmgdSPhaTTfrsMne6Ug5S0CI72XWpcrTLq3IMe1RaaPujHLRbt6TeUSjcvDLizBMAHLXl5K5GS5 -B2NzwHeRY32toI78mq -aQQgMWn70ZyPCXIoMBRB72AwaVkatE5BhYxNuhX9hZBu8oCQuVoLF4IOeTkGHK2gckjFZBkOiRDsKg3B7YYN3NtT2Xfr -0Ty0o3QOim0BeJsaaR8rhFISxPf1iX8IfroC2dj8Yc QT06CFy5oeLhFTdjQoYrHUWpgupG9G4pXHLpG5tk03TFDBa6ExHnvRx -uggfzWdjjrC4hple6IJmJfAZmtXXHXzLJE9VDxquA -Xv1ABk8D8GBAXFc78pUQbC9TVoyQAHI0R3GUSkoJyoql8lRc2fI9BmAYl61BGAxG7r5jre14oQNxqN5JHj6guic9EqsYVoUNbQZX -ogqLoERowSmByIgpTZSQOaIrNwy3PtWpcSOR7QgNZCAFcv7h4bm4vcRJOknBhMouP6jAHyrRnxAK7jSnUOG9cMZecHhQgbzGSMJw -Oj -iJu1iZRbPgiO4LldaJwpEHGKk3DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr -mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw -J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF -NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u - F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP -tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 -VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO -5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ -JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 -g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R -m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H -xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH -IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI -iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH -BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz -yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l -3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg -ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 -7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH -Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY -aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC -WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy -LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP -tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL -tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 -lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf -D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q -Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA -W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp -bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ -pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 -gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr -LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r -WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 -oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh -FNP0Y6IqX49F35bfD7kjoSWsjkyk -Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni -OeinspAF -MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC -ONwZExY64x17zX6bYpevYFprSMqe2nc6 -YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f -kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp -4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A -wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw -9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 -Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 -NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne -MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 -tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac -LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k -1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G -faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW -Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC -uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m -TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd -NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh -sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev -G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 -a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx -50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid -YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU -5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM -0RlsNFegAijnXAGnyIJzrA0nQbatU9 -ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 -s0YehjVFmDt2rClB -9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST -bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR -D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv -r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj -U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon -HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF -MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp -6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy -32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg -nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd -uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN -fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 -J8 -xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ -Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV -uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 -lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ -pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 -24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq -GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ -fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI -HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc -lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M -yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m -gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH -L5TiMCvyJYVmFNjZr9MtsvqdJ3u -a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS -Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh -MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 -mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv -TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn -6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv -YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o -Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd -oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed -tkDZE9F6vRoLXUuQAK0EZCDLKH -qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC -2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE -uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp -o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8192.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8192.expected deleted file mode 100644 index a30c8ea3471..00000000000 --- a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8192.expected +++ /dev/null @@ -1,105 +0,0 @@ -ESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr -mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw -J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF -NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u - F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP -tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 -VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO -5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ -JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 -g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R -m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H -xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH -IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI -iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH -BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz -yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l -3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg -ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 -7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH -Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY -aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC -WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy -LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP -tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL -tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 -lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf -D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q -Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA -W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp -bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ -pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 -gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr -LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r -WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 -oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh -FNP0Y6IqX49F35bfD7kjoSWsjkyk -Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni -OeinspAF -MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC -ONwZExY64x17zX6bYpevYFprSMqe2nc6 -YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f -kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp -4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A -wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw -9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 -Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 -NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne -MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 -tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac -LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k -1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G -faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW -Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC -uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m -TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd -NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh -sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev -G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 -a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx -50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid -YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU -5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM -0RlsNFegAijnXAGnyIJzrA0nQbatU9 -ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 -s0YehjVFmDt2rClB -9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST -bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR -D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv -r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj -U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon -HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF -MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp -6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy -32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg -nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd -uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN -fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 -J8 -xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ -Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV -uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 -lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ -pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 -24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq -GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ -fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI -HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc -lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M -yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m -gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH -L5TiMCvyJYVmFNjZr9MtsvqdJ3u -a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS -Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh -MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 -mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv -TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn -6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv -YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o -Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd -oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed -tkDZE9F6vRoLXUuQAK0EZCDLKH -qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC -2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE -uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp -o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8193.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8193.expected deleted file mode 100644 index b1e55dd70d7..00000000000 --- a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8193.expected +++ /dev/null @@ -1,105 +0,0 @@ -DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr -mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw -J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF -NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u - F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP -tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 -VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO -5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ -JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 -g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R -m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H -xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH -IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI -iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH -BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz -yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l -3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg -ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 -7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH -Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY -aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC -WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy -LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP -tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL -tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 -lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf -D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q -Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA -W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp -bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ -pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 -gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr -LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r -WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 -oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh -FNP0Y6IqX49F35bfD7kjoSWsjkyk -Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni -OeinspAF -MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC -ONwZExY64x17zX6bYpevYFprSMqe2nc6 -YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f -kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp -4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A -wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw -9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 -Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 -NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne -MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 -tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac -LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k -1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G -faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW -Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC -uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m -TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd -NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh -sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev -G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 -a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx -50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid -YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU -5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM -0RlsNFegAijnXAGnyIJzrA0nQbatU9 -ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 -s0YehjVFmDt2rClB -9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST -bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR -D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv -r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj -U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon -HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF -MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp -6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy -32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg -nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd -uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN -fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 -J8 -xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ -Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV -uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 -lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ -pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 -24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq -GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ -fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI -HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc -lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M -yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m -gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH -L5TiMCvyJYVmFNjZr9MtsvqdJ3u -a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS -Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh -MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 -mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv -TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn -6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv -YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o -Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd -oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed -tkDZE9F6vRoLXUuQAK0EZCDLKH -qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC -2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE -uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp -o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines.txt b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines.txt deleted file mode 100644 index 4ec2c6700c2..00000000000 --- a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines.txt +++ /dev/null @@ -1,103 +0,0 @@ -xxSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm -vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E -zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ -wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 -KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC -8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj -mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA -BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD -q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 -OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE -vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf -7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD -lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j -vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ -ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ -r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba -lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q -PU5zMN9ghlkBA -nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ -gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA -fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV -Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX -uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J -KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr -qy5YUBNVOrweJj8bdGIQ Y6M5c -kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE -dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS -GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu -oCbgLZuioXwjsO7Hqp2Gcg -BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ -xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al -rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg -BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx -9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI -1M3NvaHNmgYu89HWhuCbaGC54Eu2 -x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 -1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q -Q2CjpU1dpF5f7qohK -6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x -rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf -buZha3wYriOydbTiTRsPvfSXTbrsJ5 -ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC -2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S -EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 -nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK -dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI -k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 -gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq -yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 -TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 -ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB -b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ -KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP -PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc -8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 -52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox -LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 -HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU -rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF -9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO -AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 -icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 -jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P -cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 -QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG -eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V -gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB -4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV -Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O -szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o -PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf -YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA -HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt -kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM -y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ -HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj -eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S -vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd -kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l -cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE -drqXGjXRtcVMhSRbaBZSV -4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 -0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV -Aef5 -XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA -3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 -RoBzQN0bYJwlioLqwT56oqNY hNBx -qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK -HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw -smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 -raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX -TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k -Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L -BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav -w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI -zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj -9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI -AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY -Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 -B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY -eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe -4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT -3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_+2.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_+2.expected deleted file mode 100644 index e6c5768c7fd..00000000000 --- a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_+2.expected +++ /dev/null @@ -1,103 +0,0 @@ -xSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm -vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E -zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ -wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 -KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC -8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj -mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA -BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD -q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 -OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE -vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf -7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD -lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j -vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ -ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ -r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba -lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q -PU5zMN9ghlkBA -nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ -gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA -fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV -Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX -uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J -KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr -qy5YUBNVOrweJj8bdGIQ Y6M5c -kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE -dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS -GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu -oCbgLZuioXwjsO7Hqp2Gcg -BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ -xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al -rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg -BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx -9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI -1M3NvaHNmgYu89HWhuCbaGC54Eu2 -x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 -1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q -Q2CjpU1dpF5f7qohK -6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x -rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf -buZha3wYriOydbTiTRsPvfSXTbrsJ5 -ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC -2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S -EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 -nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK -dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI -k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 -gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq -yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 -TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 -ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB -b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ -KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP -PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc -8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 -52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox -LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 -HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU -rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF -9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO -AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 -icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 -jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P -cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 -QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG -eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V -gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB -4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV -Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O -szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o -PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf -YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA -HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt -kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM -y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ -HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj -eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S -vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd -kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l -cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE -drqXGjXRtcVMhSRbaBZSV -4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 -0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV -Aef5 -XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA -3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 -RoBzQN0bYJwlioLqwT56oqNY hNBx -qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK -HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw -smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 -raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX -TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k -Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L -BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav -w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI -zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj -9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI -AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY -Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 -B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY -eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe -4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT -3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-1.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-1.expected deleted file mode 100644 index 8b137891791..00000000000 --- a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-1.expected +++ /dev/null @@ -1 +0,0 @@ - diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-8191.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-8191.expected deleted file mode 100644 index e6c5768c7fd..00000000000 --- a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-8191.expected +++ /dev/null @@ -1,103 +0,0 @@ -xSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm -vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E -zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ -wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 -KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC -8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj -mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA -BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD -q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 -OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE -vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf -7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD -lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j -vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ -ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ -r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba -lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q -PU5zMN9ghlkBA -nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ -gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA -fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV -Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX -uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J -KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr -qy5YUBNVOrweJj8bdGIQ Y6M5c -kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE -dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS -GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu -oCbgLZuioXwjsO7Hqp2Gcg -BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ -xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al -rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg -BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx -9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI -1M3NvaHNmgYu89HWhuCbaGC54Eu2 -x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 -1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q -Q2CjpU1dpF5f7qohK -6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x -rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf -buZha3wYriOydbTiTRsPvfSXTbrsJ5 -ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC -2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S -EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 -nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK -dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI -k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 -gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq -yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 -TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 -ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB -b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ -KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP -PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc -8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 -52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox -LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 -HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU -rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF -9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO -AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 -icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 -jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P -cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 -QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG -eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V -gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB -4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV -Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O -szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o -PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf -YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA -HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt -kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM -y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ -HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj -eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S -vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd -kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l -cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE -drqXGjXRtcVMhSRbaBZSV -4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 -0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV -Aef5 -XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA -3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 -RoBzQN0bYJwlioLqwT56oqNY hNBx -qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK -HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw -smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 -raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX -TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k -Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L -BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav -w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI -zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj -9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI -AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY -Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 -B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY -eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe -4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT -3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_+2.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_+2.expected deleted file mode 100644 index b78a76687d4..00000000000 --- a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_+2.expected +++ /dev/null @@ -1,102 +0,0 @@ -vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E -zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ -wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 -KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC -8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj -mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA -BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD -q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 -OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE -vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf -7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD -lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j -vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ -ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ -r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba -lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q -PU5zMN9ghlkBA -nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ -gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA -fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV -Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX -uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J -KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr -qy5YUBNVOrweJj8bdGIQ Y6M5c -kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE -dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS -GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu -oCbgLZuioXwjsO7Hqp2Gcg -BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ -xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al -rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg -BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx -9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI -1M3NvaHNmgYu89HWhuCbaGC54Eu2 -x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 -1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q -Q2CjpU1dpF5f7qohK -6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x -rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf -buZha3wYriOydbTiTRsPvfSXTbrsJ5 -ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC -2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S -EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 -nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK -dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI -k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 -gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq -yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 -TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 -ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB -b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ -KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP -PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc -8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 -52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox -LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 -HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU -rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF -9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO -AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 -icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 -jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P -cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 -QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG -eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V -gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB -4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV -Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O -szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o -PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf -YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA -HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt -kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM -y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ -HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj -eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S -vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd -kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l -cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE -drqXGjXRtcVMhSRbaBZSV -4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 -0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV -Aef5 -XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA -3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 -RoBzQN0bYJwlioLqwT56oqNY hNBx -qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK -HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw -smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 -raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX -TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k -Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L -BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav -w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI -zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj -9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI -AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY -Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 -B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY -eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe -4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT -3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-1.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-1.expected deleted file mode 100644 index 30b643a88e9..00000000000 --- a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-1.expected +++ /dev/null @@ -1 +0,0 @@ -3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-102.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-102.expected deleted file mode 100644 index b78a76687d4..00000000000 --- a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-102.expected +++ /dev/null @@ -1,102 +0,0 @@ -vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E -zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ -wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 -KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC -8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj -mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA -BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD -q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 -OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE -vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf -7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD -lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j -vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ -ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ -r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba -lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q -PU5zMN9ghlkBA -nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ -gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA -fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV -Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX -uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J -KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr -qy5YUBNVOrweJj8bdGIQ Y6M5c -kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE -dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS -GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu -oCbgLZuioXwjsO7Hqp2Gcg -BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ -xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al -rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg -BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx -9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI -1M3NvaHNmgYu89HWhuCbaGC54Eu2 -x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 -1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q -Q2CjpU1dpF5f7qohK -6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x -rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf -buZha3wYriOydbTiTRsPvfSXTbrsJ5 -ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC -2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S -EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 -nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK -dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI -k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 -gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq -yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 -TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 -ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB -b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ -KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP -PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc -8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 -52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox -LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 -HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU -rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF -9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO -AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 -icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 -jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P -cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 -QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG -eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V -gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB -4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV -Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O -szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o -PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf -YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA -HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt -kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM -y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ -HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj -eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S -vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd -kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l -cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE -drqXGjXRtcVMhSRbaBZSV -4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 -0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV -Aef5 -XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA -3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 -RoBzQN0bYJwlioLqwT56oqNY hNBx -qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK -HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw -smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 -raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX -TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k -Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L -BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav -w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI -zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj -9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI -AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY -Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 -B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY -eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe -4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT -3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines.txt b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines.txt deleted file mode 100644 index d6fb16fa7f0..00000000000 --- a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines.txt +++ /dev/null @@ -1,103 +0,0 @@ -xxSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm -vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E -zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ -wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 -KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC -8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj -mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA -BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD -q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 -OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE -vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf -7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD -lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j -vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ -ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ -r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba -lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q -PU5zMN9ghlkBA -nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ -gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA -fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV -Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX -uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J -KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr -qy5YUBNVOrweJj8bdGIQ Y6M5c -kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE -dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS -GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu -oCbgLZuioXwjsO7Hqp2Gcg -BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ -xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al -rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg -BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx -9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI -1M3NvaHNmgYu89HWhuCbaGC54Eu2 -x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 -1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q -Q2CjpU1dpF5f7qohK -6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x -rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf -buZha3wYriOydbTiTRsPvfSXTbrsJ5 -ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC -2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S -EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 -nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK -dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI -k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 -gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq -yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 -TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 -ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB -b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ -KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP -PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc -8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 -52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox -LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 -HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU -rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF -9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO -AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 -icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 -jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P -cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 -QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG -eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V -gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB -4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV -Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O -szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o -PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf -YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA -HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt -kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM -y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ -HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj -eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S -vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd -kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l -cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE -drqXGjXRtcVMhSRbaBZSV -4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 -0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV -Aef5 -XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA -3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 -RoBzQN0bYJwlioLqwT56oqNY hNBx -qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK -HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw -smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 -raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX -TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k -Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L -BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav -w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI -zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj -9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI -AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY -Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 -B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY -eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe -4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT -3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_+2.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_+2.expected deleted file mode 100644 index b7cf0e1ac78..00000000000 --- a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_+2.expected +++ /dev/null @@ -1,103 +0,0 @@ -xSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm -vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E -zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ -wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 -KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC -8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj -mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA -BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD -q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 -OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE -vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf -7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD -lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j -vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ -ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ -r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba -lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q -PU5zMN9ghlkBA -nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ -gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA -fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV -Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX -uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J -KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr -qy5YUBNVOrweJj8bdGIQ Y6M5c -kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE -dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS -GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu -oCbgLZuioXwjsO7Hqp2Gcg -BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ -xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al -rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg -BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx -9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI -1M3NvaHNmgYu89HWhuCbaGC54Eu2 -x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 -1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q -Q2CjpU1dpF5f7qohK -6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x -rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf -buZha3wYriOydbTiTRsPvfSXTbrsJ5 -ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC -2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S -EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 -nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK -dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI -k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 -gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq -yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 -TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 -ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB -b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ -KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP -PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc -8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 -52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox -LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 -HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU -rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF -9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO -AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 -icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 -jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P -cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 -QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG -eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V -gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB -4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV -Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O -szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o -PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf -YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA -HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt -kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM -y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ -HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj -eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S -vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd -kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l -cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE -drqXGjXRtcVMhSRbaBZSV -4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 -0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV -Aef5 -XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA -3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 -RoBzQN0bYJwlioLqwT56oqNY hNBx -qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK -HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw -smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 -raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX -TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k -Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L -BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav -w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI -zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj -9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI -AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY -Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 -B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY -eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe -4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT -3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-1.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-1.expected deleted file mode 100644 index 8b137891791..00000000000 --- a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-1.expected +++ /dev/null @@ -1 +0,0 @@ - diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-8192.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-8192.expected deleted file mode 100644 index b7cf0e1ac78..00000000000 --- a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-8192.expected +++ /dev/null @@ -1,103 +0,0 @@ -xSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm -vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E -zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ -wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 -KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC -8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj -mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA -BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD -q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 -OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE -vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf -7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD -lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j -vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ -ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ -r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba -lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q -PU5zMN9ghlkBA -nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ -gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA -fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV -Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX -uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J -KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr -qy5YUBNVOrweJj8bdGIQ Y6M5c -kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE -dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS -GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu -oCbgLZuioXwjsO7Hqp2Gcg -BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ -xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al -rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg -BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx -9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI -1M3NvaHNmgYu89HWhuCbaGC54Eu2 -x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 -1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q -Q2CjpU1dpF5f7qohK -6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x -rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf -buZha3wYriOydbTiTRsPvfSXTbrsJ5 -ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC -2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S -EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 -nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK -dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI -k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 -gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq -yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 -TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 -ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB -b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ -KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP -PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc -8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 -52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox -LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 -HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU -rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF -9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO -AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 -icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 -jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P -cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 -QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG -eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V -gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB -4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV -Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O -szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o -PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf -YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA -HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt -kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM -y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ -HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj -eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S -vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd -kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l -cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE -drqXGjXRtcVMhSRbaBZSV -4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 -0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV -Aef5 -XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA -3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 -RoBzQN0bYJwlioLqwT56oqNY hNBx -qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK -HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw -smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 -raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX -TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k -Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L -BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav -w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI -zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj -9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI -AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY -Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 -B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY -eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe -4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT -3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_+2.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_+2.expected deleted file mode 100644 index 3797bf0301e..00000000000 --- a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_+2.expected +++ /dev/null @@ -1,102 +0,0 @@ -vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E -zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ -wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 -KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC -8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj -mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA -BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD -q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 -OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE -vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf -7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD -lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j -vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ -ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ -r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba -lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q -PU5zMN9ghlkBA -nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ -gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA -fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV -Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX -uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J -KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr -qy5YUBNVOrweJj8bdGIQ Y6M5c -kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE -dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS -GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu -oCbgLZuioXwjsO7Hqp2Gcg -BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ -xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al -rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg -BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx -9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI -1M3NvaHNmgYu89HWhuCbaGC54Eu2 -x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 -1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q -Q2CjpU1dpF5f7qohK -6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x -rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf -buZha3wYriOydbTiTRsPvfSXTbrsJ5 -ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC -2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S -EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 -nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK -dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI -k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 -gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq -yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 -TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 -ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB -b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ -KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP -PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc -8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 -52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox -LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 -HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU -rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF -9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO -AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 -icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 -jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P -cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 -QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG -eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V -gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB -4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV -Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O -szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o -PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf -YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA -HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt -kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM -y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ -HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj -eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S -vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd -kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l -cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE -drqXGjXRtcVMhSRbaBZSV -4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 -0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV -Aef5 -XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA -3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 -RoBzQN0bYJwlioLqwT56oqNY hNBx -qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK -HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw -smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 -raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX -TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k -Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L -BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav -w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI -zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj -9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI -AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY -Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 -B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY -eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe -4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT -3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-1.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-1.expected deleted file mode 100644 index e9e28bd1608..00000000000 --- a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-1.expected +++ /dev/null @@ -1 +0,0 @@ -3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-102.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-102.expected deleted file mode 100644 index 3797bf0301e..00000000000 --- a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-102.expected +++ /dev/null @@ -1,102 +0,0 @@ -vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E -zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ -wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 -KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC -8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj -mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA -BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD -q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 -OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE -vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf -7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD -lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j -vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ -ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ -r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba -lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q -PU5zMN9ghlkBA -nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ -gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA -fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV -Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX -uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J -KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr -qy5YUBNVOrweJj8bdGIQ Y6M5c -kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE -dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS -GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu -oCbgLZuioXwjsO7Hqp2Gcg -BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ -xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al -rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg -BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx -9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI -1M3NvaHNmgYu89HWhuCbaGC54Eu2 -x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 -1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q -Q2CjpU1dpF5f7qohK -6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x -rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf -buZha3wYriOydbTiTRsPvfSXTbrsJ5 -ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC -2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S -EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 -nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK -dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI -k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 -gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq -yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 -TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 -ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB -b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ -KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP -PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc -8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 -52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox -LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 -HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU -rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF -9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO -AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 -icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 -jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P -cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 -QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG -eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V -gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB -4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV -Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O -szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o -PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf -YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA -HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt -kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM -y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ -HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj -eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S -vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd -kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l -cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE -drqXGjXRtcVMhSRbaBZSV -4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 -0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV -Aef5 -XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA -3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 -RoBzQN0bYJwlioLqwT56oqNY hNBx -qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK -HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw -smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 -raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX -TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k -Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L -BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav -w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI -zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj -9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI -AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY -Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 -B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY -eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe -4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT -3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX From 25a5cb3bbcb4e6d59da5fcbd26e72f2f99370de8 Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Wed, 24 Aug 2022 23:48:56 +0200 Subject: [PATCH 09/29] tail: Fix failing tests because of -Zpanic_abort_tests but unwind used in unit tests --- src/uu/tail/src/chunks.rs | 22 +++++++++++++++------- 1 file changed, 15 insertions(+), 7 deletions(-) diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs index ef8fdffcf3c..e765ab8a5e9 100644 --- a/src/uu/tail/src/chunks.rs +++ b/src/uu/tail/src/chunks.rs @@ -490,18 +490,26 @@ mod tests { } #[test] - fn test_bytes_chunk_from_when_offset_is_larger_than_chunk_size_then_panics() { + #[should_panic] + fn test_bytes_chunk_from_when_offset_is_larger_than_chunk_size_then_panics_1() { let mut chunk = BytesChunk::new(); chunk.bytes = BUFFER_SIZE; - let result = std::panic::catch_unwind(|| BytesChunk::from(&chunk, BUFFER_SIZE + 1)); - assert!(result.is_err()); + BytesChunk::from(&chunk, BUFFER_SIZE + 1); + } + #[test] + #[should_panic] + fn test_bytes_chunk_from_when_offset_is_larger_than_chunk_size_then_panics_2() { + let mut chunk = BytesChunk::new(); chunk.bytes = 0; - let result = std::panic::catch_unwind(|| BytesChunk::from(&chunk, 1)); - assert!(result.is_err()); + BytesChunk::from(&chunk, 1); + } + #[test] + #[should_panic] + fn test_bytes_chunk_from_when_offset_is_larger_than_chunk_size_then_panics_3() { + let mut chunk = BytesChunk::new(); chunk.bytes = 1; - let result = std::panic::catch_unwind(|| BytesChunk::from(&chunk, 2)); - assert!(result.is_err()); + BytesChunk::from(&chunk, 2); } } From f1e568f5822f1797010f5ea8d0b8134f4c2a4801 Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Thu, 25 Aug 2022 01:31:09 +0200 Subject: [PATCH 10/29] tests/tail: Remove test for insufficient memory on 32-bit systems Since we're processing piped stdin in chunks now (fa51fe8f0) this limit doesn't apply anymore. --- tests/by-util/test_tail.rs | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs index 55eb4bef920..ce86c59c714 100644 --- a/tests/by-util/test_tail.rs +++ b/tests/by-util/test_tail.rs @@ -1046,18 +1046,6 @@ fn test_invalid_num() { .fails() .stderr_str() .starts_with("tail: invalid number of lines: '1Y': Value too large for defined data type"); - #[cfg(target_pointer_width = "32")] - { - let sizes = ["1000G", "10T"]; - for size in &sizes { - new_ucmd!() - .args(&["-c", size]) - .fails() - .code_is(1) - .stderr_str() - .starts_with("tail: Insufficient addressable memory"); - } - } new_ucmd!() .args(&["-c", "-³"]) .fails() From 0667d0e54d96ebd1d26ccaf605b12f85c0217b34 Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Thu, 25 Aug 2022 02:46:41 +0200 Subject: [PATCH 11/29] Revert "gitignore: ignore big test fixtures which are used only locally" This reverts commit fc1b94021087ddabe00c41bd483ff88dabaff2cc. --- .gitignore | 2 -- 1 file changed, 2 deletions(-) diff --git a/.gitignore b/.gitignore index 9589b855d61..77e8f717e5e 100644 --- a/.gitignore +++ b/.gitignore @@ -15,5 +15,3 @@ lib*.a *.iml ### macOS ### .DS_Store - -**/*.BIG From 83930ae36229fffa3ee9b8b929ebe8ad6e2bb883 Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Fri, 26 Aug 2022 20:47:53 +0200 Subject: [PATCH 12/29] tail: Fix piped input on windows not recognized as tailable --- src/uu/tail/src/tail.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs index c5f202632ac..cb1ec3e16ce 100644 --- a/src/uu/tail/src/tail.rs +++ b/src/uu/tail/src/tail.rs @@ -437,7 +437,7 @@ fn uu_tail(mut settings: Settings) -> UResult<()> { let metadata = path.metadata().ok(); - if display_name.is_stdin() && path_is_tailable { + if display_name.is_stdin() && (path_is_tailable || settings.stdin_is_pipe_or_fifo) { if settings.verbose { files.print_header(Path::new(text::STDIN_HEADER), !first_header); first_header = false; From 38bc35baa91085644f2ba9c46e23c0c70c455a2f Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Sat, 27 Aug 2022 04:00:45 +0200 Subject: [PATCH 13/29] Revert "tail: Fix piped input on windows not recognized as tailable" This reverts commit 83930ae36229fffa3ee9b8b929ebe8ad6e2bb883. --- src/uu/tail/src/tail.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs index 99bb4a477d7..4a5136ff233 100644 --- a/src/uu/tail/src/tail.rs +++ b/src/uu/tail/src/tail.rs @@ -437,7 +437,7 @@ fn uu_tail(mut settings: Settings) -> UResult<()> { let metadata = path.metadata().ok(); - if display_name.is_stdin() && (path_is_tailable || settings.stdin_is_pipe_or_fifo) { + if display_name.is_stdin() && path_is_tailable { if settings.verbose { files.print_header(Path::new(text::STDIN_HEADER), !first_header); first_header = false; From 284ef3b9ff665d6a8517e0fc8b6cf29600763f48 Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Sat, 27 Aug 2022 05:20:45 +0200 Subject: [PATCH 14/29] tests/tail: Do not execute piped input tests on windows and android targets See also https://github.com/uutils/coreutils/issues/3881 --- tests/by-util/test_tail.rs | 917 +++++++++++++++++++------------------ 1 file changed, 461 insertions(+), 456 deletions(-) diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs index 979b9f3c47d..4cf409854a4 100644 --- a/tests/by-util/test_tail.rs +++ b/tests/by-util/test_tail.rs @@ -9,9 +9,7 @@ extern crate tail; -use crate::common::random::*; use crate::common::util::*; -use rand::distributions::Alphanumeric; use std::char::from_digit; #[cfg(unix)] use std::io::Read; @@ -32,8 +30,6 @@ static FOLLOW_NAME_SHORT_EXP: &str = "follow_name_short.expected"; #[cfg(target_os = "linux")] static FOLLOW_NAME_EXP: &str = "follow_name.expected"; -const CHUNK_BUFFER_SIZE: usize = 8192; - #[test] #[cfg(all(unix, not(target_os = "android")))] // FIXME: fix this test for Android fn test_stdin_default() { @@ -2428,504 +2424,513 @@ fn test_illegal_seek() { assert_eq!(p.wait().unwrap().code().unwrap(), 1); } -#[test] -fn test_pipe_when_lines_option_value_is_higher_than_contained_lines() { - let test_string = "a\nb\n"; - new_ucmd!() - .args(&["-n", "3"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(test_string); - new_ucmd!() - .args(&["-n", "4"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(test_string); - new_ucmd!() - .args(&["-n", "999"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(test_string); - new_ucmd!() - .args(&["-n", "+3"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(""); - new_ucmd!() - .args(&["-n", "+4"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(""); - new_ucmd!() - .args(&["-n", "+999"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(""); -} +#[cfg(all(not(target_os = "android"), not(target_os = "windows")))] // FIXME: See https://github.com/uutils/coreutils/issues/3881 +mod pipe_tests { + use super::*; + use crate::common::random::*; + use rand::distributions::Alphanumeric; + const CHUNK_BUFFER_SIZE: usize = 8192; -#[test] -fn test_pipe_when_negative_lines_option_given_no_newline_at_eof() { - let test_string = "a\nb"; - new_ucmd!() - .args(&["-n", "0"]) - .pipe_in(test_string) - .succeeds() - .no_stdout() - .no_stderr(); - new_ucmd!() - .args(&["-n", "1"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("b"); - new_ucmd!() - .args(&["-n", "2"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("a\nb"); -} + #[test] + fn test_pipe_when_lines_option_value_is_higher_than_contained_lines() { + let test_string = "a\nb\n"; + new_ucmd!() + .args(&["-n", "3"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-n", "4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-n", "999"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-n", "+3"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-n", "+4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-n", "+999"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + } -#[test] -fn test_pipe_when_positive_lines_option_given_no_newline_at_eof() { - let test_string = "a\nb"; - new_ucmd!() - .args(&["-n", "+0"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("a\nb"); - new_ucmd!() - .args(&["-n", "+1"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("a\nb"); - new_ucmd!() - .args(&["-n", "+2"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("b"); -} + #[test] + fn test_pipe_when_negative_lines_option_given_no_newline_at_eof() { + let test_string = "a\nb"; + new_ucmd!() + .args(&["-n", "0"]) + .pipe_in(test_string) + .succeeds() + .no_stdout() + .no_stderr(); + new_ucmd!() + .args(&["-n", "1"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("b"); + new_ucmd!() + .args(&["-n", "2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a\nb"); + } -#[test] -fn test_pipe_when_lines_option_given_multibyte_utf8_characters() { - // the test string consists of from left to right a 4-byte,3-byte,2-byte,1-byte utf-8 character - let test_string = "𝅘𝅥𝅮\n⏻\nƒ\na"; - new_ucmd!() - .args(&["-n", "+0"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(test_string); - new_ucmd!() - .args(&["-n", "+2"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("⏻\nƒ\na"); - new_ucmd!() - .args(&["-n", "+3"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("ƒ\na"); - new_ucmd!() - .args(&["-n", "+4"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("a"); - new_ucmd!() - .args(&["-n", "+5"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(""); - new_ucmd!() - .args(&["-n", "-4"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(test_string); - new_ucmd!() - .args(&["-n", "-3"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("⏻\nƒ\na"); - new_ucmd!() - .args(&["-n", "-2"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("ƒ\na"); - new_ucmd!() - .args(&["-n", "-1"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("a"); - new_ucmd!() - .args(&["-n", "-0"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(""); -} + #[test] + fn test_pipe_when_positive_lines_option_given_no_newline_at_eof() { + let test_string = "a\nb"; + new_ucmd!() + .args(&["-n", "+0"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a\nb"); + new_ucmd!() + .args(&["-n", "+1"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a\nb"); + new_ucmd!() + .args(&["-n", "+2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("b"); + } -#[test] -fn test_pipe_when_lines_option_given_input_size_is_equal_to_buffer_size() { - let total_lines = 100; - let random_string = RandomString::generate_with_delimiter( - Alphanumeric, - b'\n', - total_lines, - true, - CHUNK_BUFFER_SIZE, - ); - let random_string = random_string.as_str(); - let lines = random_string.split_inclusive('\n'); + #[test] + fn test_pipe_when_lines_option_given_multibyte_utf8_characters() { + // the test string consists of from left to right a 4-byte,3-byte,2-byte,1-byte utf-8 character + let test_string = "𝅘𝅥𝅮\n⏻\nƒ\na"; + new_ucmd!() + .args(&["-n", "+0"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-n", "+2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("⏻\nƒ\na"); + new_ucmd!() + .args(&["-n", "+3"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("ƒ\na"); + new_ucmd!() + .args(&["-n", "+4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a"); + new_ucmd!() + .args(&["-n", "+5"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-n", "-4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-n", "-3"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("⏻\nƒ\na"); + new_ucmd!() + .args(&["-n", "-2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("ƒ\na"); + new_ucmd!() + .args(&["-n", "-1"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a"); + new_ucmd!() + .args(&["-n", "-0"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + } - new_ucmd!() - .args(&["-n", "+0"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(random_string); + #[test] + fn test_pipe_when_lines_option_given_input_size_is_equal_to_buffer_size() { + let total_lines = 100; + let random_string = RandomString::generate_with_delimiter( + Alphanumeric, + b'\n', + total_lines, + true, + CHUNK_BUFFER_SIZE, + ); + let random_string = random_string.as_str(); + let lines = random_string.split_inclusive('\n'); - let expected = lines.clone().skip(1).collect::(); - new_ucmd!() - .args(&["-n", "+2"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(expected); + new_ucmd!() + .args(&["-n", "+0"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(random_string); - new_ucmd!() - .args(&["-n", "-0"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(""); + let expected = lines.clone().skip(1).collect::(); + new_ucmd!() + .args(&["-n", "+2"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(expected); - let expected = lines.clone().skip(total_lines - 1).collect::(); - new_ucmd!() - .args(&["-n", "-1"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(expected); + new_ucmd!() + .args(&["-n", "-0"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(""); - let expected = lines.clone().skip(1).collect::(); - new_ucmd!() - .args(&["-n", "-99"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(expected); + let expected = lines.clone().skip(total_lines - 1).collect::(); + new_ucmd!() + .args(&["-n", "-1"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(expected); - new_ucmd!() - .args(&["-n", "-100"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(random_string); -} + let expected = lines.clone().skip(1).collect::(); + new_ucmd!() + .args(&["-n", "-99"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(expected); -#[test] -fn test_pipe_when_lines_option_given_input_size_is_one_byte_greater_than_buffer_size() { - let total_lines = 100; - let random_string = RandomString::generate_with_delimiter( - Alphanumeric, - b'\n', - total_lines, - true, - CHUNK_BUFFER_SIZE + 1, - ); - let random_string = random_string.as_str(); - let lines = random_string.split_inclusive('\n'); + new_ucmd!() + .args(&["-n", "-100"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(random_string); + } - new_ucmd!() - .args(&["-n", "+0"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(random_string); + #[test] + fn test_pipe_when_lines_option_given_input_size_is_one_byte_greater_than_buffer_size() { + let total_lines = 100; + let random_string = RandomString::generate_with_delimiter( + Alphanumeric, + b'\n', + total_lines, + true, + CHUNK_BUFFER_SIZE + 1, + ); + let random_string = random_string.as_str(); + let lines = random_string.split_inclusive('\n'); - let expected = lines.clone().skip(total_lines - 1).collect::(); - new_ucmd!() - .args(&["-n", "-1"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(expected); + new_ucmd!() + .args(&["-n", "+0"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(random_string); - let expected = lines.clone().skip(1).collect::(); - new_ucmd!() - .args(&["-n", "+2"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(expected); + let expected = lines.clone().skip(total_lines - 1).collect::(); + new_ucmd!() + .args(&["-n", "-1"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(expected); - let expected = lines.clone().skip(1).collect::(); - new_ucmd!() - .args(&["-n", "-99"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(expected); -} + let expected = lines.clone().skip(1).collect::(); + new_ucmd!() + .args(&["-n", "+2"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(expected); -#[test] -fn test_pipe_when_bytes_option_value_is_higher_than_contained_bytes() { - let test_string = "a\nb"; - new_ucmd!() - .args(&["-c", "4"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(test_string); - new_ucmd!() - .args(&["-c", "5"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(test_string); - new_ucmd!() - .args(&["-c", "999"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(test_string); - new_ucmd!() - .args(&["-c", "+4"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(""); - new_ucmd!() - .args(&["-c", "+5"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(""); - new_ucmd!() - .args(&["-c", "+999"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(""); -} + let expected = lines.clone().skip(1).collect::(); + new_ucmd!() + .args(&["-n", "-99"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(expected); + } -#[test] -fn test_pipe_when_bytes_option_given_multibyte_utf8_characters() { - // the test string consists of from left to right a 4-byte,3-byte,2-byte,1-byte utf-8 character - let test_string = "𝅘𝅥𝅮⏻ƒa"; - new_ucmd!() - .args(&["-c", "+0"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(test_string); - new_ucmd!() - .args(&["-c", "+2"]) - .pipe_in(test_string) - .succeeds() - .stdout_only_bytes(&test_string.as_bytes()[1..]); - new_ucmd!() - .args(&["-c", "+5"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("⏻ƒa"); - new_ucmd!() - .args(&["-c", "+8"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("ƒa"); - new_ucmd!() - .args(&["-c", "+10"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("a"); - new_ucmd!() - .args(&["-c", "+11"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(""); - new_ucmd!() - .args(&["-c", "-1"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("a"); - new_ucmd!() - .args(&["-c", "-2"]) - .pipe_in(test_string) - .succeeds() - .stdout_only_bytes(&"ƒa".as_bytes()[1..]); - new_ucmd!() - .args(&["-c", "-3"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("ƒa"); - new_ucmd!() - .args(&["-c", "-6"]) - .pipe_in(test_string) - .succeeds() - .stdout_only("⏻ƒa"); - new_ucmd!() - .args(&["-c", "-10"]) - .pipe_in(test_string) - .succeeds() - .stdout_only(test_string); -} + #[test] + fn test_pipe_when_bytes_option_value_is_higher_than_contained_bytes() { + let test_string = "a\nb"; + new_ucmd!() + .args(&["-c", "4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-c", "5"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-c", "999"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-c", "+4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-c", "+5"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-c", "+999"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + } -#[test] -fn test_pipe_when_bytes_option_given_input_size_is_equal_to_buffer_size() { - let random_string = RandomString::generate(AlphanumericNewline, CHUNK_BUFFER_SIZE); - let random_string = random_string.as_str(); + #[test] + fn test_pipe_when_bytes_option_given_multibyte_utf8_characters() { + // the test string consists of from left to right a 4-byte,3-byte,2-byte,1-byte utf-8 character + let test_string = "𝅘𝅥𝅮⏻ƒa"; + new_ucmd!() + .args(&["-c", "+0"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-c", "+2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only_bytes(&test_string.as_bytes()[1..]); + new_ucmd!() + .args(&["-c", "+5"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("⏻ƒa"); + new_ucmd!() + .args(&["-c", "+8"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("ƒa"); + new_ucmd!() + .args(&["-c", "+10"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a"); + new_ucmd!() + .args(&["-c", "+11"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-c", "-1"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a"); + new_ucmd!() + .args(&["-c", "-2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only_bytes(&"ƒa".as_bytes()[1..]); + new_ucmd!() + .args(&["-c", "-3"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("ƒa"); + new_ucmd!() + .args(&["-c", "-6"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("⏻ƒa"); + new_ucmd!() + .args(&["-c", "-10"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + } - new_ucmd!() - .args(&["-c", "+0"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(random_string); + #[test] + fn test_pipe_when_bytes_option_given_input_size_is_equal_to_buffer_size() { + let random_string = RandomString::generate(AlphanumericNewline, CHUNK_BUFFER_SIZE); + let random_string = random_string.as_str(); - let expected = &random_string.as_bytes()[1..]; - new_ucmd!() - .args(&["-c", "+2"]) - .pipe_in(random_string) - .succeeds() - .stdout_only_bytes(expected); + new_ucmd!() + .args(&["-c", "+0"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(random_string); - new_ucmd!() - .args(&["-c", "-0"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(""); + let expected = &random_string.as_bytes()[1..]; + new_ucmd!() + .args(&["-c", "+2"]) + .pipe_in(random_string) + .succeeds() + .stdout_only_bytes(expected); - let expected = &random_string.as_bytes()[1..]; - new_ucmd!() - .args(&["-c", "-8191"]) - .pipe_in(random_string) - .succeeds() - .stdout_only_bytes(expected); + new_ucmd!() + .args(&["-c", "-0"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(""); - new_ucmd!() - .args(&["-c", "-8192"]) - .pipe_in(random_string) - .succeeds() - .stdout_only_bytes(random_string); + let expected = &random_string.as_bytes()[1..]; + new_ucmd!() + .args(&["-c", "-8191"]) + .pipe_in(random_string) + .succeeds() + .stdout_only_bytes(expected); - new_ucmd!() - .args(&["-c", "-8193"]) - .pipe_in(random_string) - .succeeds() - .stdout_only_bytes(random_string); + new_ucmd!() + .args(&["-c", "-8192"]) + .pipe_in(random_string) + .succeeds() + .stdout_only_bytes(random_string); - let expected = &random_string.as_bytes()[CHUNK_BUFFER_SIZE - 1..]; - new_ucmd!() - .args(&["-c", "-1"]) - .pipe_in(random_string) - .succeeds() - .stdout_only_bytes(expected); -} + new_ucmd!() + .args(&["-c", "-8193"]) + .pipe_in(random_string) + .succeeds() + .stdout_only_bytes(random_string); -#[test] -fn test_pipe_when_bytes_option_given_input_size_is_one_byte_greater_than_buffer_size() { - let random_string = RandomString::generate(AlphanumericNewline, CHUNK_BUFFER_SIZE + 1); - let random_string = random_string.as_str(); + let expected = &random_string.as_bytes()[CHUNK_BUFFER_SIZE - 1..]; + new_ucmd!() + .args(&["-c", "-1"]) + .pipe_in(random_string) + .succeeds() + .stdout_only_bytes(expected); + } - new_ucmd!() - .args(&["-c", "+0"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(random_string); + #[test] + fn test_pipe_when_bytes_option_given_input_size_is_one_byte_greater_than_buffer_size() { + let random_string = RandomString::generate(AlphanumericNewline, CHUNK_BUFFER_SIZE + 1); + let random_string = random_string.as_str(); - let expected = &random_string.as_bytes()[1..]; - new_ucmd!() - .args(&["-c", "+2"]) - .pipe_in(random_string) - .succeeds() - .stdout_only_bytes(expected); + new_ucmd!() + .args(&["-c", "+0"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(random_string); - new_ucmd!() - .args(&["-c", "-0"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(""); + let expected = &random_string.as_bytes()[1..]; + new_ucmd!() + .args(&["-c", "+2"]) + .pipe_in(random_string) + .succeeds() + .stdout_only_bytes(expected); - let expected = &random_string.as_bytes()[CHUNK_BUFFER_SIZE..]; - new_ucmd!() - .args(&["-c", "-1"]) - .pipe_in(random_string) - .succeeds() - .stdout_only_bytes(expected); + new_ucmd!() + .args(&["-c", "-0"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(""); - let expected = &random_string.as_bytes()[1..]; - new_ucmd!() - .args(&["-c", "-8192"]) - .pipe_in(random_string) - .succeeds() - .stdout_only_bytes(expected); + let expected = &random_string.as_bytes()[CHUNK_BUFFER_SIZE..]; + new_ucmd!() + .args(&["-c", "-1"]) + .pipe_in(random_string) + .succeeds() + .stdout_only_bytes(expected); - new_ucmd!() - .args(&["-c", "-8193"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(random_string); -} + let expected = &random_string.as_bytes()[1..]; + new_ucmd!() + .args(&["-c", "-8192"]) + .pipe_in(random_string) + .succeeds() + .stdout_only_bytes(expected); -#[test] -fn test_pipe_when_bytes_option_given_input_size_has_multiple_size_of_buffer_size() { - let random_string = RandomString::generate(AlphanumericNewline, CHUNK_BUFFER_SIZE * 3); - let random_string = random_string.as_str(); + new_ucmd!() + .args(&["-c", "-8193"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(random_string); + } - new_ucmd!() - .args(&["-c", "+0"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(random_string); + #[test] + fn test_pipe_when_bytes_option_given_input_size_has_multiple_size_of_buffer_size() { + let random_string = RandomString::generate(AlphanumericNewline, CHUNK_BUFFER_SIZE * 3); + let random_string = random_string.as_str(); - new_ucmd!() - .args(&["-c", "-0"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(""); + new_ucmd!() + .args(&["-c", "+0"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(random_string); - let expected = &random_string.as_bytes()[8192..]; - new_ucmd!() - .args(&["-c", "+8193"]) - .pipe_in(random_string) - .succeeds() - .stdout_only_bytes(expected); + new_ucmd!() + .args(&["-c", "-0"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(""); - let expected = &random_string.as_bytes()[8193..]; - new_ucmd!() - .args(&["-c", "+8194"]) - .pipe_in(random_string) - .succeeds() - .stdout_only_bytes(expected); + let expected = &random_string.as_bytes()[8192..]; + new_ucmd!() + .args(&["-c", "+8193"]) + .pipe_in(random_string) + .succeeds() + .stdout_only_bytes(expected); - let expected = &random_string.as_bytes()[16384..]; - new_ucmd!() - .args(&["-c", "+16385"]) - .pipe_in(random_string) - .succeeds() - .stdout_only_bytes(expected); + let expected = &random_string.as_bytes()[8193..]; + new_ucmd!() + .args(&["-c", "+8194"]) + .pipe_in(random_string) + .succeeds() + .stdout_only_bytes(expected); - let expected = &random_string.as_bytes()[16385..]; - new_ucmd!() - .args(&["-c", "+16386"]) - .pipe_in(random_string) - .succeeds() - .stdout_only_bytes(expected); + let expected = &random_string.as_bytes()[16384..]; + new_ucmd!() + .args(&["-c", "+16385"]) + .pipe_in(random_string) + .succeeds() + .stdout_only_bytes(expected); - let expected = &random_string.as_bytes()[16384..]; - new_ucmd!() - .args(&["-c", "-8192"]) - .pipe_in(random_string) - .succeeds() - .stdout_only_bytes(expected); + let expected = &random_string.as_bytes()[16385..]; + new_ucmd!() + .args(&["-c", "+16386"]) + .pipe_in(random_string) + .succeeds() + .stdout_only_bytes(expected); - let expected = &random_string.as_bytes()[16383..]; - new_ucmd!() - .args(&["-c", "-8193"]) - .pipe_in(random_string) - .succeeds() - .stdout_only_bytes(expected); + let expected = &random_string.as_bytes()[16384..]; + new_ucmd!() + .args(&["-c", "-8192"]) + .pipe_in(random_string) + .succeeds() + .stdout_only_bytes(expected); - let expected = &random_string.as_bytes()[8192..]; - new_ucmd!() - .args(&["-c", "-16384"]) - .pipe_in(random_string) - .succeeds() - .stdout_only_bytes(expected); + let expected = &random_string.as_bytes()[16383..]; + new_ucmd!() + .args(&["-c", "-8193"]) + .pipe_in(random_string) + .succeeds() + .stdout_only_bytes(expected); - let expected = &random_string.as_bytes()[8191..]; - new_ucmd!() - .args(&["-c", "-16385"]) - .pipe_in(random_string) - .succeeds() - .stdout_only_bytes(expected); + let expected = &random_string.as_bytes()[8192..]; + new_ucmd!() + .args(&["-c", "-16384"]) + .pipe_in(random_string) + .succeeds() + .stdout_only_bytes(expected); - new_ucmd!() - .args(&["-c", "-24576"]) - .pipe_in(random_string) - .succeeds() - .stdout_only(random_string); + let expected = &random_string.as_bytes()[8191..]; + new_ucmd!() + .args(&["-c", "-16385"]) + .pipe_in(random_string) + .succeeds() + .stdout_only_bytes(expected); + + new_ucmd!() + .args(&["-c", "-24576"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(random_string); + } } +#[test] fn test_seek_bytes_backward_outside_file() { new_ucmd!() .arg("-c") From 76677fe5eefa9544bfcb5ce157edffdf7fc8faef Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Sat, 27 Aug 2022 15:17:20 +0200 Subject: [PATCH 15/29] tail/chunks: Adjust BytesChunk.from_chunk() to behave like LinesChunk.from_chunk() --- src/uu/tail/src/chunks.rs | 95 ++++++++++++++++++++++++++++++--------- 1 file changed, 73 insertions(+), 22 deletions(-) diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs index e765ab8a5e9..dbe2ef1a0b4 100644 --- a/src/uu/tail/src/chunks.rs +++ b/src/uu/tail/src/chunks.rs @@ -110,11 +110,37 @@ impl BytesChunk { } } - fn from(chunk: &Self, offset: usize) -> Self { - assert!( - offset <= chunk.bytes, - "offset may not be larger than the chunk size" - ); + /// Create a new chunk from an existing chunk. The new chunk's buffer will be copied from the + /// old chunk's buffer, copying the slice `[offset..old_chunk.bytes]` into the new chunk's + /// buffer but starting at 0 instead of offset. If the offset is larger or equal to + /// `chunk.lines` then a new empty `BytesChunk` is returned. + /// + /// # Arguments + /// + /// * `chunk`: The chunk to create a new `BytesChunk` chunk from + /// * `offset`: Start to copy the old chunk's buffer from this position. May not be larger + /// than `chunk.bytes`. + /// + /// returns: BytesChunk + /// + /// # Examples + /// + /// ```rust,ignore + /// let mut chunk = BytesChunk::new(); + /// chunk.buffer[1] = 1; + /// chunk.bytes = 2; + /// let new_chunk = BytesChunk::from_chunk(&chunk, 0); + /// assert_eq!(2, new_chunk.get_buffer().len()); + /// assert_eq!(&[0, 1], new_chunk.get_buffer()); + /// + /// let new_chunk = BytesChunk::from_chunk(&chunk, 1); + /// assert_eq!(1, new_chunk.get_buffer().len()); + /// assert_eq!(&[1], new_chunk.get_buffer()); + /// ``` + fn from_chunk(chunk: &Self, offset: usize) -> Self { + if offset >= chunk.bytes { + Self::new(); + } let mut buffer: ChunkBuffer = [0; BUFFER_SIZE]; let slice = chunk.get_buffer_with(offset); @@ -233,7 +259,7 @@ impl BytesChunkBuffer { }; self.chunks - .push_front(Box::new(BytesChunk::from(&chunk, offset))); + .push_front(Box::new(BytesChunk::from_chunk(&chunk, offset))); Ok(self.chunks.iter()) } @@ -287,6 +313,8 @@ impl LinesChunk { /// assert_eq!("world\n".as_bytes(), new_chunk.get_buffer()); /// assert_eq!(6, new_chunk.bytes); /// assert_eq!(1, new_chunk.lines); + /// + /// let offset = 13; // offset larger /// ``` fn from_chunk(chunk: &Self, offset: usize) -> Self { if offset >= chunk.lines { @@ -447,27 +475,27 @@ impl LinesChunkBuffer { #[cfg(test)] mod tests { - use crate::chunks::{BytesChunk, BUFFER_SIZE}; + use crate::chunks::{BytesChunk, ChunkBuffer, BUFFER_SIZE}; #[test] fn test_bytes_chunk_from_when_offset_is_zero() { let mut chunk = BytesChunk::new(); chunk.bytes = BUFFER_SIZE; chunk.buffer[1] = 1; - let other = BytesChunk::from(&chunk, 0); + let other = BytesChunk::from_chunk(&chunk, 0); assert_eq!(other, chunk); chunk.bytes = 2; - let other = BytesChunk::from(&chunk, 0); + let other = BytesChunk::from_chunk(&chunk, 0); assert_eq!(other, chunk); chunk.bytes = 1; - let other = BytesChunk::from(&chunk, 0); + let other = BytesChunk::from_chunk(&chunk, 0); assert_eq!(other.buffer, [0; BUFFER_SIZE]); assert_eq!(other.bytes, chunk.bytes); chunk.bytes = BUFFER_SIZE; - let other = BytesChunk::from(&chunk, 2); + let other = BytesChunk::from_chunk(&chunk, 2); assert_eq!(other.buffer, [0; BUFFER_SIZE]); assert_eq!(other.bytes, BUFFER_SIZE - 2); } @@ -478,38 +506,61 @@ mod tests { chunk.bytes = BUFFER_SIZE; chunk.buffer[1] = 1; - let other = BytesChunk::from(&chunk, 1); + let other = BytesChunk::from_chunk(&chunk, 1); let mut expected_buffer = [0; BUFFER_SIZE]; expected_buffer[0] = 1; assert_eq!(other.buffer, expected_buffer); assert_eq!(other.bytes, BUFFER_SIZE - 1); - let other = BytesChunk::from(&chunk, 2); + let other = BytesChunk::from_chunk(&chunk, 2); assert_eq!(other.buffer, [0; BUFFER_SIZE]); assert_eq!(other.bytes, BUFFER_SIZE - 2); } #[test] - #[should_panic] - fn test_bytes_chunk_from_when_offset_is_larger_than_chunk_size_then_panics_1() { + fn test_bytes_chunk_from_when_offset_is_larger_than_chunk_size_1() { let mut chunk = BytesChunk::new(); chunk.bytes = BUFFER_SIZE; - BytesChunk::from(&chunk, BUFFER_SIZE + 1); + let new_chunk = BytesChunk::from_chunk(&chunk, BUFFER_SIZE + 1); + assert_eq!(0, new_chunk.bytes); } #[test] - #[should_panic] - fn test_bytes_chunk_from_when_offset_is_larger_than_chunk_size_then_panics_2() { + fn test_bytes_chunk_from_when_offset_is_larger_than_chunk_size_2() { let mut chunk = BytesChunk::new(); chunk.bytes = 0; - BytesChunk::from(&chunk, 1); + let new_chunk = BytesChunk::from_chunk(&chunk, 1); + assert_eq!(0, new_chunk.bytes); } #[test] - #[should_panic] - fn test_bytes_chunk_from_when_offset_is_larger_than_chunk_size_then_panics_3() { + fn test_bytes_chunk_from_when_offset_is_larger_than_chunk_size_3() { let mut chunk = BytesChunk::new(); chunk.bytes = 1; - BytesChunk::from(&chunk, 2); + let new_chunk = BytesChunk::from_chunk(&chunk, 2); + assert_eq!(0, new_chunk.bytes); + } + + #[test] + fn test_bytes_chunk_from_when_offset_is_equal_to_chunk_size() { + let mut chunk = BytesChunk::new(); + chunk.buffer[0] = 1; + chunk.bytes = 1; + let new_chunk = BytesChunk::from_chunk(&chunk, 1); + assert_eq!(0, new_chunk.bytes); + } + + #[test] + fn example() { + let mut chunk = BytesChunk::new(); + chunk.buffer[1] = 1; + chunk.bytes = 2; + let new_chunk = BytesChunk::from_chunk(&chunk, 0); + assert_eq!(2, new_chunk.get_buffer().len()); + assert_eq!(&[0, 1], new_chunk.get_buffer()); + + let new_chunk = BytesChunk::from_chunk(&chunk, 1); + assert_eq!(1, new_chunk.get_buffer().len()); + assert_eq!(&[1], new_chunk.get_buffer()); } } From 980ce07c4d279234338de4d4ba5d1a24bfb8498b Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Sat, 27 Aug 2022 17:01:46 +0200 Subject: [PATCH 16/29] tail/chunks: Fix missing return in in BytesChunk::from_chunk and LinesChunk::from_chunk --- src/uu/tail/src/chunks.rs | 20 +++----------------- 1 file changed, 3 insertions(+), 17 deletions(-) diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs index dbe2ef1a0b4..aecfcf5dc19 100644 --- a/src/uu/tail/src/chunks.rs +++ b/src/uu/tail/src/chunks.rs @@ -139,7 +139,7 @@ impl BytesChunk { /// ``` fn from_chunk(chunk: &Self, offset: usize) -> Self { if offset >= chunk.bytes { - Self::new(); + return Self::new(); } let mut buffer: ChunkBuffer = [0; BUFFER_SIZE]; @@ -318,7 +318,7 @@ impl LinesChunk { /// ``` fn from_chunk(chunk: &Self, offset: usize) -> Self { if offset >= chunk.lines { - Self::new(chunk.delimiter); + return Self::new(chunk.delimiter); } let mut buffer: ChunkBuffer = [0; BUFFER_SIZE]; @@ -475,7 +475,7 @@ impl LinesChunkBuffer { #[cfg(test)] mod tests { - use crate::chunks::{BytesChunk, ChunkBuffer, BUFFER_SIZE}; + use crate::chunks::{BytesChunk, BUFFER_SIZE}; #[test] fn test_bytes_chunk_from_when_offset_is_zero() { @@ -549,18 +549,4 @@ mod tests { let new_chunk = BytesChunk::from_chunk(&chunk, 1); assert_eq!(0, new_chunk.bytes); } - - #[test] - fn example() { - let mut chunk = BytesChunk::new(); - chunk.buffer[1] = 1; - chunk.bytes = 2; - let new_chunk = BytesChunk::from_chunk(&chunk, 0); - assert_eq!(2, new_chunk.get_buffer().len()); - assert_eq!(&[0, 1], new_chunk.get_buffer()); - - let new_chunk = BytesChunk::from_chunk(&chunk, 1); - assert_eq!(1, new_chunk.get_buffer().len()); - assert_eq!(&[1], new_chunk.get_buffer()); - } } From 17de1a2e78b5cda2ca4f89694bb3c2ac91f87c07 Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Sat, 27 Aug 2022 17:01:57 +0200 Subject: [PATCH 17/29] tail/chunks: Add documentation for BytesChunk, LinesChunk etc. --- src/uu/tail/src/chunks.rs | 193 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 186 insertions(+), 7 deletions(-) diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs index aecfcf5dc19..c87bfc17d56 100644 --- a/src/uu/tail/src/chunks.rs +++ b/src/uu/tail/src/chunks.rs @@ -93,12 +93,20 @@ impl<'a> Iterator for ReverseChunks<'a> { } } -/// The type of the backing buffer of the BytesChunk and LinesChunk structs. +/// The type of the backing buffer of [`BytesChunk`] and [`LinesChunk`] which can hold +/// [`BUFFER_SIZE`] elements at max. type ChunkBuffer = [u8; BUFFER_SIZE]; +/// A [`BytesChunk`] storing a fixed size number of bytes in a buffer. #[derive(Clone, PartialEq, Eq, Debug)] pub struct BytesChunk { + /// The [`ChunkBuffer`], an array storing the bytes, for example filled by + /// [`BytesChunk::fill`] buffer: ChunkBuffer, + + /// Stores the number of bytes, this buffer holds. This is not equal to buffer.len(), since the + /// [`BytesChunk`] may store less bytes than the internal buffer can hold. In addition + /// [`BytesChunk`] may be reused, what makes it necessary to track the number of stored bytes. bytes: usize, } @@ -151,14 +159,47 @@ impl BytesChunk { } } + /// Receive the internal buffer safely, so it returns a slice only containing as many bytes as + /// large the `self.bytes` value is. + /// + /// returns: a slice containing the bytes of the internal buffer from `[0..self.bytes]` + /// + /// # Examples + /// + /// ```rust,ignore + /// let mut chunk = BytesChunk::new(); + /// chunk.bytes = 1; + /// assert_eq!(&[0], chunk.get_buffer()); + /// ``` pub(crate) fn get_buffer(&self) -> &[u8] { &self.buffer[..self.bytes] } + /// Like [`BytesChunk::get_buffer`], but returning a slice from `[offset.self.bytes]`. + /// + /// returns: a slice containing the bytes of the internal buffer from `[offset..self.bytes]` + /// + /// # Examples + /// + /// ```rust,ignore + /// let mut chunk = BytesChunk::new(); + /// chunk.bytes = 2; + /// assert_eq!(&[0], chunk.get_buffer_with(1)); + /// ``` pub(crate) fn get_buffer_with(&self, offset: usize) -> &[u8] { &self.buffer[offset..self.bytes] } + /// Fills this [`buffer`](Self::buffer) with maximal [`BUFFER_SIZE`] number of bytes, draining the reader by that + /// number of bytes. If EOF is reached (so 0 bytes are read), then returns [`UResult`] or + /// else the result with [`Some(bytes)`] where bytes is the number of bytes read from the + /// source. + /// + /// # Arguments + /// + /// * `filehandle`: A [`BufReader`], where the inner must implement [`Read`] + /// + /// returns: `Result, Box>` pub(crate) fn fill(&mut self, filehandle: &mut BufReader) -> UResult> { let num_bytes = filehandle.read(&mut self.buffer)?; self.bytes = num_bytes; @@ -170,13 +211,40 @@ impl BytesChunk { } } +/// An abstraction layer on top of [`BytesChunk`] mainly to simplify filling only the needed amount +/// of chunks. See also [`Self::fill`]. pub(crate) struct BytesChunkBuffer { + /// The number of bytes to print num_print: u64, + /// The current number of bytes summed over all stored chunks in [`Self::chunks`] bytes: u64, + /// The buffer to store [`BytesChunk`] in chunks: VecDeque>, } impl BytesChunkBuffer { + /// Creates a new [`BytesChunkBuffer`]. + /// + /// # Arguments + /// + /// * `num_print`: The number of bytes to print + /// + /// returns: BytesChunk + /// + /// # Examples + /// + /// ```rust,ignore + /// let mut chunk = BytesChunk::new(); + /// chunk.buffer[1] = 1; + /// chunk.bytes = 2; + /// let new_chunk = BytesChunk::from_chunk(&chunk, 0); + /// assert_eq!(2, new_chunk.get_buffer().len()); + /// assert_eq!(&[0, 1], new_chunk.get_buffer()); + /// + /// let new_chunk = BytesChunk::from_chunk(&chunk, 1); + /// assert_eq!(1, new_chunk.get_buffer().len()); + /// assert_eq!(&[1], new_chunk.get_buffer()); + /// ``` pub(crate) fn new(num_print: u64) -> Self { Self { bytes: 0, @@ -185,15 +253,15 @@ impl BytesChunkBuffer { } } - /// Fills the chunks collection with chunks and consumes the reader completely. This method - /// ensures that there are exactly as many chunks as needed to match `self.num_print` bytes, so - /// there are in sum exactly `self.num_print` bytes stored in all chunks. The method returns - /// an iterator over these chunks. If there are no chunks, for example because the piped stdin - /// contained no bytes, or `num_print = 0` then `iterator.next` returns None. + /// Fills this buffer with chunks and consumes the reader completely. This method ensures that + /// there are exactly as many chunks as needed to match [`Self::num_print`] bytes, so there are in + /// sum exactly `self.num_print` bytes stored in all chunks. The method returns an iterator over + /// these chunks. If there are no chunks, for example because the piped stdin contained no + /// bytes, or `num_print = 0` then `iterator.next` returns None. /// /// # Arguments /// - /// * `reader`: A buffered reader with an inner element implementing the [`Read`] trait. + /// * `reader`: A [`BufReader`] with an inner element implementing the [`Read`] trait. /// /// returns: Result>, Box> /// @@ -265,10 +333,16 @@ impl BytesChunkBuffer { } } +/// Works similar to a [`BytesChunk`] but also stores the number of lines encountered in the current +/// buffer. The size of the buffer is limited to a fixed size number of bytes (See [`ChunkBuffer`]) pub(crate) struct LinesChunk { + /// The [`ChunkBuffer`] to store the bytes buffer: ChunkBuffer, + /// The number of bytes stored in the buffer bytes: usize, + /// The number of lines delimited by `delimiter` lines: usize, + /// The delimiter to use, to count the lines delimiter: u8, } @@ -282,6 +356,22 @@ impl LinesChunk { } } + /// Count the number of lines delimited with [`Self::delimiter`] contained in the buffer. + /// Currently [`memchr`] is used because performance is better than using an iterator or for + /// loop. + /// + /// # Examples + /// + /// ```rust,ignore + /// let mut chunk = LinesChunk::new(b'\n'); + /// chunk.buffer[0..12].copy_from_slice("hello\nworld\n".as_bytes()); + /// chunk.bytes = 12; + /// assert_eq!(2, chunk.count_lines()); + /// + /// chunk.buffer[0..14].copy_from_slice("hello\r\nworld\r\n".as_bytes()); + /// chunk.bytes = 14; + /// assert_eq!(2, chunk.count_lines()); + /// ``` fn count_lines(&self) -> usize { memchr::memchr_iter(self.delimiter, self.get_buffer()).count() } @@ -335,27 +425,61 @@ impl LinesChunk { } } + /// Returns true if this buffer has stored any bytes. + /// + /// # Examples + /// + /// ```rust,ignore + /// let mut chunk = LinesChunk::new(b'\n'); + /// assert!(!chunk.has_data()); + /// + /// chunk.buffer[0] = 1; + /// assert!(!chunk.has_data()); + /// + /// chunk.bytes = 1; + /// assert!(chunk.has_data()); + /// ``` pub(crate) fn has_data(&self) -> bool { self.bytes > 0 } + /// Returns this buffer safely. See [`BytesChunk::get_buffer`] + /// + /// returns: &[u8] with length [`Self::bytes`] pub(crate) fn get_buffer(&self) -> &[u8] { &self.buffer[..self.bytes] } + /// Returns this buffer safely with an offset applied. See [`BytesChunk::get_buffer_with`]. + /// + /// returns: &[u8] with length `self.bytes - offset` pub(crate) fn get_buffer_with(&self, offset: usize) -> &[u8] { &self.buffer[offset..self.bytes] } + /// Return the number of lines the buffer contains. `self.lines` needs to be set before the call + /// to this function returns the correct value. If the calculation of lines is needed then + /// better use [`Self::count_lines`]. pub(crate) fn get_lines(&self) -> usize { self.lines } + /// Increment the number of lines stored in the field [`Self::lines`] by one. pub(crate) fn increment_lines(&mut self) -> usize { self.lines += 1; self.lines } + /// Fills this [`buffer`](Self::buffer) with maximal [`BUFFER_SIZE`] number of bytes, draining + /// the reader by that number of bytes. This function works like the [`BytesChunk::fill`] + /// function besides that this function also counts and stores the number of lines encountered + /// while reading from the [`reader`]. + /// + /// # Arguments + /// + /// * `filehandle`: A [`BufReader`], where the inner must implement [`Read`] + /// + /// returns: `Result, Box>` pub(crate) fn fill(&mut self, filehandle: &mut BufReader) -> UResult> { let num_bytes = filehandle.read(&mut self.buffer)?; self.bytes = num_bytes; @@ -369,6 +493,29 @@ impl LinesChunk { Ok(Some(self.bytes)) } + /// Calculates the offset in bytes within this buffer from the offset in number of lines. The + /// resulting offset is 0-based and points to the byte after the delimiter. + /// + /// # Arguments + /// + /// * `offset`: the offset in number of lines. If offset is 0 then 0 is returned, if larger than + /// the contained lines then self.bytes is returned. + /// + /// returns: usize + /// + /// # Examples + /// + /// ```rust,ignore + /// let mut chunk = LinesChunk::new(b'\n'); + /// chunk.buffer[0..12].copy_from_slice("hello\nworld\n".as_bytes()); + /// chunk.bytes = 12; + /// chunk.lines = 2; // note that if not setting lines the result might not be what is expected + /// let bytes_offset = chunk.calculate_bytes_offset_from(1); + /// assert_eq!(6, bytes_offset); + /// assert_eq!( + /// "world\n", + /// String::from_utf8_lossy(chunk.get_buffer_with(bytes_offset))); + /// ``` fn calculate_bytes_offset_from(&self, offset: usize) -> usize { let mut lines_offset = offset; let mut bytes_offset = 0; @@ -384,24 +531,45 @@ impl LinesChunk { bytes_offset } + /// Print the bytes contained in this buffer calculated with the given offset in number of + /// lines. + /// + /// # Arguments + /// + /// * `writer`: must implement [`Write`] + /// * `offset`: An offset in number of lines. pub(crate) fn print_lines(&self, writer: &mut impl Write, offset: usize) -> UResult<()> { self.print_bytes(writer, self.calculate_bytes_offset_from(offset)) } + /// Print the bytes contained in this buffer beginning from the given offset in number of bytes. + /// + /// # Arguments + /// + /// * `writer`: must implement [`Write`] + /// * `offset`: An offset in number of bytes. pub(crate) fn print_bytes(&self, writer: &mut impl Write, offset: usize) -> UResult<()> { writer.write_all(&self.buffer[offset..self.bytes])?; Ok(()) } } +/// An abstraction layer on top of [`LinesChunk`] mainly to simplify filling only the needed amount +/// of chunks. See also [`Self::fill`]. Works similar like [`BytesChunkBuffer`], but works on top +/// of lines delimited by [`Self::delimiter`] instead of bytes. pub struct LinesChunkBuffer { + // The delimiter to recognize a line. Any [`u8`] is allowed. delimiter: u8, + // The amount of lines occurring in all currently stored [`LinesChunk`]s lines: u64, + // The amount of lines to print. num_print: u64, + // Stores the [`LinesChunk`] chunks: VecDeque>, } impl LinesChunkBuffer { + /// Create a new [`LinesChunkBuffer`] pub(crate) fn new(delimiter: u8, num_print: u64) -> Self { Self { delimiter, @@ -411,6 +579,17 @@ impl LinesChunkBuffer { } } + /// Fills this buffer with chunks and consumes the reader completely. This method ensures that + /// there are exactly as many chunks as needed to match [`Self::num_print`] lines, so there are + /// in sum exactly `self.num_print` lines stored in all chunks. The method returns an iterator + /// over these chunks. If there are no chunks, for example because the piped stdin contained no + /// lines, or `num_print = 0` then `iterator.next` will return None. + /// + /// # Arguments + /// + /// * `reader`: A [`BufReader`] with an inner element implementing the [`Read`] trait. + /// + /// returns: Result>, Box> pub(crate) fn fill( &mut self, reader: &mut BufReader, From 4397df7dc4905166b36d8bb3b7e8cafd471d4438 Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Sat, 27 Aug 2022 18:34:51 +0200 Subject: [PATCH 18/29] tail/chunks: Refactor LinesChunk to use a BytesChunk as backing buffer --- src/uu/tail/src/chunks.rs | 50 +++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 28 deletions(-) diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs index c87bfc17d56..410a57a0c3d 100644 --- a/src/uu/tail/src/chunks.rs +++ b/src/uu/tail/src/chunks.rs @@ -333,13 +333,12 @@ impl BytesChunkBuffer { } } +#[derive(Debug)] /// Works similar to a [`BytesChunk`] but also stores the number of lines encountered in the current /// buffer. The size of the buffer is limited to a fixed size number of bytes (See [`ChunkBuffer`]) pub(crate) struct LinesChunk { - /// The [`ChunkBuffer`] to store the bytes - buffer: ChunkBuffer, - /// The number of bytes stored in the buffer - bytes: usize, + /// Work on top of a [`BytesChunk`] + chunk: BytesChunk, /// The number of lines delimited by `delimiter` lines: usize, /// The delimiter to use, to count the lines @@ -349,8 +348,7 @@ pub(crate) struct LinesChunk { impl LinesChunk { pub(crate) fn new(delimiter: u8) -> Self { Self { - buffer: [0; BUFFER_SIZE], - bytes: 0, + chunk: BytesChunk::new(), lines: 0, delimiter, } @@ -407,20 +405,16 @@ impl LinesChunk { /// let offset = 13; // offset larger /// ``` fn from_chunk(chunk: &Self, offset: usize) -> Self { - if offset >= chunk.lines { + if offset > chunk.lines { return Self::new(chunk.delimiter); } - let mut buffer: ChunkBuffer = [0; BUFFER_SIZE]; - let bytes_offset = chunk.calculate_bytes_offset_from(offset); - let slice = chunk.get_buffer_with(bytes_offset); - buffer[..slice.len()].copy_from_slice(slice); + let new_chunk = BytesChunk::from_chunk(&chunk.chunk, bytes_offset); Self { - buffer, + chunk: new_chunk, lines: chunk.lines - offset, - bytes: chunk.bytes - bytes_offset, delimiter: chunk.delimiter, } } @@ -440,26 +434,26 @@ impl LinesChunk { /// assert!(chunk.has_data()); /// ``` pub(crate) fn has_data(&self) -> bool { - self.bytes > 0 + self.chunk.bytes > 0 } /// Returns this buffer safely. See [`BytesChunk::get_buffer`] /// /// returns: &[u8] with length [`Self::bytes`] pub(crate) fn get_buffer(&self) -> &[u8] { - &self.buffer[..self.bytes] + self.chunk.get_buffer() } /// Returns this buffer safely with an offset applied. See [`BytesChunk::get_buffer_with`]. /// /// returns: &[u8] with length `self.bytes - offset` pub(crate) fn get_buffer_with(&self, offset: usize) -> &[u8] { - &self.buffer[offset..self.bytes] + self.chunk.get_buffer_with(offset) } /// Return the number of lines the buffer contains. `self.lines` needs to be set before the call /// to this function returns the correct value. If the calculation of lines is needed then - /// better use [`Self::count_lines`]. + /// use [`Self::count_lines`]. pub(crate) fn get_lines(&self) -> usize { self.lines } @@ -481,16 +475,16 @@ impl LinesChunk { /// /// returns: `Result, Box>` pub(crate) fn fill(&mut self, filehandle: &mut BufReader) -> UResult> { - let num_bytes = filehandle.read(&mut self.buffer)?; - self.bytes = num_bytes; - - if num_bytes == 0 { - self.lines = 0; - return Ok(None); + match self.chunk.fill(filehandle)? { + None => { + self.lines = 0; + Ok(None) + } + Some(bytes) => { + self.lines = self.count_lines(); + Ok(Some(bytes)) + } } - - self.lines = self.count_lines(); - Ok(Some(self.bytes)) } /// Calculates the offset in bytes within this buffer from the offset in number of lines. The @@ -549,7 +543,7 @@ impl LinesChunk { /// * `writer`: must implement [`Write`] /// * `offset`: An offset in number of bytes. pub(crate) fn print_bytes(&self, writer: &mut impl Write, offset: usize) -> UResult<()> { - writer.write_all(&self.buffer[offset..self.bytes])?; + writer.write_all(self.get_buffer_with(offset))?; Ok(()) } } @@ -613,7 +607,7 @@ impl LinesChunkBuffer { if !&self.chunks.is_empty() { let length = &self.chunks.len(); let last = &mut self.chunks[length - 1]; - if !last.buffer[..last.bytes].ends_with(&[self.delimiter]) { + if !last.get_buffer().ends_with(&[self.delimiter]) { last.lines += 1; self.lines += 1; } From 65f51ecab2b1ea712749225196691c5991ff9386 Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Sat, 27 Aug 2022 19:04:33 +0200 Subject: [PATCH 19/29] tail/chunks: Fix formatting and linking issues in the documentation --- src/uu/tail/src/chunks.rs | 30 ++++++++++++++---------------- 1 file changed, 14 insertions(+), 16 deletions(-) diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs index 410a57a0c3d..2d51c8d976f 100644 --- a/src/uu/tail/src/chunks.rs +++ b/src/uu/tail/src/chunks.rs @@ -190,10 +190,10 @@ impl BytesChunk { &self.buffer[offset..self.bytes] } - /// Fills this [`buffer`](Self::buffer) with maximal [`BUFFER_SIZE`] number of bytes, draining the reader by that - /// number of bytes. If EOF is reached (so 0 bytes are read), then returns [`UResult`] or - /// else the result with [`Some(bytes)`] where bytes is the number of bytes read from the - /// source. + /// Fills this [`buffer`](Self::buffer) with maximal [`BUFFER_SIZE`] number of bytes, draining + /// the reader by that number of bytes. If EOF is reached (so 0 bytes are read), then returns + /// [`UResult`] or else the result with [`Some(bytes)`] where bytes is the number of bytes + /// read from the source. /// /// # Arguments /// @@ -254,9 +254,9 @@ impl BytesChunkBuffer { } /// Fills this buffer with chunks and consumes the reader completely. This method ensures that - /// there are exactly as many chunks as needed to match [`Self::num_print`] bytes, so there are in - /// sum exactly `self.num_print` bytes stored in all chunks. The method returns an iterator over - /// these chunks. If there are no chunks, for example because the piped stdin contained no + /// there are exactly as many chunks as needed to match [`Self::num_print`] bytes, so there are + /// in sum exactly `self.num_print` bytes stored in all chunks. The method returns an iterator + /// over these chunks. If there are no chunks, for example because the piped stdin contained no /// bytes, or `num_print = 0` then `iterator.next` returns None. /// /// # Arguments @@ -377,8 +377,8 @@ impl LinesChunk { /// Creates a new [`LinesChunk`] from an existing one with an offset in lines. The new chunk /// contains exactly `chunk.lines - offset` lines. The offset in bytes is calculated and applied /// to the new chunk, so the new chunk contains only the bytes encountered after the offset in - /// number of lines and the `delimiter`. If the offset is larger or equal to `chunk.lines` then - /// a new empty `LinesChunk` is returned. + /// number of lines and the `delimiter`. If the offset is larger than `chunk.lines` then a new + /// empty `LinesChunk` is returned. /// /// # Arguments /// @@ -401,8 +401,6 @@ impl LinesChunk { /// assert_eq!("world\n".as_bytes(), new_chunk.get_buffer()); /// assert_eq!(6, new_chunk.bytes); /// assert_eq!(1, new_chunk.lines); - /// - /// let offset = 13; // offset larger /// ``` fn from_chunk(chunk: &Self, offset: usize) -> Self { if offset > chunk.lines { @@ -439,7 +437,7 @@ impl LinesChunk { /// Returns this buffer safely. See [`BytesChunk::get_buffer`] /// - /// returns: &[u8] with length [`Self::bytes`] + /// returns: &[u8] with length `self.bytes` pub(crate) fn get_buffer(&self) -> &[u8] { self.chunk.get_buffer() } @@ -464,10 +462,10 @@ impl LinesChunk { self.lines } - /// Fills this [`buffer`](Self::buffer) with maximal [`BUFFER_SIZE`] number of bytes, draining - /// the reader by that number of bytes. This function works like the [`BytesChunk::fill`] - /// function besides that this function also counts and stores the number of lines encountered - /// while reading from the [`reader`]. + /// Fills `self.buffer` with maximal [`BUFFER_SIZE`] number of bytes, draining the reader by + /// that number of bytes. This function works like the [`BytesChunk::fill`] function besides + /// that this function also counts and stores the number of lines encountered while reading from + /// the `filehandle`. /// /// # Arguments /// From 6e1dbcf10b31b9be5148be64243240e997cd020f Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Sat, 27 Aug 2022 22:34:23 +0200 Subject: [PATCH 20/29] tail: Refactor unbounded_tail and add more tests for code coverage --- src/uu/tail/src/chunks.rs | 7 +++-- src/uu/tail/src/tail.rs | 5 +--- tests/by-util/test_tail.rs | 53 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 59 insertions(+), 6 deletions(-) diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs index 2d51c8d976f..46194195092 100644 --- a/src/uu/tail/src/chunks.rs +++ b/src/uu/tail/src/chunks.rs @@ -4,7 +4,6 @@ //! Use [`ReverseChunks::new`] to create a new iterator over chunks of bytes from the file. // spell-checker:ignore (ToDO) filehandle - use std::collections::vec_deque::{Iter, VecDeque}; use std::fs::File; use std::io::{BufReader, Read, Seek, SeekFrom, Write}; @@ -190,6 +189,10 @@ impl BytesChunk { &self.buffer[offset..self.bytes] } + pub(crate) fn has_data(&self) -> bool { + self.bytes > 0 + } + /// Fills this [`buffer`](Self::buffer) with maximal [`BUFFER_SIZE`] number of bytes, draining /// the reader by that number of bytes. If EOF is reached (so 0 bytes are read), then returns /// [`UResult`] or else the result with [`Some(bytes)`] where bytes is the number of bytes @@ -432,7 +435,7 @@ impl LinesChunk { /// assert!(chunk.has_data()); /// ``` pub(crate) fn has_data(&self) -> bool { - self.chunk.bytes > 0 + self.chunk.has_data() } /// Returns this buffer safely. See [`BytesChunk::get_buffer`] diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs index 4a5136ff233..b2542c5c427 100644 --- a/src/uu/tail/src/tail.rs +++ b/src/uu/tail/src/tail.rs @@ -1432,17 +1432,16 @@ fn bounded_tail(file: &mut File, settings: &Settings) { fn unbounded_tail(reader: &mut BufReader, settings: &Settings) -> UResult<()> { let stdout = stdout(); + let mut writer = BufWriter::new(stdout.lock()); match (&settings.mode, settings.beginning) { (FilterMode::Lines(count, sep), false) => { let mut chunks = chunks::LinesChunkBuffer::new(*sep, *count); - let mut writer = BufWriter::new(stdout.lock()); for chunk in chunks.fill(reader)? { writer.write_all(chunk.get_buffer())?; } } (FilterMode::Lines(count, sep), true) => { let mut num_skip = (*count).max(1) - 1; - let mut writer = BufWriter::new(stdout.lock()); let mut chunk = chunks::LinesChunk::new(*sep); while chunk.fill(reader)?.is_some() { let lines = chunk.get_lines() as u64; @@ -1465,14 +1464,12 @@ fn unbounded_tail(reader: &mut BufReader, settings: &Settings) -> UR } (FilterMode::Bytes(count), false) => { let mut chunks = chunks::BytesChunkBuffer::new(*count); - let mut writer = BufWriter::new(stdout.lock()); for chunk in chunks.fill(reader)? { writer.write_all(chunk.get_buffer())?; } } (FilterMode::Bytes(count), true) => { let mut num_skip = (*count).max(1) - 1; - let mut writer = BufWriter::new(stdout.lock()); let mut chunk = chunks::BytesChunk::new(); loop { if let Some(bytes) = chunk.fill(reader)? { diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs index 4cf409854a4..7d28e07b3bb 100644 --- a/tests/by-util/test_tail.rs +++ b/tests/by-util/test_tail.rs @@ -2657,6 +2657,59 @@ mod pipe_tests { .stdout_only(expected); } + #[test] + fn test_pipe_when_lines_option_given_input_size_has_multiple_size_of_buffer_size() { + let total_lines = 100; + let random_string = RandomString::generate_with_delimiter( + Alphanumeric, + b'\n', + total_lines, + true, + CHUNK_BUFFER_SIZE * 3 + 1, + ); + let random_string = random_string.as_str(); + let lines = random_string.split_inclusive('\n'); + + new_ucmd!() + .args(&["-n", "+0"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(random_string); + + let expected = lines.clone().skip(1).collect::(); + new_ucmd!() + .args(&["-n", "+2"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(expected); + + new_ucmd!() + .args(&["-n", "-0"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(""); + + let expected = lines.clone().skip(total_lines - 1).collect::(); + new_ucmd!() + .args(&["-n", "-1"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(expected); + + let expected = lines.clone().skip(1).collect::(); + new_ucmd!() + .args(&["-n", "-99"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(expected); + + new_ucmd!() + .args(&["-n", "-100"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(random_string); + } + #[test] fn test_pipe_when_bytes_option_value_is_higher_than_contained_bytes() { let test_string = "a\nb"; From ada66f4af6a59fe6c621238583a94f25c27abfaf Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Sun, 28 Aug 2022 01:13:34 +0200 Subject: [PATCH 21/29] tail: Remove redundant code and add tests --- src/uu/tail/src/chunks.rs | 6 ------ src/uu/tail/src/tail.rs | 4 +--- tests/by-util/test_tail.rs | 28 ++++++++++++++++++++++++++++ 3 files changed, 29 insertions(+), 9 deletions(-) diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs index 46194195092..6c09ee2eb34 100644 --- a/src/uu/tail/src/chunks.rs +++ b/src/uu/tail/src/chunks.rs @@ -459,12 +459,6 @@ impl LinesChunk { self.lines } - /// Increment the number of lines stored in the field [`Self::lines`] by one. - pub(crate) fn increment_lines(&mut self) -> usize { - self.lines += 1; - self.lines - } - /// Fills `self.buffer` with maximal [`BUFFER_SIZE`] number of bytes, draining the reader by /// that number of bytes. This function works like the [`BytesChunk::fill`] function besides /// that this function also counts and stores the number of lines encountered while reading from diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs index b2542c5c427..0231a5580e5 100644 --- a/src/uu/tail/src/tail.rs +++ b/src/uu/tail/src/tail.rs @@ -1455,9 +1455,6 @@ fn unbounded_tail(reader: &mut BufReader, settings: &Settings) -> UR } } if chunk.has_data() { - if !chunk.get_buffer().ends_with(&[*sep]) { - chunk.increment_lines(); - } chunk.print_lines(&mut writer, num_skip as usize)?; io::copy(reader, &mut writer)?; } @@ -1488,6 +1485,7 @@ fn unbounded_tail(reader: &mut BufReader, settings: &Settings) -> UR return Ok(()); } } + io::copy(reader, &mut writer)?; } } diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs index 7d28e07b3bb..b5a202dbaa0 100644 --- a/tests/by-util/test_tail.rs +++ b/tests/by-util/test_tail.rs @@ -2563,6 +2563,34 @@ mod pipe_tests { .stdout_only(""); } + #[test] + fn test_pipe_when_lines_option_given_input_size_is_equal_to_buffer_size_no_newline_at_eof() { + let total_lines = 1; + let random_string = RandomString::generate_with_delimiter( + Alphanumeric, + b'\n', + total_lines, + false, + CHUNK_BUFFER_SIZE, + ); + let random_string = random_string.as_str(); + let lines = random_string.split_inclusive('\n'); + + let expected = lines.clone().skip(1).collect::(); + new_ucmd!() + .args(&["-n", "+2"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(expected); + + let expected = lines.clone().skip(1).collect::(); + new_ucmd!() + .args(&["-n", "-1"]) + .pipe_in(random_string) + .succeeds() + .stdout_only(expected); + } + #[test] fn test_pipe_when_lines_option_given_input_size_is_equal_to_buffer_size() { let total_lines = 100; From 69aa570ffc858e777414daecab15bd0c75533a0c Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Mon, 29 Aug 2022 00:26:59 +0200 Subject: [PATCH 22/29] tests/common: Rewrite and fix RandomString::generate_with_delimiter(), add documentation and tests --- tests/common/random.rs | 284 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 259 insertions(+), 25 deletions(-) diff --git a/tests/common/random.rs b/tests/common/random.rs index b1f0b73e0f7..d5089bc7ba8 100644 --- a/tests/common/random.rs +++ b/tests/common/random.rs @@ -5,16 +5,38 @@ #![allow(dead_code)] -use rand::distributions::Distribution; -use rand::Rng; +use rand::distributions::{Distribution, Uniform}; +use rand::{thread_rng, Rng}; +/// Samples alphanumeric characters `[A-Za-z0-9]` including newline `\n` +/// +/// # Examples +/// +/// ```rust,ignore +/// use rand::{Rng, thread_rng}; +/// +/// let vec = thread_rng() +/// .sample_iter(AlphanumericNewline) +/// .take(10) +/// .collect::>(); +/// println!("Random chars: {}", String::from_utf8(vec).unwrap()); +/// ``` #[derive(Clone, Copy, Debug)] #[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))] pub struct AlphanumericNewline; impl AlphanumericNewline { + /// The charset to act upon const CHARSET: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\n"; + + /// Generate a random byte from [`Self::CHARSET`] and return it as `char`. + /// + /// # Arguments + /// + /// * `rng`: A [`rand::Rng`] + /// + /// returns: char fn random_char(rng: &mut R) -> char where R: Rng + ?Sized, @@ -22,6 +44,13 @@ impl AlphanumericNewline { Self::random(rng) as char } + /// Generate a random byte from [`Self::CHARSET`] and return it as `u8`. + /// + /// # Arguments + /// + /// * `rng`: A [`rand::Rng`] + /// + /// returns: u8 fn random(rng: &mut R) -> u8 where R: Rng + ?Sized, @@ -37,20 +66,73 @@ impl Distribution for AlphanumericNewline { } } +/// Generate a random string from a [`Distribution`] +/// +/// # Examples +/// +/// ```rust,ignore +/// use crate::common::random::{AlphanumericNewline, RandomString}; +/// use rand::distributions::Alphanumeric; +/// +/// // generates a 100 byte string with characters from AlphanumericNewline +/// let random_string = RandomString::generate(&AlphanumericNewline, 100); +/// assert_eq!(100, random_string.len()); +/// +/// // generates a 100 byte string with 10 newline characters not ending with a newline +/// let string = RandomString::generate_with_delimiter(&Alphanumeric, b'\n', 10, false, 100); +/// assert_eq!(100, random_string.len()); +/// ``` pub struct RandomString; impl RandomString { + /// Generate a random string from the given [`Distribution`] with the given `length` in bytes. + /// + /// # Arguments + /// + /// * `dist`: A u8 [`Distribution`] + /// * `length`: the length of the resulting string in bytes + /// + /// returns: String pub fn generate(dist: D, length: usize) -> String where D: Distribution, { - rand::thread_rng() + thread_rng() .sample_iter(dist) .take(length) .map(|b| b as char) .collect() } + /// Generate a random string from the [`Distribution`] with the given `length` in bytes. The + /// function takes a `delimiter`, which is randomly distributed in the string, such that exactly + /// `num_delimiter` amount of `delimiter`s occur. If `end_with_delimiter` is set, then the + /// string ends with the delimiter, else the string does not end with the delimiter. + /// + /// # Arguments + /// + /// * `dist`: A `u8` [`Distribution`] + /// * `delimiter`: A `u8` delimiter, which does not need to be included in the `Distribution` + /// * `num_delimiter`: The number of `delimiter`s contained in the resulting string + /// * `end_with_delimiter`: If the string shall end with the given delimiter + /// * `length`: the length of the resulting string in bytes + /// + /// returns: String + /// + /// # Examples + /// + /// ```rust,ignore + /// use crate::common::random::{AlphanumericNewline, RandomString}; + /// + /// // generates a 100 byte string with 10 '\0' byte characters not ending with a '\0' byte + /// let string = RandomString::generate_with_delimiter(&AlphanumericNewline, 0, 10, false, 100); + /// assert_eq!(100, random_string.len()); + /// assert_eq!( + /// 10, + /// random_string.as_bytes().iter().filter(|p| **p == 0).count() + /// ); + /// assert!(!random_string.as_bytes().ends_with(&[0])); + /// ``` pub fn generate_with_delimiter( dist: D, delimiter: u8, @@ -63,35 +145,187 @@ impl RandomString { { if length == 0 { return String::from(""); + } else if length == 1 { + return if num_delimiter > 0 { + String::from(delimiter as char) + } else { + String::from(thread_rng().sample(&dist) as char) + }; + } + + let samples = length - 1; + let mut result: Vec = thread_rng().sample_iter(&dist).take(samples).collect(); + + if num_delimiter == 0 { + result.push(thread_rng().sample(&dist)); + return String::from_utf8(result).unwrap(); } - let mut result = String::from(""); - let mut samples = if end_with_delimiter { - num_delimiter.max(1) + + let num_delimiter = if end_with_delimiter { + num_delimiter - 1 } else { - num_delimiter + 1 + num_delimiter }; - let characters_per_sample = length / samples; - while samples != 0 { - result.extend( - rand::thread_rng() - .sample_iter(&dist) - .take(characters_per_sample) - .map(|b| b as char), - ); - result.push(delimiter as char); - samples -= 1; + + let between = Uniform::new(0, samples); + for _ in 0..num_delimiter { + let mut pos = between.sample(&mut thread_rng()); + let turn = pos; + while result[pos] == delimiter { + pos += 1; + if pos >= samples { + pos = 0; + } + if pos == turn { + break; + } + } + result[pos] = delimiter; } if end_with_delimiter { - let mut string = result - .bytes() - .take(length - 1) - .map(|b| b as char) - .collect::(); - string.push(delimiter as char); - string + result.push(delimiter); } else { - result.bytes().take(length).map(|b| b as char).collect() + result.push(thread_rng().sample(&dist)); } + + String::from_utf8(result).unwrap() + } +} + +#[cfg(test)] +mod tests { + use super::*; + use rand::distributions::Alphanumeric; + + #[test] + fn test_random_string_generate() { + let random_string = RandomString::generate(&AlphanumericNewline, 0); + assert_eq!(0, random_string.len()); + + let random_string = RandomString::generate(&AlphanumericNewline, 1); + assert_eq!(1, random_string.len()); + + let random_string = RandomString::generate(&AlphanumericNewline, 100); + assert_eq!(100, random_string.len()); + } + + #[test] + fn test_random_string_generate_with_delimiter_when_length_is_zero() { + let random_string = RandomString::generate_with_delimiter(&Alphanumeric, 0, 0, false, 0); + assert_eq!(0, random_string.len()); + } + + #[test] + fn test_random_string_generate_with_delimiter_when_num_delimiter_is_greater_than_length() { + let random_string = RandomString::generate_with_delimiter(&Alphanumeric, 0, 2, false, 1); + assert_eq!(1, random_string.len()); + assert!(random_string.as_bytes().contains(&0)); + assert!(random_string.as_bytes().ends_with(&[0])); + } + + #[test] + fn test_random_string_generate_with_delimiter_should_end_with_delimiter() { + let random_string = RandomString::generate_with_delimiter(&Alphanumeric, 0, 1, true, 1); + assert_eq!(1, random_string.len()); + assert_eq!( + 1, + random_string.as_bytes().iter().filter(|p| **p == 0).count() + ); + assert!(random_string.as_bytes().ends_with(&[0])); + + let random_string = RandomString::generate_with_delimiter(&Alphanumeric, 0, 1, false, 1); + assert_eq!(1, random_string.len()); + assert_eq!( + 1, + random_string.as_bytes().iter().filter(|p| **p == 0).count() + ); + assert!(random_string.as_bytes().ends_with(&[0])); + + let random_string = RandomString::generate_with_delimiter(&Alphanumeric, 0, 1, true, 2); + assert_eq!(2, random_string.len()); + assert_eq!( + 1, + random_string.as_bytes().iter().filter(|p| **p == 0).count() + ); + assert!(random_string.as_bytes().ends_with(&[0])); + + let random_string = RandomString::generate_with_delimiter(&Alphanumeric, 0, 2, true, 2); + assert_eq!(2, random_string.len()); + assert_eq!( + 2, + random_string.as_bytes().iter().filter(|p| **p == 0).count() + ); + assert!(random_string.as_bytes().ends_with(&[0])); + + let random_string = RandomString::generate_with_delimiter(&Alphanumeric, 0, 1, true, 3); + assert_eq!(3, random_string.len()); + assert_eq!( + 1, + random_string.as_bytes().iter().filter(|p| **p == 0).count() + ); + assert!(random_string.as_bytes().ends_with(&[0])); + } + + #[test] + fn test_random_string_generate_with_delimiter_should_not_end_with_delimiter() { + let random_string = RandomString::generate_with_delimiter(&Alphanumeric, 0, 0, false, 1); + assert_eq!(1, random_string.len()); + assert_eq!( + 0, + random_string.as_bytes().iter().filter(|p| **p == 0).count() + ); + + let random_string = RandomString::generate_with_delimiter(&Alphanumeric, 0, 0, true, 1); + assert_eq!(1, random_string.len()); + assert_eq!( + 0, + random_string.as_bytes().iter().filter(|p| **p == 0).count() + ); + + let random_string = RandomString::generate_with_delimiter(&Alphanumeric, 0, 1, false, 2); + assert_eq!(2, random_string.len()); + assert_eq!( + 1, + random_string.as_bytes().iter().filter(|p| **p == 0).count() + ); + assert!(!random_string.as_bytes().ends_with(&[0])); + + let random_string = RandomString::generate_with_delimiter(&Alphanumeric, 0, 1, false, 3); + assert_eq!(3, random_string.len()); + assert_eq!( + 1, + random_string.as_bytes().iter().filter(|p| **p == 0).count() + ); + assert!(!random_string.as_bytes().ends_with(&[0])); + + let random_string = RandomString::generate_with_delimiter(&Alphanumeric, 0, 2, false, 3); + assert_eq!(3, random_string.len()); + assert_eq!( + 2, + random_string.as_bytes().iter().filter(|p| **p == 0).count() + ); + assert!(!random_string.as_bytes().ends_with(&[0])); + } + + #[test] + fn test_generate_with_delimiter_with_greater_length() { + let random_string = + RandomString::generate_with_delimiter(&Alphanumeric, 0, 100, false, 1000); + assert_eq!(1000, random_string.len()); + assert_eq!( + 100, + random_string.as_bytes().iter().filter(|p| **p == 0).count() + ); + assert!(!random_string.as_bytes().ends_with(&[0])); + + let random_string = + RandomString::generate_with_delimiter(&Alphanumeric, 0, 100, true, 1000); + assert_eq!(1000, random_string.len()); + assert_eq!( + 100, + random_string.as_bytes().iter().filter(|p| **p == 0).count() + ); + assert!(random_string.as_bytes().ends_with(&[0])); } } From 38b6c79c1ac52196db7be2ac35df80013575567b Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Mon, 29 Aug 2022 13:22:35 +0200 Subject: [PATCH 23/29] tests/tail: broken pipe error: Switch off tests on macos if no output is expected --- tests/by-util/test_tail.rs | 95 ++++++++++++++++++++++++++++++++------ 1 file changed, 80 insertions(+), 15 deletions(-) diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs index b5a202dbaa0..9c639c42c69 100644 --- a/tests/by-util/test_tail.rs +++ b/tests/by-util/test_tail.rs @@ -2423,7 +2423,7 @@ fn test_illegal_seek() { ); assert_eq!(p.wait().unwrap().code().unwrap(), 1); } - +// FIXME: Occasionally broken pipe on macos when no output is expected. Switch on such cases for macos when fixed. #[cfg(all(not(target_os = "android"), not(target_os = "windows")))] // FIXME: See https://github.com/uutils/coreutils/issues/3881 mod pipe_tests { use super::*; @@ -2439,47 +2439,62 @@ mod pipe_tests { .pipe_in(test_string) .succeeds() .stdout_only(test_string); + new_ucmd!() .args(&["-n", "4"]) .pipe_in(test_string) .succeeds() .stdout_only(test_string); + new_ucmd!() .args(&["-n", "999"]) .pipe_in(test_string) .succeeds() .stdout_only(test_string); + + #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-n", "+3"]) .pipe_in(test_string) .succeeds() - .stdout_only(""); + .no_stdout() + .no_stderr(); + + #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-n", "+4"]) .pipe_in(test_string) .succeeds() - .stdout_only(""); + .no_stdout() + .no_stderr(); + + #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-n", "+999"]) .pipe_in(test_string) .succeeds() - .stdout_only(""); + .no_stdout() + .no_stderr(); } #[test] fn test_pipe_when_negative_lines_option_given_no_newline_at_eof() { let test_string = "a\nb"; + + #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-n", "0"]) .pipe_in(test_string) .succeeds() .no_stdout() .no_stderr(); + new_ucmd!() .args(&["-n", "1"]) .pipe_in(test_string) .succeeds() .stdout_only("b"); + new_ucmd!() .args(&["-n", "2"]) .pipe_in(test_string) @@ -2490,16 +2505,19 @@ mod pipe_tests { #[test] fn test_pipe_when_positive_lines_option_given_no_newline_at_eof() { let test_string = "a\nb"; + new_ucmd!() .args(&["-n", "+0"]) .pipe_in(test_string) .succeeds() .stdout_only("a\nb"); + new_ucmd!() .args(&["-n", "+1"]) .pipe_in(test_string) .succeeds() .stdout_only("a\nb"); + new_ucmd!() .args(&["-n", "+2"]) .pipe_in(test_string) @@ -2511,56 +2529,70 @@ mod pipe_tests { fn test_pipe_when_lines_option_given_multibyte_utf8_characters() { // the test string consists of from left to right a 4-byte,3-byte,2-byte,1-byte utf-8 character let test_string = "𝅘𝅥𝅮\n⏻\nƒ\na"; + new_ucmd!() .args(&["-n", "+0"]) .pipe_in(test_string) .succeeds() .stdout_only(test_string); + new_ucmd!() .args(&["-n", "+2"]) .pipe_in(test_string) .succeeds() .stdout_only("⏻\nƒ\na"); + new_ucmd!() .args(&["-n", "+3"]) .pipe_in(test_string) .succeeds() .stdout_only("ƒ\na"); + new_ucmd!() .args(&["-n", "+4"]) .pipe_in(test_string) .succeeds() .stdout_only("a"); + + #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-n", "+5"]) .pipe_in(test_string) .succeeds() - .stdout_only(""); + .no_stdout() + .no_stderr(); + new_ucmd!() .args(&["-n", "-4"]) .pipe_in(test_string) .succeeds() .stdout_only(test_string); + new_ucmd!() .args(&["-n", "-3"]) .pipe_in(test_string) .succeeds() .stdout_only("⏻\nƒ\na"); + new_ucmd!() .args(&["-n", "-2"]) .pipe_in(test_string) .succeeds() .stdout_only("ƒ\na"); + new_ucmd!() .args(&["-n", "-1"]) .pipe_in(test_string) .succeeds() .stdout_only("a"); + + #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-n", "-0"]) .pipe_in(test_string) .succeeds() - .stdout_only(""); + .no_stdout() + .no_stderr(); } #[test] @@ -2617,11 +2649,13 @@ mod pipe_tests { .succeeds() .stdout_only(expected); + #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-n", "-0"]) .pipe_in(random_string) .succeeds() - .stdout_only(""); + .no_stdout() + .no_stderr(); let expected = lines.clone().skip(total_lines - 1).collect::(); new_ucmd!() @@ -2711,11 +2745,13 @@ mod pipe_tests { .succeeds() .stdout_only(expected); + #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-n", "-0"]) .pipe_in(random_string) .succeeds() - .stdout_only(""); + .no_stdout() + .no_stderr(); let expected = lines.clone().skip(total_lines - 1).collect::(); new_ucmd!() @@ -2746,31 +2782,42 @@ mod pipe_tests { .pipe_in(test_string) .succeeds() .stdout_only(test_string); + new_ucmd!() .args(&["-c", "5"]) .pipe_in(test_string) .succeeds() .stdout_only(test_string); + new_ucmd!() .args(&["-c", "999"]) .pipe_in(test_string) .succeeds() .stdout_only(test_string); + + #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-c", "+4"]) .pipe_in(test_string) .succeeds() - .stdout_only(""); + .no_stdout() + .no_stderr(); + + #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-c", "+5"]) .pipe_in(test_string) .succeeds() - .stdout_only(""); + .no_stdout() + .no_stderr(); + + #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-c", "+999"]) .pipe_in(test_string) .succeeds() - .stdout_only(""); + .no_stdout() + .no_stderr(); } #[test] @@ -2782,51 +2829,63 @@ mod pipe_tests { .pipe_in(test_string) .succeeds() .stdout_only(test_string); + new_ucmd!() .args(&["-c", "+2"]) .pipe_in(test_string) .succeeds() .stdout_only_bytes(&test_string.as_bytes()[1..]); + new_ucmd!() .args(&["-c", "+5"]) .pipe_in(test_string) .succeeds() .stdout_only("⏻ƒa"); + new_ucmd!() .args(&["-c", "+8"]) .pipe_in(test_string) .succeeds() .stdout_only("ƒa"); + new_ucmd!() .args(&["-c", "+10"]) .pipe_in(test_string) .succeeds() .stdout_only("a"); + + #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-c", "+11"]) .pipe_in(test_string) .succeeds() - .stdout_only(""); + .no_stdout() + .no_stderr(); + new_ucmd!() .args(&["-c", "-1"]) .pipe_in(test_string) .succeeds() .stdout_only("a"); + new_ucmd!() .args(&["-c", "-2"]) .pipe_in(test_string) .succeeds() .stdout_only_bytes(&"ƒa".as_bytes()[1..]); + new_ucmd!() .args(&["-c", "-3"]) .pipe_in(test_string) .succeeds() .stdout_only("ƒa"); + new_ucmd!() .args(&["-c", "-6"]) .pipe_in(test_string) .succeeds() .stdout_only("⏻ƒa"); + new_ucmd!() .args(&["-c", "-10"]) .pipe_in(test_string) @@ -2852,11 +2911,13 @@ mod pipe_tests { .succeeds() .stdout_only_bytes(expected); + #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-c", "-0"]) .pipe_in(random_string) .succeeds() - .stdout_only(""); + .no_stdout() + .no_stderr(); let expected = &random_string.as_bytes()[1..]; new_ucmd!() @@ -2903,11 +2964,13 @@ mod pipe_tests { .succeeds() .stdout_only_bytes(expected); + #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-c", "-0"]) .pipe_in(random_string) .succeeds() - .stdout_only(""); + .no_stdout() + .no_stderr(); let expected = &random_string.as_bytes()[CHUNK_BUFFER_SIZE..]; new_ucmd!() @@ -2941,11 +3004,13 @@ mod pipe_tests { .succeeds() .stdout_only(random_string); + #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-c", "-0"]) .pipe_in(random_string) .succeeds() - .stdout_only(""); + .no_stdout() + .no_stderr(); let expected = &random_string.as_bytes()[8192..]; new_ucmd!() From 29169eef9f2dffaf11374b8f2dd376ec498339ad Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Fri, 2 Sep 2022 17:49:01 +0200 Subject: [PATCH 24/29] tail: Apply suggested changes from review of pr #3874 --- src/uu/tail/src/chunks.rs | 201 +++++++++++++++++-------------------- src/uu/tail/src/tail.rs | 18 ++-- tests/by-util/test_tail.rs | 2 +- tests/common/random.rs | 16 +-- 4 files changed, 99 insertions(+), 138 deletions(-) diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs index 6c09ee2eb34..09314a4b5a3 100644 --- a/src/uu/tail/src/chunks.rs +++ b/src/uu/tail/src/chunks.rs @@ -1,10 +1,14 @@ +// * This file is part of the uutils coreutils package. +// * +// * For the full copyright and license information, please view the LICENSE +// * file that was distributed with this source code. + //! Iterating over a file by chunks, either starting at the end of the file with [`ReverseChunks`] //! or at the end of piped stdin with [`LinesChunk`] or [`BytesChunk`]. //! //! Use [`ReverseChunks::new`] to create a new iterator over chunks of bytes from the file. - -// spell-checker:ignore (ToDO) filehandle -use std::collections::vec_deque::{Iter, VecDeque}; +// spell-checker:ignore (ToDO) filehandle BUFSIZ +use std::collections::VecDeque; use std::fs::File; use std::io::{BufReader, Read, Seek, SeekFrom, Write}; use uucore::error::UResult; @@ -13,10 +17,11 @@ use uucore::error::UResult; /// block read at a time. pub const BLOCK_SIZE: u64 = 1 << 16; -/// The size of the backing buffer of a LinesChunk or BytesChunk. Some calculations concerning the -/// buffer assume that the target system's usize is greater than this BUFFER_SIZE, and therefore -/// convert from u64 to usize as long as it is known, that the value resides somewhere between 0 -/// and the BUFFER_SIZE. +/// The size of the backing buffer of a LinesChunk or BytesChunk in bytes. The value of BUFFER_SIZE +/// originates from the BUFSIZ constant in stdio.h and the libc crate to make stream IO efficient. +/// In the latter the value is constantly set to 8192 on all platforms, where the value in stdio.h +/// is determined on each platform differently. Since libc chose 8192 as a reasonable default the +/// value here is set to this value, too. pub const BUFFER_SIZE: usize = 8192; /// An iterator over a file in non-overlapping chunks from the end of the file. @@ -106,11 +111,21 @@ pub struct BytesChunk { /// Stores the number of bytes, this buffer holds. This is not equal to buffer.len(), since the /// [`BytesChunk`] may store less bytes than the internal buffer can hold. In addition /// [`BytesChunk`] may be reused, what makes it necessary to track the number of stored bytes. + /// The choice of usize is sufficient here, since the number of bytes max value is + /// [`BUFFER_SIZE`], which is a usize. bytes: usize, } +// Silence a clippy warning about a missing default trait implementation, because a user might +// expect to be able to use `Default` as the type can be constructed without arguments. +impl Default for BytesChunk { + fn default() -> Self { + Self::new() + } +} + impl BytesChunk { - pub(crate) fn new() -> Self { + pub fn new() -> Self { Self { buffer: [0; BUFFER_SIZE], bytes: 0, @@ -128,8 +143,6 @@ impl BytesChunk { /// * `offset`: Start to copy the old chunk's buffer from this position. May not be larger /// than `chunk.bytes`. /// - /// returns: BytesChunk - /// /// # Examples /// /// ```rust,ignore @@ -170,7 +183,7 @@ impl BytesChunk { /// chunk.bytes = 1; /// assert_eq!(&[0], chunk.get_buffer()); /// ``` - pub(crate) fn get_buffer(&self) -> &[u8] { + pub fn get_buffer(&self) -> &[u8] { &self.buffer[..self.bytes] } @@ -185,25 +198,19 @@ impl BytesChunk { /// chunk.bytes = 2; /// assert_eq!(&[0], chunk.get_buffer_with(1)); /// ``` - pub(crate) fn get_buffer_with(&self, offset: usize) -> &[u8] { + pub fn get_buffer_with(&self, offset: usize) -> &[u8] { &self.buffer[offset..self.bytes] } - pub(crate) fn has_data(&self) -> bool { + pub fn has_data(&self) -> bool { self.bytes > 0 } - /// Fills this [`buffer`](Self::buffer) with maximal [`BUFFER_SIZE`] number of bytes, draining - /// the reader by that number of bytes. If EOF is reached (so 0 bytes are read), then returns + /// Fills `self.buffer` with maximal [`BUFFER_SIZE`] number of bytes, draining the reader by + /// that number of bytes. If EOF is reached (so 0 bytes are read), then returns /// [`UResult`] or else the result with [`Some(bytes)`] where bytes is the number of bytes /// read from the source. - /// - /// # Arguments - /// - /// * `filehandle`: A [`BufReader`], where the inner must implement [`Read`] - /// - /// returns: `Result, Box>` - pub(crate) fn fill(&mut self, filehandle: &mut BufReader) -> UResult> { + pub fn fill(&mut self, filehandle: &mut BufReader) -> UResult> { let num_bytes = filehandle.read(&mut self.buffer)?; self.bytes = num_bytes; if num_bytes == 0 { @@ -216,10 +223,12 @@ impl BytesChunk { /// An abstraction layer on top of [`BytesChunk`] mainly to simplify filling only the needed amount /// of chunks. See also [`Self::fill`]. -pub(crate) struct BytesChunkBuffer { +pub struct BytesChunkBuffer { /// The number of bytes to print num_print: u64, - /// The current number of bytes summed over all stored chunks in [`Self::chunks`] + /// The current number of bytes summed over all stored chunks in [`Self::chunks`]. Use u64 here + /// to support files > 4GB on 32-bit systems. Note, this differs from `BytesChunk::bytes` which + /// is a usize. The choice of u64 is based on `tail::FilterMode::Bytes`. bytes: u64, /// The buffer to store [`BytesChunk`] in chunks: VecDeque>, @@ -232,8 +241,6 @@ impl BytesChunkBuffer { /// /// * `num_print`: The number of bytes to print /// - /// returns: BytesChunk - /// /// # Examples /// /// ```rust,ignore @@ -248,7 +255,7 @@ impl BytesChunkBuffer { /// assert_eq!(1, new_chunk.get_buffer().len()); /// assert_eq!(&[1], new_chunk.get_buffer()); /// ``` - pub(crate) fn new(num_print: u64) -> Self { + pub fn new(num_print: u64) -> Self { Self { bytes: 0, num_print, @@ -257,17 +264,11 @@ impl BytesChunkBuffer { } /// Fills this buffer with chunks and consumes the reader completely. This method ensures that - /// there are exactly as many chunks as needed to match [`Self::num_print`] bytes, so there are + /// there are exactly as many chunks as needed to match `self.num_print` bytes, so there are /// in sum exactly `self.num_print` bytes stored in all chunks. The method returns an iterator /// over these chunks. If there are no chunks, for example because the piped stdin contained no /// bytes, or `num_print = 0` then `iterator.next` returns None. /// - /// # Arguments - /// - /// * `reader`: A [`BufReader`] with an inner element implementing the [`Read`] trait. - /// - /// returns: Result>, Box> - /// /// # Examples /// /// ```rust,ignore @@ -276,25 +277,14 @@ impl BytesChunkBuffer { /// let mut reader = BufReader::new(Cursor::new("")); /// let num_print = 0; /// let mut chunks = BytesChunkBuffer::new(num_print); - /// let mut iter = chunks.fill(&mut reader).unwrap(); - /// - /// let chunk = iter.next(); - /// assert!(chunk.is_none()); + /// chunks.fill(&mut reader).unwrap(); /// - /// let mut reader = BufReader::new(Cursor::new("a")); + /// let mut reader = BufReader::new(Cursor::new("a"); /// let num_print = 1; /// let mut chunks = BytesChunkBuffer::new(num_print); - /// let mut iter = chunks.fill(&mut reader).unwrap(); - /// - /// let chunk = iter.next(); - /// assert!(chunk.is_some()); - /// assert_eq!(&[b'a'], chunk.unwrap().get_buffer()); - /// assert_eq!(None, iter.next()); + /// chunks.fill(&mut reader).unwrap(); /// ``` - pub(crate) fn fill( - &mut self, - reader: &mut BufReader, - ) -> UResult>> { + pub fn fill(&mut self, reader: &mut BufReader) -> UResult<()> { let mut chunk = Box::new(BytesChunk::new()); // fill chunks with all bytes from reader and reuse already instantiated chunks if possible @@ -313,43 +303,45 @@ impl BytesChunkBuffer { // quit early if there are no chunks for example in case the pipe was empty if self.chunks.is_empty() { - return Ok(self.chunks.iter()); + return Ok(()); } let chunk = self.chunks.pop_front().unwrap(); - // calculate the offset in the first chunk and put the calculated chunk as first element in - // the self.chunks collection. - let offset = if self.num_print >= self.bytes { - // ignore a passed in value exceeding the number of actually read bytes and treat it - // like a value equal to the number of bytes. - 0 - } else { - // the calculated offset must be in the range 0 to BUFFER_SIZE and is therefore safely - // convertible to a usize without losses. - (self.bytes - self.num_print) as usize - }; + // calculate the offset in the first chunk and put the calculated chunk as first element in + // the self.chunks collection. The calculated offset must be in the range 0 to BUFFER_SIZE + // and is therefore safely convertible to a usize without losses. + let offset = self.bytes.saturating_sub(self.num_print) as usize; self.chunks .push_front(Box::new(BytesChunk::from_chunk(&chunk, offset))); - Ok(self.chunks.iter()) + Ok(()) + } + + pub fn print(&self, mut writer: impl Write) -> UResult<()> { + for chunk in &self.chunks { + writer.write_all(chunk.get_buffer())?; + } + Ok(()) } } -#[derive(Debug)] /// Works similar to a [`BytesChunk`] but also stores the number of lines encountered in the current -/// buffer. The size of the buffer is limited to a fixed size number of bytes (See [`ChunkBuffer`]) -pub(crate) struct LinesChunk { +/// buffer. The size of the buffer is limited to a fixed size number of bytes. +#[derive(Debug)] +pub struct LinesChunk { /// Work on top of a [`BytesChunk`] chunk: BytesChunk, - /// The number of lines delimited by `delimiter` + /// The number of lines delimited by `delimiter`. The choice of usize is sufficient here, + /// because lines max value is the number of bytes contained in this chunk's buffer, and the + /// number of bytes max value is [`BUFFER_SIZE`], which is a usize. lines: usize, /// The delimiter to use, to count the lines delimiter: u8, } impl LinesChunk { - pub(crate) fn new(delimiter: u8) -> Self { + pub fn new(delimiter: u8) -> Self { Self { chunk: BytesChunk::new(), lines: 0, @@ -388,8 +380,6 @@ impl LinesChunk { /// * `chunk`: The chunk to create the new chunk from /// * `offset`: The offset in number of lines (not bytes) /// - /// returns: LinesChunk - /// /// # Examples /// /// ```rust,ignore @@ -434,28 +424,28 @@ impl LinesChunk { /// chunk.bytes = 1; /// assert!(chunk.has_data()); /// ``` - pub(crate) fn has_data(&self) -> bool { + pub fn has_data(&self) -> bool { self.chunk.has_data() } /// Returns this buffer safely. See [`BytesChunk::get_buffer`] /// /// returns: &[u8] with length `self.bytes` - pub(crate) fn get_buffer(&self) -> &[u8] { + pub fn get_buffer(&self) -> &[u8] { self.chunk.get_buffer() } /// Returns this buffer safely with an offset applied. See [`BytesChunk::get_buffer_with`]. /// /// returns: &[u8] with length `self.bytes - offset` - pub(crate) fn get_buffer_with(&self, offset: usize) -> &[u8] { + pub fn get_buffer_with(&self, offset: usize) -> &[u8] { self.chunk.get_buffer_with(offset) } /// Return the number of lines the buffer contains. `self.lines` needs to be set before the call /// to this function returns the correct value. If the calculation of lines is needed then - /// use [`Self::count_lines`]. - pub(crate) fn get_lines(&self) -> usize { + /// use `self.count_lines`. + pub fn get_lines(&self) -> usize { self.lines } @@ -463,13 +453,7 @@ impl LinesChunk { /// that number of bytes. This function works like the [`BytesChunk::fill`] function besides /// that this function also counts and stores the number of lines encountered while reading from /// the `filehandle`. - /// - /// # Arguments - /// - /// * `filehandle`: A [`BufReader`], where the inner must implement [`Read`] - /// - /// returns: `Result, Box>` - pub(crate) fn fill(&mut self, filehandle: &mut BufReader) -> UResult> { + pub fn fill(&mut self, filehandle: &mut BufReader) -> UResult> { match self.chunk.fill(filehandle)? { None => { self.lines = 0; @@ -490,8 +474,6 @@ impl LinesChunk { /// * `offset`: the offset in number of lines. If offset is 0 then 0 is returned, if larger than /// the contained lines then self.bytes is returned. /// - /// returns: usize - /// /// # Examples /// /// ```rust,ignore @@ -527,7 +509,7 @@ impl LinesChunk { /// /// * `writer`: must implement [`Write`] /// * `offset`: An offset in number of lines. - pub(crate) fn print_lines(&self, writer: &mut impl Write, offset: usize) -> UResult<()> { + pub fn print_lines(&self, writer: &mut impl Write, offset: usize) -> UResult<()> { self.print_bytes(writer, self.calculate_bytes_offset_from(offset)) } @@ -537,7 +519,7 @@ impl LinesChunk { /// /// * `writer`: must implement [`Write`] /// * `offset`: An offset in number of bytes. - pub(crate) fn print_bytes(&self, writer: &mut impl Write, offset: usize) -> UResult<()> { + pub fn print_bytes(&self, writer: &mut impl Write, offset: usize) -> UResult<()> { writer.write_all(self.get_buffer_with(offset))?; Ok(()) } @@ -545,21 +527,23 @@ impl LinesChunk { /// An abstraction layer on top of [`LinesChunk`] mainly to simplify filling only the needed amount /// of chunks. See also [`Self::fill`]. Works similar like [`BytesChunkBuffer`], but works on top -/// of lines delimited by [`Self::delimiter`] instead of bytes. +/// of lines delimited by `self.delimiter` instead of bytes. pub struct LinesChunkBuffer { - // The delimiter to recognize a line. Any [`u8`] is allowed. + /// The delimiter to recognize a line. Any [`u8`] is allowed. delimiter: u8, - // The amount of lines occurring in all currently stored [`LinesChunk`]s + /// The amount of lines occurring in all currently stored [`LinesChunk`]s. Use u64 here to + /// support files > 4GB on 32-bit systems. Note, this differs from [`LinesChunk::lines`] which + /// is a usize. The choice of u64 is based on `tail::FilterMode::Lines`. lines: u64, - // The amount of lines to print. + /// The amount of lines to print. num_print: u64, - // Stores the [`LinesChunk`] + /// Stores the [`LinesChunk`] chunks: VecDeque>, } impl LinesChunkBuffer { /// Create a new [`LinesChunkBuffer`] - pub(crate) fn new(delimiter: u8, num_print: u64) -> Self { + pub fn new(delimiter: u8, num_print: u64) -> Self { Self { delimiter, num_print, @@ -569,20 +553,11 @@ impl LinesChunkBuffer { } /// Fills this buffer with chunks and consumes the reader completely. This method ensures that - /// there are exactly as many chunks as needed to match [`Self::num_print`] lines, so there are + /// there are exactly as many chunks as needed to match `self.num_print` lines, so there are /// in sum exactly `self.num_print` lines stored in all chunks. The method returns an iterator /// over these chunks. If there are no chunks, for example because the piped stdin contained no /// lines, or `num_print = 0` then `iterator.next` will return None. - /// - /// # Arguments - /// - /// * `reader`: A [`BufReader`] with an inner element implementing the [`Read`] trait. - /// - /// returns: Result>, Box> - pub(crate) fn fill( - &mut self, - reader: &mut BufReader, - ) -> UResult>> { + pub fn fill(&mut self, reader: &mut BufReader) -> UResult<()> { let mut chunk = Box::new(LinesChunk::new(self.delimiter)); while (chunk.fill(reader)?).is_some() { @@ -608,7 +583,7 @@ impl LinesChunkBuffer { } } else { // chunks is empty when a file is empty so quitting early here - return Ok(self.chunks.iter()); + return Ok(()); } // skip unnecessary chunks and save the first chunk which may hold some lines we have to @@ -627,17 +602,21 @@ impl LinesChunkBuffer { } }; - // calculate the number of lines to skip in the chunk - let skip_lines = if self.num_print >= self.lines { - 0 - } else { - (self.lines - self.num_print) as usize - }; - + // Calculate the number of lines to skip in the current chunk. The calculated value must be + // in the range 0 to BUFFER_SIZE and is therefore safely convertible to a usize without + // losses. + let skip_lines = self.lines.saturating_sub(self.num_print) as usize; let chunk = LinesChunk::from_chunk(&chunk, skip_lines); self.chunks.push_front(Box::new(chunk)); - Ok(self.chunks.iter()) + Ok(()) + } + + pub fn print(&self, mut writer: impl Write) -> UResult<()> { + for chunk in &self.chunks { + chunk.print_bytes(&mut writer, 0)?; + } + Ok(()) } } diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs index 0231a5580e5..db6aa15e9c0 100644 --- a/src/uu/tail/src/tail.rs +++ b/src/uu/tail/src/tail.rs @@ -23,7 +23,7 @@ extern crate clap; extern crate uucore; extern crate core; -mod chunks; +pub mod chunks; mod parse; mod platform; use crate::files::FileHandling; @@ -32,12 +32,10 @@ use chunks::ReverseChunks; use clap::{Arg, Command, ValueSource}; use notify::{RecommendedWatcher, RecursiveMode, Watcher, WatcherKind}; use std::cmp::Ordering; -use std::collections::vec_deque::VecDeque; -use std::collections::HashMap; +use std::collections::{HashMap, VecDeque}; use std::ffi::OsString; use std::fs::{File, Metadata}; -use std::io; -use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Seek, SeekFrom, Write}; +use std::io::{self, stdin, stdout, BufRead, BufReader, BufWriter, Read, Seek, SeekFrom, Write}; use std::path::{Path, PathBuf}; use std::sync::mpsc::{self, channel, Receiver}; use std::time::Duration; @@ -1436,9 +1434,8 @@ fn unbounded_tail(reader: &mut BufReader, settings: &Settings) -> UR match (&settings.mode, settings.beginning) { (FilterMode::Lines(count, sep), false) => { let mut chunks = chunks::LinesChunkBuffer::new(*sep, *count); - for chunk in chunks.fill(reader)? { - writer.write_all(chunk.get_buffer())?; - } + chunks.fill(reader)?; + chunks.print(writer)?; } (FilterMode::Lines(count, sep), true) => { let mut num_skip = (*count).max(1) - 1; @@ -1461,9 +1458,8 @@ fn unbounded_tail(reader: &mut BufReader, settings: &Settings) -> UR } (FilterMode::Bytes(count), false) => { let mut chunks = chunks::BytesChunkBuffer::new(*count); - for chunk in chunks.fill(reader)? { - writer.write_all(chunk.get_buffer())?; - } + chunks.fill(reader)?; + chunks.print(writer)?; } (FilterMode::Bytes(count), true) => { let mut num_skip = (*count).max(1) - 1; diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs index 9c639c42c69..ac0daa5be88 100644 --- a/tests/by-util/test_tail.rs +++ b/tests/by-util/test_tail.rs @@ -2429,7 +2429,7 @@ mod pipe_tests { use super::*; use crate::common::random::*; use rand::distributions::Alphanumeric; - const CHUNK_BUFFER_SIZE: usize = 8192; + use tail::chunks::BUFFER_SIZE as CHUNK_BUFFER_SIZE; #[test] fn test_pipe_when_lines_option_value_is_higher_than_contained_lines() { diff --git a/tests/common/random.rs b/tests/common/random.rs index d5089bc7ba8..36be8e24578 100644 --- a/tests/common/random.rs +++ b/tests/common/random.rs @@ -3,7 +3,7 @@ // * For the full copyright and license information, please view the LICENSE // * file that was distributed with this source code. -#![allow(dead_code)] +// #![allow(dead_code)] use rand::distributions::{Distribution, Uniform}; use rand::{thread_rng, Rng}; @@ -30,20 +30,6 @@ impl AlphanumericNewline { const CHARSET: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\n"; - /// Generate a random byte from [`Self::CHARSET`] and return it as `char`. - /// - /// # Arguments - /// - /// * `rng`: A [`rand::Rng`] - /// - /// returns: char - fn random_char(rng: &mut R) -> char - where - R: Rng + ?Sized, - { - Self::random(rng) as char - } - /// Generate a random byte from [`Self::CHARSET`] and return it as `u8`. /// /// # Arguments From c59860d0a15fe88ccd863c57d180d1269bf7a90a Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Sat, 3 Sep 2022 01:35:21 +0200 Subject: [PATCH 25/29] tail: Apply additional suggested changes from review of pr #3874 --- src/uu/tail/src/chunks.rs | 9 +-------- src/uu/tail/src/tail.rs | 11 ++++------- tests/common/random.rs | 3 --- 3 files changed, 5 insertions(+), 18 deletions(-) diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs index 09314a4b5a3..737b866ab3f 100644 --- a/src/uu/tail/src/chunks.rs +++ b/src/uu/tail/src/chunks.rs @@ -116,15 +116,8 @@ pub struct BytesChunk { bytes: usize, } -// Silence a clippy warning about a missing default trait implementation, because a user might -// expect to be able to use `Default` as the type can be constructed without arguments. -impl Default for BytesChunk { - fn default() -> Self { - Self::new() - } -} - impl BytesChunk { + #[allow(clippy::new_without_default)] pub fn new() -> Self { Self { buffer: [0; BUFFER_SIZE], diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs index db6aa15e9c0..9de2de80071 100644 --- a/src/uu/tail/src/tail.rs +++ b/src/uu/tail/src/tail.rs @@ -1442,13 +1442,10 @@ fn unbounded_tail(reader: &mut BufReader, settings: &Settings) -> UR let mut chunk = chunks::LinesChunk::new(*sep); while chunk.fill(reader)?.is_some() { let lines = chunk.get_lines() as u64; - match lines.cmp(&num_skip) { - Ordering::Less => { - num_skip -= lines; - } - Ordering::Equal | Ordering::Greater => { - break; - } + if lines < num_skip { + num_skip -= lines; + } else { + break; } } if chunk.has_data() { diff --git a/tests/common/random.rs b/tests/common/random.rs index 36be8e24578..338aeab5070 100644 --- a/tests/common/random.rs +++ b/tests/common/random.rs @@ -3,8 +3,6 @@ // * For the full copyright and license information, please view the LICENSE // * file that was distributed with this source code. -// #![allow(dead_code)] - use rand::distributions::{Distribution, Uniform}; use rand::{thread_rng, Rng}; @@ -22,7 +20,6 @@ use rand::{thread_rng, Rng}; /// println!("Random chars: {}", String::from_utf8(vec).unwrap()); /// ``` #[derive(Clone, Copy, Debug)] -#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))] pub struct AlphanumericNewline; impl AlphanumericNewline { From 6b65f0e9e72d8d759f27fb147cb834d06d4bbb4f Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Sat, 3 Sep 2022 12:27:17 +0200 Subject: [PATCH 26/29] tail: Fix rust error in documentation --- src/uu/tail/src/chunks.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs index 737b866ab3f..c34b51d5f15 100644 --- a/src/uu/tail/src/chunks.rs +++ b/src/uu/tail/src/chunks.rs @@ -265,6 +265,7 @@ impl BytesChunkBuffer { /// # Examples /// /// ```rust,ignore + /// use crate::chunks::BytesChunkBuffer; /// use std::io::{BufReader, Cursor}; /// /// let mut reader = BufReader::new(Cursor::new("")); @@ -272,7 +273,7 @@ impl BytesChunkBuffer { /// let mut chunks = BytesChunkBuffer::new(num_print); /// chunks.fill(&mut reader).unwrap(); /// - /// let mut reader = BufReader::new(Cursor::new("a"); + /// let mut reader = BufReader::new(Cursor::new("a")); /// let num_print = 1; /// let mut chunks = BytesChunkBuffer::new(num_print); /// chunks.fill(&mut reader).unwrap(); From e46f89d96ebd042f14ee57a91c3d1602d9370f1b Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Wed, 7 Sep 2022 20:10:38 +0200 Subject: [PATCH 27/29] tests/tail: Switch off pipe tests on macos because of random failures See also #3895 --- tests/by-util/test_tail.rs | 21 +++++---------------- 1 file changed, 5 insertions(+), 16 deletions(-) diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs index ac0daa5be88..fc3e392b5a1 100644 --- a/tests/by-util/test_tail.rs +++ b/tests/by-util/test_tail.rs @@ -2423,7 +2423,10 @@ fn test_illegal_seek() { ); assert_eq!(p.wait().unwrap().code().unwrap(), 1); } -// FIXME: Occasionally broken pipe on macos when no output is expected. Switch on such cases for macos when fixed. +// FIXME: Occasionally broken pipe on macos, mostly when no output is expected. +// Given `+0` or `-c -1` on macos the test fails because of a todo() in `tail.rs`. +// See https://github.com/uutils/coreutils/issues/3895 +#[cfg(all(not(target_os = "macos")))] #[cfg(all(not(target_os = "android"), not(target_os = "windows")))] // FIXME: See https://github.com/uutils/coreutils/issues/3881 mod pipe_tests { use super::*; @@ -2452,7 +2455,6 @@ mod pipe_tests { .succeeds() .stdout_only(test_string); - #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-n", "+3"]) .pipe_in(test_string) @@ -2460,7 +2462,6 @@ mod pipe_tests { .no_stdout() .no_stderr(); - #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-n", "+4"]) .pipe_in(test_string) @@ -2468,7 +2469,6 @@ mod pipe_tests { .no_stdout() .no_stderr(); - #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-n", "+999"]) .pipe_in(test_string) @@ -2481,7 +2481,6 @@ mod pipe_tests { fn test_pipe_when_negative_lines_option_given_no_newline_at_eof() { let test_string = "a\nb"; - #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-n", "0"]) .pipe_in(test_string) @@ -2554,7 +2553,6 @@ mod pipe_tests { .succeeds() .stdout_only("a"); - #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-n", "+5"]) .pipe_in(test_string) @@ -2586,7 +2584,6 @@ mod pipe_tests { .succeeds() .stdout_only("a"); - #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-n", "-0"]) .pipe_in(test_string) @@ -2649,7 +2646,6 @@ mod pipe_tests { .succeeds() .stdout_only(expected); - #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-n", "-0"]) .pipe_in(random_string) @@ -2745,7 +2741,6 @@ mod pipe_tests { .succeeds() .stdout_only(expected); - #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-n", "-0"]) .pipe_in(random_string) @@ -2795,7 +2790,6 @@ mod pipe_tests { .succeeds() .stdout_only(test_string); - #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-c", "+4"]) .pipe_in(test_string) @@ -2803,7 +2797,6 @@ mod pipe_tests { .no_stdout() .no_stderr(); - #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-c", "+5"]) .pipe_in(test_string) @@ -2811,7 +2804,6 @@ mod pipe_tests { .no_stdout() .no_stderr(); - #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-c", "+999"]) .pipe_in(test_string) @@ -2824,6 +2816,7 @@ mod pipe_tests { fn test_pipe_when_bytes_option_given_multibyte_utf8_characters() { // the test string consists of from left to right a 4-byte,3-byte,2-byte,1-byte utf-8 character let test_string = "𝅘𝅥𝅮⏻ƒa"; + new_ucmd!() .args(&["-c", "+0"]) .pipe_in(test_string) @@ -2854,7 +2847,6 @@ mod pipe_tests { .succeeds() .stdout_only("a"); - #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-c", "+11"]) .pipe_in(test_string) @@ -2911,7 +2903,6 @@ mod pipe_tests { .succeeds() .stdout_only_bytes(expected); - #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-c", "-0"]) .pipe_in(random_string) @@ -2964,7 +2955,6 @@ mod pipe_tests { .succeeds() .stdout_only_bytes(expected); - #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-c", "-0"]) .pipe_in(random_string) @@ -3004,7 +2994,6 @@ mod pipe_tests { .succeeds() .stdout_only(random_string); - #[cfg(all(not(target_os = "macos")))] new_ucmd!() .args(&["-c", "-0"]) .pipe_in(random_string) From 997bdc10f3244cbbfc7eff5da01250ab49281cb4 Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Thu, 8 Sep 2022 22:13:13 +0200 Subject: [PATCH 28/29] tests/tail: Switch pipe tests on macos back on --- tests/by-util/test_tail.rs | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs index 275a1166587..0cb2046baf3 100644 --- a/tests/by-util/test_tail.rs +++ b/tests/by-util/test_tail.rs @@ -2471,10 +2471,7 @@ fn test_illegal_seek() { ); assert_eq!(p.wait().unwrap().code().unwrap(), 1); } -// FIXME: Occasionally broken pipe on macos, mostly when no output is expected. -// Given `+0` or `-c -1` on macos the test fails because of a todo() in `tail.rs`. -// See https://github.com/uutils/coreutils/issues/3895 -#[cfg(all(not(target_os = "macos")))] + #[cfg(all(not(target_os = "android"), not(target_os = "windows")))] // FIXME: See https://github.com/uutils/coreutils/issues/3881 mod pipe_tests { use super::*; From f0319dfc0c97e629867b906dad53f14ee4de42d2 Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Thu, 8 Sep 2022 23:46:19 +0200 Subject: [PATCH 29/29] tests/tail: ignore stdin write errors --- tests/by-util/test_tail.rs | 81 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 81 insertions(+) diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs index 0cb2046baf3..442c07979f5 100644 --- a/tests/by-util/test_tail.rs +++ b/tests/by-util/test_tail.rs @@ -2485,24 +2485,28 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "3"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(test_string); new_ucmd!() .args(&["-n", "4"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(test_string); new_ucmd!() .args(&["-n", "999"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(test_string); new_ucmd!() .args(&["-n", "+3"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .no_stdout() .no_stderr(); @@ -2510,6 +2514,7 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "+4"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .no_stdout() .no_stderr(); @@ -2517,6 +2522,7 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "+999"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .no_stdout() .no_stderr(); @@ -2529,6 +2535,7 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "0"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .no_stdout() .no_stderr(); @@ -2536,12 +2543,14 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "1"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("b"); new_ucmd!() .args(&["-n", "2"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("a\nb"); } @@ -2553,18 +2562,21 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "+0"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("a\nb"); new_ucmd!() .args(&["-n", "+1"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("a\nb"); new_ucmd!() .args(&["-n", "+2"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("b"); } @@ -2577,30 +2589,35 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "+0"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(test_string); new_ucmd!() .args(&["-n", "+2"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("⏻\nƒ\na"); new_ucmd!() .args(&["-n", "+3"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("ƒ\na"); new_ucmd!() .args(&["-n", "+4"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("a"); new_ucmd!() .args(&["-n", "+5"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .no_stdout() .no_stderr(); @@ -2608,30 +2625,35 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "-4"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(test_string); new_ucmd!() .args(&["-n", "-3"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("⏻\nƒ\na"); new_ucmd!() .args(&["-n", "-2"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("ƒ\na"); new_ucmd!() .args(&["-n", "-1"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("a"); new_ucmd!() .args(&["-n", "-0"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .no_stdout() .no_stderr(); @@ -2654,6 +2676,7 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "+2"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(expected); @@ -2661,6 +2684,7 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "-1"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(expected); } @@ -2681,6 +2705,7 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "+0"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(random_string); @@ -2688,12 +2713,14 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "+2"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(expected); new_ucmd!() .args(&["-n", "-0"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .no_stdout() .no_stderr(); @@ -2702,6 +2729,7 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "-1"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(expected); @@ -2709,12 +2737,14 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "-99"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(expected); new_ucmd!() .args(&["-n", "-100"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(random_string); } @@ -2735,6 +2765,7 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "+0"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(random_string); @@ -2742,6 +2773,7 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "-1"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(expected); @@ -2749,6 +2781,7 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "+2"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(expected); @@ -2756,6 +2789,7 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "-99"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(expected); } @@ -2776,6 +2810,7 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "+0"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(random_string); @@ -2783,12 +2818,14 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "+2"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(expected); new_ucmd!() .args(&["-n", "-0"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .no_stdout() .no_stderr(); @@ -2797,6 +2834,7 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "-1"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(expected); @@ -2804,12 +2842,14 @@ mod pipe_tests { new_ucmd!() .args(&["-n", "-99"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(expected); new_ucmd!() .args(&["-n", "-100"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(random_string); } @@ -2820,24 +2860,28 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "4"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(test_string); new_ucmd!() .args(&["-c", "5"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(test_string); new_ucmd!() .args(&["-c", "999"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(test_string); new_ucmd!() .args(&["-c", "+4"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .no_stdout() .no_stderr(); @@ -2845,6 +2889,7 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "+5"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .no_stdout() .no_stderr(); @@ -2852,6 +2897,7 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "+999"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .no_stdout() .no_stderr(); @@ -2865,36 +2911,42 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "+0"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(test_string); new_ucmd!() .args(&["-c", "+2"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(&test_string.as_bytes()[1..]); new_ucmd!() .args(&["-c", "+5"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("⏻ƒa"); new_ucmd!() .args(&["-c", "+8"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("ƒa"); new_ucmd!() .args(&["-c", "+10"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("a"); new_ucmd!() .args(&["-c", "+11"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .no_stdout() .no_stderr(); @@ -2902,30 +2954,35 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "-1"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("a"); new_ucmd!() .args(&["-c", "-2"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(&"ƒa".as_bytes()[1..]); new_ucmd!() .args(&["-c", "-3"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("ƒa"); new_ucmd!() .args(&["-c", "-6"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only("⏻ƒa"); new_ucmd!() .args(&["-c", "-10"]) .pipe_in(test_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(test_string); } @@ -2938,6 +2995,7 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "+0"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(random_string); @@ -2945,12 +3003,14 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "+2"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(expected); new_ucmd!() .args(&["-c", "-0"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .no_stdout() .no_stderr(); @@ -2959,18 +3019,21 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "-8191"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(expected); new_ucmd!() .args(&["-c", "-8192"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(random_string); new_ucmd!() .args(&["-c", "-8193"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(random_string); @@ -2978,6 +3041,7 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "-1"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(expected); } @@ -2990,6 +3054,7 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "+0"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(random_string); @@ -2997,12 +3062,14 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "+2"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(expected); new_ucmd!() .args(&["-c", "-0"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .no_stdout() .no_stderr(); @@ -3011,6 +3078,7 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "-1"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(expected); @@ -3018,12 +3086,14 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "-8192"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(expected); new_ucmd!() .args(&["-c", "-8193"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(random_string); } @@ -3036,12 +3106,14 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "+0"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(random_string); new_ucmd!() .args(&["-c", "-0"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .no_stdout() .no_stderr(); @@ -3050,6 +3122,7 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "+8193"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(expected); @@ -3057,6 +3130,7 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "+8194"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(expected); @@ -3064,6 +3138,7 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "+16385"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(expected); @@ -3071,6 +3146,7 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "+16386"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(expected); @@ -3078,6 +3154,7 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "-8192"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(expected); @@ -3085,6 +3162,7 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "-8193"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(expected); @@ -3092,6 +3170,7 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "-16384"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(expected); @@ -3099,12 +3178,14 @@ mod pipe_tests { new_ucmd!() .args(&["-c", "-16385"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only_bytes(expected); new_ucmd!() .args(&["-c", "-24576"]) .pipe_in(random_string) + .ignore_stdin_write_error() .succeeds() .stdout_only(random_string); }