glyph_core/

lib.rs

mod error;
mod format;

pub use error::{GlyphError, Result};
pub use format::{Frame, Glyph};

#[cfg(test)]
mod tests {
    use super::*;
    use std::io::Cursor;

    fn create_test_frame(content: &str) -> Frame {
        Frame::new(content.to_string())
    }

    fn create_test_frame_with_duration(content: &str, duration: u32) -> Frame {
        Frame::with_duration(content.to_string(), duration)
    }

    #[test]
    fn test_frame_creation() {
        let frame = create_test_frame("abc\ndef");
        assert_eq!(frame.content, "abc\ndef");
        assert_eq!(frame.duration_ms, None);

        let frame_with_duration = create_test_frame_with_duration("abc\ndef", 200);
        assert_eq!(frame_with_duration.content, "abc\ndef");
        assert_eq!(frame_with_duration.duration_ms, Some(200));
    }

    #[test]
    fn test_single_frame() {
        let mut glyph = Glyph::new(3, 2, 100);
        let frame = create_test_frame("abc\ndef");
        glyph.add_frame(frame).unwrap();

        let mut buffer = Vec::new();
        glyph.write(&mut buffer).unwrap();

        let mut cursor = Cursor::new(buffer);
        let read_glyph = Glyph::read(&mut cursor).unwrap();

        assert_eq!(read_glyph.width, 3);
        assert_eq!(read_glyph.height, 2);
        assert_eq!(read_glyph.default_duration_ms, 100);
        assert_eq!(read_glyph.frames.len(), 1);
        assert_eq!(read_glyph.frames[0].content, "abc\ndef");
    }

    #[test]
    fn test_multiple_frames() {
        let mut glyph = Glyph::new(3, 2, 100);

        let frame1 = create_test_frame("abc\ndef");
        glyph.add_frame(frame1).unwrap();

        let frame2 = create_test_frame_with_duration("abc\ndEf", 200);
        glyph.add_frame(frame2).unwrap();

        let mut buffer = Vec::new();
        glyph.write(&mut buffer).unwrap();

        let mut cursor = Cursor::new(buffer);
        let read_glyph = Glyph::read(&mut cursor).unwrap();

        assert_eq!(read_glyph.frames.len(), 2);
        assert_eq!(read_glyph.frames[0].content, "abc\ndef");
        assert_eq!(read_glyph.frames[1].content, "abc\ndEf");
        assert_eq!(read_glyph.frames[1].duration_ms, Some(200));
    }

    #[test]
    fn test_invalid_dimensions() {
        let mut glyph = Glyph::new(3, 2, 100);

        // Wrong height
        let frame1 = create_test_frame("abc");
        assert!(matches!(
            glyph.add_frame(frame1),
            Err(GlyphError::InvalidDimensions {
                width: 3,
                height: 1
            })
        ));

        // Wrong width
        let frame2 = create_test_frame("abcd\ndef");
        assert!(matches!(
            glyph.add_frame(frame2),
            Err(GlyphError::InvalidDimensions {
                width: 4,
                height: 2
            })
        ));
    }

    #[test]
    fn test_delta_encoding() {
        let mut glyph = Glyph::new(3, 2, 100);

        // First frame
        glyph.add_frame(create_test_frame("abc\ndef")).unwrap();

        // Second frame with one character changed
        glyph.add_frame(create_test_frame("abC\ndef")).unwrap();

        let mut buffer = Vec::new();
        glyph.write(&mut buffer).unwrap();

        // Verify we can read back the frames correctly
        let mut cursor = Cursor::new(buffer);
        let read_glyph = Glyph::read(&mut cursor).unwrap();

        assert_eq!(read_glyph.frames[0].content, "abc\ndef");
        assert_eq!(read_glyph.frames[1].content, "abC\ndef");

        // Verify the frames have the expected differences
        let different_chars: Vec<_> = read_glyph.frames[0]
            .content
            .chars()
            .zip(read_glyph.frames[1].content.chars())
            .enumerate()
            .filter(|(_, (a, b))| a != b)
            .map(|(i, _)| i)
            .collect();

        assert_eq!(different_chars.len(), 1); // Only one character should be different
        assert_eq!(different_chars[0], 2); // The third character (index 2) should be different
    }

    #[test]
    fn test_invalid_magic_number() {
        let mut buffer = Vec::new();
        buffer.extend_from_slice(b"INVALID"); // Wrong magic number
        let mut cursor = Cursor::new(buffer);
        assert!(matches!(
            Glyph::read(&mut cursor),
            Err(GlyphError::InvalidMagic)
        ));
    }

    #[test]
    fn test_invalid_version() {
        let mut buffer = Vec::new();
        buffer.extend_from_slice(b"GLYF");
        buffer.extend_from_slice(&99u32.to_le_bytes()); // Wrong version
        let mut cursor = Cursor::new(buffer);
        assert!(matches!(
            Glyph::read(&mut cursor),
            Err(GlyphError::InvalidVersion)
        ));
    }

    #[test]
    fn test_empty_glyph() {
        let glyph = Glyph::new(10, 5, 100);
        assert_eq!(glyph.width, 10);
        assert_eq!(glyph.height, 5);
        assert_eq!(glyph.default_duration_ms, 100);
        assert!(glyph.frames.is_empty());
    }

    #[test]
    fn test_large_frame_sequence() {
        let mut glyph = Glyph::new(3, 2, 100);
        let base_frame = "abc\ndef";

        // Add 100 frames with slight modifications
        for i in 0..100 {
            let content = if i == 0 {
                base_frame.to_string()
            } else {
                format!("ab{}\ndef", (b'c' + (i % 26) as u8) as char)
            };
            glyph.add_frame(create_test_frame(&content)).unwrap();
        }

        let mut buffer = Vec::new();
        glyph.write(&mut buffer).unwrap();

        let mut cursor = Cursor::new(buffer);
        let read_glyph = Glyph::read(&mut cursor).unwrap();

        assert_eq!(read_glyph.frames.len(), 100);
        for i in 0..100 {
            let expected = if i == 0 {
                base_frame.to_string()
            } else {
                format!("ab{}\ndef", (b'c' + (i % 26) as u8) as char)
            };
            assert_eq!(read_glyph.frames[i].content, expected);
        }
    }
}