redcar 0.9.1 → 0.9.2

data/plugins/project_search/vendor/lucene/spec/lucene/document_spec.rb

@@ -1,32 +0,0 @@
-$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/../../lib")
-require 'lucene'
-
-include Lucene
-
-describe Document do
-  before(:all) do
-    @infos = IndexInfo.new(:my_id)
-    @infos[:value] = {:type => Float}
-  end
-  
-  it "should have field infos" do
-    doc = Document.new(@infos)    
-    doc.field_infos.should be_equal(@infos)
-  end
-  
-  it "should convert fields" do
-    #$LUCENE_LOGGER.level = Logger::DEBUG
-    doc = Document.new(@infos, {:my_id => 1, :value => '1.23'})    
-    doc[:my_id].should be_kind_of(String)
-    doc[:value].should be_kind_of(Float)    
-    doc[:my_id].should == "1"
-    doc[:value].should == 1.23
-    #$LUCENE_LOGGER.level = Logger::WARN
-  end
-  
-  it "should handle multiple fields with the same id" do
-    doc = Document.new(@infos, {:my_id => 1, :name => ['abc', 'def', '123']})    
-    doc[:name].should == ['abc', 'def', '123']
-  end
-end
-

data/plugins/project_search/vendor/lucene/spec/lucene/field_info_spec.rb

@@ -1,70 +0,0 @@
-$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/../../lib")
-require 'lucene'
-
-include Lucene
-
-describe FieldInfo do
-  it "should have default values" do
-    f = FieldInfo.new({})
-    f.store?.should == false
-    f[:store].should == false
-    f[:type].should == String
-  end
-  
-  it "should be possible to override default values" do
-    f = FieldInfo.new(:store => true)
-    f.store?.should == true
-  end
-
-  it "should be possible to set any field" do
-    f = FieldInfo.new(:store => true, :foo => 1, :bar=>2)
-    f[:foo].should == 1
-    f[:bar].should == 2
-  end
-  
-  it "should handle dup - create a new copy of it" do
-    f1 = FieldInfo.new(:store => true, :foo => 1, :bar=>2)
-    f1.freeze
-    f2 = f1.dup
-    f2[:store] = false
-    f1[:store].should be_true
-    f2[:store].should be_false
-  end
-  
-  it "should handle conversion of arrays" do
-    f = FieldInfo.new
-    c = f.convert_to_lucene(['a','b','c'])
-    c.should == ['a', 'b', 'c']
-  end
-  
-  it "should handle conversion of arrays and each value should be converted to correct type" do
-    f = FieldInfo.new
-    f[:type] = Fixnum
-    c = f.convert_to_lucene(['1','2','3'])
-    c.should == ["00000000001", "00000000002", "00000000003"]
-  end
-
-  it "should convert to correct ruby type from a lucene string value" do
-    f = FieldInfo.new
-    f[:type] = Fixnum
-    f.convert_to_ruby("123").should == 123
-  end
-
-  it "should convert Dates to lucene" do
-    f = FieldInfo.new
-    f[:type] = Date
-    f.convert_to_lucene(Date.new(2008,12,15)).should == "20081215"
-  end
-
-  it "should convert Dates from lucene" do
-    f = FieldInfo.new
-    f[:type] = Date
-    d = f.convert_to_ruby('20081215')
-    d.should be_instance_of(Date)
-    d.year.should == 2008
-    d.month.should == 12
-    d.day.should == 15
-  end
-
-end
-

data/plugins/project_search/vendor/lucene/spec/lucene/index_info_spec.rb

@@ -1,76 +0,0 @@
-$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/../../lib")
-require 'lucene'
-
-include Lucene
-
-describe IndexInfo do
-  it "should have an id_field" do
-    f = IndexInfo.new('path')
-    f.id_field = :my_id
-    f.id_field.should == :my_id
-  end
-  
-  it "should have a default for any key" do
-    f = IndexInfo.new('some_path')
-    f[42].should == IndexInfo::DEFAULTS
-    IndexInfo::DEFAULTS[:store].should == false
-    f[42][:store].should == false
-  end
-  
-  it "can set a field by a hash of infos " do
-    # given
-    f = IndexInfo.new('some_path')
-    # when
-    f[:value] = {:type => Float}
-    # then
-    f[:value].should be_kind_of(FieldInfo)
-    f[:value][:type].should == Float
-  end
-
-  it "can set a field by a FieldInfo" do
-    # given
-    f = IndexInfo.new('some_path')
-    # when
-    f[:value] = FieldInfo.new(:type => Float)
-    # then
-    f[:value].should be_kind_of(FieldInfo)
-    f[:value][:type].should == Float
-  end
-
-  it "can set a individual property of a FieldInfo" do
-    # given
-    f = IndexInfo.new('some_path')
-    
-    # when
-    f[:value][:type] = Float
-    
-    # then
-    f[:value].should be_kind_of(FieldInfo)
-    f[:value][:type].should == Float
-  end
-
-  it "can set several individual properties of a FieldInfo" do
-    # given
-    f = IndexInfo.new('some_path')
-    
-    # when
-    f[:value][:type] = Float
-    f[:foo][:type] = Fixnum
-    f[:value][:bar] = 42
-    
-    # then
-    f[:value].object_id.should_not == f[:foo].object_id
-    
-    f[:value][:type].should == Float
-    f[:foo][:type].should == Fixnum
-    f[:value][:bar].should == 42
-  end
-  
-end
-
-describe "IndexInfo::DEFAULTS" do
-  it "should have default values" do
-    IndexInfo::DEFAULTS[:store].should == false
-    IndexInfo::DEFAULTS[:type].should == String
-  end
-end

data/plugins/project_search/vendor/lucene/spec/lucene/index_spec.rb

@@ -1,643 +0,0 @@
-$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/../../lib")
-$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/..")
-require 'lucene'
-require 'lucene/spec_helper'
-
-
-
-describe Index, '(one uncommited document)' do
-  before(:each) do
-    setup_lucene
-    @index = Index.new('my_index')
-    @index.clear
-    @index << {:id => '42', :name => 'andreas'}
-  end
-
-  it "has a to_s method with which says: index path and number of not commited documents" do
-    @index.to_s.should == "Index [path: 'my_index', 1 documents]"
-  end
-
-  it "should be empty after clear" do
-    # when 
-    @index.clear
-
-    # then
-    @index.uncommited.size.should == 0
-  end
-
-  it "should be empty after commit" do
-    # when 
-    @index.commit
-
-    # then
-    @index.uncommited.size.should == 0
-  end
-
-  it "contains one uncommited document" do
-    # then
-    @index.uncommited.size.should == 1
-    @index.uncommited['42'][:id].should == '42'
-    @index.uncommited['42'][:name].should == 'andreas'
-  end
-end
-
-
-describe Index, '(no uncommited documents)' do
-  before(:each) do
-    setup_lucene
-    @index = Index.new 'myindex'
-    @index.clear
-  end
-
-  it "has a to_s method with which says: index path and no uncommited documents" do
-    @index.to_s.should == "Index [path: 'myindex', 0 documents]"
-  end
-
-  it "has no uncommited documents" do
-    @index.uncommited.size.should == 0
-  end
-end
-
-
-describe Index, ".find (range)" do
-  before(:each) do
-    setup_lucene
-    @index = Index.new('some_index')
-    @index.field_infos[:id][:type] = Fixnum
-    @index.field_infos[:value][:type] = Fixnum
-  end
-
-  it "should find docs using an inclusive range query" do
-    # given
-    @docs = {}
-    for i in 1..5 do
-      @index << {:id => i, :value=>i}
-      @docs[i] = @index.uncommited[i]
-    end
-    @index.commit
-
-    # when
-    result = @index.find(:value => 2..4)
-
-    # then
-    result.size.should == 3
-    result.should include(@docs[2], @docs[3], @docs[4])
-  end
-
-  it "should find docs using an inclusive range query with padding 0's" do
-    # given
-    @index << {:id => 3, :value=>3}
-    @index << {:id => 30, :value=>30}
-    @index << {:id => 32, :value=>32}
-    @index << {:id => 100, :value=>100}
-    doc30 = @index.uncommited[30]
-    doc32 = @index.uncommited[32]
-    @index.commit
-
-    # when
-    result = @index.find(:value => 30..35)
-
-    # then
-    result.size.should == 2
-    result.should include(doc30, doc32)
-  end
-
-end
-
-
-describe Index, ".find (with TOKENIZED index)" do
-  before(:each) do
-    setup_lucene
-    @index = Index.new('my index')
-    @index.field_infos[:name][:tokenized] = true
-
-    @index << {:id => "1", :name => 'hej hopp', :name2=>'hej hopp'}
-    @index << {:id => "2", :name => 'hello world', :name2=>'hej hopp'}
-    @index << {:id => "3", :name => 'hello there', :name2=>'hej hopp'}
-    @index << {:id => "4", :name => ['hello', 'hej', '123']}
-    @doc1 = @index.uncommited["1"]
-    @doc2 = @index.uncommited["2"]
-    @doc3 = @index.uncommited["3"]
-    @doc4 = @index.uncommited["4"]
-    @index.commit
-  end
-
-  it "should find indexed documents using the tokenized field" do
-    result = @index.find(:name=>"hello")
-    result.size.should == 3
-    result.should include(@doc2, @doc3, @doc4)
-
-    result = @index.find(:name=>"world")
-    result.size.should == 1
-    result.should include(@doc2)
-  end
-
-  it "should find indexed documents using the tokenized field" do
-    result = @index.find("name:he*")
-    result.size.should == 4
-    result.should include(@doc1, @doc2, @doc3)
-  end
-
-  it "should not find stopwords like 'there'" do
-    result = @index.find(:name=>"there")
-    result.size.should == 0
-  end
-
-  it "should not find indexed documents using the untokenized field" do
-    result = @index.find(:name2=>"hello")
-    result.size.should == 0
-  end
-end
-
-describe Index, "#find (with string queries)" do
-  before(:each) do
-    setup_lucene
-    @index = Index.new('myindex')
-    @index.field_infos[:name] = FieldInfo.new(:store => true)
-    @index << {:id => "1", :name => 'name1', :value=>1, :group=>'a'}
-    @index << {:id => "2", :name => 'name2', :value=>2, :group=>'a'}
-    @index << {:id => "3", :name => 'name3', :value=>2, :group=>'b'}
-    @index << {:id => "4", :name => ['abc', 'def', '123']}
-    @doc1 = @index.uncommited["1"]
-    @doc2 = @index.uncommited["2"]
-    @doc3 = @index.uncommited["3"]
-    @doc4 = @index.uncommited["4"]
-    @index.commit
-  end
-
-
-  it "should find a doc by only using its id, index.find('1')" do
-    r = @index.find("1")
-    r.size.should == 1
-    r.should include(@doc1)
-  end
-
-  it "should find a doc with a specified field, index.find('name:\"name1\"')" do
-    r = @index.find("name:'name2'")
-    r.size.should == 1
-    r.should include(@doc2)
-  end
-
-  it "should find a doc with wildcard queries" do
-    r = @index.find("name:name*")
-    r.size.should == 3
-    r.should include(@doc2)
-  end
-
-  it "should find handle OR queries" do
-    r = @index.find('group:\"b\" OR name:\"name1\"')
-    r.size.should == 2
-    r.should include(@doc3, @doc1)
-  end
-
-end
-
-
-describe Index, ".find (exact match)" do
-  before(:each) do
-    setup_lucene
-    @index = Index.new('myindex')
-    @index.field_infos[:name] = FieldInfo.new(:store => true)
-    @index << {:id => "1", :name => 'name1', :value=>1, :group=>'a'}
-    @index << {:id => "2", :name => 'name2', :value=>2, :group=>'a'}
-    @index << {:id => "3", :name => 'name3', :value=>2, :group=>'b'}
-    @index << {:id => "4", :name => ['abc', 'def', '123']}
-    @doc1 = @index.uncommited["1"]
-    @doc2 = @index.uncommited["2"]
-    @doc3 = @index.uncommited["3"]
-    @doc4 = @index.uncommited["4"]
-    @index.commit
-  end
-
-  it "should find indexed documents using the id field" do
-    result = @index.find(:id=>"1")
-    result.size.should == 1
-    result.should include(@doc1)
-  end
-
-  it "should find indexed documents using any field" do
-    result = @index.find(:name=>"name1")
-    result.size.should == 1
-    result.should include(@doc1)
-
-    result = @index.find(:value=>1)
-    result.size.should == 1
-    result.should include(@doc1)
-  end
-
-  it "should find nothing if it does not exist" do
-    result = @index.find(:name=>"name")
-    result.should be_empty
-  end
-
-
-  it "should find several documents having the same property" do
-    result = @index.find(:value => 2)
-    result.size.should == 2
-    result.should include(@doc2, @doc3)
-  end
-
-  it "should find using several fields" do
-    result = @index.find(:value => 2, :group => 'a')
-    result.size.should == 1
-    result.should include(@doc2)
-  end
-
-  it "should find a document that has several values for the same key" do
-    result = @index.find(:name => 'def')
-    result.size.should == 1
-    result.should include(@doc4)
-
-    result = @index.find(:name => '123')
-    result.size.should == 1
-    result.should include(@doc4)
-
-    result = @index.find(:name => 'ojo')
-    result.size.should == 0
-  end
-
-  it "should return document containing the stored fields for that index" do
-    # when
-    result = @index.find(:id=>"1")
-
-    # then
-    doc = result[0]
-    doc.id.should == '1'
-    doc[:name].should == 'name1'
-    doc[:value].should be_nil # since its default FieldInfo has :store=>false
-  end
-
-end
-
-describe Index, "<< (add documents to be commited)" do
-  before(:each) do
-    setup_lucene
-    @index = Index.new('myindex')
-    @index.field_infos[:foo] = FieldInfo.new(:store => true)
-  end
-
-  it "converts all fields into strings" do
-    @index << {:id => 42, :foo => 1}
-    @index.uncommited['42'][:foo].should == '1'
-  end
-
-  it "can add several documents" do
-    @index << {:id => "1", :foo => 'a'} << {:id => "2", :foo => 'b'}
-
-    # then
-    @index.uncommited.size.should == 2
-    @index.uncommited['1'][:foo].should == 'a'
-    @index.uncommited['2'][:foo].should == 'b'
-  end
-
-  it "can have several values for the same key" do
-    @index << {:id => 42, :name => ['foo', 'bar', 'baaz']}
-    @index.uncommited['42'][:name].should == ['foo', 'bar', 'baaz']
-  end
-end
-
-describe Index, ".id_field" do
-  before(:each) do
-    setup_lucene
-  end
-
-  it "has a default" do
-    index = Index.new 'myindex'
-    index.id_field.should == :id
-  end
-
-  it "can have a specified one" do
-    index = Index.new('myindex')
-    index.field_infos.id_field = :my_id
-    index.id_field.should == :my_id
-  end
-
-  it "is used to find uncommited documents" do
-    # given
-    index = Index.new('myindex')
-    index.field_infos.id_field = :my_id
-    index << {:my_id => '123', :name=>"foo"}
-
-    # when then
-    index.uncommited['123'][:name].should == 'foo'
-  end
-
-  it "can be used to delete documents" do
-    # given
-    index = Index.new('myindex')
-    index.field_infos.id_field = :my_id
-    index.field_infos[:my_id][:type] = Fixnum
-    index << {:my_id => 123, :name=>"foo"}
-    index.commit
-    index.find(:name=>'foo').should_not be_empty
-
-    # when delete it
-    index.delete(123)
-    index.commit
-
-    # then
-    index.find(:name=>'foo').should be_empty
-  end
-
-  it "must be included in all documents" do
-    # given
-    index = Index.new('myindex')
-    index.field_infos.id_field = :my_id
-    # when not included
-    lambda {
-      index << {:id=>2, :name=>"foo"} # my_id missing
-    }.should raise_error # then it should raise an exception
-  end
-end
-
-describe Index, ".new" do
-  it "should not create a new instance if one already exists (singelton)" do
-    index1 = Index.new($INDEX_DIR)
-    index2 = Index.new($INDEX_DIR)
-    index1.object_id.should == index2.object_id
-  end
-
-  it "should be possible to create a new instance even if one already exists" do
-    index1 = Index.new($INDEX_DIR)
-    index1.clear
-    index2 = Index.new($INDEX_DIR)
-    index1.object_id.should_not == index2.object_id
-  end
-end
-
-describe Index, ".field_infos" do
-  before(:each) do
-    setup_lucene
-    @index = Index.new('myindex')
-    @index.clear
-  end
-
-  it "has a default value for the id_field - store => true" do
-    @index.field_infos[:id][:store].should == true
-    $LUCENE_LOGGER.level = Logger::INFO
-  end
-
-  it "has a default for unspecified fields" do
-    @index.field_infos[:foo].should == IndexInfo::DEFAULTS
-  end
-
-  it "should use a default for unspecified type, for example all fields has default :type => String" do
-    @index.field_infos[:value] = FieldInfo.new(:store => true, :foo => 1)
-
-    # should use default field info for unspecified
-    @index.field_infos[:value][:type].should == String
-  end
-
-  it "has a default that can be overridden" do
-    # given
-    @index.field_infos[:bar][:type] = Float
-    # then
-    @index.field_infos[:bar][:type].should == Float
-    @index.field_infos[:id][:type].should == String
-    @index.field_infos[:name][:type].should == String
-  end
-
-  it "can be used to convert properties" do
-    #given
-    @index.field_infos[:bar][:store] = true
-    @index.field_infos[:bar][:type] = Float
-    @index.field_infos[:id][:type] = Fixnum
-    @index.field_infos[:name][:store] = true
-
-    @index << {:id => 1, :bar => 3.14, :name => "andreas"}
-    @index.commit
-
-    # when
-    hits = @index.find(:name => 'andreas')
-
-    @index.field_infos[:id][:type].should == Fixnum
-    # then
-    hits.size.should == 1
-    hits[0][:id].should == 1
-    hits[0][:bar].should == 3.14
-    hits[0][:name].should == 'andreas'
-  end
-
-
-  it "can be used to convert and store Date field" do
-    #given
-    @index.field_infos[:since][:store] = true
-    @index.field_infos[:since][:type] = Date
-
-    @index << {:id => 1, :since => Date.new(2008, 3, 26)}
-    @index.commit
-
-    # when
-    hits = @index.find(:id => "1")
-
-    # then
-    hits.size.should == 1
-    hits[0][:since].should be_instance_of(Date)
-    hits[0][:since].year.should == 2008
-    hits[0][:since].month.should == 3
-    hits[0][:since].day.should == 26
-  end
-
-
-  it "can be used to convert and store DateTime field" do
-    #given
-    @index.field_infos[:since][:store] = true
-    @index.field_infos[:since][:type] = DateTime
-    date = DateTime.new(2008, 12, 18, 11, 4, 59)
-    @index << {:id => 1, :since => date}
-    @index.commit
-
-    # when
-    hits = @index.find(:id => "1")
-
-    # then
-    hits.size.should == 1
-    hits[0][:since].should be_instance_of(DateTime)
-    hits[0][:since].year.should == 2008
-    hits[0][:since].month.should == 12
-    hits[0][:since].day.should == 18
-    hits[0][:since].hour.should == 11
-    hits[0][:since].min.should == 4
-    hits[0][:since].sec.should == 59
-  end
-
-end
-
-describe Index, " when updating a document" do
-  before(:each) do
-    setup_lucene
-    @index = Index.new('myindex')
-  end
-
-  it "should remove the field if set to nil" do
-    # given
-    @index << {:id => 'a', :name=>'andreas'}
-    @index.commit
-    @index.find(:name => 'andreas').size.should == 1
-
-    # when
-    @index << {:id => 'a', :name=>nil}
-    @index.commit
-
-    # then
-    @index.find(:name => 'andreas').size.should == 0
-  end
-
-
-  it "should not find the old field if the field has been changed" do
-    # given
-    @index << {:id => 'a', :name=>'andreas'}
-    @index.commit
-    @index.find(:name => 'andreas').should_not be_empty
-
-    # when it change
-    @index << {:id => 'a', :name=>'foo'}
-    @index.commit
-
-    # then it can not be found
-    @index.find(:name => 'andreas').should be_empty
-  end
-
-  it "should not find a deleted document" do
-    # given
-    @index << {:id => 'a', :name=>'andreas'}
-    @index.commit
-    @index.find(:name => 'andreas').should_not be_empty
-
-    # when it is deleted
-    @index.delete('a')
-    @index.commit
-
-    # then it can not be found
-    @index.find(:name => 'andreas').should be_empty
-  end
-
-  it "should find documents that have the same properties" do
-    # given
-    @index << {:id => 'a', :name=>'bar'}
-    @index << {:id => 'a.1', :name=>'bar'}
-
-    @index.commit
-    res = @index.find(:name => 'bar')
-    res.size.should == 2
-  end
-
-
-  describe "Indexing with Dates" do
-    before(:each) do
-      setup_lucene
-      @index = Index.new('myindex')
-      @index.field_infos[:since][:store] = false
-      @index.field_infos[:since][:type] = Date
-
-      @index.field_infos[:born][:store] = false
-      @index.field_infos[:born][:type] = DateTime
-    end
-
-
-    it "can find an index using a date" do
-      #given
-      @index << {:id => 1, :since => Date.new(2008, 4, 26)}
-      @index.commit
-
-      # when
-      hits = @index.find(:since => Date.new(2008, 4, 26))
-
-      # then
-      hits.size.should == 1
-      hits[0][:id].should == '1'
-    end
-
-    it "can find an index using a Date range" do
-      #given
-      @index << {:id => 1, :since => Date.new(2008, 4, 26)}
-      @index.commit
-
-      # then
-      @index.find("since:[20080427 TO 20100203]").size.should == 0
-      @index.find("since:[20080422 TO 20080425]").size.should == 0
-      @index.find("since:{20080426 TO 20090425}").size.should == 0
-      @index.find("since:[20080426 TO 20090203]")[0][:id].should == '1'
-      @index.find("since:[20080425 TO 20080426]")[0][:id].should == '1'
-      @index.find("since:[20000425 TO 20200426]")[0][:id].should == '1'
-    end
-
-    it "can find an index using a DateTime range" do
-      #given
-      # only UTC times are supported 
-      @index << {:id => 1, :born => DateTime.civil(2008, 4, 26, 15, 58, 02)}
-      @index.commit
-
-      # then
-      @index.find("born:[20080427 TO 20100203]").size.should == 0
-      @index.find("born:[20080422 TO 20080425]").size.should == 0
-      @index.find("born:[20080426 TO 20090203]")[0][:id].should == '1'
-      @index.find("born:[20080425 TO 20080427]")[0][:id].should == '1'
-      @index.find("born:[20000425 TO 20200426]")[0][:id].should == '1'
-
-      @index.find("born:[200804260000 TO 200804262359]")[0][:id].should == '1'
-      @index.find("born:[200804261500 TO 200804261600]")[0][:id].should == '1'
-      @index.find("born:[200804261557 TO 200804261559]")[0][:id].should == '1'
-      @index.find("born:[20080426155759 TO 20080426155804]")[0][:id].should == '1'
-      @index.find("born:[200804261559 TO 200804261601]").size.should == 0
-      @index.find("born:[200804261557 TO 200804261500]").size.should == 0
-    end
-
-  end
-end
-
-
-describe Index, " #analyzer" do
-  before(:each) do
-    setup_lucene
-    @index = Index.new('myindex')
-  end
-
-  it "should default to StandardAnalyzer" do
-#    @index.analyzer = :keyword
-
-    # given some a stop word
-    @index << {:id => 'a', :name=>'it'}
-    @index.commit
-
-    # then it should not found it with the standard default analyzer
-    @index.find("name:it").should be_empty
-  end
-
-  it "can be set to keyword analyzer for one field" do
-    @index.field_infos[:code][:analyzer] = :keyword
-
-    # given some a stop word
-    @index << {:id => 'a', :code=>'it'}
-    @index.commit
-
-    # then it should not found it with the standard default analyzer
-    @index.find("code:it").should_not be_empty
-  end
-
-
-  it "can be set to keyword analyzer for one field and simple analyzer for another field" do
-    @index.field_infos[:code][:analyzer] = :keyword
-    @index.field_infos[:w][:analyzer] = :whitespace
-    @index.field_infos[:w][:tokenized] = true
-
-    @index.field_infos[:s][:analyzer] = :simple
-    @index.field_infos[:s][:tokenized] = true
-
-    # given some a stop word
-    @index << {:id => 'a', :code=>'it', :w => "XY&Z Corporation - xyz@example.com", :s => "XY&Z Corporation - xyz@example.com"}
-    @index.commit
-
-    # then it should not found it with the standard default analyzer
-    @index.find("code:it").should_not be_empty
-    @index.find(:w => "Corporation").should_not be_empty
-    @index.find(:w => "corporation").should be_empty
-
-    @index.find(:w => "XY&Z").should_not be_empty
-    @index.find(:w => "XY").should be_empty
-
-    @index.find(:s => "XY&Z").should be_empty
-    @index.find(:s => "xy").should_not be_empty    
-  end
-
-end