use tracing::trace;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct GrowSegment {
written_length: u64,
}
impl GrowSegment {
pub fn new() -> Self {
GrowSegment { written_length: 0 }
}
pub fn is_complete(&self) -> bool {
false
}
pub fn index(&self) -> usize {
0
}
pub fn position(&self) -> u64 {
0
}
pub fn position_to_write(&self) -> u64 {
self.written_length
}
pub fn length(&self) -> u64 {
0
}
pub fn segment_length(&self) -> u64 {
0
}
pub fn written_length(&self) -> u64 {
self.written_length
}
pub fn update_written_length(&mut self, bytes: u64) {
trace!(
previous = self.written_length,
increment = bytes,
"GrowSegment: updating written length"
);
self.written_length = self.written_length.saturating_add(bytes);
}
pub fn update_hash(&self, _begin: u64, _data: &[u8]) -> bool {
false
}
pub fn is_hash_calculated(&self) -> bool {
false
}
pub fn digest(&self) -> String {
String::new()
}
pub fn clear(&mut self) {
trace!(previous = self.written_length, "GrowSegment: clearing");
self.written_length = 0;
}
}
impl Default for GrowSegment {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_new_has_zero_written_length() {
let seg = GrowSegment::new();
assert_eq!(seg.written_length(), 0);
assert_eq!(seg.position_to_write(), 0);
}
#[test]
fn test_default_equals_new() {
let seg_default = GrowSegment::default();
let seg_new = GrowSegment::new();
assert_eq!(seg_default, seg_new);
}
#[test]
fn test_never_complete() {
let mut seg = GrowSegment::new();
assert!(!seg.is_complete());
seg.update_written_length(1024);
assert!(!seg.is_complete());
seg.update_written_length(u64::MAX - 1024);
assert!(!seg.is_complete());
}
#[test]
fn test_index_always_zero() {
let seg = GrowSegment::new();
assert_eq!(seg.index(), 0);
}
#[test]
fn test_position_always_zero() {
let mut seg = GrowSegment::new();
assert_eq!(seg.position(), 0);
seg.update_written_length(9999);
assert_eq!(seg.position(), 0);
}
#[test]
fn test_length_always_zero() {
let mut seg = GrowSegment::new();
assert_eq!(seg.length(), 0);
assert_eq!(seg.segment_length(), 0);
seg.update_written_length(5000);
assert_eq!(seg.length(), 0);
assert_eq!(seg.segment_length(), 0);
}
#[test]
fn test_position_to_write_equals_written_length() {
let mut seg = GrowSegment::new();
assert_eq!(seg.position_to_write(), 0);
seg.update_written_length(100);
assert_eq!(seg.position_to_write(), 100);
assert_eq!(seg.position_to_write(), seg.written_length());
seg.update_written_length(200);
assert_eq!(seg.position_to_write(), 300);
assert_eq!(seg.position_to_write(), seg.written_length());
}
#[test]
fn test_update_written_length_accumulates() {
let mut seg = GrowSegment::new();
seg.update_written_length(1024);
assert_eq!(seg.written_length(), 1024);
seg.update_written_length(2048);
assert_eq!(seg.written_length(), 3072);
seg.update_written_length(0);
assert_eq!(seg.written_length(), 3072);
}
#[test]
fn test_update_written_length_saturating_add() {
let mut seg = GrowSegment::new();
seg.update_written_length(u64::MAX - 100);
assert_eq!(seg.written_length(), u64::MAX - 100);
seg.update_written_length(200);
assert_eq!(seg.written_length(), u64::MAX);
}
#[test]
fn test_update_hash_always_false() {
let seg = GrowSegment::new();
assert!(!seg.update_hash(0, &[]));
assert!(!seg.update_hash(0, &[1, 2, 3, 4]));
assert!(!seg.update_hash(100, &[0xAA; 1024]));
}
#[test]
fn test_is_hash_calculated_always_false() {
let seg = GrowSegment::new();
assert!(!seg.is_hash_calculated());
}
#[test]
fn test_digest_always_empty() {
let seg = GrowSegment::new();
assert!(seg.digest().is_empty());
}
#[test]
fn test_clear_resets_written_length() {
let mut seg = GrowSegment::new();
seg.update_written_length(4096);
assert_eq!(seg.written_length(), 4096);
seg.clear();
assert_eq!(seg.written_length(), 0);
assert_eq!(seg.position_to_write(), 0);
}
#[test]
fn test_clear_then_update() {
let mut seg = GrowSegment::new();
seg.update_written_length(1000);
seg.clear();
seg.update_written_length(500);
assert_eq!(seg.written_length(), 500);
assert!(!seg.is_complete());
}
#[test]
fn test_clone_independence() {
let mut seg = GrowSegment::new();
seg.update_written_length(2048);
let clone = seg.clone();
assert_eq!(clone.written_length(), 2048);
seg.update_written_length(1024);
assert_eq!(seg.written_length(), 3072);
assert_eq!(clone.written_length(), 2048);
}
#[test]
fn test_equality() {
let mut seg1 = GrowSegment::new();
let mut seg2 = GrowSegment::new();
assert_eq!(seg1, seg2);
seg1.update_written_length(1024);
assert_ne!(seg1, seg2);
seg2.update_written_length(1024);
assert_eq!(seg1, seg2);
}
#[test]
fn test_large_written_length() {
let mut seg = GrowSegment::new();
seg.update_written_length(4 * 1024 * 1024 * 1024);
assert_eq!(seg.written_length(), 4 * 1024 * 1024 * 1024);
assert_eq!(seg.position_to_write(), 4 * 1024 * 1024 * 1024);
assert!(!seg.is_complete());
assert_eq!(seg.length(), 0);
}
#[test]
fn test_incremental_download_simulation() {
let mut seg = GrowSegment::new();
let chunk_sizes: &[u64] = &[8192, 16384, 32768, 65536, 131072];
let mut total = 0u64;
for &chunk in chunk_sizes {
seg.update_written_length(chunk);
total += chunk;
assert_eq!(seg.written_length(), total);
assert_eq!(seg.position_to_write(), total);
assert!(!seg.is_complete());
}
assert_eq!(seg.written_length(), 253952);
}
#[test]
fn test_clear_multiple_times() {
let mut seg = GrowSegment::new();
seg.update_written_length(100);
seg.clear();
assert_eq!(seg.written_length(), 0);
seg.clear(); assert_eq!(seg.written_length(), 0);
seg.update_written_length(200);
assert_eq!(seg.written_length(), 200);
}
}