Added unit tests

Cargo.toml

@@ -41,7 +41,7 @@ error-chain = "0.8"
 owning_ref = "0.3"
 stable_deref_trait = "1.0.0"
 rust-stemmers = "0.1.0"
-downcast = "0.9"
+downcast = { version="0.9", features = ["nightly"]}
 matches = "0.1"
 
 [target.'cfg(windows)'.dependencies]

src/query/boolean_query/mod.rs

@@ -10,11 +10,17 @@ mod tests {
     use query::Occur;
     use query::Query;
     use query::TermQuery;
+    use query::Intersection;
+    use query::Scorer;
+    use query::term_query::TermScorer;
     use collector::tests::TestCollector;
     use Index;
+    use downcast::Downcast;
     use schema::*;
-    use schema::IndexRecordOption;
     use query::QueryParser;
+    use query::RequiredOptionalScorer;
+    use query::score_combiner::SumWithCoordsCombiner;
+
 
 
     fn aux_test_helper() -> (Index, Field) {
@@ -56,10 +62,58 @@ mod tests {
         let (index, text_field) = aux_test_helper();
         let query_parser = QueryParser::for_index(&index, vec![text_field]);
         let query = query_parser.parse_query("(+a +b) d").unwrap();
-        println!("{:?}", query);
         assert_eq!(query.count(&*index.searcher()).unwrap(), 3);
     }
 
+    #[test]
+    pub fn test_boolean_single_must_clause() {
+        let (index, text_field) = aux_test_helper();
+        let query_parser = QueryParser::for_index(&index, vec![text_field]);
+        let query = query_parser.parse_query("+a").unwrap();
+        let searcher = index.searcher();
+        let weight = query.weight(&*searcher, true).unwrap();
+        let scorer = weight.scorer(searcher.segment_reader(0u32)).unwrap();
+        assert!(Downcast::<TermScorer>::is_type(&*scorer));
+    }
+
+    #[test]
+    pub fn test_boolean_termonly_intersection() {
+        let (index, text_field) = aux_test_helper();
+        let query_parser = QueryParser::for_index(&index, vec![text_field]);
+        let searcher = index.searcher();
+        {
+            let query = query_parser.parse_query("+a +b +c").unwrap();
+            let weight = query.weight(&*searcher, true).unwrap();
+            let scorer = weight.scorer(searcher.segment_reader(0u32)).unwrap();
+            assert!(Downcast::<Intersection<TermScorer>>::is_type(&*scorer));
+        }
+        {
+            let query = query_parser.parse_query("+a +(b c)").unwrap();
+            let weight = query.weight(&*searcher, true).unwrap();
+            let scorer = weight.scorer(searcher.segment_reader(0u32)).unwrap();
+            assert!(Downcast::<Intersection<Box<Scorer>>>::is_type(&*scorer));
+        }
+    }
+
+    #[test]
+    pub fn test_boolean_reqopt() {
+        let (index, text_field) = aux_test_helper();
+        let query_parser = QueryParser::for_index(&index, vec![text_field]);
+        let searcher = index.searcher();
+        {
+            let query = query_parser.parse_query("+a b").unwrap();
+            let weight = query.weight(&*searcher, true).unwrap();
+            let scorer = weight.scorer(searcher.segment_reader(0u32)).unwrap();
+            assert!(Downcast::<RequiredOptionalScorer<Box<Scorer>, Box<Scorer>, SumWithCoordsCombiner>>::is_type(&*scorer));
+        }
+        {
+            let query = query_parser.parse_query("+a b").unwrap();
+            let weight = query.weight(&*searcher, false).unwrap();
+            let scorer = weight.scorer(searcher.segment_reader(0u32)).unwrap();
+            assert!(Downcast::<TermScorer>::is_type(&*scorer));
+        }
+    }
+
     #[test]
     pub fn test_boolean_query() {
 

src/query/query_parser/query_grammar.rs

@@ -41,10 +41,10 @@ fn leaf<I>(input: I) -> ParseResult<UserInputAST, I>
 where
     I: Stream<Item = char>,
 {
-    (char('-'), parser(literal)).map(|(_, expr)| UserInputAST::Not(box expr))
-        .or((char('+'), parser(literal)).map(|(_, expr)| UserInputAST::Must(box expr)))
-        .or(parser(literal))
+    (char('-'), parser(leaf)).map(|(_, expr)| UserInputAST::Not(box expr))
+        .or((char('+'), parser(leaf)).map(|(_, expr)| UserInputAST::Must(box expr)))
         .or((char('('), parser(parse_to_ast), char(')')).map(|(_, expr, _)| expr))
+        .or(parser(literal))
         .parse_stream(input)
 }
 
@@ -80,6 +80,7 @@ mod test {
 
     #[test]
     fn test_parse_query_to_ast() {
+        test_parse_query_to_ast_helper("+(a b) +d", "(+((\"a\" \"b\")) +(\"d\"))");
         test_parse_query_to_ast_helper("(+a +b) d", "((+(\"a\") +(\"b\")) \"d\")");
         test_parse_query_to_ast_helper("(+a)", "+(\"a\")");
         test_parse_query_to_ast_helper("(+a +b)", "(+(\"a\") +(\"b\"))");