partial parsing possible with PsycParser and PsycListParser

rust/tests/test_dict_parser.rs

@@ -0,0 +1,90 @@
+extern crate psyc;
+use psyc::parser::*;
+
+#[test]
+fn test_parse() {
+    let test_data = "{foo1} bar1{foo2} bar2".to_string().into_bytes();
+
+    let expected1 = PsycDictParserResult::DictEntry{
+        key: b"foo1",
+        value: b"bar1"
+    };
+
+    let expected2 = PsycDictParserResult::DictEntry{
+        key: b"foo2",
+        value: b"bar2"
+    };
+
+    let expected3 = PsycDictParserResult::Complete;
+
+    let mut parser = PsycDictParser::new();
+
+    parser.set_buffer(&test_data);
+
+    assert_eq!(parser.parse().unwrap(), expected1);
+    assert_eq!(parser.parse().unwrap(), expected2);
+    assert_eq!(parser.parse().unwrap(), expected3);
+}
+
+#[test]
+fn test_empty() {
+    let test_data = "".to_string().into_bytes();
+
+    let mut parser = PsycDictParser::new();
+
+    parser.set_buffer(&test_data);
+
+    assert_eq!(parser.parse().unwrap(), PsycDictParserResult::Complete);
+}
+
+#[test]
+fn test_incomplete() {
+    let test_data1 = "{foo1}4 bar".to_string().into_bytes();
+    let test_data2 = "1{foo2} bar2".to_string().into_bytes();
+
+    let expected = vec![PsycDictParserResult::DictEntryStart {
+                            key: b"foo1",
+                            value_part: b"bar"    
+                        },
+                        PsycDictParserResult::DictEntryEnd {
+                           value_part: b"1"
+                        },
+                        PsycDictParserResult::DictEntry {
+                           key: b"foo2",
+                           value: b"bar2"
+                        }];
+
+    let mut parser = PsycDictParser::new();
+
+    parser.set_buffer(&test_data1);
+    assert_eq!(parser.parse().unwrap(), expected[0]);
+
+    parser.set_buffer(&test_data2);
+    assert_eq!(parser.parse().unwrap(), expected[1]);
+
+    assert_eq!(parser.parse().unwrap(), expected[2]);
+}
+
+//#[test]
+//fn test_insufficient() {
+//    let mut test_data1 = "{4 foo".to_string().into_bytes();
+//    let mut test_data2 = "1} bar1".to_string().into_bytes();
+//    let mut test_data3 = "{4 foo1} bar1".to_string().into_bytes();
+//
+//    let expected = vec![PsycDictParserResult::InsufficientData,
+//                        PsycDictParserResult::DictEntry {
+//                            key: b"foo1",
+//                            value: b"bar1"
+//                        }];
+//
+//    let mut parser = PsycDictParser::new();
+//
+//    parser.set_buffer(&test_data1);
+//    assert_eq!(parser.parse().unwrap(), expected[0]);
+//
+//    //let unparsed_length = parser.copy_unparsed_into_buffer(&mut test_data1);
+//    //test_data1.resize(unparsed_length, 0);
+//    //test_data1.append(&mut test_data2);
+//    parser.set_buffer(&test_data3);
+//    assert_eq!(parser.parse().unwrap(), expected[1]);
+//}

rust/tests/test_list_parser.rs

@@ -0,0 +1,90 @@
+extern crate psyc;
+use psyc::parser::*;
+
+#[test]
+fn test_parse() {
+    let test_data = "| element1| element2| element3".to_string().into_bytes();
+
+    let expected1 = PsycListParserResult::ListElement {
+        value: b"element1"
+    };
+
+    let expected2 = PsycListParserResult::ListElement {
+        value: b"element2"
+    };
+    
+    let expected3 = PsycListParserResult::ListElement {
+        value: b"element3"
+    };
+
+    let expected4 = PsycListParserResult::Complete;
+
+    let mut parser = PsycListParser::new();
+
+    parser.set_buffer(&test_data);
+
+    assert_eq!(parser.parse().unwrap(), expected1);
+    assert_eq!(parser.parse().unwrap(), expected2);
+    assert_eq!(parser.parse().unwrap(), expected3);
+    assert_eq!(parser.parse().unwrap(), expected4);
+}
+
+#[test]
+fn test_empty() {
+    let test_data = "".to_string().into_bytes();
+
+    let mut parser = PsycListParser::new();
+
+    parser.set_buffer(&test_data);
+
+    assert_eq!(parser.parse().unwrap(), PsycListParserResult::Complete);
+}
+
+#[test]
+fn test_incomplete() {
+    let test_data1 = "|8 element".to_string().into_bytes();
+    let test_data2 = "1| element2|".to_string().into_bytes();
+
+    let expected = vec![PsycListParserResult::ListElementStart {
+                            value_part: b"element"
+                        },
+                        PsycListParserResult::ListElementEnd {
+                            value_part: b"1"
+                        },
+                        PsycListParserResult::ListElement {
+                            value: b"element2"
+                        }];
+
+    let mut parser = PsycListParser::new();
+
+    parser.set_buffer(&test_data1);
+    assert_eq!(parser.parse().unwrap(), expected[0]);
+
+    parser.set_buffer(&test_data2);
+    assert_eq!(parser.parse().unwrap(), expected[1]);
+
+    assert_eq!(parser.parse().unwrap(), expected[2]);
+}
+
+#[test]
+fn test_insufficient() {
+    let mut test_data1 = "|4".to_string().into_bytes();
+    let mut test_data2 = " foo1".to_string().into_bytes();
+
+    let expected = vec![PsycListParserResult::InsufficientData,
+                        PsycListParserResult::ListElement {
+                            value: b"foo1"
+                        }];
+
+    let mut parser = PsycListParser::new();
+
+    parser.set_buffer(&test_data1);
+
+    assert_eq!(parser.parse().unwrap(), expected[0]);
+
+    let unparsed_length = parser.copy_unparsed_into_buffer(&mut test_data1);
+    test_data1.resize(unparsed_length, 0);
+    test_data1.append(&mut test_data2);
+    parser.set_buffer(&test_data1);
+    assert_eq!(parser.parse().unwrap(), expected[1]);
+}

rust/tests/test_parser.rs

@@ -21,6 +21,43 @@ fn test_parse() {
     assert_eq!(parser.parse().unwrap(), expected[1]);
 }
 
+#[test]
+fn test_empty() {
+    let test_data = "".to_string().into_bytes();
+
+    let mut parser = PsycParser::new();
+
+    parser.set_buffer(&test_data);
+
+    // FIXME: InsufficientData or Complete?
+    assert_eq!(parser.parse().unwrap(), PsycParserResult::InsufficientData);
+}
+
+#[test]
+fn test_incomplete() {
+    let test_data1 = ":_target\tpsyc://ve.symlynx.com/@blog\n\n:_nick 6\t".to_string().into_bytes();
+
+    let test_data2 = "lurchi".to_string().into_bytes();
+
+    let expected = vec![PsycParserResult::EntityModifierStart {
+                            operator: ':',
+                            name: b"_nick",
+                            value_part: b""
+                        },
+                        PsycParserResult::EntityModifierEnd {
+                            value_part: b"lurchi"
+                        }];
+
+    let mut parser = PsycParser::new();
+
+    parser.set_buffer(&test_data1);
+    let _ = parser.parse();
+    assert_eq!(parser.parse().unwrap(), expected[0]);
+
+    parser.set_buffer(&test_data2);
+    assert_eq!(parser.parse().unwrap(), expected[1]);
+}
+
 #[test]
 fn test_insufficient() {
     let mut test_data1 = ":_target\tpsyc://ve.symlynx.com/@blog\n\n:_nick".to_string().into_bytes();