You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucy.apache.org by ma...@apache.org on 2010/11/04 06:36:56 UTC
[lucy-commits] svn commit: r1030838 [10/12] - in /incubator/lucy/trunk: ./
clownfish/lib/Clownfish/Binding/ clownfish/lib/Clownfish/Binding/Core/
clownfish/lib/Clownfish/Binding/Perl/ core/KinoSearch/ core/Lucy/
core/Lucy/Analysis/ core/Lucy/Docs/ core/Lucy/Document/...
Modified: incubator/lucy/trunk/perl/t/233-background_merger.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/233-background_merger.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/233-background_merger.t (original)
+++ incubator/lucy/trunk/perl/t/233-background_merger.t Thu Nov 4 05:36:36 2010
@@ -18,18 +18,18 @@ use warnings;
use lib 'buildlib';
package NoMergeManager;
-use base qw( KinoSearch::Index::IndexManager );
+use base qw( Lucy::Index::IndexManager );
sub recycle { [] }
package main;
use Test::More tests => 15;
-use KinoSearch::Test;
+use Lucy::Test;
-my $folder = KinoSearch::Store::RAMFolder->new;
-my $schema = KinoSearch::Test::TestSchema->new;
+my $folder = Lucy::Store::RAMFolder->new;
+my $schema = Lucy::Test::TestSchema->new;
for my $letter (qw( a b c )) {
- my $indexer = KinoSearch::Index::Indexer->new(
+ my $indexer = Lucy::Index::Indexer->new(
index => $folder,
schema => $schema,
manager => NoMergeManager->new,
@@ -37,16 +37,16 @@ for my $letter (qw( a b c )) {
$indexer->add_doc( { content => $letter } );
$indexer->commit;
}
-my $bg_merger = KinoSearch::Index::BackgroundMerger->new( index => $folder );
+my $bg_merger = Lucy::Index::BackgroundMerger->new( index => $folder );
-my $indexer = KinoSearch::Index::Indexer->new( index => $folder );
+my $indexer = Lucy::Index::Indexer->new( index => $folder );
$indexer->add_doc( { content => 'd' } );
$indexer->commit;
is( count_segs($folder), 4,
"BackgroundMerger prevents Indexer from merging claimed segments" );
-$indexer = KinoSearch::Index::Indexer->new( index => $folder );
+$indexer = Lucy::Index::Indexer->new( index => $folder );
$indexer->add_doc( { content => 'e' } );
$indexer->delete_by_term( field => 'content', term => 'b' );
$indexer->commit;
@@ -57,26 +57,26 @@ is( count_segs($folder), 3, "Background
ok( $folder->exists("seg_7/deletions-seg_4.bv"),
"deletions carried forward" );
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
is( $searcher->hits( query => 'b' )->total_hits,
0, "deleted term still deleted" );
is( $searcher->hits( query => $_ )->total_hits, 1, "term $_ still present" )
for qw( a c d e );
# Simulate failed background merge.
-$bg_merger = KinoSearch::Index::BackgroundMerger->new( index => $folder );
+$bg_merger = Lucy::Index::BackgroundMerger->new( index => $folder );
$bg_merger->prepare_commit;
undef $bg_merger;
$folder->delete("merge.lock");
die "test set up failed" unless $folder->exists("merge.json");
-$indexer = KinoSearch::Index::Indexer->new( index => $folder );
+$indexer = Lucy::Index::Indexer->new( index => $folder );
$indexer->optimize;
$indexer->commit;
ok( !$folder->exists("merge.json"), "Cleaned up after failed bg merge" );
-$searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+$searcher = Lucy::Search::IndexSearcher->new( index => $folder );
is( $searcher->hits( query => 'b' )->total_hits,
0, "deleted term still deleted after full optimize" );
is( $searcher->hits( query => $_ )->total_hits,
Modified: incubator/lucy/trunk/perl/t/302-many_fields.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/302-many_fields.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/302-many_fields.t (original)
+++ incubator/lucy/trunk/perl/t/302-many_fields.t Thu Nov 4 05:36:36 2010
@@ -17,25 +17,25 @@ use strict;
use warnings;
package MySchema;
-use base qw( KinoSearch::Plan::Schema );
-use KinoSearch::Analysis::Tokenizer;
+use base qw( Lucy::Plan::Schema );
+use Lucy::Analysis::Tokenizer;
our %fields = ();
package main;
use Test::More tests => 10;
-use KinoSearch::Test;
+use Lucy::Test;
my $schema = MySchema->new;
-my $type = KinoSearch::Plan::FullTextType->new(
- analyzer => KinoSearch::Analysis::Tokenizer->new, );
+my $type = Lucy::Plan::FullTextType->new(
+ analyzer => Lucy::Analysis::Tokenizer->new, );
for my $num_fields ( 1 .. 10 ) {
# Build an index with $num_fields fields, and the same content in each.
$schema->spec_field( name => "field$num_fields", type => $type );
- my $folder = KinoSearch::Store::RAMFolder->new;
- my $indexer = KinoSearch::Index::Indexer->new(
+ my $folder = Lucy::Store::RAMFolder->new;
+ my $indexer = Lucy::Index::Indexer->new(
schema => $schema,
index => $folder,
);
@@ -50,7 +50,7 @@ for my $num_fields ( 1 .. 10 ) {
$indexer->commit;
# See if our search results match as expected.
- my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+ my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
my $hits = $searcher->hits(
query => 'x',
num_wanted => 100,
Modified: incubator/lucy/trunk/perl/t/303-highlighter.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/303-highlighter.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/303-highlighter.t (original)
+++ incubator/lucy/trunk/perl/t/303-highlighter.t Thu Nov 4 05:36:36 2010
@@ -18,18 +18,18 @@ use warnings;
use lib 'buildlib';
package MySchema;
-use base qw( KinoSearch::Plan::Schema );
-use KinoSearch::Analysis::Tokenizer;
+use base qw( Lucy::Plan::Schema );
+use Lucy::Analysis::Tokenizer;
sub new {
my $class = shift;
my $self = $class->SUPER::new(@_);
- my $tokenizer = KinoSearch::Analysis::Tokenizer->new;
- my $plain_type = KinoSearch::Plan::FullTextType->new(
+ my $tokenizer = Lucy::Analysis::Tokenizer->new;
+ my $plain_type = Lucy::Plan::FullTextType->new(
analyzer => $tokenizer,
highlightable => 1,
);
- my $dunked_type = KinoSearch::Plan::FullTextType->new(
+ my $dunked_type = Lucy::Plan::FullTextType->new(
analyzer => $tokenizer,
highlightable => 1,
boost => 0.1,
@@ -40,7 +40,7 @@ sub new {
}
package MyHighlighter;
-use base qw( KinoSearch::Highlight::Highlighter );
+use base qw( Lucy::Highlight::Highlighter );
sub encode {
my ( $self, $text ) = @_;
@@ -56,7 +56,7 @@ sub highlight {
package main;
use Test::More tests => 34;
-use KinoSearch::Test;
+use Lucy::Test;
binmode( STDOUT, ":utf8" );
@@ -68,8 +68,8 @@ $string .= "$phi a b c d x y z h i j k "
$string .= '6 7 8 9 0 ' x 20;
my $with_quotes = '"I see," said the blind man.';
-my $folder = KinoSearch::Store::RAMFolder->new;
-my $indexer = KinoSearch::Index::Indexer->new(
+my $folder = Lucy::Store::RAMFolder->new;
+my $indexer = Lucy::Index::Indexer->new(
index => $folder,
schema => MySchema->new,
);
@@ -82,18 +82,18 @@ $indexer->add_doc(
);
$indexer->commit;
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
my $q = qq|"x y z" AND $phi|;
my $hits = $searcher->hits( query => $q );
-my $hl = KinoSearch::Highlight::Highlighter->new(
+my $hl = Lucy::Highlight::Highlighter->new(
searcher => $searcher,
query => $q,
field => 'content',
excerpt_length => 3,
);
-my $target = KinoSearch::Object::ViewCharBuf->_new("");
+my $target = Lucy::Object::ViewCharBuf->_new("");
my $field_val = make_cb("a $phi $phi b c");
my $top = $hl->_find_best_fragment(
@@ -137,7 +137,7 @@ is( $target->to_perl,
is( $top, 0, "correct offset" );
undef $target;
-$hl = KinoSearch::Highlight::Highlighter->new(
+$hl = Lucy::Highlight::Highlighter->new(
searcher => $searcher,
query => $q,
field => 'content',
@@ -196,7 +196,7 @@ $top = $hl->_raw_excerpt(
is( $target->to_perl, "Iz no\x{2026}", "Ellipsis at end" );
is( $top, 6, "top trimmed" );
-$hl = KinoSearch::Highlight::Highlighter->new(
+$hl = Lucy::Highlight::Highlighter->new(
searcher => $searcher,
query => $q,
field => 'content',
@@ -238,7 +238,7 @@ like(
"Highlight_Excerpt pays attention to offset"
);
-$hl = KinoSearch::Highlight::Highlighter->new(
+$hl = Lucy::Highlight::Highlighter->new(
searcher => $searcher,
query => $q,
field => 'content',
@@ -267,7 +267,7 @@ like( $hl->create_excerpt( $hits->next()
"excerpt field with partial hit doesn't cause highlighter freakout" );
$hits = $searcher->hits( query => $q = 'x "x y z" AND b' );
-$hl = KinoSearch::Highlight::Highlighter->new(
+$hl = Lucy::Highlight::Highlighter->new(
searcher => $searcher,
query => $q,
field => 'content',
@@ -279,7 +279,7 @@ like( $excerpt, qr/x y z/,
$hits = $searcher->hits( query => $q = 'blind' );
like(
- KinoSearch::Highlight::Highlighter->new(
+ Lucy::Highlight::Highlighter->new(
searcher => $searcher,
query => $q,
field => 'content',
@@ -290,7 +290,7 @@ like(
$hits = $searcher->hits( query => $q = 'why' );
unlike(
- KinoSearch::Highlight::Highlighter->new(
+ Lucy::Highlight::Highlighter->new(
searcher => $searcher,
query => $q,
field => 'content',
@@ -299,14 +299,14 @@ unlike(
"no ellipsis for short excerpt"
);
-my $term_query = KinoSearch::Search::TermQuery->new(
+my $term_query = Lucy::Search::TermQuery->new(
field => 'content',
term => 'x',
);
$hits = $searcher->hits( query => $term_query );
$hit = $hits->next();
like(
- KinoSearch::Highlight::Highlighter->new(
+ Lucy::Highlight::Highlighter->new(
searcher => $searcher,
query => $term_query,
field => 'content',
@@ -315,7 +315,7 @@ like(
"specify field highlights correct field..."
);
unlike(
- KinoSearch::Highlight::Highlighter->new(
+ Lucy::Highlight::Highlighter->new(
searcher => $searcher,
query => $term_query,
field => 'alt',
@@ -325,7 +325,7 @@ unlike(
);
my $sentence_text = 'This is a sentence. ' x 15;
-$hl = KinoSearch::Highlight::Highlighter->new(
+$hl = Lucy::Highlight::Highlighter->new(
searcher => $searcher,
query => $q,
field => 'content',
@@ -375,15 +375,15 @@ like( $hl->create_excerpt($hit),
qr/\*wise\*/, "override both Encode() and Highlight()" );
sub make_cb {
- return KinoSearch::Object::CharBuf->new(shift);
+ return Lucy::Object::CharBuf->new(shift);
}
sub make_heat_map {
- return KinoSearch::Highlight::HeatMap->new( spans => make_spans(@_) );
+ return Lucy::Highlight::HeatMap->new( spans => make_spans(@_) );
}
sub make_span {
- return KinoSearch::Search::Span->new(
+ return Lucy::Search::Span->new(
offset => $_[0],
length => $_[1],
weight => $_[2],
@@ -391,7 +391,7 @@ sub make_span {
}
sub make_spans {
- my $spans = KinoSearch::Object::VArray->new( capacity => scalar @_ );
+ my $spans = Lucy::Object::VArray->new( capacity => scalar @_ );
for my $span_spec (@_) {
$spans->push( make_span( @{$span_spec}[ 0 .. 2 ] ) );
}
Modified: incubator/lucy/trunk/perl/t/304-verify_utf8.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/304-verify_utf8.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/304-verify_utf8.t (original)
+++ incubator/lucy/trunk/perl/t/304-verify_utf8.t Thu Nov 4 05:36:36 2010
@@ -18,20 +18,20 @@ use warnings;
use lib 'buildlib';
package MySchema;
-use base qw( KinoSearch::Plan::Schema );
-use KinoSearch::Analysis::Tokenizer;
+use base qw( Lucy::Plan::Schema );
+use Lucy::Analysis::Tokenizer;
sub new {
my $self = shift->SUPER::new(@_);
- my $analyzer = KinoSearch::Analysis::Tokenizer->new( pattern => '\S+' );
- my $type = KinoSearch::Plan::FullTextType->new( analyzer => $analyzer, );
+ my $analyzer = Lucy::Analysis::Tokenizer->new( pattern => '\S+' );
+ my $type = Lucy::Plan::FullTextType->new( analyzer => $analyzer, );
$self->spec_field( name => 'content', type => $type );
return $self;
}
package main;
use Test::More tests => 14;
-use KinoSearch::Test;
+use Lucy::Test;
use Lucy::Test::TestUtils qw( utf8_test_strings );
my ( $smiley, $not_a_smiley, $frowny ) = utf8_test_strings();
@@ -42,9 +42,9 @@ utf8::upgrade($polished_turd);
is( $turd, $polished_turd, "verify encoding acrobatics" );
-my $folder = KinoSearch::Store::RAMFolder->new;
+my $folder = Lucy::Store::RAMFolder->new;
my $schema = MySchema->new;
-my $indexer = KinoSearch::Index::Indexer->new(
+my $indexer = Lucy::Index::Indexer->new(
index => $folder,
schema => $schema,
);
@@ -54,8 +54,8 @@ $indexer->add_doc( { content => $not_a_s
$indexer->add_doc( { content => $turd } );
$indexer->commit;
-my $qparser = KinoSearch::Search::QueryParser->new( schema => MySchema->new );
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $qparser = Lucy::Search::QueryParser->new( schema => MySchema->new );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
my $hits = $searcher->hits( query => $qparser->parse($smiley) );
is( $hits->total_hits, 1 );
@@ -71,7 +71,7 @@ is( $hits->total_hits, 1 );
is( $hits->next->{content},
$not_a_smiley, "QueryParser upgrades non-UTF-8 correctly" );
-my $term_query = KinoSearch::Search::TermQuery->new(
+my $term_query = Lucy::Search::TermQuery->new(
field => 'content',
term => $not_a_smiley,
);
@@ -80,7 +80,7 @@ is( $hits->total_hits, 1 );
is( $hits->next->{content},
$not_a_smiley, "TermQuery upgrades non-UTF-8 correctly" );
-$term_query = KinoSearch::Search::TermQuery->new(
+$term_query = Lucy::Search::TermQuery->new(
field => 'content',
term => $smiley,
);
@@ -90,13 +90,13 @@ is( $hits->total_hits, 1 );
is( $hits->next->{content}, $smiley, "TermQuery handles UTF-8 correctly" );
undef $indexer;
-$indexer = KinoSearch::Index::Indexer->new(
+$indexer = Lucy::Index::Indexer->new(
index => $folder,
schema => $schema,
);
$indexer->delete_by_term( field => 'content', term => $smiley );
$indexer->commit;
-$searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+$searcher = Lucy::Search::IndexSearcher->new( index => $folder );
$hits = $searcher->hits( query => $smiley );
is( $hits->total_hits, 0, "delete_by_term handles UTF-8 correctly" );
@@ -105,13 +105,13 @@ $hits = $searcher->hits( query => $frown
is( $hits->total_hits, 1, "delete_by_term handles UTF-8 correctly" );
undef $indexer;
-$indexer = KinoSearch::Index::Indexer->new(
+$indexer = Lucy::Index::Indexer->new(
index => $folder,
schema => $schema,
);
$indexer->delete_by_term( field => 'content', term => $not_a_smiley );
$indexer->commit;
-$searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+$searcher = Lucy::Search::IndexSearcher->new( index => $folder );
$hits = $searcher->hits( query => $frowny );
is( $hits->total_hits, 0, "delete_by_term upgrades non-UTF-8 correctly" );
Modified: incubator/lucy/trunk/perl/t/305-indexer.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/305-indexer.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/305-indexer.t (original)
+++ incubator/lucy/trunk/perl/t/305-indexer.t Thu Nov 4 05:36:36 2010
@@ -18,12 +18,12 @@ use warnings;
use lib 'buildlib';
use Test::More tests => 4;
-use KinoSearch::Test;
+use Lucy::Test;
-my $folder = KinoSearch::Store::RAMFolder->new;
-my $schema = KinoSearch::Test::TestSchema->new;
+my $folder = Lucy::Store::RAMFolder->new;
+my $schema = Lucy::Test::TestSchema->new;
-my $indexer = KinoSearch::Index::Indexer->new(
+my $indexer = Lucy::Index::Indexer->new(
index => $folder,
schema => $schema,
);
@@ -31,7 +31,7 @@ my $indexer = KinoSearch::Index::Indexer
$indexer->add_doc( { content => 'foo' } );
undef $indexer;
-$indexer = KinoSearch::Index::Indexer->new(
+$indexer = Lucy::Index::Indexer->new(
index => $folder,
schema => $schema,
);
@@ -42,15 +42,15 @@ SKIP: {
skip( "Known leak, though might be fixable", 2 ) if $ENV{LUCY_VALGRIND};
eval {
my $manager
- = KinoSearch::Index::IndexManager->new( host => 'somebody_else' );
- my $inv = KinoSearch::Index::Indexer->new(
+ = Lucy::Index::IndexManager->new( host => 'somebody_else' );
+ my $inv = Lucy::Index::Indexer->new(
manager => $manager,
index => $folder,
schema => $schema,
);
};
like( $@, qr/write.lock/, "failed to get lock with competing host" );
- isa_ok( $@, "KinoSearch::Store::LockErr", "Indexer throws a LockErr" );
+ isa_ok( $@, "Lucy::Store::LockErr", "Indexer throws a LockErr" );
}
my $pid = 12345678;
@@ -58,7 +58,7 @@ do {
# Fake a write lock.
$folder->delete("locks/write.lock") or die "Couldn't delete 'write.lock'";
my $outstream = $folder->open_out('locks/write.lock')
- or die KinoSearch->error;
+ or die Lucy->error;
while ( kill( 0, $pid ) ) {
$pid++;
}
@@ -74,8 +74,8 @@ do {
eval {
my $manager
- = KinoSearch::Index::IndexManager->new( host => 'somebody_else' );
- my $inv = KinoSearch::Index::Indexer->new(
+ = Lucy::Index::IndexManager->new( host => 'somebody_else' );
+ my $inv = Lucy::Index::Indexer->new(
manager => $manager,
schema => $schema,
index => $folder,
Modified: incubator/lucy/trunk/perl/t/306-dynamic_schema.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/306-dynamic_schema.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/306-dynamic_schema.t (original)
+++ incubator/lucy/trunk/perl/t/306-dynamic_schema.t Thu Nov 4 05:36:36 2010
@@ -18,12 +18,12 @@ use warnings;
use lib 'buildlib';
use Test::More tests => 9;
-use KinoSearch::Test;
+use Lucy::Test;
-my $schema = KinoSearch::Test::TestSchema->new;
+my $schema = Lucy::Test::TestSchema->new;
my $type = $schema->fetch_type('content');
-my $folder = KinoSearch::Store::RAMFolder->new;
-my $indexer = KinoSearch::Index::Indexer->new(
+my $folder = Lucy::Store::RAMFolder->new;
+my $indexer = Lucy::Index::Indexer->new(
schema => $schema,
index => $folder,
);
@@ -54,7 +54,7 @@ $indexer->add_doc( \%three_fields );
pass('Add another field');
$indexer->commit;
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
my $hits = $searcher->hits( query => 'x', num_wanted => 100 );
is( $hits->total_hits, 3,
"disparate docs successfully indexed and retrieved" );
@@ -62,10 +62,10 @@ my $top_hit = $hits->next;
is_deeply( $top_hit->get_fields, \%three_fields,
"all fields stored successfully" );
-my $schema2 = KinoSearch::Test::TestSchema->new;
-my $folder2 = KinoSearch::Store::RAMFolder->new;
+my $schema2 = Lucy::Test::TestSchema->new;
+my $folder2 = Lucy::Store::RAMFolder->new;
$schema2->spec_field( name => 'foo', type => $type );
-my $indexer2 = KinoSearch::Index::Indexer->new(
+my $indexer2 = Lucy::Index::Indexer->new(
schema => $schema2,
index => $folder2,
);
@@ -73,7 +73,7 @@ $indexer2->add_doc( \%foo_doc );
$indexer2->commit;
undef $indexer;
-$indexer = KinoSearch::Index::Indexer->new(
+$indexer = Lucy::Index::Indexer->new(
schema => $schema,
index => $folder,
);
@@ -86,7 +86,7 @@ $indexer->add_doc( \%five_fields );
pass('successfully absorbed new field def during add_index');
$indexer->commit;
-$searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+$searcher = Lucy::Search::IndexSearcher->new( index => $folder );
$hits = $searcher->hits( query => 'stuff', num_wanted => 100 );
is( $hits->total_hits, 1,
"successfully aborbed unknown field during add_index" );
Modified: incubator/lucy/trunk/perl/t/309-span.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/309-span.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/309-span.t (original)
+++ incubator/lucy/trunk/perl/t/309-span.t Thu Nov 4 05:36:36 2010
@@ -19,10 +19,10 @@ use lib 'buildlib';
use Test::More tests => 6;
-use KinoSearch::Test;
-use KinoSearch::Search::Span;
+use Lucy::Test;
+use Lucy::Search::Span;
-my $span = KinoSearch::Search::Span->new(
+my $span = Lucy::Search::Span->new(
offset => 2,
length => 3,
weight => 7,
Modified: incubator/lucy/trunk/perl/t/310-heat_map.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/310-heat_map.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/310-heat_map.t (original)
+++ incubator/lucy/trunk/perl/t/310-heat_map.t Thu Nov 4 05:36:36 2010
@@ -17,9 +17,9 @@ use strict;
use warnings;
use Test::More tests => 13;
-use KinoSearch::Test;
+use Lucy::Test;
-my $heat_map = KinoSearch::Highlight::HeatMap->new( spans => [], );
+my $heat_map = Lucy::Highlight::HeatMap->new( spans => [], );
my $big_boost = $heat_map->calc_proximity_boost(
span1 => make_span( 0, 10, 1.0 ),
@@ -117,7 +117,7 @@ $boosts = $heat_map->generate_proximity_
is( scalar @$boosts, 2 + 1, "boosts not generated for out of range span" );
sub make_span {
- return KinoSearch::Search::Span->new(
+ return Lucy::Search::Span->new(
offset => $_[0],
length => $_[1],
weight => $_[2],
Modified: incubator/lucy/trunk/perl/t/400-match_posting.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/400-match_posting.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/400-match_posting.t (original)
+++ incubator/lucy/trunk/perl/t/400-match_posting.t Thu Nov 4 05:36:36 2010
@@ -18,28 +18,28 @@ use warnings;
use lib 'buildlib';
package MatchOnlySim;
-use base qw( KinoSearch::Index::Similarity );
+use base qw( Lucy::Index::Similarity );
sub make_posting {
my $self = shift;
- return KinoSearch::Index::Posting::MatchPosting->new(
+ return Lucy::Index::Posting::MatchPosting->new(
similarity => $self );
}
package MatchSchema::MatchOnly;
-use base qw( KinoSearch::Plan::FullTextType );
-use KinoSearch::Index::Posting::MatchPosting;
+use base qw( Lucy::Plan::FullTextType );
+use Lucy::Index::Posting::MatchPosting;
sub make_similarity { MatchOnlySim->new }
package MatchSchema;
-use base qw( KinoSearch::Plan::Schema );
-use KinoSearch::Analysis::Tokenizer;
+use base qw( Lucy::Plan::Schema );
+use Lucy::Analysis::Tokenizer;
sub new {
my $self = shift->SUPER::new(@_);
my $type = MatchSchema::MatchOnly->new(
- analyzer => KinoSearch::Analysis::Tokenizer->new );
+ analyzer => Lucy::Analysis::Tokenizer->new );
$self->spec_field( name => 'content', type => $type );
return $self;
}
@@ -52,12 +52,12 @@ use Test::More tests => 6;
my $uscon_docs = get_uscon_docs();
my $match_folder = make_index( MatchSchema->new, $uscon_docs );
my $score_folder
- = make_index( KinoSearch::Test::TestSchema->new, $uscon_docs );
+ = make_index( Lucy::Test::TestSchema->new, $uscon_docs );
my $match_searcher
- = KinoSearch::Search::IndexSearcher->new( index => $match_folder );
+ = Lucy::Search::IndexSearcher->new( index => $match_folder );
my $score_searcher
- = KinoSearch::Search::IndexSearcher->new( index => $score_folder );
+ = Lucy::Search::IndexSearcher->new( index => $score_folder );
for (qw( land of the free )) {
my $match_got = hit_ids_array( $match_searcher, $_ );
@@ -73,8 +73,8 @@ ok( !scalar @$should_be_empty, "no hits
sub make_index {
my ( $schema, $docs ) = @_;
- my $folder = KinoSearch::Store::RAMFolder->new;
- my $indexer = KinoSearch::Index::Indexer->new(
+ my $folder = Lucy::Store::RAMFolder->new;
+ my $indexer = Lucy::Index::Indexer->new(
schema => $schema,
index => $folder,
);
@@ -87,9 +87,9 @@ sub hit_ids_array {
my ( $searcher, $query_string ) = @_;
my $query = $searcher->glean_query($query_string);
- my $bit_vec = KinoSearch::Object::BitVector->new(
+ my $bit_vec = Lucy::Object::BitVector->new(
capacity => $searcher->doc_max + 1 );
- my $bit_collector = KinoSearch::Search::Collector::BitCollector->new(
+ my $bit_collector = Lucy::Search::Collector::BitCollector->new(
bit_vector => $bit_vec, );
$searcher->collect( query => $query, collector => $bit_collector );
return $bit_vec->to_array->to_arrayref;
Modified: incubator/lucy/trunk/perl/t/501-termquery.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/501-termquery.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/501-termquery.t (original)
+++ incubator/lucy/trunk/perl/t/501-termquery.t Thu Nov 4 05:36:36 2010
@@ -19,14 +19,14 @@ use lib 'buildlib';
use Test::More tests => 12;
use Storable qw( freeze thaw );
-use KinoSearch::Test;
+use Lucy::Test;
use Lucy::Test::TestUtils qw( create_index );
my $folder = create_index( 'a', 'b', 'c c c d', 'c d', 'd' .. 'z', );
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
my $term_query
- = KinoSearch::Search::TermQuery->new( field => 'content', term => 'c' );
+ = Lucy::Search::TermQuery->new( field => 'content', term => 'c' );
is( $term_query->to_string, "content:c", "to_string" );
my $hits = $searcher->hits( query => $term_query );
@@ -47,11 +47,11 @@ is( $thawed->get_boost, $term_query->get
ok( $thawed->equals($term_query), "equals" );
$thawed->set_boost(10);
ok( !$thawed->equals($term_query), "!equals (boost)" );
-my $different_term = KinoSearch::Search::TermQuery->new(
+my $different_term = Lucy::Search::TermQuery->new(
field => 'content',
term => 'd'
);
-my $different_field = KinoSearch::Search::TermQuery->new(
+my $different_field = Lucy::Search::TermQuery->new(
field => 'title',
term => 'c'
);
Modified: incubator/lucy/trunk/perl/t/502-phrasequery.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/502-phrasequery.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/502-phrasequery.t (original)
+++ incubator/lucy/trunk/perl/t/502-phrasequery.t Thu Nov 4 05:36:36 2010
@@ -19,7 +19,7 @@ use lib 'buildlib';
use Test::More tests => 9;
use Storable qw( freeze thaw );
-use KinoSearch::Test;
+use Lucy::Test;
use Lucy::Test::TestUtils qw( create_index );
my $best_match = 'x a b c d a b c d';
@@ -33,14 +33,14 @@ my @docs = (
);
my $folder = create_index(@docs);
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
-my $phrase_query = KinoSearch::Search::PhraseQuery->new(
+my $phrase_query = Lucy::Search::PhraseQuery->new(
field => 'content',
terms => [],
);
is( $phrase_query->to_string, 'content:""', "empty PhraseQuery to_string" );
-$phrase_query = KinoSearch::Search::PhraseQuery->new(
+$phrase_query = Lucy::Search::PhraseQuery->new(
field => 'content',
terms => [qw( a b c d )],
);
@@ -58,7 +58,7 @@ ok( $first_hit->get_score > $second_hit-
. $second_hit->get_score
);
-$phrase_query = KinoSearch::Search::PhraseQuery->new(
+$phrase_query = Lucy::Search::PhraseQuery->new(
field => 'content',
terms => [qw( c a )],
);
@@ -66,7 +66,7 @@ $hits = $searcher->hits( query => $phras
is( $hits->total_hits, 1, 'avoid underflow when subtracting offset' );
# "a b c"
-$phrase_query = KinoSearch::Search::PhraseQuery->new(
+$phrase_query = Lucy::Search::PhraseQuery->new(
field => 'content',
terms => [qw( a b c )],
);
Modified: incubator/lucy/trunk/perl/t/504-similarity.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/504-similarity.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/504-similarity.t (original)
+++ incubator/lucy/trunk/perl/t/504-similarity.t Thu Nov 4 05:36:36 2010
@@ -17,20 +17,20 @@ use strict;
use warnings;
package MySchema::LongTextField;
-use base qw( KinoSearch::Plan::FullTextType );
+use base qw( Lucy::Plan::FullTextType );
use LucyX::Index::LongFieldSim;
sub make_similarity { LucyX::Index::LongFieldSim->new }
package MySchema;
-use base qw( KinoSearch::Plan::Schema );
-use KinoSearch::Analysis::Tokenizer;
+use base qw( Lucy::Plan::Schema );
+use Lucy::Analysis::Tokenizer;
sub new {
my $self = shift->SUPER::new(@_);
- my $analyzer = KinoSearch::Analysis::Tokenizer->new;
+ my $analyzer = Lucy::Analysis::Tokenizer->new;
my $plain_type
- = KinoSearch::Plan::FullTextType->new( analyzer => $analyzer, );
+ = Lucy::Plan::FullTextType->new( analyzer => $analyzer, );
my $long_field_type
= MySchema::LongTextField->new( analyzer => $analyzer, );
$self->spec_field( name => 'title', type => $plain_type );
@@ -40,11 +40,11 @@ sub new {
package main;
use Test::More tests => 9;
-use KinoSearch::Test;
+use Lucy::Test;
use bytes;
no bytes;
-my $sim = KinoSearch::Index::Similarity->new;
+my $sim = Lucy::Index::Similarity->new;
my $evil_twin = $sim->load( $sim->dump );
ok( $sim->equals($evil_twin), "Dump/Load" );
@@ -80,8 +80,8 @@ for ( 0 .. 255 ) {
is_deeply( \@transformed, \@floats,
"using the norm_decoder produces desired results" );
-my $folder = KinoSearch::Store::RAMFolder->new;
-my $indexer = KinoSearch::Index::Indexer->new(
+my $folder = Lucy::Store::RAMFolder->new;
+my $indexer = Lucy::Index::Indexer->new(
index => $folder,
schema => MySchema->new,
);
@@ -100,10 +100,10 @@ while ( my ( $title, $body ) = each %sou
$indexer->commit;
undef $indexer;
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
my $hits = $searcher->hits(
- query => KinoSearch::Search::TermQuery->new(
+ query => Lucy::Search::TermQuery->new(
field => 'title',
term => 'spam',
)
@@ -112,7 +112,7 @@ is( $hits->next->{'title'},
'spam', "Default Similarity biased towards short fields" );
$hits = $searcher->hits(
- query => KinoSearch::Search::TermQuery->new(
+ query => Lucy::Search::TermQuery->new(
field => 'body',
term => 'spam',
)
Modified: incubator/lucy/trunk/perl/t/505-hit_queue.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/505-hit_queue.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/505-hit_queue.t (original)
+++ incubator/lucy/trunk/perl/t/505-hit_queue.t Thu Nov 4 05:36:36 2010
@@ -17,10 +17,10 @@ use strict;
use warnings;
use Test::More tests => 36;
-use KinoSearch::Test;
+use Lucy::Test;
use List::Util qw( shuffle );
-my $hit_q = KinoSearch::Search::HitQueue->new( wanted => 10 );
+my $hit_q = Lucy::Search::HitQueue->new( wanted => 10 );
my @docs_and_scores = (
[ 0, 1.0 ],
@@ -32,7 +32,7 @@ my @docs_and_scores = (
);
my @match_docs = map {
- KinoSearch::Search::MatchDoc->new(
+ Lucy::Search::MatchDoc->new(
doc_id => $_->[0],
score => $_->[1],
)
@@ -54,14 +54,14 @@ is_deeply( \@scores, \@correct_scores, "
my @doc_ids = map { $_->get_doc_id } @$got;
is_deeply( \@doc_ids, \@correct_docs, "rank by doc_id after score" );
-my $schema = KinoSearch::Plan::Schema->new;
-my $type = KinoSearch::Plan::StringType->new( sortable => 1 );
+my $schema = Lucy::Plan::Schema->new;
+my $type = Lucy::Plan::StringType->new( sortable => 1 );
$schema->spec_field( name => 'letter', type => $type );
$schema->spec_field( name => 'number', type => $type );
$schema->spec_field( name => 'id', type => $type );
-my $folder = KinoSearch::Store::RAMFolder->new;
-my $indexer = KinoSearch::Index::Indexer->new(
+my $folder = Lucy::Store::RAMFolder->new;
+my $indexer = Lucy::Index::Indexer->new(
index => $folder,
schema => $schema,
);
@@ -79,21 +79,21 @@ for my $id ( 1 .. 100 ) {
$indexer->add_doc($doc);
}
$indexer->commit;
-my $seg_reader = KinoSearch::Index::IndexReader->open( index => $folder );
+my $seg_reader = Lucy::Index::IndexReader->open( index => $folder );
-my $by_letter = KinoSearch::Search::SortSpec->new(
+my $by_letter = Lucy::Search::SortSpec->new(
rules => [
- KinoSearch::Search::SortRule->new( field => 'letter' ),
- KinoSearch::Search::SortRule->new( type => 'doc_id' ),
+ Lucy::Search::SortRule->new( field => 'letter' ),
+ Lucy::Search::SortRule->new( type => 'doc_id' ),
]
);
-$hit_q = KinoSearch::Search::HitQueue->new(
+$hit_q = Lucy::Search::HitQueue->new(
wanted => 100,
schema => $schema,
sort_spec => $by_letter,
);
for my $doc_id ( shuffle( 1 .. 100 ) ) {
- my $match_doc = KinoSearch::Search::MatchDoc->new(
+ my $match_doc = Lucy::Search::MatchDoc->new(
doc_id => $doc_id,
score => 1.0,
values => [ $docs[ $doc_id - 1 ]{letter} ],
@@ -105,21 +105,21 @@ my @wanted = map { $_->{id} }
my @got = map { $_->get_doc_id } @{ $hit_q->pop_all };
is_deeply( \@got, \@wanted, "sort by letter then doc id" );
-my $by_num_then_letter = KinoSearch::Search::SortSpec->new(
+my $by_num_then_letter = Lucy::Search::SortSpec->new(
rules => [
- KinoSearch::Search::SortRule->new( field => 'number' ),
- KinoSearch::Search::SortRule->new( field => 'letter', reverse => 1 ),
- KinoSearch::Search::SortRule->new( type => 'doc_id' ),
+ Lucy::Search::SortRule->new( field => 'number' ),
+ Lucy::Search::SortRule->new( field => 'letter', reverse => 1 ),
+ Lucy::Search::SortRule->new( type => 'doc_id' ),
]
);
-$hit_q = KinoSearch::Search::HitQueue->new(
+$hit_q = Lucy::Search::HitQueue->new(
wanted => 100,
schema => $schema,
sort_spec => $by_num_then_letter,
);
for my $doc_id ( shuffle( 1 .. 100 ) ) {
my $doc = $docs[ $doc_id - 1 ];
- my $match_doc = KinoSearch::Search::MatchDoc->new(
+ my $match_doc = Lucy::Search::MatchDoc->new(
doc_id => $doc_id,
score => 1.0,
values => [ $doc->{number}, $doc->{letter} ],
@@ -135,21 +135,21 @@ for my $doc_id ( shuffle( 1 .. 100 ) ) {
@got = map { $_->get_doc_id } @{ $hit_q->pop_all };
is_deeply( \@got, \@wanted, "sort by num then letter reversed then doc id" );
-my $by_num_then_score = KinoSearch::Search::SortSpec->new(
+my $by_num_then_score = Lucy::Search::SortSpec->new(
rules => [
- KinoSearch::Search::SortRule->new( field => 'number' ),
- KinoSearch::Search::SortRule->new( type => 'score' ),
- KinoSearch::Search::SortRule->new( type => 'doc_id' ),
+ Lucy::Search::SortRule->new( field => 'number' ),
+ Lucy::Search::SortRule->new( type => 'score' ),
+ Lucy::Search::SortRule->new( type => 'doc_id' ),
]
);
-$hit_q = KinoSearch::Search::HitQueue->new(
+$hit_q = Lucy::Search::HitQueue->new(
wanted => 100,
schema => $schema,
sort_spec => $by_num_then_score,
);
for my $doc_id ( shuffle( 1 .. 100 ) ) {
- my $match_doc = KinoSearch::Search::MatchDoc->new(
+ my $match_doc = Lucy::Search::MatchDoc->new(
doc_id => $doc_id,
score => $doc_id,
values => [ $docs[ $doc_id - 1 ]{number} ],
@@ -161,7 +161,7 @@ for my $doc_id ( shuffle( 1 .. 100 ) ) {
@got = map { $_->get_doc_id } @{ $hit_q->pop_all };
is_deeply( \@got, \@wanted, "sort by num then score then doc id" );
-$hit_q = KinoSearch::Search::HitQueue->new(
+$hit_q = Lucy::Search::HitQueue->new(
wanted => 100,
schema => $schema,
sort_spec => $by_num_then_score,
@@ -169,9 +169,9 @@ $hit_q = KinoSearch::Search::HitQueue->n
for my $doc_id ( shuffle( 1 .. 100 ) ) {
my $fields = $docs[ $doc_id - 1 ];
- my $values = KinoSearch::Object::VArray->new( capacity => 1 );
- $values->push( KinoSearch::Object::CharBuf->new( $fields->{number} ) );
- my $match_doc = KinoSearch::Search::MatchDoc->new(
+ my $values = Lucy::Object::VArray->new( capacity => 1 );
+ $values->push( Lucy::Object::CharBuf->new( $fields->{number} ) );
+ my $match_doc = Lucy::Search::MatchDoc->new(
doc_id => $doc_id,
score => $doc_id,
values => $values,
@@ -191,14 +191,14 @@ for ( 1 .. 30 ) {
@doc_ids = map { $_->[0] } @docs_and_scores;
@match_docs = map {
- KinoSearch::Search::MatchDoc->new(
+ Lucy::Search::MatchDoc->new(
doc_id => $_->[0],
score => $_->[1],
)
} sort { $a->[0] <=> $b->[0] } @docs_and_scores;
for my $size ( 0 .. $#match_docs ) {
- $hit_q = KinoSearch::Search::HitQueue->new( wanted => $size, );
+ $hit_q = Lucy::Search::HitQueue->new( wanted => $size, );
$hit_q->insert($_) for @match_docs;
if ($size) {
Modified: incubator/lucy/trunk/perl/t/506-collector.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/506-collector.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/506-collector.t (original)
+++ incubator/lucy/trunk/perl/t/506-collector.t Thu Nov 4 05:36:36 2010
@@ -17,28 +17,28 @@ use strict;
use warnings;
use Test::More tests => 5;
-use KinoSearch::Test;
+use Lucy::Test;
use LucyX::Search::MockScorer;
my @docs = ( 1, 5, 10, 1000 );
my @scores = ( 2, 0, 0, 1 );
my $collector
- = KinoSearch::Search::Collector::SortCollector->new( wanted => 3 );
+ = Lucy::Search::Collector::SortCollector->new( wanted => 3 );
test_collect($collector);
my @got = map { $_->get_score } @{ $collector->pop_match_docs };
is_deeply( \@got, [ 2, 1, 0 ], "collect into HitQueue" );
-$collector = KinoSearch::Search::Collector::SortCollector->new( wanted => 0 );
+$collector = Lucy::Search::Collector::SortCollector->new( wanted => 0 );
test_collect($collector);
is( $collector->get_total_hits, 4,
"get_total_hits is accurate when no hits are requested" );
my $match_docs = $collector->pop_match_docs;
is( scalar @$match_docs, 0, "no hits wanted, so no hits returned" );
-my $bit_vec = KinoSearch::Object::BitVector->new;
-$collector = KinoSearch::Search::Collector::BitCollector->new(
+my $bit_vec = Lucy::Object::BitVector->new;
+$collector = Lucy::Search::Collector::BitCollector->new(
bit_vector => $bit_vec );
test_collect($collector);
is_deeply(
@@ -47,10 +47,10 @@ is_deeply(
"BitCollector collects the right doc nums"
);
-$bit_vec = KinoSearch::Object::BitVector->new;
-my $inner_coll = KinoSearch::Search::Collector::BitCollector->new(
+$bit_vec = Lucy::Object::BitVector->new;
+my $inner_coll = Lucy::Search::Collector::BitCollector->new(
bit_vector => $bit_vec );
-my $offset_coll = KinoSearch::Search::Collector::OffsetCollector->new(
+my $offset_coll = Lucy::Search::Collector::OffsetCollector->new(
collector => $inner_coll,
offset => 10,
);
Modified: incubator/lucy/trunk/perl/t/507-filter.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/507-filter.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/507-filter.t (original)
+++ incubator/lucy/trunk/perl/t/507-filter.t Thu Nov 4 05:36:36 2010
@@ -19,12 +19,12 @@ use lib 'buildlib';
use Test::More tests => 24;
use Storable qw( nfreeze thaw );
-use KinoSearch::Test;
+use Lucy::Test;
use Lucy::Test::TestUtils qw( create_index );
use LucyX::Search::Filter;
-my $query_parser = KinoSearch::Search::QueryParser->new(
- schema => KinoSearch::Test::TestSchema->new );
+my $query_parser = Lucy::Search::QueryParser->new(
+ schema => Lucy::Test::TestSchema->new );
## Set up main objects.
my ( $filter_1, $filter_2 );
@@ -33,14 +33,14 @@ my ( $filter_1, $filter_2 );
my $folder_2 = create_index( 'a w', 'b w', 'c w', 'a z', 'b z', 'c z' );
my $searcher_1
- = KinoSearch::Search::IndexSearcher->new( index => $folder_1 );
+ = Lucy::Search::IndexSearcher->new( index => $folder_1 );
my $searcher_2
- = KinoSearch::Search::IndexSearcher->new( index => $folder_2 );
+ = Lucy::Search::IndexSearcher->new( index => $folder_2 );
my $reader_1 = $searcher_1->get_reader->get_seg_readers->[0];
my $reader_2 = $searcher_2->get_reader->get_seg_readers->[0];
- my $only_a_query = KinoSearch::Search::TermQuery->new(
+ my $only_a_query = Lucy::Search::TermQuery->new(
field => 'content',
term => 'a',
);
@@ -115,7 +115,7 @@ my ( $filter_1, $filter_2 );
sub filt_query {
my ( $filter, $query_string ) = @_;
- return KinoSearch::Search::ANDQuery->new(
+ return Lucy::Search::ANDQuery->new(
children => [ $filter, $query_parser->parse($query_string) ], );
}
Modified: incubator/lucy/trunk/perl/t/508-hits.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/508-hits.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/508-hits.t (original)
+++ incubator/lucy/trunk/perl/t/508-hits.t Thu Nov 4 05:36:36 2010
@@ -18,12 +18,12 @@ use warnings;
use lib 'buildlib';
use Test::More tests => 9;
-use KinoSearch::Test;
+use Lucy::Test;
use Lucy::Test::TestUtils qw( create_index );
my @docs = ( 'a b', 'a a b', 'a a a b', 'x' );
my $folder = create_index(@docs);
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
my $hits = $searcher->hits(
query => 'a',
Modified: incubator/lucy/trunk/perl/t/509-poly_searcher.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/509-poly_searcher.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/509-poly_searcher.t (original)
+++ incubator/lucy/trunk/perl/t/509-poly_searcher.t Thu Nov 4 05:36:36 2010
@@ -18,16 +18,16 @@ use warnings;
use lib 'buildlib';
use Test::More tests => 8;
-use KinoSearch::Test;
+use Lucy::Test;
use Lucy::Test::TestUtils qw( create_index );
my $folder_a = create_index( 'x a', 'x b', 'x c' );
my $folder_b = create_index( 'y b', 'y c', 'y d' );
-my $searcher_a = KinoSearch::Search::IndexSearcher->new( index => $folder_a );
-my $searcher_b = KinoSearch::Search::IndexSearcher->new( index => $folder_b );
+my $searcher_a = Lucy::Search::IndexSearcher->new( index => $folder_a );
+my $searcher_b = Lucy::Search::IndexSearcher->new( index => $folder_b );
-my $poly_searcher = KinoSearch::Search::PolySearcher->new(
- schema => KinoSearch::Test::TestSchema->new,
+my $poly_searcher = Lucy::Search::PolySearcher->new(
+ schema => Lucy::Test::TestSchema->new,
searchers => [ $searcher_a, $searcher_b ],
);
@@ -35,7 +35,7 @@ is( $poly_searcher->doc_freq( field => '
2, 'doc_freq' );
is( $poly_searcher->doc_max, 6, 'doc_max' );
is( $poly_searcher->fetch_doc(1)->{content}, 'x a', "fetch_doc" );
-isa_ok( $poly_searcher->fetch_doc_vec(1), 'KinoSearch::Index::DocVector' );
+isa_ok( $poly_searcher->fetch_doc_vec(1), 'Lucy::Index::DocVector' );
my $hits = $poly_searcher->hits( query => 'a' );
is( $hits->total_hits, 1, "Find hit in first searcher" );
@@ -46,9 +46,9 @@ is( $hits->total_hits, 1, "Find hit in s
$hits = $poly_searcher->hits( query => 'c' );
is( $hits->total_hits, 2, "Find hits in both searchers" );
-my $bit_vec = KinoSearch::Object::BitVector->new(
+my $bit_vec = Lucy::Object::BitVector->new(
capacity => $poly_searcher->doc_max );
-my $bitcoll = KinoSearch::Search::Collector::BitCollector->new(
+my $bitcoll = Lucy::Search::Collector::BitCollector->new(
bit_vector => $bit_vec );
my $query = $poly_searcher->glean_query('b');
$poly_searcher->collect( query => $query, collector => $bitcoll );
Modified: incubator/lucy/trunk/perl/t/510-remote_search.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/510-remote_search.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/510-remote_search.t (original)
+++ incubator/lucy/trunk/perl/t/510-remote_search.t Thu Nov 4 05:36:36 2010
@@ -31,14 +31,14 @@ BEGIN {
}
package SortSchema;
-use base qw( KinoSearch::Plan::Schema );
-use KinoSearch::Analysis::Tokenizer;
+use base qw( Lucy::Plan::Schema );
+use Lucy::Analysis::Tokenizer;
sub new {
my $self = shift->SUPER::new(@_);
- my $plain_type = KinoSearch::Plan::FullTextType->new(
- analyzer => KinoSearch::Analysis::Tokenizer->new );
- my $string_type = KinoSearch::Plan::StringType->new( sortable => 1 );
+ my $plain_type = Lucy::Plan::FullTextType->new(
+ analyzer => Lucy::Analysis::Tokenizer->new );
+ my $string_type = Lucy::Plan::StringType->new( sortable => 1 );
$self->spec_field( name => 'content', type => $plain_type );
$self->spec_field( name => 'number', type => $string_type );
return $self;
@@ -46,7 +46,7 @@ sub new {
package main;
-use KinoSearch::Test;
+use Lucy::Test;
use LucyX::Remote::SearchServer;
use LucyX::Remote::SearchClient;
@@ -57,8 +57,8 @@ if ($kid) {
die "Failed fork: $!" unless defined $kid;
}
else {
- my $folder = KinoSearch::Store::RAMFolder->new;
- my $indexer = KinoSearch::Index::Indexer->new(
+ my $folder = Lucy::Store::RAMFolder->new;
+ my $indexer = Lucy::Index::Indexer->new(
index => $folder,
schema => SortSchema->new,
);
@@ -69,7 +69,7 @@ else {
}
$indexer->commit;
- my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+ my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
my $server = LucyX::Remote::SearchServer->new(
port => $PORT_NUM,
searcher => $searcher,
@@ -101,10 +101,10 @@ is( $searchclient->doc_freq( field => 'c
3, "doc_freq" );
is( $searchclient->doc_max, 3, "doc_max" );
isa_ok( $searchclient->fetch_doc(1),
- "KinoSearch::Document::HitDoc", "fetch_doc" );
+ "Lucy::Document::HitDoc", "fetch_doc" );
isa_ok(
$searchclient->fetch_doc_vec(1),
- "KinoSearch::Index::DocVector",
+ "Lucy::Index::DocVector",
"fetch_doc_vec"
);
@@ -114,10 +114,10 @@ is( $hits->total_hits, 3, "retrieved hit
$hits = $searchclient->hits( query => 'a' );
is( $hits->total_hits, 1, "retrieved hit from search server" );
-my $folder_b = KinoSearch::Store::RAMFolder->new;
+my $folder_b = Lucy::Store::RAMFolder->new;
my $number = 6;
for (qw( a b c )) {
- my $indexer = KinoSearch::Index::Indexer->new(
+ my $indexer = Lucy::Index::Indexer->new(
index => $folder_b,
schema => SortSchema->new,
);
@@ -128,10 +128,10 @@ for (qw( a b c )) {
}
my $searcher_b
- = KinoSearch::Search::IndexSearcher->new( index => $folder_b, );
-is( ref( $searcher_b->get_reader ), 'KinoSearch::Index::PolyReader', );
+ = Lucy::Search::IndexSearcher->new( index => $folder_b, );
+is( ref( $searcher_b->get_reader ), 'Lucy::Index::PolyReader', );
-my $poly_searcher = KinoSearch::Search::PolySearcher->new(
+my $poly_searcher = Lucy::Search::PolySearcher->new(
schema => SortSchema->new,
searchers => [ $searcher_b, $searchclient ],
);
@@ -146,10 +146,10 @@ my %expected = ( 'x b' => 1, 'y b' => 1,
is_deeply( \%results, \%expected, "docs fetched from both local and remote" );
-my $sort_spec = KinoSearch::Search::SortSpec->new(
+my $sort_spec = Lucy::Search::SortSpec->new(
rules => [
- KinoSearch::Search::SortRule->new( field => 'number' ),
- KinoSearch::Search::SortRule->new( type => 'doc_id' ),
+ Lucy::Search::SortRule->new( field => 'number' ),
+ Lucy::Search::SortRule->new( type => 'doc_id' ),
],
);
$hits = $poly_searcher->hits(
@@ -161,10 +161,10 @@ my @got;
while ( my $hit = $hits->next ) {
push @got, $hit->{content};
}
-$sort_spec = KinoSearch::Search::SortSpec->new(
+$sort_spec = Lucy::Search::SortSpec->new(
rules => [
- KinoSearch::Search::SortRule->new( field => 'number', reverse => 1 ),
- KinoSearch::Search::SortRule->new( type => 'doc_id' ),
+ Lucy::Search::SortRule->new( field => 'number', reverse => 1 ),
+ Lucy::Search::SortRule->new( type => 'doc_id' ),
],
);
$hits = $poly_searcher->hits(
Modified: incubator/lucy/trunk/perl/t/511-sort_spec.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/511-sort_spec.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/511-sort_spec.t (original)
+++ incubator/lucy/trunk/perl/t/511-sort_spec.t Thu Nov 4 05:36:36 2010
@@ -21,7 +21,7 @@ use Test::More tests => 18;
use List::Util qw( shuffle );
package ReverseType;
-use base qw( KinoSearch::Plan::Int32Type );
+use base qw( Lucy::Plan::Int32Type );
sub new {
return shift->SUPER::new( indexed => 0, sortable => 1, @_ );
@@ -33,26 +33,26 @@ sub compare_values {
}
package SortSchema;
-use base qw( KinoSearch::Plan::Schema );
+use base qw( Lucy::Plan::Schema );
sub new {
my $self = shift->SUPER::new(@_);
- my $unsortable = KinoSearch::Plan::FullTextType->new(
- analyzer => KinoSearch::Analysis::Tokenizer->new, );
- my $string_type = KinoSearch::Plan::StringType->new( sortable => 1 );
- my $int32_type = KinoSearch::Plan::Int32Type->new(
+ my $unsortable = Lucy::Plan::FullTextType->new(
+ analyzer => Lucy::Analysis::Tokenizer->new, );
+ my $string_type = Lucy::Plan::StringType->new( sortable => 1 );
+ my $int32_type = Lucy::Plan::Int32Type->new(
indexed => 0,
sortable => 1,
);
- my $int64_type = KinoSearch::Plan::Int64Type->new(
+ my $int64_type = Lucy::Plan::Int64Type->new(
indexed => 0,
sortable => 1,
);
- my $float32_type = KinoSearch::Plan::Float32Type->new(
+ my $float32_type = Lucy::Plan::Float32Type->new(
indexed => 0,
sortable => 1,
);
- my $float64_type = KinoSearch::Plan::Float64Type->new(
+ my $float64_type = Lucy::Plan::Float64Type->new(
indexed => 0,
sortable => 1,
);
@@ -72,7 +72,7 @@ sub new {
}
package main;
-use KinoSearch::Test;
+use Lucy::Test;
my $airplane = {
name => 'airplane',
@@ -99,13 +99,13 @@ my $car = {
cat => 'vehicle',
};
-my $folder = KinoSearch::Store::RAMFolder->new;
+my $folder = Lucy::Store::RAMFolder->new;
my $schema = SortSchema->new;
my $indexer;
sub refresh_indexer {
$indexer->commit if $indexer;
- $indexer = KinoSearch::Index::Indexer->new(
+ $indexer = Lucy::Index::Indexer->new(
index => $folder,
schema => $schema,
);
@@ -209,7 +209,7 @@ for ( shuffle( 0 .. 99 ) ) {
}
$indexer->commit;
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
my $results = test_sorted_search( 'vehicle', 100, name => 0 );
is_deeply( $results, [qw( airplane bike car )], "sort by one criteria" );
@@ -279,7 +279,7 @@ is_deeply( $ten_results, \@first_ten_of_
# Add another seg to index.
undef $indexer;
-$indexer = KinoSearch::Index::Indexer->new(
+$indexer = Lucy::Index::Indexer->new(
schema => $schema,
index => $folder,
);
@@ -292,7 +292,7 @@ $indexer->add_doc(
}
);
$indexer->commit;
-$searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+$searcher = Lucy::Search::IndexSearcher->new( index => $folder );
$results = test_sorted_search( 'vehicle', 100, name => 0 );
is_deeply( $results, [qw( airplane bike car )], "Multi-segment sort" );
@@ -307,13 +307,13 @@ sub test_sorted_search {
my $field = shift @criteria;
my $rev = shift @criteria;
push @rules,
- KinoSearch::Search::SortRule->new(
+ Lucy::Search::SortRule->new(
field => $field,
reverse => $rev,
);
}
- push @rules, KinoSearch::Search::SortRule->new( type => 'doc_id' );
- my $sort_spec = KinoSearch::Search::SortSpec->new( rules => \@rules );
+ push @rules, Lucy::Search::SortRule->new( type => 'doc_id' );
+ my $sort_spec = Lucy::Search::SortSpec->new( rules => \@rules );
my $hits = $searcher->hits(
query => $query,
sort_spec => $sort_spec,
Modified: incubator/lucy/trunk/perl/t/513-matcher.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/513-matcher.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/513-matcher.t (original)
+++ incubator/lucy/trunk/perl/t/513-matcher.t Thu Nov 4 05:36:36 2010
@@ -18,14 +18,14 @@ use warnings;
use lib 'buildlib';
package MyMatcher;
-use base qw( KinoSearch::Search::Matcher );
+use base qw( Lucy::Search::Matcher );
package main;
use Test::More tests => 22;
use LucyX::Search::MockScorer;
-use KinoSearch::Test;
+use Lucy::Test;
my $matcher = MyMatcher->new;
for (qw( score get_doc_id next )) {
@@ -106,17 +106,17 @@ sub test_search {
scores => [ (0) x scalar @$docs ],
);
if (@$dels) {
- my $bit_vec = KinoSearch::Object::BitVector->new(
+ my $bit_vec = Lucy::Object::BitVector->new(
capacity => $dels->[-1] + 1 );
$bit_vec->set($_) for @$dels;
- $del_enum = KinoSearch::Search::BitVecMatcher->new(
+ $del_enum = Lucy::Search::BitVecMatcher->new(
bit_vector => $bit_vec );
}
my $collector
- = KinoSearch::Search::Collector::SortCollector->new( wanted => 100 );
+ = Lucy::Search::Collector::SortCollector->new( wanted => 100 );
$matcher->collect(
- %KinoSearch::Search::Matcher::collect_PARAMS,
+ %Lucy::Search::Matcher::collect_PARAMS,
collector => $collector,
deletions => $del_enum,
%args,
Modified: incubator/lucy/trunk/perl/t/514-and_scorer.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/514-and_scorer.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/514-and_scorer.t (original)
+++ incubator/lucy/trunk/perl/t/514-and_scorer.t Thu Nov 4 05:36:36 2010
@@ -18,11 +18,11 @@ use warnings;
use lib 'buildlib';
use Test::More tests => 1362;
-use KinoSearch::Test;
+use Lucy::Test;
use LucyX::Search::MockScorer;
use Lucy::Test::TestUtils qw( modulo_set doc_ids_from_td_coll );
-my $sim = KinoSearch::Index::Similarity->new;
+my $sim = Lucy::Index::Similarity->new;
for my $interval_a ( reverse 1 .. 17 ) {
for my $interval_b ( reverse 10 .. 17 ) {
@@ -44,13 +44,13 @@ sub check_scorer {
scores => [ (0) x scalar @$_ ],
)
} @doc_id_arrays;
- my $and_scorer = KinoSearch::Search::ANDScorer->new(
+ my $and_scorer = Lucy::Search::ANDScorer->new(
children => \@children,
similarity => $sim,
);
my @expected = intersect(@doc_id_arrays);
my $collector
- = KinoSearch::Search::Collector::SortCollector->new( wanted => 1000 );
+ = Lucy::Search::Collector::SortCollector->new( wanted => 1000 );
$and_scorer->collect( collector => $collector );
is( $collector->get_total_hits,
scalar @expected,
Modified: incubator/lucy/trunk/perl/t/515-range_query.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/515-range_query.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/515-range_query.t (original)
+++ incubator/lucy/trunk/perl/t/515-range_query.t Thu Nov 4 05:36:36 2010
@@ -20,15 +20,15 @@ use lib 'buildlib';
use Test::More tests => 63;
use List::Util qw( shuffle );
use Storable qw( nfreeze thaw );
-use KinoSearch::Test;
+use Lucy::Test;
package RangeSchema;
-use base qw( KinoSearch::Plan::Schema );
-use KinoSearch::Analysis::Tokenizer;
+use base qw( Lucy::Plan::Schema );
+use Lucy::Analysis::Tokenizer;
sub new {
my $self = shift->SUPER::new(@_);
- my $type = KinoSearch::Plan::StringType->new( sortable => 1 );
+ my $type = Lucy::Plan::StringType->new( sortable => 1 );
$self->spec_field( name => 'name', type => $type );
$self->spec_field( name => 'cat', type => $type );
$self->spec_field( name => 'unused', type => $type );
@@ -37,9 +37,9 @@ sub new {
package main;
-my $folder = KinoSearch::Store::RAMFolder->new;
+my $folder = Lucy::Store::RAMFolder->new;
my $schema = RangeSchema->new;
-my $indexer = KinoSearch::Index::Indexer->new(
+my $indexer = Lucy::Index::Indexer->new(
index => $folder,
schema => $schema,
);
@@ -57,7 +57,7 @@ for my $letter ( shuffle @letters ) {
}
$indexer->commit;
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
my $results = test_range_search(
field => 'name',
@@ -254,7 +254,7 @@ like( $@, qr/lower_term/,
"Failing to supply either lower_term or upper_term throws an exception" );
# Add more docs, test multi-segment searches.
-$indexer = KinoSearch::Index::Indexer->new(
+$indexer = Lucy::Index::Indexer->new(
index => $folder,
schema => $schema,
);
@@ -265,7 +265,7 @@ $indexer->add_doc(
);
$indexer->commit;
$letters{'mh'} = ++$count;
-$searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+$searcher = Lucy::Search::IndexSearcher->new( index => $folder );
$results = test_range_search(
field => 'name',
@@ -281,7 +281,7 @@ test_results( $results, [ 'i' .. 'm', 'm
sub test_range_search {
my %args = @_;
my $string = delete $args{string};
- my $query = KinoSearch::Search::RangeQuery->new(%args);
+ my $query = Lucy::Search::RangeQuery->new(%args);
if ( defined $string ) {
is( $query->to_string, $string );
}
Modified: incubator/lucy/trunk/perl/t/518-or_scorer.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/518-or_scorer.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/518-or_scorer.t (original)
+++ incubator/lucy/trunk/perl/t/518-or_scorer.t Thu Nov 4 05:36:36 2010
@@ -18,11 +18,11 @@ use warnings;
use lib 'buildlib';
use Test::More tests => 900;
-use KinoSearch::Test;
+use Lucy::Test;
use LucyX::Search::MockScorer;
use Lucy::Test::TestUtils qw( modulo_set doc_ids_from_td_coll );
-my $sim = KinoSearch::Index::Similarity->new;
+my $sim = Lucy::Index::Similarity->new;
for my $interval_a ( 1 .. 10 ) {
for my $interval_b ( 5 .. 10 ) {
@@ -38,7 +38,7 @@ sub check_scorer {
my @intervals = @_;
my @doc_id_arrays = map { modulo_set( $_, 100 ) } @intervals;
my $subscorers
- = KinoSearch::Object::VArray->new( capacity => scalar @intervals );
+ = Lucy::Object::VArray->new( capacity => scalar @intervals );
for my $doc_id_array (@doc_id_arrays) {
my $mock = LucyX::Search::MockScorer->new(
doc_ids => $doc_id_array,
@@ -47,12 +47,12 @@ sub check_scorer {
$subscorers->push($mock);
}
- my $or_scorer = KinoSearch::Search::ORScorer->new(
+ my $or_scorer = Lucy::Search::ORScorer->new(
similarity => $sim,
children => $subscorers,
);
my $collector
- = KinoSearch::Search::Collector::SortCollector->new( wanted => 100 );
+ = Lucy::Search::Collector::SortCollector->new( wanted => 100 );
$or_scorer->collect( collector => $collector );
my ( $got_by_score, $got_by_id ) = doc_ids_from_td_coll($collector);
my ( $expected_by_count, $expected_by_id )
Modified: incubator/lucy/trunk/perl/t/519-req_opt_scorer.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/519-req_opt_scorer.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/519-req_opt_scorer.t (original)
+++ incubator/lucy/trunk/perl/t/519-req_opt_scorer.t Thu Nov 4 05:36:36 2010
@@ -18,11 +18,11 @@ use warnings;
use lib 'buildlib';
use Test::More tests => 726;
-use KinoSearch::Test;
+use Lucy::Test;
use LucyX::Search::MockScorer;
use Lucy::Test::TestUtils qw( modulo_set doc_ids_from_td_coll );
-my $sim = KinoSearch::Index::Similarity->new;
+my $sim = Lucy::Index::Similarity->new;
for my $req_interval ( 1 .. 10, 75 ) {
for my $opt_interval ( 1 .. 10, 75 ) {
@@ -43,13 +43,13 @@ sub check_scorer {
doc_ids => $opt_docs,
scores => [ (1) x scalar @$opt_docs ],
);
- my $req_opt_scorer = KinoSearch::Search::RequiredOptionalScorer->new(
+ my $req_opt_scorer = Lucy::Search::RequiredOptionalScorer->new(
similarity => $sim,
required_matcher => $req_mock,
optional_matcher => $opt_mock,
);
my $collector
- = KinoSearch::Search::Collector::SortCollector->new( wanted => 1000 );
+ = Lucy::Search::Collector::SortCollector->new( wanted => 1000 );
$req_opt_scorer->collect( collector => $collector );
my ( $got_by_score, $got_by_id ) = doc_ids_from_td_coll($collector);
my ( $expected_by_count, $expected_by_id )
Modified: incubator/lucy/trunk/perl/t/520-match_doc.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/520-match_doc.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/520-match_doc.t (original)
+++ incubator/lucy/trunk/perl/t/520-match_doc.t Thu Nov 4 05:36:36 2010
@@ -19,9 +19,9 @@ use lib 'buildlib';
use Test::More tests => 7;
use Storable qw( freeze thaw );
-use KinoSearch::Test;
+use Lucy::Test;
-my $match_doc = KinoSearch::Search::MatchDoc->new(
+my $match_doc = Lucy::Search::MatchDoc->new(
doc_id => 31,
score => 5.0,
);
@@ -36,10 +36,10 @@ is( $match_doc_copy->get_score, $match_d
is( $match_doc_copy->get_values, $match_doc->get_values,
"empty values still empty after serialization" );
-my $values = KinoSearch::Object::VArray->new( capacity => 4 );
-$values->store( 0, KinoSearch::Object::CharBuf->new("foo") );
-$values->store( 3, KinoSearch::Object::CharBuf->new("bar") );
-$match_doc = KinoSearch::Search::MatchDoc->new(
+my $values = Lucy::Object::VArray->new( capacity => 4 );
+$values->store( 0, Lucy::Object::CharBuf->new("foo") );
+$values->store( 3, Lucy::Object::CharBuf->new("bar") );
+$match_doc = Lucy::Search::MatchDoc->new(
doc_id => 120,
score => 35,
values => $values,
Modified: incubator/lucy/trunk/perl/t/523-and_query.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/523-and_query.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/523-and_query.t (original)
+++ incubator/lucy/trunk/perl/t/523-and_query.t Thu Nov 4 05:36:36 2010
@@ -22,20 +22,20 @@ use Storable qw( freeze thaw );
use Lucy::Test::TestUtils qw( create_index );
my $folder = create_index( 'a', 'b', 'c c c d', 'c d', 'd' .. 'z', );
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
my $reader = $searcher->get_reader->get_seg_readers->[0];
-my $a_query = KinoSearch::Search::TermQuery->new(
+my $a_query = Lucy::Search::TermQuery->new(
field => 'content',
term => 'a'
);
-my $b_query = KinoSearch::Search::TermQuery->new(
+my $b_query = Lucy::Search::TermQuery->new(
field => 'content',
term => 'b'
);
-my $and_query = KinoSearch::Search::ANDQuery->new;
+my $and_query = Lucy::Search::ANDQuery->new;
is( $and_query->to_string, "()", "to_string (empty)" );
$and_query->add_child($a_query);
$and_query->add_child($b_query);
@@ -47,17 +47,17 @@ ok( $and_query->equals($thawed), "equals
$thawed->set_boost(10);
ok( !$and_query->equals($thawed), '!equals (boost)' );
-my $different_children = KinoSearch::Search::ANDQuery->new(
+my $different_children = Lucy::Search::ANDQuery->new(
children => [ $a_query, $a_query ], # a_query added twice
);
ok( !$and_query->equals($different_children),
'!equals (different children)' );
-my $one_child = KinoSearch::Search::ANDQuery->new( children => [$a_query] );
+my $one_child = Lucy::Search::ANDQuery->new( children => [$a_query] );
ok( !$and_query->equals($one_child), '!equals (too few children)' );
my $and_compiler = $and_query->make_compiler( searcher => $searcher );
-isa_ok( $and_compiler, "KinoSearch::Search::ANDCompiler", "make_compiler" );
+isa_ok( $and_compiler, "Lucy::Search::ANDCompiler", "make_compiler" );
$frozen = freeze($and_compiler);
$thawed = thaw($frozen);
ok( $thawed->equals($and_compiler), "freeze/thaw compiler" );
@@ -66,17 +66,17 @@ my $and_scorer = $and_compiler->make_mat
reader => $reader,
need_score => 0,
);
-isa_ok( $and_scorer, "KinoSearch::Search::ANDScorer", "make_matcher" );
+isa_ok( $and_scorer, "Lucy::Search::ANDScorer", "make_matcher" );
my $term_scorer = $one_child->make_compiler( searcher => $searcher )
->make_matcher( reader => $reader, need_score => 0 );
isa_ok(
$term_scorer,
- "KinoSearch::Search::TermScorer",
+ "Lucy::Search::TermScorer",
"make_matcher compiles to child's scorer if there's only one child"
);
-my $hopeless_query = KinoSearch::Search::TermQuery->new(
+my $hopeless_query = Lucy::Search::TermQuery->new(
field => 'nyet',
term => 'nein',
);
Modified: incubator/lucy/trunk/perl/t/524-poly_query.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/524-poly_query.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/524-poly_query.t (original)
+++ incubator/lucy/trunk/perl/t/524-poly_query.t Thu Nov 4 05:36:36 2010
@@ -22,21 +22,21 @@ use Storable qw( freeze thaw );
use Lucy::Test::TestUtils qw( create_index );
my $folder = create_index( 'a', 'b', 'c c c d', 'c d', 'd' .. 'z', );
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
my $reader = $searcher->get_reader->get_seg_readers->[0];
-my $a_query = KinoSearch::Search::TermQuery->new(
+my $a_query = Lucy::Search::TermQuery->new(
field => 'content',
term => 'a'
);
-my $b_query = KinoSearch::Search::TermQuery->new(
+my $b_query = Lucy::Search::TermQuery->new(
field => 'content',
term => 'b'
);
for my $conjunction (qw( AND OR )) {
- my $class = "KinoSearch::Search::${conjunction}Query";
+ my $class = "Lucy::Search::${conjunction}Query";
my $polyquery = $class->new( children => [ $a_query, $b_query ] );
my $frozen = freeze($polyquery);
@@ -53,7 +53,7 @@ for my $conjunction (qw( AND OR )) {
ok( !$polyquery->equals($one_child), '!equals (too few children)' );
my $compiler = $polyquery->make_compiler( searcher => $searcher );
- isa_ok( $compiler, "KinoSearch::Search::${conjunction}Compiler",
+ isa_ok( $compiler, "Lucy::Search::${conjunction}Compiler",
"make_compiler" );
$frozen = freeze($compiler);
$thawed = thaw($frozen);
@@ -63,7 +63,7 @@ for my $conjunction (qw( AND OR )) {
= $compiler->make_matcher( reader => $reader, need_score => 1 );
isa_ok(
$matcher,
- "KinoSearch::Search::${conjunction}Scorer",
+ "Lucy::Search::${conjunction}Scorer",
"make_matcher with need_score"
);
@@ -71,15 +71,15 @@ for my $conjunction (qw( AND OR )) {
->make_matcher( reader => $reader, need_score => 0 );
isa_ok(
$term_matcher,
- "KinoSearch::Search::TermScorer",
+ "Lucy::Search::TermScorer",
"make_matcher compiles to child's scorer if there's only one child"
);
- my $hopeless_query = KinoSearch::Search::TermQuery->new(
+ my $hopeless_query = Lucy::Search::TermQuery->new(
field => 'nyet',
term => 'nein',
);
- my $doomed_query = KinoSearch::Search::TermQuery->new(
+ my $doomed_query = Lucy::Search::TermQuery->new(
field => 'luckless',
term => 'zero',
);
Modified: incubator/lucy/trunk/perl/t/525-match_all_query.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/525-match_all_query.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/525-match_all_query.t (original)
+++ incubator/lucy/trunk/perl/t/525-match_all_query.t Thu Nov 4 05:36:36 2010
@@ -22,22 +22,22 @@ use Storable qw( freeze thaw );
use Lucy::Test::TestUtils qw( create_index );
my $folder = create_index( 'a' .. 'z' );
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
-my $match_all_query = KinoSearch::Search::MatchAllQuery->new;
+my $match_all_query = Lucy::Search::MatchAllQuery->new;
is( $match_all_query->to_string, "[MATCHALL]", "to_string" );
my $hits = $searcher->hits( query => $match_all_query );
is( $hits->total_hits, 26, "match all" );
-my $indexer = KinoSearch::Index::Indexer->new(
+my $indexer = Lucy::Index::Indexer->new(
index => $folder,
- schema => KinoSearch::Test::TestSchema->new,
+ schema => Lucy::Test::TestSchema->new,
);
$indexer->delete_by_term( field => 'content', term => 'b' );
$indexer->commit;
-$searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+$searcher = Lucy::Search::IndexSearcher->new( index => $folder );
$hits = $searcher->hits( query => $match_all_query, num_wanted => 100 );
is( $hits->total_hits, 25, "match all minus a deletion" );
my @got;
Modified: incubator/lucy/trunk/perl/t/526-not_query.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/526-not_query.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/526-not_query.t (original)
+++ incubator/lucy/trunk/perl/t/526-not_query.t Thu Nov 4 05:36:36 2010
@@ -26,22 +26,22 @@ my @got;
my $folder = create_index( 'a' .. 'z' );
-my $b_query = KinoSearch::Search::TermQuery->new(
+my $b_query = Lucy::Search::TermQuery->new(
field => 'content',
term => 'b'
);
-my $c_query = KinoSearch::Search::TermQuery->new(
+my $c_query = Lucy::Search::TermQuery->new(
field => 'content',
term => 'c'
);
my $not_b_query
- = KinoSearch::Search::NOTQuery->new( negated_query => $b_query );
+ = Lucy::Search::NOTQuery->new( negated_query => $b_query );
my $not_c_query
- = KinoSearch::Search::NOTQuery->new( negated_query => $c_query );
+ = Lucy::Search::NOTQuery->new( negated_query => $c_query );
is( $not_b_query->to_string, "-content:b", "to_string" );
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
my $reader = $searcher->get_reader;
my $hits = $searcher->hits(
query => $not_b_query,
@@ -80,12 +80,12 @@ for my $num_negated ( 1 .. 26 ) {
doc_ids => \@mock_ids,
scores => [ (1) x scalar @mock_ids ],
);
- my $not_scorer = KinoSearch::Search::NOTScorer->new(
+ my $not_scorer = Lucy::Search::NOTScorer->new(
doc_max => $reader->doc_max,
negated_matcher => $mock_scorer,
);
- my $bit_vec = KinoSearch::Object::BitVector->new( capacity => 30 );
- my $collector = KinoSearch::Search::Collector::BitCollector->new(
+ my $bit_vec = Lucy::Object::BitVector->new( capacity => 30 );
+ my $collector = Lucy::Search::Collector::BitCollector->new(
bit_vector => $bit_vec, );
$not_scorer->collect( collector => $collector );
my $got = $bit_vec->to_arrayref;
@@ -93,15 +93,15 @@ for my $num_negated ( 1 .. 26 ) {
is_deeply( $got, \@source_ids, "correct retrieval ($num_negated)" );
}
-my $indexer = KinoSearch::Index::Indexer->new(
+my $indexer = Lucy::Index::Indexer->new(
index => $folder,
- schema => KinoSearch::Test::TestSchema->new,
+ schema => Lucy::Test::TestSchema->new,
);
$indexer->delete_by_term( field => 'content', term => 'b' );
$indexer->commit;
@got = ();
-$searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+$searcher = Lucy::Search::IndexSearcher->new( index => $folder );
$hits = $searcher->hits( query => $not_b_query, num_wanted => 100 );
is( $hits->total_hits, 25, "still correct after deletion" );
while ( my $hit = $hits->next ) {
Modified: incubator/lucy/trunk/perl/t/527-req_opt_query.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/527-req_opt_query.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/527-req_opt_query.t (original)
+++ incubator/lucy/trunk/perl/t/527-req_opt_query.t Thu Nov 4 05:36:36 2010
@@ -22,23 +22,23 @@ use Storable qw( freeze thaw );
use Lucy::Test::TestUtils qw( create_index );
my $folder = create_index( 'a', 'b', 'b c', 'c', 'c d', 'd', 'e' );
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
my $reader = $searcher->get_reader->get_seg_readers->[0];
-my $b_query = KinoSearch::Search::TermQuery->new(
+my $b_query = Lucy::Search::TermQuery->new(
field => 'content',
term => 'b'
);
-my $c_query = KinoSearch::Search::TermQuery->new(
+my $c_query = Lucy::Search::TermQuery->new(
field => 'content',
term => 'c'
);
-my $x_query = KinoSearch::Search::TermQuery->new(
+my $x_query = Lucy::Search::TermQuery->new(
field => 'content',
term => 'x'
);
-my $req_opt_query = KinoSearch::Search::RequiredOptionalQuery->new(
+my $req_opt_query = Lucy::Search::RequiredOptionalQuery->new(
required_query => $b_query,
optional_query => $c_query,
);
@@ -49,9 +49,9 @@ my $frozen = freeze($compiler);
my $thawed = thaw($frozen);
ok( $thawed->equals($compiler), "freeze/thaw compiler" );
my $matcher = $compiler->make_matcher( reader => $reader, need_score => 1 );
-isa_ok( $matcher, 'KinoSearch::Search::RequiredOptionalScorer' );
+isa_ok( $matcher, 'Lucy::Search::RequiredOptionalScorer' );
-$req_opt_query = KinoSearch::Search::RequiredOptionalQuery->new(
+$req_opt_query = Lucy::Search::RequiredOptionalQuery->new(
required_query => $b_query,
optional_query => $x_query,
);
@@ -59,11 +59,11 @@ $matcher = $req_opt_query->make_compiler
->make_matcher( reader => $reader, need_score => 0 );
isa_ok(
$matcher,
- 'KinoSearch::Search::TermScorer',
+ 'Lucy::Search::TermScorer',
"return required matcher only when opt matcher doesn't match"
);
-$req_opt_query = KinoSearch::Search::RequiredOptionalQuery->new(
+$req_opt_query = Lucy::Search::RequiredOptionalQuery->new(
required_query => $x_query,
optional_query => $b_query,
);
Modified: incubator/lucy/trunk/perl/t/528-leaf_query.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/528-leaf_query.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/528-leaf_query.t (original)
+++ incubator/lucy/trunk/perl/t/528-leaf_query.t Thu Nov 4 05:36:36 2010
@@ -22,14 +22,14 @@ use Storable qw( freeze thaw );
use Lucy::Test::TestUtils qw( create_index );
my $folder = create_index( 'a', 'b', 'b c', 'c', 'c d', 'd', 'e' );
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
my $reader = $searcher->get_reader;
-my $leaf_query = KinoSearch::Search::LeafQuery->new(
+my $leaf_query = Lucy::Search::LeafQuery->new(
field => 'content',
text => 'b'
);
-my $no_field_leaf_query = KinoSearch::Search::LeafQuery->new( text => 'b' );
+my $no_field_leaf_query = Lucy::Search::LeafQuery->new( text => 'b' );
is( $leaf_query->to_string, "content:b", "to_string" );
is( $no_field_leaf_query->to_string, "b", "no field to_string" );
@@ -41,11 +41,11 @@ ok( !$leaf_query->equals($no_field_leaf_
ok( !$no_field_leaf_query->equals($leaf_query), "!equals (nofield/field)" );
my $diff_field
- = KinoSearch::Search::LeafQuery->new( field => 'oink', text => 'b' );
+ = Lucy::Search::LeafQuery->new( field => 'oink', text => 'b' );
ok( !$diff_field->equals($leaf_query), "!equals (different field)" );
my $diff_text
- = KinoSearch::Search::LeafQuery->new( field => 'content', text => 'c' );
+ = Lucy::Search::LeafQuery->new( field => 'content', text => 'c' );
ok( !$diff_text->equals($leaf_query), "!equals (different text)" );
eval { $leaf_query->make_compiler( searcher => $searcher ); };
Modified: incubator/lucy/trunk/perl/t/529-no_match_query.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/529-no_match_query.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/529-no_match_query.t (original)
+++ incubator/lucy/trunk/perl/t/529-no_match_query.t Thu Nov 4 05:36:36 2010
@@ -22,9 +22,9 @@ use Storable qw( freeze thaw );
use Lucy::Test::TestUtils qw( create_index );
my $folder = create_index( 'a' .. 'z' );
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
-my $no_match_query = KinoSearch::Search::NoMatchQuery->new;
+my $no_match_query = Lucy::Search::NoMatchQuery->new;
is( $no_match_query->to_string, "[NOMATCH]", "to_string" );
my $hits = $searcher->hits( query => $no_match_query );
Modified: incubator/lucy/trunk/perl/t/532-sort_collector.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/532-sort_collector.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/532-sort_collector.t (original)
+++ incubator/lucy/trunk/perl/t/532-sort_collector.t Thu Nov 4 05:36:36 2010
@@ -17,18 +17,18 @@ use strict;
use warnings;
use Test::More tests => 32;
-use KinoSearch::Test;
+use Lucy::Test;
use List::Util qw( shuffle );
use LucyX::Search::MockScorer;
-my $schema = KinoSearch::Plan::Schema->new;
-my $type = KinoSearch::Plan::StringType->new( sortable => 1 );
+my $schema = Lucy::Plan::Schema->new;
+my $type = Lucy::Plan::StringType->new( sortable => 1 );
$schema->spec_field( name => 'letter', type => $type );
$schema->spec_field( name => 'number', type => $type );
$schema->spec_field( name => 'id', type => $type );
-my $folder = KinoSearch::Store::RAMFolder->new;
-my $indexer = KinoSearch::Index::Indexer->new(
+my $folder = Lucy::Store::RAMFolder->new;
+my $indexer = Lucy::Index::Indexer->new(
index => $folder,
schema => $schema,
);
@@ -51,17 +51,17 @@ for my $id ( 4 .. 100 ) {
$indexer->add_doc($_) for @docs;
$indexer->commit;
-my $polyreader = KinoSearch::Index::IndexReader->open( index => $folder );
+my $polyreader = Lucy::Index::IndexReader->open( index => $folder );
my $seg_reader = $polyreader->get_seg_readers->[0];
-my $by_letter = KinoSearch::Search::SortSpec->new(
+my $by_letter = Lucy::Search::SortSpec->new(
rules => [
- KinoSearch::Search::SortRule->new( field => 'letter' ),
- KinoSearch::Search::SortRule->new( type => 'doc_id' ),
+ Lucy::Search::SortRule->new( field => 'letter' ),
+ Lucy::Search::SortRule->new( type => 'doc_id' ),
]
);
-my $collector = KinoSearch::Search::Collector::SortCollector->new(
+my $collector = Lucy::Search::Collector::SortCollector->new(
sort_spec => $by_letter,
schema => $schema,
wanted => 1,
@@ -95,7 +95,7 @@ for my $size ( 0 .. @doc_ids ) {
scores => \@scores,
);
my $collector
- = KinoSearch::Search::Collector::SortCollector->new( wanted => $size,
+ = Lucy::Search::Collector::SortCollector->new( wanted => $size,
);
$collector->set_matcher($matcher);
$matcher->collect( collector => $collector );
Modified: incubator/lucy/trunk/perl/t/601-queryparser.t
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/perl/t/601-queryparser.t?rev=1030838&r1=1030837&r2=1030838&view=diff
==============================================================================
--- incubator/lucy/trunk/perl/t/601-queryparser.t (original)
+++ incubator/lucy/trunk/perl/t/601-queryparser.t Thu Nov 4 05:36:36 2010
@@ -17,57 +17,57 @@ use strict;
use warnings;
use lib 'buildlib';
-use KinoSearch::Test;
+use Lucy::Test;
package PlainSchema;
-use base qw( KinoSearch::Plan::Schema );
-use KinoSearch::Analysis::Tokenizer;
+use base qw( Lucy::Plan::Schema );
+use Lucy::Analysis::Tokenizer;
sub new {
my $self = shift->SUPER::new(@_);
- my $tokenizer = KinoSearch::Analysis::Tokenizer->new( pattern => '\S+' );
- my $type = KinoSearch::Plan::FullTextType->new( analyzer => $tokenizer, );
+ my $tokenizer = Lucy::Analysis::Tokenizer->new( pattern => '\S+' );
+ my $type = Lucy::Plan::FullTextType->new( analyzer => $tokenizer, );
$self->spec_field( name => 'content', type => $type );
return $self;
}
package StopSchema;
-use base qw( KinoSearch::Plan::Schema );
+use base qw( Lucy::Plan::Schema );
sub new {
my $self = shift->SUPER::new(@_);
my $whitespace_tokenizer
- = KinoSearch::Analysis::Tokenizer->new( token_re => qr/\S+/ );
+ = Lucy::Analysis::Tokenizer->new( token_re => qr/\S+/ );
my $stopalizer
- = KinoSearch::Analysis::Stopalizer->new( stoplist => { x => 1 } );
- my $polyanalyzer = KinoSearch::Analysis::PolyAnalyzer->new(
+ = Lucy::Analysis::Stopalizer->new( stoplist => { x => 1 } );
+ my $polyanalyzer = Lucy::Analysis::PolyAnalyzer->new(
analyzers => [ $whitespace_tokenizer, $stopalizer, ], );
my $type
- = KinoSearch::Plan::FullTextType->new( analyzer => $polyanalyzer, );
+ = Lucy::Plan::FullTextType->new( analyzer => $polyanalyzer, );
$self->spec_field( name => 'content', type => $type );
return $self;
}
package MyTermQuery;
-use base qw( KinoSearch::Search::TermQuery );
+use base qw( Lucy::Search::TermQuery );
package MyPhraseQuery;
-use base qw( KinoSearch::Search::PhraseQuery );
+use base qw( Lucy::Search::PhraseQuery );
package MyANDQuery;
-use base qw( KinoSearch::Search::ANDQuery );
+use base qw( Lucy::Search::ANDQuery );
package MyORQuery;
-use base qw( KinoSearch::Search::ORQuery );
+use base qw( Lucy::Search::ORQuery );
package MyNOTQuery;
-use base qw( KinoSearch::Search::NOTQuery );
+use base qw( Lucy::Search::NOTQuery );
package MyReqOptQuery;
-use base qw( KinoSearch::Search::RequiredOptionalQuery );
+use base qw( Lucy::Search::RequiredOptionalQuery );
package MyQueryParser;
-use base qw( KinoSearch::Search::QueryParser );
+use base qw( Lucy::Search::QueryParser );
sub make_term_query { shift; MyTermQuery->new(@_) }
sub make_phrase_query { shift; MyPhraseQuery->new(@_) }
@@ -78,20 +78,20 @@ sub make_req_opt_query { shift; MyReqOpt
package main;
use Test::More tests => 224;
-use KinoSearch::Util::StringHelper qw( utf8_flag_on utf8ify );
+use Lucy::Util::StringHelper qw( utf8_flag_on utf8ify );
use Lucy::Test::TestUtils qw( create_index );
-my $folder = KinoSearch::Store::RAMFolder->new;
-my $stop_folder = KinoSearch::Store::RAMFolder->new;
+my $folder = Lucy::Store::RAMFolder->new;
+my $stop_folder = Lucy::Store::RAMFolder->new;
my $plain_schema = PlainSchema->new;
my $stop_schema = StopSchema->new;
my @docs = ( 'x', 'y', 'z', 'x a', 'x a b', 'x a b c', 'x foo a b c d', );
-my $indexer = KinoSearch::Index::Indexer->new(
+my $indexer = Lucy::Index::Indexer->new(
index => $folder,
schema => $plain_schema,
);
-my $stop_indexer = KinoSearch::Index::Indexer->new(
+my $stop_indexer = Lucy::Index::Indexer->new(
index => $stop_folder,
schema => $stop_schema,
);
@@ -104,8 +104,8 @@ $indexer->commit;
$stop_indexer->commit;
my $OR_parser
- = KinoSearch::Search::QueryParser->new( schema => $plain_schema, );
-my $AND_parser = KinoSearch::Search::QueryParser->new(
+ = Lucy::Search::QueryParser->new( schema => $plain_schema, );
+my $AND_parser = Lucy::Search::QueryParser->new(
schema => $plain_schema,
default_boolop => 'AND',
);
@@ -113,17 +113,17 @@ $OR_parser->set_heed_colons(1);
$AND_parser->set_heed_colons(1);
my $OR_stop_parser
- = KinoSearch::Search::QueryParser->new( schema => $stop_schema, );
-my $AND_stop_parser = KinoSearch::Search::QueryParser->new(
+ = Lucy::Search::QueryParser->new( schema => $stop_schema, );
+my $AND_stop_parser = Lucy::Search::QueryParser->new(
schema => $stop_schema,
default_boolop => 'AND',
);
$OR_stop_parser->set_heed_colons(1);
$AND_stop_parser->set_heed_colons(1);
-my $searcher = KinoSearch::Search::IndexSearcher->new( index => $folder );
+my $searcher = Lucy::Search::IndexSearcher->new( index => $folder );
my $stop_searcher
- = KinoSearch::Search::IndexSearcher->new( index => $stop_folder );
+ = Lucy::Search::IndexSearcher->new( index => $stop_folder );
my @logical_tests = (
@@ -227,7 +227,7 @@ my $motorhead = "Mot\xF6rhead";
utf8ify($motorhead);
my $unicode_folder = create_index($motorhead);
$searcher
- = KinoSearch::Search::IndexSearcher->new( index => $unicode_folder );
+ = Lucy::Search::IndexSearcher->new( index => $unicode_folder );
my $hits = $searcher->hits( query => 'Mot' );
is( $hits->total_hits, 0, "Pre-test - indexing worked properly" );