@@ -338,3 +338,139 @@ impl FileHeader {
338338 Self :: from_bytes ( & buffer)
339339 }
340340}
341+
342+ #[ cfg( test) ]
343+ mod tests {
344+ use super :: * ;
345+
346+ // ==================== FileHeaderBuilder Tests ====================
347+
348+ #[ test]
349+ fn test_builder_default ( ) {
350+ let builder = FileHeaderBuilder :: default ( ) ;
351+ // Missing slen should fail to build
352+ assert ! ( builder. build( ) . is_err( ) ) ;
353+ }
354+
355+ #[ test]
356+ fn test_builder_bitsize ( ) {
357+ let header = FileHeaderBuilder :: new ( )
358+ . slen ( 64 )
359+ . bitsize ( BitSize :: Four )
360+ . build ( )
361+ . unwrap ( ) ;
362+ assert_eq ! ( header. bits, BitSize :: Four ) ;
363+ }
364+
365+ #[ test]
366+ fn test_builder_missing_slen ( ) {
367+ let result = FileHeaderBuilder :: new ( ) . xlen ( 10 ) . build ( ) ;
368+ assert ! ( result. is_err( ) ) ;
369+ }
370+
371+ // ==================== FileHeader Constructor Tests ====================
372+
373+ #[ test]
374+ fn test_header_new ( ) {
375+ let header = FileHeader :: new ( BitSize :: Two , 100 , true ) ;
376+ assert_eq ! ( header. slen, 100 ) ;
377+ assert_eq ! ( header. xlen, 0 ) ;
378+ assert ! ( header. flags) ;
379+ assert ! ( !header. is_paired( ) ) ;
380+ }
381+
382+ #[ test]
383+ fn test_header_new_extended ( ) {
384+ let header = FileHeader :: new_extended ( BitSize :: Four , 100 , 50 , false ) ;
385+ assert_eq ! ( header. slen, 100 ) ;
386+ assert_eq ! ( header. xlen, 50 ) ;
387+ assert_eq ! ( header. bits, BitSize :: Four ) ;
388+ assert ! ( header. is_paired( ) ) ;
389+ }
390+
391+ #[ test]
392+ fn test_set_bitsize ( ) {
393+ let mut header = FileHeader :: new ( BitSize :: Two , 100 , false ) ;
394+ header. set_bitsize ( BitSize :: Four ) ;
395+ assert_eq ! ( header. bits, BitSize :: Four ) ;
396+ }
397+
398+ // ==================== from_bytes Tests ====================
399+
400+ #[ test]
401+ fn test_from_bytes_invalid_format_version ( ) {
402+ let header = FileHeader :: new ( BitSize :: Two , 32 , false ) ;
403+ let mut buffer = [ 0u8 ; SIZE_HEADER ] ;
404+ let mut cursor = std:: io:: Cursor :: new ( & mut buffer[ ..] ) ;
405+ header. write_bytes ( & mut cursor) . unwrap ( ) ;
406+ buffer[ 4 ] = 99 ; // corrupt format version
407+ let result = FileHeader :: from_bytes ( & buffer) ;
408+ assert ! ( result. is_err( ) ) ;
409+ }
410+
411+ #[ test]
412+ fn test_from_bytes_four_bit_size ( ) {
413+ let header = FileHeader :: new ( BitSize :: Four , 32 , false ) ;
414+ let mut buffer = [ 0u8 ; SIZE_HEADER ] ;
415+ let mut cursor = std:: io:: Cursor :: new ( & mut buffer[ ..] ) ;
416+ header. write_bytes ( & mut cursor) . unwrap ( ) ;
417+ let parsed = FileHeader :: from_bytes ( & buffer) . unwrap ( ) ;
418+ assert_eq ! ( parsed. bits, BitSize :: Four ) ;
419+ }
420+
421+ #[ test]
422+ fn test_from_bytes_invalid_bitsize ( ) {
423+ let header = FileHeader :: new ( BitSize :: Two , 32 , false ) ;
424+ let mut buffer = [ 0u8 ; SIZE_HEADER ] ;
425+ let mut cursor = std:: io:: Cursor :: new ( & mut buffer[ ..] ) ;
426+ header. write_bytes ( & mut cursor) . unwrap ( ) ;
427+ buffer[ 13 ] = 99 ; // corrupt bitsize byte
428+ let result = FileHeader :: from_bytes ( & buffer) ;
429+ assert ! ( result. is_err( ) ) ;
430+ }
431+
432+ #[ test]
433+ fn test_from_bytes_invalid_magic ( ) {
434+ let buffer = [ 0u8 ; SIZE_HEADER ] ;
435+ let result = FileHeader :: from_bytes ( & buffer) ;
436+ assert ! ( result. is_err( ) ) ;
437+ }
438+
439+ // ==================== from_buffer Tests ====================
440+
441+ #[ test]
442+ fn test_from_buffer_too_small ( ) {
443+ let buffer = [ 0u8 ; 10 ] ;
444+ let result = FileHeader :: from_buffer ( & buffer) ;
445+ assert ! ( result. is_err( ) ) ;
446+ }
447+
448+ #[ test]
449+ fn test_from_buffer_valid ( ) {
450+ let header = FileHeader :: new ( BitSize :: Two , 32 , false ) ;
451+ let mut buffer = Vec :: new ( ) ;
452+ header. write_bytes ( & mut buffer) . unwrap ( ) ;
453+ buffer. extend_from_slice ( & [ 0u8 ; 16 ] ) ; // trailing data beyond header
454+ let parsed = FileHeader :: from_buffer ( & buffer) . unwrap ( ) ;
455+ assert_eq ! ( parsed. slen, 32 ) ;
456+ }
457+
458+ // ==================== from_reader Tests ====================
459+
460+ #[ test]
461+ fn test_from_reader_valid ( ) {
462+ let header = FileHeader :: new_extended ( BitSize :: Two , 32 , 16 , true ) ;
463+ let mut buffer = Vec :: new ( ) ;
464+ header. write_bytes ( & mut buffer) . unwrap ( ) ;
465+ let mut cursor = std:: io:: Cursor :: new ( buffer) ;
466+ let parsed = FileHeader :: from_reader ( & mut cursor) . unwrap ( ) ;
467+ assert_eq ! ( parsed, header) ;
468+ }
469+
470+ #[ test]
471+ fn test_from_reader_truncated ( ) {
472+ let mut cursor = std:: io:: Cursor :: new ( vec ! [ 0u8 ; 5 ] ) ;
473+ let result = FileHeader :: from_reader ( & mut cursor) ;
474+ assert ! ( result. is_err( ) ) ;
475+ }
476+ }
0 commit comments