github.com/balzaczyy/golucene@v0.0.0-20151210033525-d0be9ee89713/core_test/search_test.go (about)

     1  package core_test
     2  
     3  import (
     4  	"fmt"
     5  	std "github.com/balzaczyy/golucene/analysis/standard"
     6  	_ "github.com/balzaczyy/golucene/core/codec/lucene410"
     7  	docu "github.com/balzaczyy/golucene/core/document"
     8  	"github.com/balzaczyy/golucene/core/index"
     9  	"github.com/balzaczyy/golucene/core/search"
    10  	"github.com/balzaczyy/golucene/core/store"
    11  	"github.com/balzaczyy/golucene/core/util"
    12  	// . "github.com/balzaczyy/golucene/test_framework"
    13  	// "github.com/balzaczyy/golucene/test_framework/analysis"
    14  	// . "github.com/balzaczyy/golucene/test_framework/util"
    15  	. "github.com/balzaczyy/gounit"
    16  	"os"
    17  	"testing"
    18  )
    19  
    20  // Hook up custom test logic into Go's test runner.
    21  func TestBefore(t *testing.T) {
    22  	fmt.Printf("tests_codec: %v\n", os.Getenv("tests_codec"))
    23  
    24  	// util.SetDefaultInfoStream(util.NewPrintStreamInfoStream(os.Stdout))
    25  	index.DefaultSimilarity = func() index.Similarity {
    26  		return search.NewDefaultSimilarity()
    27  	}
    28  	// This controls how suite-level rules are nested. It is important
    29  	// that _all_ rules declared in testcase are executed in proper
    30  	// order if they depend on each other.
    31  	// ClassRuleChain(ClassEnvRule)
    32  
    33  	// BeforeSuite(t)
    34  }
    35  
    36  func TestBasicIndexAndSearch(t *testing.T) {
    37  	q := search.NewTermQuery(index.NewTerm("foo", "bar"))
    38  	q.SetBoost(-42)
    39  
    40  	os.RemoveAll(".gltest")
    41  
    42  	directory, err := store.OpenFSDirectory(".gltest")
    43  	It(t).Should("has no error: %v", err).Assert(err == nil)
    44  	It(t).Should("has valid directory").Assert(directory != nil)
    45  	fmt.Println("Directory", directory)
    46  	defer directory.Close()
    47  
    48  	analyzer := std.NewStandardAnalyzer()
    49  	conf := index.NewIndexWriterConfig(util.VERSION_LATEST, analyzer)
    50  
    51  	writer, err := index.NewIndexWriter(directory, conf)
    52  	It(t).Should("has no error: %v", err).Assert(err == nil)
    53  
    54  	d := docu.NewDocument()
    55  	d.Add(docu.NewTextFieldFromString("foo", "bar", docu.STORE_YES))
    56  	err = writer.AddDocument(d.Fields())
    57  	It(t).Should("has no error: %v", err).Assert(err == nil)
    58  	err = writer.Close() // ensure index is written
    59  	It(t).Should("has no error: %v", err).Assert(err == nil)
    60  
    61  	reader, err := index.OpenDirectoryReader(directory)
    62  	It(t).Should("has no error: %v", err).Assert(err == nil)
    63  	defer reader.Close()
    64  
    65  	searcher := search.NewIndexSearcher(reader)
    66  	res, err := searcher.Search(q, nil, 1000)
    67  	It(t).Should("has no error: %v", err).Assert(err == nil)
    68  	hits := res.ScoreDocs
    69  	It(t).Should("expect 1 hits, but %v only.", len(hits)).Assert(len(hits) == 1)
    70  	It(t).Should("expect score to be negative (got %v)", hits[0].Score).Verify(hits[0].Score < 0)
    71  
    72  	explain, err := searcher.Explain(q, hits[0].Doc)
    73  	It(t).Should("has no error: %v", err).Assert(err == nil)
    74  	It(t).Should("score doesn't match explanation (%v vs %v)", hits[0].Score, explain.Value()).Verify(isSimilar(hits[0].Score, explain.Value(), 0.001))
    75  	It(t).Should("explain doesn't think doc is a match").Verify(explain.IsMatch())
    76  }
    77  
    78  // func TestNegativeQueryBoost(t *testing.T) {
    79  // 	Test(t, func(t *T) {
    80  // 		q := search.NewTermQuery(index.NewTerm("foo", "bar"))
    81  // 		q.SetBoost(-42)
    82  // 		t.Assert(-42 == q.Boost())
    83  
    84  // 		directory := NewDirectory()
    85  // 		defer directory.Close()
    86  
    87  // 		analyzer := analysis.NewMockAnalyzerWithRandom(Random())
    88  // 		conf := NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer)
    89  
    90  // 		writer, err := index.NewIndexWriter(directory, conf)
    91  // 		if err != nil {
    92  // 			t.Error(err)
    93  // 		}
    94  // 		defer writer.Close()
    95  
    96  // 		d := docu.NewDocument()
    97  // 		d.Add(NewTextField("foo", "bar", true))
    98  // 		writer.AddDocument(d.Fields())
    99  // 		writer.Close() // ensure index is written
   100  
   101  // 		reader, err := index.OpenDirectoryReader(directory)
   102  // 		if err != nil {
   103  // 			t.Error(err)
   104  // 		}
   105  // 		defer reader.Close()
   106  
   107  // 		searcher := NewSearcher(reader)
   108  // 		res, err := searcher.Search(q, nil, 1000)
   109  // 		if err != nil {
   110  // 			t.Error(err)
   111  // 		}
   112  // 		hits := res.ScoreDocs
   113  // 		t.Assert(1 == len(hits))
   114  // 		t.Assert2(hits[0].Score < 0, fmt.Sprintf("score is not negative: %v", hits[0].Score))
   115  
   116  // 		explain, err := searcher.Explain(q, hits[0].Doc)
   117  // 		if err != nil {
   118  // 			t.Error(err)
   119  // 		}
   120  // 		t.Assert2(isSimilar(hits[0].Score, explain.Value(), 0.001), "score doesn't match explanation")
   121  // 		t.Assert2(explain.IsMatch(), "explain doesn't think doc is a match")
   122  // 	})
   123  // }
   124  
   125  func isSimilar(f1, f2, delta float32) bool {
   126  	diff := f1 - f2
   127  	return diff >= 0 && diff < delta || diff < 0 && -diff < delta
   128  }
   129  
   130  func TestAfter(t *testing.T) {
   131  	// AfterSuite(t)
   132  }