ferret 0.3.2 → 0.9.0

data/test/unit/document/tc_field.rb

@@ -25,70 +25,4 @@ class FieldTest < Test::Unit::TestCase
     assert_equal("WITH_OFFSETS", Field::TermVector::WITH_OFFSETS.to_s)
     assert_equal("WITH_POSITIONS_OFFSETS", Field::TermVector::WITH_POSITIONS_OFFSETS.to_s)
   end
-
-  def test_standard_field()
-    f = Field.new("name", "value", Field::Store::COMPRESS, Field::Index::TOKENIZED)
-    assert_equal("name", f.name)
-    assert_equal("value", f.data)
-    assert_equal(true, f.stored?)
-    assert_equal(true, f.compressed?)
-    assert_equal(true, f.indexed?)
-    assert_equal(true, f.tokenized?)
-    assert_equal(false, f.store_term_vector?)
-    assert_equal(false, f.store_offsets?)
-    assert_equal(false, f.store_positions?)
-    assert_equal(false, f.omit_norms?)
-    assert_equal(false, f.binary?)
-    assert_equal("stored/compressed,indexed,tokenized,<name:value>", f.to_s)
-  end
-
-  def test_set_store()
-    f = Field.new("name", nil, Field::Store::COMPRESS, Field::Index::TOKENIZED)
-    f.stored = Field::Store::NO
-    assert_equal(false, f.stored?)
-    assert_equal(false, f.compressed?)
-    assert_equal("indexed,tokenized,<name:>", f.to_s)
-  end
-
-  def test_set_index()
-    f = Field.new("name", "value", Field::Store::COMPRESS, Field::Index::TOKENIZED)
-    f.index = Field::Index::NO
-    assert_equal(false, f.indexed?)
-    assert_equal(false, f.tokenized?)
-    assert_equal(false, f.omit_norms?)
-    assert_equal("stored/compressed,<name:value>", f.to_s)
-    f.index = Field::Index::NO_NORMS
-    assert_equal(true, f.indexed?)
-    assert_equal(false, f.tokenized?)
-    assert_equal(true, f.omit_norms?)
-    assert_equal("stored/compressed,indexed,omit_norms,<name:value>", f.to_s)
-  end
-
-  def test_set_term_vector()
-    f = Field.new("name", "value", Field::Store::COMPRESS, Field::Index::TOKENIZED)
-    f.store_term_vector = Field::TermVector::WITH_POSITIONS_OFFSETS
-    assert_equal(true, f.store_term_vector?)
-    assert_equal(true, f.store_offsets?)
-    assert_equal(true, f.store_positions?)
-    assert_equal("stored/compressed,indexed,tokenized,store_term_vector,tv_offset,tv_position,<name:value>", f.to_s)
-  end
-
-  def test_new_binary_field()
-    tmp = []
-    256.times {|i| tmp[i] = i}
-    bin = tmp.pack("c*")
-    f = Field.new_binary_field("name", bin, Field::Store::YES)
-    assert_equal("name", f.name)
-    assert_equal(bin, f.data)
-    assert_equal(true, f.stored?)
-    assert_equal(false, f.compressed?)
-    assert_equal(false, f.indexed?)
-    assert_equal(false, f.tokenized?)
-    assert_equal(false, f.store_term_vector?)
-    assert_equal(false, f.store_offsets?)
-    assert_equal(false, f.store_positions?)
-    assert_equal(false, f.omit_norms?)
-    assert_equal(true, f.binary?)
-    assert_equal("stored/uncompressed,binary,<name:#{bin}>", f.to_s)
-  end
 end

data/test/unit/index/{tc_index.rb → c_index.rb}

@@ -16,7 +16,10 @@ class IndexTest < Test::Unit::TestCase
 
   def check_results(index, query, expected)
     cnt = 0
+    #puts "#{query} - #{expected.inspect}"
+    #puts index.size
     index.search_each(query) do |doc, score|
+      #puts "doc-#{doc} score=#{score}"
       assert(expected.index(doc))
       cnt += 1
     end
@@ -136,7 +139,7 @@ class IndexTest < Test::Unit::TestCase
     do_test_index_with_hash(index)
     index.close
 
-    index = Index.new(:default_field => "def_field")
+    index = Index.new(:default_field => "def_field", :id_field => "id")
     do_test_index_with_doc_array(index)
     index.close
   end
@@ -144,7 +147,11 @@ class IndexTest < Test::Unit::TestCase
   def test_fs_index
     fs_path = File.expand_path(File.join(File.dirname(__FILE__), '../../temp/fsdir'))
     Dir[File.join(fs_path, "*")].each {|path| begin File.delete(path) rescue nil end}
-    assert_raise(Errno::ENOENT) {Index.new(:path => fs_path, :create_if_missing => false, :default_field => "def_field")}
+    assert_raise(StandardError) do
+      Index.new(:path => fs_path,
+                :create_if_missing => false,
+                :default_field => "def_field")
+    end
     index = Index.new(:path => fs_path, :default_field => "def_field")
     do_test_index_with_array(index)
     index.close
@@ -155,7 +162,9 @@ class IndexTest < Test::Unit::TestCase
     index.close
 
     Dir[File.join(fs_path, "*")].each {|path| begin File.delete(path) rescue nil end}
-    index = Index.new(:path => fs_path, :default_field => "def_field")
+    index = Index.new(:path => fs_path,
+                      :default_field => "def_field",
+                      :id_field => "id")
     do_test_index_with_doc_array(index)
     index.close
   end
@@ -317,12 +326,16 @@ class IndexTest < Test::Unit::TestCase
     index2 << "document 2"
     assert_equal(2, index2.size)
     assert_equal(2, index.size)
+    top_docs = index.search("content3")
+    assert_equal(0, top_docs.size)
 
     iw = IndexWriter.new(fs_path, :analyzer => WhiteSpaceAnalyzer.new())
     doc = Document.new
     doc << Field.new("f", "content3", Field::Store::YES, Field::Index::TOKENIZED)
     iw << doc
     iw.close()
+    top_docs = index.search("content3")
+    assert_equal(1, top_docs.size)
     assert_equal(3, index.size)
     assert_equal("content3", index[2]["f"])
     index.close
@@ -373,7 +386,8 @@ class IndexTest < Test::Unit::TestCase
       {:id => 9, :cat => "/cat2/subcat5", :content => "content9"},
     ]
     index = Index.new(:analyzer => WhiteSpaceAnalyzer.new,
-                      :default_field => :content)
+                      :default_field => :content,
+                      :id_field => :id)
     data.each { |doc| index << doc }
     assert_equal(10, index.size)
     assert_equal("content5", index["5"][:content])
@@ -449,6 +463,39 @@ class IndexTest < Test::Unit::TestCase
     index.close
   end
 
+  def test_index_multi_key_untokenized
+    data = [
+      {:id => 0, :table => "Product", :product => "tent"},
+      {:id => 0, :table => "location", :location => "first floor"},
+      {:id => 0, :table => "Product", :product => "super tent"},
+      {:id => 0, :table => "location", :location => "second floor"},
+      {:id => 1, :table => "Product", :product => "backback"},
+      {:id => 1, :table => "location", :location => "second floor"},
+      {:id => 1, :table => "location", :location => "first floor"},
+      {:id => 1, :table => "Product", :product => "rucksack"},
+      {:id => 1, :table => "Product", :product => "backpack"}
+    ]
+    index = Index.new(:analyzer => Analyzer.new,
+                      :key => ["id", "table"])
+    data.each do |dat|
+      doc = Document.new
+      dat.each_pair do |key, value|
+        if ([:id, :table].include?(key))
+          doc << Field.new(key, value, Field::Store::YES, Field::Index::UNTOKENIZED)
+        else
+          doc << Field.new(key, value, Field::Store::YES, Field::Index::TOKENIZED)
+        end
+      end
+      index << doc 
+    end
+    assert_equal(4, index.size)
+    assert_equal("super tent", index[0][:product])
+    assert_equal("second floor", index[1][:location])
+    assert_equal("backpack", index[3][:product])
+    assert_equal("first floor", index[2][:location])
+    index.close
+  end
+
   def test_sortby_date
     data = [
       {:content => "one", :date => "20051023"},
@@ -459,7 +506,7 @@ class IndexTest < Test::Unit::TestCase
       {:content => "three", :date => "19790531"},
       {:content => "one", :date => "19770725"},
       {:content => "two", :date => "19751226"},
-      {:content => "three", :date => "19390912"}
+      {:content => "four", :date => "19390912"}
     ]
     index = Index.new(:analyzer => WhiteSpaceAnalyzer.new)
     data.each { |doc|
@@ -481,8 +528,17 @@ class IndexTest < Test::Unit::TestCase
     assert_equal("19390912", index[top_docs.score_docs[0].doc][:date])
     assert_equal("three four", index[top_docs.score_docs[0].doc][:content])
     assert_equal("19390912", index[top_docs.score_docs[1].doc][:date])
-    assert_equal("three", index[top_docs.score_docs[1].doc][:content])
+    assert_equal("four", index[top_docs.score_docs[1].doc][:content])
     assert_equal("19530315", index[top_docs.score_docs[2].doc][:date])
+
+    top_docs = index.search("one two three four",
+                            :sort => [:date, :content])
+    assert_equal("19390912", index[top_docs.score_docs[0].doc][:date])
+    assert_equal("four", index[top_docs.score_docs[0].doc][:content])
+    assert_equal("19390912", index[top_docs.score_docs[1].doc][:date])
+    assert_equal("three four", index[top_docs.score_docs[1].doc][:content])
+    assert_equal("19530315", index[top_docs.score_docs[2].doc][:date])
+
     index.close
   end
 

data/test/unit/index/{tc_index_reader.rb → c_index_reader.rb}

@@ -15,6 +15,47 @@ module IndexReaderCommon
 
     do_test_get_doc()
 
+    do_test_term_enum()
+  end
+
+  def do_test_term_enum()
+    te = @ir.terms
+
+    assert(te.next?)
+    assert_equal(Term.new("author", "Leo"), te.term)
+    assert_equal(1, te.doc_freq)
+    assert(te.next?)
+    assert_equal(Term.new("author", "Tolstoy"), te.term)
+    assert_equal(1, te.doc_freq)
+    assert(te.next?)
+    assert_equal(Term.new("body", "And"), te.term)
+    assert_equal(1, te.doc_freq)
+
+
+    assert(te.skip_to(Term.new("body", "Not")))
+    assert_equal(Term.new("body", "Not"), te.term)
+    assert_equal(1, te.doc_freq)
+    assert(te.next?)
+    assert_equal(Term.new("body", "Random"), te.term)
+    assert_equal(16, te.doc_freq)
+
+    assert(te.skip_to(Term.new("text", "which")))
+    assert(Term.new("text", "which"), te.term)
+    assert_equal(1, te.doc_freq)
+    assert(te.next?)
+    assert_equal(Term.new("title", "War And Peace"), te.term)
+    assert_equal(1, te.doc_freq)
+    assert(!te.next?)
+
+    te.close
+
+    te = @ir.terms_from(Term.new("body", "Not"))
+    assert_equal(Term.new("body", "Not"), te.term)
+    assert_equal(1, te.doc_freq)
+    assert(te.next?)
+    assert_equal(Term.new("body", "Random"), te.term)
+    assert_equal(16, te.doc_freq)
+    te.close
   end
 
   def do_test_term_doc_enum()
@@ -155,7 +196,7 @@ module IndexReaderCommon
 
     assert_equal("body", tv.field)
     assert_equal(["word1", "word2", "word3", "word4"], tv.terms)
-    assert_equal([3, 1, 4, 2], tv.term_frequencies)
+    assert_equal([3, 1, 4, 2], tv.freqs)
     assert_equal([[2, 4, 7], [3], [0, 5, 8, 9], [1,6]], tv.positions)
     assert_equal([[t(12,17), t(24,29), t(42,47)],
                   [t(18,23)],
@@ -489,15 +530,15 @@ class IndexReaderTest < Test::Unit::TestCase
     doc << Field.new("title", "this is the title DocField", Field::Store::YES, Field::Index::UNTOKENIZED, Field::TermVector::WITH_POSITIONS_OFFSETS)
     doc << Field.new("author", "this is the author field", Field::Store::YES, Field::Index::UNTOKENIZED, Field::TermVector::WITH_POSITIONS_OFFSETS)
 
-    fis = FieldInfos.new()
-    fis << doc
-    assert_equal(4, fis.size)
+    #fis = FieldInfos.new()
+    #fis << doc
+    #assert_equal(4, fis.size)
 
-    fi = fis["tag"]
-    assert_equal(true, fi.indexed?)
-    assert_equal(true, fi.store_term_vector?)
-    assert_equal(true, fi.store_positions?)
-    assert_equal(true, fi.store_offsets?)
+    #fi = fis["tag"]
+    #assert_equal(true, fi.indexed?)
+    #assert_equal(true, fi.store_term_vector?)
+    #assert_equal(true, fi.store_positions?)
+    #assert_equal(true, fi.store_offsets?)
 
     iw << doc
     iw.close()
@@ -549,7 +590,7 @@ class IndexReaderTest < Test::Unit::TestCase
 
     assert_equal("body", tv.field)
     assert_equal(["word1", "word2", "word3", "word4"], tv.terms)
-    assert_equal([3, 1, 4, 2], tv.term_frequencies)
+    assert_equal([3, 1, 4, 2], tv.freqs)
     assert_equal([[2, 4, 7], [3], [0, 5, 8, 9], [1,6]], tv.positions)
     assert_equal([[t(12,17), t(24,29), t(42,47)],
                   [t(18,23)],

data/test/unit/index/{tc_index_writer.rb → c_index_writer.rb}

@@ -30,8 +30,6 @@ class IndexWriterTest < Test::Unit::TestCase
   def test_add_document
     iw = IndexWriter.new(@dir, :analyzer => StandardAnalyzer.new(), :create => true)
     doc = IndexTestHelper.prepare_document()
-    infos = FieldInfos.new
-    infos << doc
     iw.add_document(doc)
     assert_equal(1, iw.doc_count)
     iw.close()
@@ -44,8 +42,6 @@ class IndexWriterTest < Test::Unit::TestCase
     iw.merge_factor = 3
     iw.min_merge_docs = 3
     docs = IndexTestHelper.prepare_book_list()
-    infos = FieldInfos.new
-    infos << docs[0]
     docs.each_with_index do |doc, i|
       #puts "Index doc " + i.to_s
       iw.add_document(doc)

data/test/unit/index/{tc_term.rb → c_term.rb}

@@ -1,6 +1,5 @@
 require File.dirname(__FILE__) + "/../../test_helper"
 
-
 class TermTest < Test::Unit::TestCase
   include Ferret::Index
   def test_term()
@@ -16,7 +15,6 @@ class TermTest < Test::Unit::TestCase
     assert(term1 == term4)
     assert(term1.eql?(term4))
     term4.set!("field3", "text3")
-    assert(term1 != term4)
+    assert_not_equal(term1, term4)
   end
-
 end

data/test/unit/index/{tc_term_vector_offset_info.rb → c_term_voi.rb}

@@ -5,14 +5,14 @@ class TermVectorOffsetInfoTest < Test::Unit::TestCase
   include Ferret::Index
   def test_tvoi()
     t1 = TermVectorOffsetInfo.new(1, 3)
-    assert_equal(t1.start_offset, 1)
-    assert_equal(t1.end_offset, 3)
+    assert_equal(t1.start, 1)
+    assert_equal(t1.end, 3)
     t2 = TermVectorOffsetInfo.new(1, 3)
     assert(t1 == t2)
-    t2.start_offset = 2
+    t2.start = 2
     assert(t1 != t2)
-    t2.start_offset = 1
-    t2.end_offset = 1
+    t2.start = 1
+    t2.end = 1
     assert(t1 != t2)
   end
 end

data/test/unit/index/tc_segment_term_vector.rb

@@ -17,7 +17,7 @@ class SegmentTermVectorTest < Test::Unit::TestCase
 
   def test_index_of()
     assert_equal(0, @stv.index_of("Apples"))
-    assert_equal(4, @stv.term_frequencies[@stv.index_of("Apples")])
+    assert_equal(4, @stv.freqs[@stv.index_of("Apples")])
   end
 
   def test_indexes_of()
@@ -56,7 +56,7 @@ class SegmentTermVectorWithPosOffsetsTest < Test::Unit::TestCase
 
   def test_index_of()
     assert_equal(0, @stv.index_of("Apples"))
-    assert_equal(4, @stv.term_frequencies[@stv.index_of("Apples")])
+    assert_equal(4, @stv.freqs[@stv.index_of("Apples")])
   end
 
   def test_indexes_of()

data/test/unit/index/tc_term_vectors_io.rb

@@ -33,12 +33,12 @@ class TermVectorsIOTest < Test::Unit::TestCase
 
     assert_equal(2, tv.size)
     assert_equal("text1", tv.terms[0])
-    assert_equal(1, tv.term_frequencies[0])
+    assert_equal(1, tv.freqs[0])
     assert_equal(1, tv.positions[0][0])
     assert_equal(t(0,4), tv.offsets[0][0])
 
     assert_equal("text2", tv.terms[1])
-    assert_equal(2, tv.term_frequencies[1])
+    assert_equal(2, tv.freqs[1])
     assert_equal(3, tv.positions[1][0])
     assert_equal(t(5,10), tv.offsets[1][0])
     assert_equal(4, tv.positions[1][1])
@@ -77,7 +77,7 @@ class TermVectorsIOTest < Test::Unit::TestCase
 
     assert_equal(2, tv.size)
     assert_equal("word1", tv.terms[0])
-    assert_equal(3, tv.term_frequencies[0])
+    assert_equal(3, tv.freqs[0])
     assert_equal(1, tv.positions[0][0])
     assert_equal(5, tv.positions[0][1])
     assert_equal(8, tv.positions[0][2])
@@ -86,7 +86,7 @@ class TermVectorsIOTest < Test::Unit::TestCase
     assert_equal(t(45,50), tv.offsets[0][2])
 
     assert_equal("word2", tv.terms[1])
-    assert_equal(2, tv.term_frequencies[1])
+    assert_equal(2, tv.freqs[1])
     assert_equal(2, tv.positions[1][0])
     assert_equal(9, tv.positions[1][1])
     assert_equal(t(6,11), tv.offsets[1][0])

data/test/unit/query_parser/c_query_parser.rb

@@ -0,0 +1,138 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+class QueryParserTest < Test::Unit::TestCase
+
+  def test_strings()
+    parser = Ferret::QueryParser.new("xxx", :fields => ["xxx", "field", "f1", "f2"])
+    pairs = [
+      ['', ''],
+      ['word', 'word'],
+      ['field:word', 'field:word'],
+      ['"word1 word2 word3"', '"word word word"'],
+      ['"word1 2342 word3"', '"word word"'],
+      ['field:"one two three"', 'field:"one two three"'],
+      ['field:"one 222 three"', 'field:"one three"'],
+      ['field:"one <> three"', 'field:"one <> three"'],
+      ['field:"one <> three <>"', 'field:"one <> three"'],
+      ['field:"one <> <> <> three <>"', 'field:"one <> <> <> three"'],
+      ['field:"one <> <> <> three|four|five <>"', 'field:"one <> <> <> three|four|five"'],
+      ['field:"one|two three|four|five six|seven"', 'field:"one|two three|four|five six|seven"'],
+      ['field:"testing|trucks"', 'field:testing field:trucks'],
+      ['[aaa bbb]', '[aaa bbb]'],
+      ['{aaa bbb]', '{aaa bbb]'],
+      ['field:[aaa bbb}', 'field:[aaa bbb}'],
+      ['{aaa bbb}', '{aaa bbb}'],
+      ['{aaa>', '{aaa>'],
+      ['[aaa>', '[aaa>'],
+      ['field:<aaa}', 'field:<aaa}'],
+      ['<aaa]', '<aaa]'],
+      ['>aaa', '{aaa>'],
+      ['>=aaa', '[aaa>'],
+      ['<aaa', '<aaa}'],
+      ['field:<=aaa', 'field:<aaa]'],
+      ['REQ one REQ two', '+one +two'],
+      ['REQ one two', '+one two'],
+      ['one REQ two', 'one +two'],
+      ['+one +two', '+one +two'],
+      ['+one two', '+one two'],
+      ['one +two', 'one +two'],
+      ['-one -two', '-one -two'],
+      ['-one two', '-one two'],
+      ['one -two', 'one -two'],
+      ['!one !two', '-one -two'],
+      ['!one two', '-one two'],
+      ['one !two', 'one -two'],
+      ['NOT one NOT two', '-one -two'],
+      ['NOT one two', '-one two'],
+      ['one NOT two', 'one -two'],
+      ['one two', 'one two'],
+      ['one OR two', 'one two'],
+      ['one AND two', '+one +two'],
+      ['one two AND three', 'one two +three'],
+      ['one two OR three', 'one two three'],
+      ['one (two AND three)', 'one (+two +three)'],
+      ['one AND (two OR three)', '+one +(two three)'],
+      ['field:(one AND (two OR three))', '+field:one +(field:two field:three)'],
+      ['one AND (two OR [aaa vvv})', '+one +(two [aaa vvv})'],
+      ['one AND (f1:two OR f2:three) AND four', '+one +(f1:two f2:three) +four'],
+      ['one^1.23', 'one^1.23'],
+      ['(one AND two)^100.23', '(+one +two)^100.23'],
+      ['field:(one AND two)^100.23', '(+field:one +field:two)^100.23'],
+      ['field:(one AND [aaa bbb]^23.3)^100.23', '(+field:one +field:[aaa bbb]^23.3)^100.23'],
+      ['(REQ field:"one two three")^23', 'field:"one two three"^23.0'],
+      ['asdf~0.2', 'asdf~0.2'],
+      ['field:asdf~0.2', 'field:asdf~0.2'],
+      ['asdf~0.2^100.0', 'asdf~0.2^100.0'],
+      ['field:asdf~0.2^0.1', 'field:asdf~0.2^0.1'],
+      ['field:"asdf <> asdf|asdf"~4', 'field:"asdf <> asdf|asdf"~4'],
+      ['"one two three four five"~5', '"one two three four five"~5'],
+      ['ab?de', 'ab?de'],
+      ['ab*de', 'ab*de'],
+      ['asdf?*?asd*dsf?asfd*asdf?', 'asdf?*?asd*dsf?asfd*asdf?'],
+      ['field:a* AND field:(b*)', '+field:a* +field:b*'],
+      ['field:abc~ AND field:(b*)', '+field:abc~ +field:b*'],
+      ['asdf?*?asd*dsf?asfd*asdf?^20.0', 'asdf?*?asd*dsf?asfd*asdf?^20.0'],
+
+      ['*:xxx', 'xxx field:xxx f1:xxx f2:xxx'],
+      ['f1|f2:xxx', 'f1:xxx f2:xxx'],
+
+      ['*:asd~0.2', 'asd~0.2 field:asd~0.2 f1:asd~0.2 f2:asd~0.2'],
+      ['f1|f2:asd~0.2', 'f1:asd~0.2 f2:asd~0.2'],
+
+      ['*:a?d*^20.0', '(a?d* field:a?d* f1:a?d* f2:a?d*)^20.0'],
+      ['f1|f2:a?d*^20.0', '(f1:a?d* f2:a?d*)^20.0'],
+
+      ['*:"asdf <> xxx|yyy"', '"asdf <> xxx|yyy" field:"asdf <> xxx|yyy" f1:"asdf <> xxx|yyy" f2:"asdf <> xxx|yyy"'],
+      ['f1|f2:"asdf <> xxx|yyy"', 'f1:"asdf <> xxx|yyy" f2:"asdf <> xxx|yyy"'],
+
+      ['*:[bbb xxx]', '[bbb xxx] field:[bbb xxx] f1:[bbb xxx] f2:[bbb xxx]'],
+      ['f1|f2:[bbb xxx]', 'f1:[bbb xxx] f2:[bbb xxx]'],
+
+      ['*:(xxx AND bbb)', '+(xxx field:xxx f1:xxx f2:xxx) +(bbb field:bbb f1:bbb f2:bbb)'],
+      ['f1|f2:(xxx AND bbb)', '+(f1:xxx f2:xxx) +(f1:bbb f2:bbb)'],
+      ['asdf?*?asd*dsf?asfd*asdf?^20.0', 'asdf?*?asd*dsf?asfd*asdf?^20.0'],
+      ['"onewordphrase"', 'onewordphrase']
+    ]
+      
+    pairs.each do |query_str, expected|
+      assert_equal(expected, parser.parse(query_str).to_s("xxx"))
+    end
+  end
+
+  def test_qp_with_standard_analyzer()
+    parser = Ferret::QueryParser.new("xxx", :fields => ["xxx", "key"],
+                                     :analyzer => Ferret::Analysis::StandardAnalyzer.new)
+    pairs = [
+      ['key:1234', 'key:1234'],
+      ['key:(1234)', 'key:1234']
+    ]
+      
+    pairs.each do |query_str, expected|
+      assert_equal(expected, parser.parse(query_str).to_s("xxx"))
+    end
+  end
+  
+  def do_test_query_parse_exception_raised(str)
+    parser = Ferret::QueryParser.new("xxx", :fields => ["f1", "f2", "f3"])
+    assert_raise(Ferret::QueryParser::QueryParseException) do
+      parser.parse(str)
+    end
+  end
+
+  
+  def test_bad_queries
+    parser = Ferret::QueryParser.new("xxx", :fields => ["f1", "f2"],
+                                            :handle_parse_errors => true)
+
+    pairs = [
+      ['::*word', 'word'],
+      ['()*&)(*^&*(', ''],
+      ['()*&one)(*two(*&"', '"one two"']
+    ]
+      
+    pairs.each do |query_str, expected|
+      do_test_query_parse_exception_raised(query_str)
+      assert_equal(expected, parser.parse(query_str).to_s("xxx"))
+    end
+  end
+end