// different options for the same field
        public virtual void TestMixedOptions()
        {
            int numFields  = TestUtil.NextInt(Random(), 1, 3);
            var docFactory = new RandomDocumentFactory(this, numFields, 10);

            foreach (var options1 in ValidOptions())
            {
                foreach (var options2 in ValidOptions())
                {
                    if (options1 == options2)
                    {
                        continue;
                    }
                    using (Directory dir = NewDirectory())
                    {
                        using (var writer = new RandomIndexWriter(Random(), dir))
                        {
                            RandomDocument doc1 = docFactory.NewDocument(numFields, 20, options1);
                            RandomDocument doc2 = docFactory.NewDocument(numFields, 20, options2);
                            writer.AddDocument(AddId(doc1.ToDocument(), "1"));
                            writer.AddDocument(AddId(doc2.ToDocument(), "2"));
                            using (IndexReader reader = writer.Reader)
                            {
                                int doc1ID = DocID(reader, "1");
                                AssertEquals(doc1, reader.GetTermVectors(doc1ID));
                                int doc2ID = DocID(reader, "2");
                                AssertEquals(doc2, reader.GetTermVectors(doc2ID));
                            }
                        }
                    }
                }
            }
        }
Exemple #2
0
        public virtual void TestLotsOfFields()
        {
            RandomDocumentFactory docFactory = new RandomDocumentFactory(this, 5000, 10);

            foreach (Options options in ValidOptions())
            {
                using Directory dir            = NewDirectory();
                using RandomIndexWriter writer = new RandomIndexWriter(Random, dir);
                RandomDocument doc = docFactory.NewDocument(AtLeast(100), 5, options);
                writer.AddDocument(doc.ToDocument());
                using IndexReader reader = writer.GetReader();
                AssertEquals(doc, reader.GetTermVectors(0));
            }
        }
        public virtual void TestLotsOfFields()
        {
            RandomDocumentFactory docFactory = new RandomDocumentFactory(this, 500, 10);

            foreach (Options options in ValidOptions())
            {
                Directory         dir    = NewDirectory();
                RandomIndexWriter writer = new RandomIndexWriter(Random(), dir, ClassEnvRule.Similarity, ClassEnvRule.TimeZone);
                RandomDocument    doc    = docFactory.NewDocument(AtLeast(100), 5, options);
                writer.AddDocument(doc.ToDocument());
                IndexReader reader = writer.Reader;
                AssertEquals(doc, reader.GetTermVectors(0));
                reader.Dispose();
                writer.Dispose();
                dir.Dispose();
            }
        }
        // only one doc with vectors
        public virtual void TestRareVectors()
        {
            RandomDocumentFactory docFactory = new RandomDocumentFactory(this, 10, 20);

            foreach (Options options in ValidOptions())
            {
                int      numDocs        = AtLeast(200);
                int      docWithVectors = Random.Next(numDocs);
                Document emptyDoc       = new Document();
                using (Directory dir = NewDirectory())
                    using (RandomIndexWriter writer = new RandomIndexWriter(Random, dir, ClassEnvRule.similarity, ClassEnvRule.timeZone))
                    {
                        RandomDocument doc = docFactory.NewDocument(TestUtil.NextInt32(Random, 1, 3), 20, options);
                        for (int i = 0; i < numDocs; ++i)
                        {
                            if (i == docWithVectors)
                            {
                                writer.AddDocument(AddId(doc.ToDocument(), "42"));
                            }
                            else
                            {
                                writer.AddDocument(emptyDoc);
                            }
                        }
                        using (IndexReader reader = writer.GetReader())
                        {
                            int docWithVectorsID = DocID(reader, "42");
                            for (int i = 0; i < 10; ++i)
                            {
                                int    docID  = Random.Next(numDocs);
                                Fields fields = reader.GetTermVectors(docID);
                                if (docID == docWithVectorsID)
                                {
                                    AssertEquals(doc, fields);
                                }
                                else
                                {
                                    Assert.IsNull(fields);
                                }
                            }
                            Fields fields_ = reader.GetTermVectors(docWithVectorsID);
                            AssertEquals(doc, fields_);
                        } // reader.Dispose();
                    }// writer.Dispose();, dir.Dispose();
            }
        }
Exemple #5
0
        public virtual void TestHighFreqs()
        {
            RandomDocumentFactory docFactory = new RandomDocumentFactory(this, 3, 5);

            foreach (Options options in ValidOptions())
            {
                if (options == Options.NONE)
                {
                    continue;
                }
                using Directory dir            = NewDirectory();
                using RandomIndexWriter writer = new RandomIndexWriter(Random, dir);
                RandomDocument doc = docFactory.NewDocument(TestUtil.NextInt32(Random, 1, 2), AtLeast(20000),
                                                            options);
                writer.AddDocument(doc.ToDocument());
                using IndexReader reader = writer.GetReader();
                AssertEquals(doc, reader.GetTermVectors(0));
            }
        }
        public virtual void TestHighFreqs()
        {
            RandomDocumentFactory docFactory = new RandomDocumentFactory(this, 3, 5);

            foreach (Options options in ValidOptions())
            {
                if (options == Options.NONE)
                {
                    continue;
                }
                using (Directory dir = NewDirectory())
                    using (RandomIndexWriter writer = new RandomIndexWriter(Random(), dir, ClassEnvRule.Similarity, ClassEnvRule.TimeZone))
                    {
                        RandomDocument doc = docFactory.NewDocument(TestUtil.NextInt(Random(), 1, 2), AtLeast(20000),
                                                                    options);
                        writer.AddDocument(doc.ToDocument());
                        using (IndexReader reader = writer.Reader)
                            AssertEquals(doc, reader.GetTermVectors(0));
                    }
            }
        }