use super::piece_impl::{DEFAULT_BLOCK_LENGTH, Piece};
#[test]
fn test_new_default_block_length() {
let piece = Piece::new(5, 65536);
assert_eq!(piece.index(), 5);
assert_eq!(piece.length(), 65536);
assert_eq!(piece.block_length(), DEFAULT_BLOCK_LENGTH);
assert_eq!(piece.count_blocks(), 4); assert_eq!(piece.count_completed_blocks(), 0);
assert_eq!(piece.count_missing_blocks(), 4);
assert!(!piece.is_complete());
}
#[test]
fn test_new_custom_block_length() {
let piece = Piece::with_block_length(0, 32768, 8192);
assert_eq!(piece.count_blocks(), 4); assert_eq!(piece.block_length(), 8192);
}
#[test]
fn test_new_non_aligned_length() {
let piece = Piece::new(0, 50000);
assert_eq!(piece.count_blocks(), 4);
assert_eq!(piece.block_length_at(0), 16384);
assert_eq!(piece.block_length_at(1), 16384);
assert_eq!(piece.block_length_at(2), 16384);
assert_eq!(piece.block_length_at(3), 848); assert_eq!(piece.block_length_at(4), 0); }
#[test]
fn test_new_zero_length() {
let piece = Piece::new(0, 0);
assert_eq!(piece.count_blocks(), 0);
assert!(piece.is_complete()); assert_eq!(piece.completed_length(), 0);
}
#[test]
fn test_default() {
let piece = Piece::default();
assert_eq!(piece.index(), 0);
assert_eq!(piece.length(), 0);
assert_eq!(piece.count_blocks(), 0);
}
#[test]
fn test_complete_block() {
let mut piece = Piece::new(0, 65536);
assert_eq!(piece.count_completed_blocks(), 0);
piece.complete_block(0);
assert!(piece.has_block(0));
assert_eq!(piece.count_completed_blocks(), 1);
piece.complete_block(1);
assert!(piece.has_block(1));
assert_eq!(piece.count_completed_blocks(), 2);
}
#[test]
fn test_complete_all_blocks() {
let mut piece = Piece::new(0, 65536);
for i in 0..4 {
piece.complete_block(i);
}
assert!(piece.is_complete());
assert_eq!(piece.completed_length(), 65536);
}
#[test]
fn test_clear_all_blocks() {
let mut piece = Piece::new(0, 65536);
for i in 0..4 {
piece.complete_block(i);
}
assert!(piece.is_complete());
piece.clear_all_blocks();
assert!(!piece.is_complete());
assert_eq!(piece.count_completed_blocks(), 0);
}
#[test]
fn test_get_missing_unused_block_index() {
let mut piece = Piece::new(0, 65536);
assert_eq!(piece.get_missing_unused_block_index(), Some(0));
piece.set_block_in_use(0);
assert_eq!(piece.get_missing_unused_block_index(), Some(1));
piece.complete_block(1);
assert_eq!(piece.get_missing_unused_block_index(), Some(2));
}
#[test]
fn test_set_and_clear_block_in_use() {
let mut piece = Piece::new(0, 65536);
piece.set_block_in_use(2);
assert!(piece.is_block_in_use(2));
assert!(!piece.is_block_in_use(0));
piece.clear_block_in_use(2);
assert!(!piece.is_block_in_use(2));
}
#[test]
fn test_completed_length_partial() {
let mut piece = Piece::new(0, 65536);
piece.complete_block(0);
assert_eq!(piece.completed_length(), 16384);
piece.complete_block(1);
assert_eq!(piece.completed_length(), 32768);
}
#[test]
fn test_completed_length_non_aligned() {
let mut piece = Piece::new(0, 50000);
piece.complete_block(0);
piece.complete_block(1);
piece.complete_block(2);
assert_eq!(piece.completed_length(), 3 * 16384);
piece.complete_block(3); assert_eq!(piece.completed_length(), 50000);
}
#[test]
fn test_add_remove_user() {
let mut piece = Piece::new(0, 65536);
piece.add_user(42);
assert_eq!(piece.user_count(), 1);
piece.add_user(100);
assert_eq!(piece.user_count(), 2);
piece.remove_user(42);
assert_eq!(piece.user_count(), 1);
piece.remove_user(100);
assert_eq!(piece.user_count(), 0);
}
#[test]
fn test_used_by_segment() {
let mut piece = Piece::new(0, 65536);
assert!(!piece.is_used_by_segment());
piece.set_used_by_segment(true);
assert!(piece.is_used_by_segment());
piece.set_used_by_segment(false);
assert!(!piece.is_used_by_segment());
}
#[test]
fn test_hash_update_and_digest() {
let mut piece = Piece::new(0, 4);
piece.set_hash_type("sha-1");
assert!(piece.update_hash(0, b"test"));
assert!(piece.is_hash_calculated());
let digest = piece.get_digest();
assert!(digest.is_some());
assert_eq!(digest.unwrap().len(), 20);
}
#[test]
fn test_hash_offset_mismatch() {
let mut piece = Piece::new(0, 8);
piece.set_hash_type("sha-1");
assert!(piece.update_hash(0, b"tes"));
assert!(!piece.update_hash(5, b"t")); assert!(piece.update_hash(3, b"t")); }
#[test]
fn test_hash_no_type() {
let mut piece = Piece::new(0, 4);
assert!(!piece.update_hash(0, b"test"));
}
#[test]
fn test_destroy_hash_context() {
let mut piece = Piece::new(0, 4);
piece.set_hash_type("sha-1");
piece.update_hash(0, b"test");
assert!(piece.is_hash_calculated());
piece.destroy_hash_context();
assert!(!piece.is_hash_calculated());
}
#[test]
fn test_piece_ordering() {
let p1 = Piece::new(1, 65536);
let p2 = Piece::new(2, 65536);
let p3 = Piece::new(1, 32768);
assert!(p1 < p2);
assert!(p1 == p3); }
#[test]
fn test_piece_debug_format() {
let piece = Piece::new(5, 65536);
let debug_str = format!("{:?}", piece);
assert!(debug_str.contains("index: 5"));
assert!(debug_str.contains("length: 65536"));
}
#[test]
fn test_piece_display_format() {
let piece = Piece::new(5, 65536);
let display_str = format!("{}", piece);
assert!(display_str.contains("index=5"));
assert!(display_str.contains("length=65536"));
}