Exemple #1
0
func main() {
	util.SetDefaultInfoStream(util.NewPrintStreamInfoStream(os.Stdout))
	index.DefaultSimilarity = func() index.Similarity {
		return search.NewDefaultSimilarity()
	}

	directory, _ := store.OpenFSDirectory("test_index")
	analyzer := std.NewStandardAnalyzer()
	conf := index.NewIndexWriterConfig(util.VERSION_LATEST, analyzer)
	writer, _ := index.NewIndexWriter(directory, conf)

	d := document.NewDocument()
	d.Add(document.NewTextFieldFromString("foo", "bar", document.STORE_YES))
	writer.AddDocument(d.Fields())
	writer.Close() // ensure index is written

	reader, _ := index.OpenDirectoryReader(directory)
	searcher := search.NewIndexSearcher(reader)

	q := search.NewTermQuery(index.NewTerm("foo", "bar"))
	res, _ := searcher.Search(q, nil, 1000)
	fmt.Printf("Found %v hit(s).\n", res.TotalHits)
	for _, hit := range res.ScoreDocs {
		fmt.Printf("Doc %v score: %v\n", hit.Doc, hit.Score)
		doc, _ := reader.Document(hit.Doc)
		fmt.Printf("foo -> %v\n", doc.Get("foo"))
	}

}
// Hook up custom test logic into Go's test runner.
func TestBefore(t *testing.T) {
	fmt.Printf("tests_codec: %v\n", os.Getenv("tests_codec"))

	index.DefaultSimilarity = func() index.Similarity {
		return search.NewDefaultSimilarity()
	}
	// This controls how suite-level rules are nested. It is important
	// that _all_ rules declared in testcase are executed in proper
	// order if they depend on each other.
	ClassRuleChain(ClassEnvRule)

	BeforeSuite(t)
}
Exemple #3
0
func (rule *TestRuleSetupAndRestoreClassEnv) Before() error {
	// if verbose: print some debugging stuff about which codecs are loaded.
	if VERBOSE {
		for _, codec := range index.AvailableCodecs() {
			log.Printf("Loaded codec: '%v': %v", codec,
				reflect.TypeOf(index.LoadCodec(codec)))
		}

		for _, postingFormat := range index.AvailablePostingsFormats() {
			log.Printf("Loaded postingsFormat: '%v': %v", postingFormat,
				reflect.TypeOf(index.LoadPostingsFormat(postingFormat)))
		}
	}

	rule.savedInfoStream = util.DefaultInfoStream()
	random := Random()
	if INFOSTREAM {
		util.SetDefaultInfoStream(newThreadNameFixingPrintStreamInfoStream(os.Stdout))
	} else if random.Intn(2) == 0 {
		util.SetDefaultInfoStream(NewNullInfoStream())
	}

	rule.avoidCodecs = make(map[string]bool)
	if suppressedCodecs != "" {
		rule.avoidCodecs[suppressedCodecs] = true
	}

	PREFLEX_IMPERSONATION_IS_ACTIVE = false
	rule.savedCodec = index.DefaultCodec()
	randomVal := random.Intn(10)
	if "Lucene3x" == TEST_CODEC ||
		"random" == TEST_CODEC &&
			"random" == TEST_POSTINGSFORMAT &&
			"random" == TEST_DOCVALUESFORMAT &&
			randomVal == 3 &&
			!rule.shouldAvoidCodec("Lucene3x") { // preflex-only setup
		panic("not supported yet")
	} else if "Lucene40" == TEST_CODEC ||
		"random" == TEST_CODEC &&
			"random" == TEST_POSTINGSFORMAT &&
			randomVal == 0 &&
			!rule.shouldAvoidCodec("Lucene40") { // 4.0 setup
		panic("not supported yet")
	} else if "Lucene41" == TEST_CODEC ||
		"random" == TEST_CODEC &&
			"random" == TEST_POSTINGSFORMAT &&
			"random" == TEST_DOCVALUESFORMAT &&
			randomVal == 1 &&
			!rule.shouldAvoidCodec("Lucene41") {
		panic("not supported yet")
	} else if "Lucene42" == TEST_CODEC ||
		"random" == TEST_CODEC &&
			"random" == TEST_POSTINGSFORMAT &&
			"random" == TEST_DOCVALUESFORMAT &&
			randomVal == 2 &&
			!rule.shouldAvoidCodec("Lucene42") {
		panic("not supported yet")
	} else if "random" != TEST_POSTINGSFORMAT ||
		"random" != TEST_DOCVALUESFORMAT {
		// the user wired postings or DV: this is messy
		// refactor into RandomCodec...

		panic("not supported yet")
	} else if "SimpleText" == TEST_CODEC ||
		"random" == TEST_CODEC &&
			randomVal == 9 &&
			Rarely(random) &&
			!rule.shouldAvoidCodec("SimpleText") {
		panic("not supported yet")
	} else if "Appending" == TEST_CODEC ||
		"random" == TEST_CODEC &&
			randomVal == 8 &&
			!rule.shouldAvoidCodec("Appending") {
		panic("not supported yet")
	} else if "CheapBastard" == TEST_CODEC ||
		"random" == TEST_CODEC &&
			randomVal == 8 &&
			!rule.shouldAvoidCodec("CheapBastard") &&
			!rule.shouldAvoidCodec("Lucene41") {
		panic("not supported yet")
	} else if "Asserting" == TEST_CODEC ||
		"random" == TEST_CODEC &&
			randomVal == 6 &&
			!rule.shouldAvoidCodec("Asserting") {
		panic("not implemented yet")
	} else if "Compressing" == TEST_CODEC ||
		"random" == TEST_CODEC &&
			randomVal == 5 &&
			!rule.shouldAvoidCodec("Compressing") {
		panic("not supported yet")
	} else if "random" != TEST_CODEC {
		rule.codec = index.LoadCodec(TEST_CODEC)
	} else if "random" == TEST_POSTINGSFORMAT {
		panic("not supported yet")
	} else {
		assert(false)
	}
	log.Printf("Use codec: %v", rule.codec)
	index.DefaultCodec = func() index.Codec { return rule.codec }

	// Initialize locale/ timezone
	// testLocale := or(os.Getenv("tests.locale"), "random")
	// testTimeZon := or(os.Getenv("tests.timezone"), "random")

	// Always pick a random one for consistency (whether tests.locale
	// was specified or not)
	// Ian: it's not supported yet
	// rule.savedLocale := DefaultLocale()
	// if "random" == testLocale {
	// 	rule.locale = randomLocale(random)
	// } else {
	// 	rule.locale = localeForName(testLocale)
	// }
	// SetDefaultLocale(rule.locale)

	// SetDefaultTimeZone() will set user.timezone to the default
	// timezone of the user's locale. So store the original property
	// value and restore it at end.
	// rule.restoreProperties["user.timezone"] = os.Getenv("user.timezone")
	// rule.savedTimeZone = DefaultTimeZone()
	// if "random" == testTimeZone {
	// 	rule.timeZone = randomTimeZone(random)
	// } else {
	// 	rule.timeZone = TimeZone(testTimeZone)
	// }
	// SetDefaultTImeZone(rule.timeZone)

	if random.Intn(2) == 0 {
		rule.similarity = search.NewDefaultSimilarity()
	} else {
		rule.similarity = ts.NewRandomSimilarityProvider(random)
	}

	// Check codec restrictions once at class level.
	err := rule.checkCodecRestrictions(rule.codec)
	if err != nil {
		log.Printf("NOTE: %v Suppressed codecs: %v", err, rule.avoidCodecs)
	}
	return err
}
Exemple #4
0
func main() {
	fmt.Printf("tests_codec: %v\n", os.Getenv("tests_codec"))

	index.DefaultSimilarity = func() index.Similarity {
		return search.NewDefaultSimilarity()
	}
	// This controls how suite-level rules are nested. It is important
	// that _all_ rules declared in testcase are executed in proper
	// order if they depend on each other.
	ClassRuleChain(ClassEnvRule)

	BeforeSuite(nil)

	Test(nil, func(t *T) {
		q := search.NewTermQuery(index.NewTerm("foo", "bar"))
		q.SetBoost(-42)
		t.Assert(-42 == q.Boost())

		directory := NewDirectory()
		fmt.Println("Directory", directory)
		defer directory.Close()

		analyzer := analysis.NewMockAnalyzerWithRandom(Random())
		conf := NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer)

		writer, err := index.NewIndexWriter(directory, conf)
		if err != nil {
			t.Error(err)
		}
		if writer != nil {
			defer writer.Close()
		}

		// d := index.NewDocument()
		// d.Add(NewTextField("foo", "bar", true))
		// writer.AddDocument(d.Fields())
		// writer.Close() // ensure index is written

		// reader, err := index.OpenDirectoryReader(directory)
		// if err != nil {
		// 	t.Error(err)
		// }
		// defer reader.Close()

		// searcher := NewSearcher(reader)
		// res, err := searcher.Search(q, nil, 1000)
		// if err != nil {
		// 	t.Error(err)
		// }
		// hits := res.ScoreDocs
		// t.Assert(1 == len(hits))
		// t.Assert2(hits[0].Score < 0, fmt.Sprintf("score is not negative: %v", hits[0].Score))

		// explain, err := searcher.Explain(q, hits[0].Doc)
		// if err != nil {
		// 	t.Error(err)
		// }
		// t.Assert2(isSimilar(hits[0].Score, explain.Value(), 0.01), "score doesn't match explanation")
		// t.Assert2(explain.IsMatch(), "explain doesn't think doc is a match")
	})

	AfterSuite(nil)
}