Add tests.

tests/test_adoor2.rs

@@ -0,0 +1,36 @@
+use vocnom::parser::{BlockType, Codec, parse_voc};
+
+#[test]
+fn adoor2_test() {
+    let input = include_bytes!("../assets/ADOOR2.VOC");
+
+    match parse_voc(input) {
+        Ok((_, voc)) => {
+            // Version
+            assert_eq!((voc.version.major, voc.version.minor), (1, 20));
+
+            // Checksum
+            assert_eq!(voc.checksum.valid, true);
+            assert_eq!(voc.checksum.value, 0x111f);
+
+            // Number of blocks
+            assert_eq!(voc.blocks.len(), 2);
+
+            // Sound data new
+            if let BlockType::SoundDataNew { sample_rate, bits, channels, codec, reserved, data} = &voc.blocks[1] {
+                assert_eq!(sample_rate, &11025);
+                assert_eq!(bits, &8);
+                assert_eq!(channels, &1);
+                assert_eq!(codec, &Codec::Pcm8BitUnsigned);
+                assert_eq!(reserved, &0);
+                assert_eq!(data.len(), 21394);
+            }
+
+            // Terminator
+            assert_eq!(&voc.blocks[1], &BlockType::Terminator);
+        }
+        Err(err) => {
+            println!("Error parsing VOC file: {:?}", err);
+        }
+    }
+}

tests/test_conga.rs

@@ -0,0 +1,51 @@
+use vocnom::parser::{BlockType, Codec, parse_voc};
+
+#[test]
+fn conga_test() {
+    let input = include_bytes!("../assets/CONGA.VOC");
+
+    match parse_voc(input) {
+        Ok((_, voc)) => {
+            // Version
+            assert_eq!((voc.version.major, voc.version.minor), (1, 10));
+
+            // Checksum
+            assert_eq!(voc.checksum.valid, true);
+            assert_eq!(voc.checksum.value, 0x1129);
+
+            // Number of blocks
+            assert_eq!(voc.blocks.len(), 8);
+
+            // Repeat start
+            if let BlockType::RepeatStart { count } = &voc.blocks[0] {
+                assert_eq!(count, &1);
+            }
+
+            // Extra information
+            if let BlockType::ExtraInformation { sample_rate, channels, codec} = &voc.blocks[1] {
+                assert_eq!(sample_rate, &11158);
+                assert_eq!(channels, &1);
+                assert_eq!(codec, &Codec::Pcm8BitUnsigned);
+            }
+
+            // Sound data
+            if let BlockType::SoundData { sample_rate, codec, data} = &voc.blocks[2] {
+                assert_eq!(sample_rate, &22222);
+                assert_eq!(codec, &Codec::Pcm8BitUnsigned);
+                assert_eq!(data.len(), 164912);
+            }
+
+            // Repeat end
+            assert_eq!(&voc.blocks[3], &BlockType::RepeatEnd);
+
+            // Terminator
+            assert_eq!(&voc.blocks[4], &BlockType::Terminator);
+            assert_eq!(&voc.blocks[5], &BlockType::Terminator);
+            assert_eq!(&voc.blocks[6], &BlockType::Terminator);
+            assert_eq!(&voc.blocks[7], &BlockType::Terminator);
+        }
+        Err(err) => {
+            println!("Error parsing VOC file: {:?}", err);
+        }
+    }
+}

tests/test_edenmus.rs

@@ -0,0 +1,38 @@
+use vocnom::parser::{BlockType, Codec, parse_voc};
+
+#[test]
+fn edenmus_test() {
+    let input = include_bytes!("../assets/EDEN.MUS");
+
+    match parse_voc(input) {
+        Ok((_, voc)) => {
+            // Version
+            assert_eq!((voc.version.major, voc.version.minor), (1, 10));
+
+            // Checksum
+            assert_eq!(voc.checksum.valid, true);
+            assert_eq!(voc.checksum.value, 0x1129);
+
+            // Number of blocks
+            assert_eq!(voc.blocks.len(), 3);
+
+            // Text block
+            if let BlockType::Text { data} = &voc.blocks[0] {
+                assert_eq!(data.len(), 151);
+            }
+
+            // Sound data
+            if let BlockType::SoundData { sample_rate, codec, data} = &voc.blocks[1] {
+                assert_eq!(sample_rate, &11111);
+                assert_eq!(codec, &Codec::Pcm8BitUnsigned);
+                assert_eq!(data.len(), 809282);
+            }
+
+            // Terminator
+            assert_eq!(&voc.blocks[2], &BlockType::Terminator);
+        }
+        Err(err) => {
+            println!("Error parsing VOC file: {:?}", err);
+        }
+    }
+}

tests/test_guardian.rs

@@ -0,0 +1,35 @@
+use vocnom::parser::{BlockType, Codec, parse_voc};
+
+#[test]
+fn guardian_test() {
+    let input = include_bytes!("../assets/GUARDIAN.VOC");
+
+    match parse_voc(input) {
+        Ok((_, voc)) => {
+            // Version
+            assert_eq!((voc.version.major, voc.version.minor), (1, 10));
+
+            // Checksum
+            assert_eq!(voc.checksum.valid, true);
+            assert_eq!(voc.checksum.value, 0x1129);
+
+            // Number of blocks
+            assert_eq!(voc.blocks.len(), 5);
+
+            // Sound data
+            for idx in 0..4 {
+                if let BlockType::SoundData { sample_rate, codec, data } = &voc.blocks[idx] {
+                    assert_eq!(sample_rate, &16129);
+                    assert_eq!(codec, &Codec::Pcm8BitUnsigned);
+                    assert_eq!(data.len(), 202498);
+                }
+            }
+
+            // Terminator
+            assert_eq!(&voc.blocks[4], &BlockType::Terminator);
+        }
+        Err(err) => {
+            println!("Error parsing VOC file: {:?}", err);
+        }
+    }
+}