예제 #1
0
        public void PersistAndSorter()
        {
            IcuComparer     icomp1  = new IcuComparer("fr");
            IcuComparer     icomp2  = new IcuComparer("en");
            GenRecordSorter grs1    = new GenRecordSorter(icomp1);
            GenRecordSorter grs2    = new GenRecordSorter(icomp2);
            ArrayList       sorters = new ArrayList();

            sorters.Add(grs1);
            sorters.Add(grs2);
            AndSorter   asorter = new AndSorter(sorters);
            string      xml     = DynamicLoader.PersistObject(asorter, "sorter");
            XmlDocument doc     = new XmlDocument();

            doc.LoadXml(xml);
            Assert.AreEqual("sorter", doc.DocumentElement.Name);
            object obj = DynamicLoader.RestoreObject(doc.DocumentElement);

            Assert.IsTrue(obj is AndSorter);
            ArrayList       sortersOut = (obj as AndSorter).Sorters;
            GenRecordSorter grsOut1    = sortersOut[0] as GenRecordSorter;
            GenRecordSorter grsOut2    = sortersOut[1] as GenRecordSorter;
            IComparer       compOut1   = grsOut1.Comparer;
            IComparer       compOut2   = grsOut2.Comparer;

            Assert.IsTrue(compOut1 is IcuComparer);
            Assert.IsTrue(compOut2 is IcuComparer);
            Assert.AreEqual("fr", (compOut1 as IcuComparer).WsCode);
            Assert.AreEqual("en", (compOut2 as IcuComparer).WsCode);
        }
예제 #2
0
        public void PersistSimpleSorter()
        {
            string          xml;
            IcuComparer     icomp = new IcuComparer("fr");
            GenRecordSorter grs   = new GenRecordSorter(icomp);

            xml = DynamicLoader.PersistObject(grs, "sorter");
            XmlDocument doc = new XmlDocument();

            doc.LoadXml(xml);
            Assert.AreEqual("sorter", doc.DocumentElement.Name);
            object obj = DynamicLoader.RestoreObject(doc.DocumentElement);

            try
            {
                Assert.IsInstanceOf <GenRecordSorter>(obj);
                GenRecordSorter grsOut  = obj as GenRecordSorter;
                IComparer       compOut = grsOut.Comparer;
                Assert.IsTrue(compOut is IcuComparer);
                Assert.AreEqual("fr", (compOut as IcuComparer).WsCode);
            }
            finally
            {
                var disposable = obj as IDisposable;
                if (disposable != null)
                {
                    disposable.Dispose();
                }
            }
        }
예제 #3
0
        public void PersistReverseComparer()
        {
            string xml;
            // Putting an IntStringComparer here is utterly bizarre, but it tests out one more class.
            StringFinderCompare sfComp = new StringFinderCompare(new OwnMonoPropFinder(m_sda, 445),
                                                                 new ReverseComparer(new IntStringComparer()));

            sfComp.SortedFromEnd = true;
            // Save and restore!
            xml = DynamicLoader.PersistObject(sfComp, "comparer");
            var doc = new XmlDocument();

            doc.LoadXml(xml);
            // And check all the pieces...
            var sfCompOut = DynamicLoader.RestoreObject(doc.DocumentElement) as StringFinderCompare;

            m_objectsToDispose.Add(sfCompOut);
            sfCompOut.Cache = Cache;

            Assert.IsTrue(sfCompOut.Finder is OwnMonoPropFinder);
            Assert.IsTrue(sfCompOut.SubComparer is ReverseComparer);
            Assert.IsTrue(sfCompOut.SortedFromEnd);

            ReverseComparer rcOut = sfCompOut.SubComparer as ReverseComparer;

            Assert.IsTrue(rcOut.SubComp is IntStringComparer);
        }
예제 #4
0
        public void SortersEtc()
        {
            PropertyRecordSorter prs = new PropertyRecordSorter("longName");
            // Save and restore!
            string      xml = DynamicLoader.PersistObject(prs, "sorter");
            XmlDocument doc = new XmlDocument();

            doc.LoadXml(xml);

            // And check all the pieces...
            PropertyRecordSorter prsOut = DynamicLoader.RestoreObject(doc.DocumentElement) as PropertyRecordSorter;

            prsOut.Cache = Cache;
            Assert.AreEqual("longName", prsOut.PropertyName);
        }
예제 #5
0
        public void PersistSimpleSorter()
        {
            IcuComparer     icomp = new IcuComparer("fr");
            GenRecordSorter grs   = new GenRecordSorter(icomp);
            string          xml   = DynamicLoader.PersistObject(grs, "sorter");
            XmlDocument     doc   = new XmlDocument();

            doc.LoadXml(xml);
            Assert.AreEqual("sorter", doc.DocumentElement.Name);
            object obj = DynamicLoader.RestoreObject(doc.DocumentElement);

            Assert.IsTrue(obj is GenRecordSorter);
            GenRecordSorter grsOut  = obj as GenRecordSorter;
            IComparer       compOut = grsOut.Comparer;

            Assert.IsTrue(compOut is IcuComparer);
            Assert.AreEqual("fr", (compOut as IcuComparer).WsCode);
        }
예제 #6
0
        public void SortersEtc()
        {
            PropertyRecordSorter prs = new PropertyRecordSorter("longName");
            // Save and restore!
            string      xml = DynamicLoader.PersistObject(prs, "sorter");
            XmlDocument doc = new XmlDocument();

            doc.LoadXml(xml);

            // And check all the pieces...
            PropertyRecordSorter prsOut = DynamicLoader.RestoreObject(doc.DocumentElement) as PropertyRecordSorter;

            prsOut.Cache = m_cache;
            Assert.AreEqual("longName", prsOut.PropertyName);

            // Putting an IntStringComparer here is utterly bizarre, but it tests out one more class.
            StringFinderCompare sfComp = new StringFinderCompare(new OwnMonoPropFinder(m_cache.MainCacheAccessor, 445),
                                                                 new ReverseComparer(new IntStringComparer()));

            sfComp.SortedFromEnd = true;
            // Save and restore!
            xml = DynamicLoader.PersistObject(sfComp, "comparer");
            doc = new XmlDocument();
            doc.LoadXml(xml);
            // And check all the pieces...
            StringFinderCompare sfCompOut = DynamicLoader.RestoreObject(doc.DocumentElement) as StringFinderCompare;

            sfCompOut.Cache = m_cache;

            Assert.IsTrue(sfCompOut.Finder is OwnMonoPropFinder);
            Assert.IsTrue(sfCompOut.SubComparer is ReverseComparer);
            Assert.IsTrue(sfCompOut.SortedFromEnd);

            ReverseComparer rcOut = sfCompOut.SubComparer as ReverseComparer;

            Assert.IsTrue(rcOut.SubComp is IntStringComparer);
        }
예제 #7
0
        public void PersistMatchersEtc()
        {
            // BaseMatcher is abstract
            // IntMatcher is abstract
            RangeIntMatcher rangeIntMatch = new RangeIntMatcher(5, 23);

            rangeIntMatch.WritingSystemFactory = m_cache.LanguageWritingSystemFactoryAccessor;
            ITsString tssLabel = m_cache.MakeAnalysisTss("label1");

            rangeIntMatch.Label = tssLabel;
            OwnIntPropFinder    ownIntFinder   = new OwnIntPropFinder(m_sda, 551);
            FilterBarCellFilter rangeIntFilter = new FilterBarCellFilter(ownIntFinder, rangeIntMatch);
            AndFilter           andFilter      = new AndFilter();

            andFilter.Add(rangeIntFilter);

            ITsStrFactory tsf       = TsStrFactoryClass.Create();
            int           ws        = m_cache.DefaultAnalWs;
            IVwPattern    m_pattern = VwPatternClass.Create();

            m_pattern.MatchOldWritingSystem = false;
            m_pattern.MatchDiacritics       = false;
            m_pattern.MatchWholeWord        = false;
            m_pattern.MatchCase             = false;
            m_pattern.UseRegularExpressions = false;

            andFilter.Add(new FilterBarCellFilter(ownIntFinder, new NotEqualIntMatcher(77)));

            OwnMlPropFinder mlPropFinder = new OwnMlPropFinder(m_cache.MainCacheAccessor, 788, 23);

            m_pattern.Pattern = tsf.MakeString("hello", ws);
            andFilter.Add(new FilterBarCellFilter(mlPropFinder, new ExactMatcher(m_pattern)));

            OwnMonoPropFinder monoPropFinder = new OwnMonoPropFinder(m_cache.MainCacheAccessor, 954);

            m_pattern = VwPatternClass.Create();
            m_pattern.MatchOldWritingSystem = false;
            m_pattern.MatchDiacritics       = false;
            m_pattern.MatchWholeWord        = false;
            m_pattern.MatchCase             = false;
            m_pattern.UseRegularExpressions = false;
            m_pattern.Pattern = tsf.MakeString("goodbye", ws);
            andFilter.Add(new FilterBarCellFilter(monoPropFinder, new BeginMatcher(m_pattern)));

            OneIndirectMlPropFinder oneIndMlPropFinder =
                new OneIndirectMlPropFinder(m_cache.MainCacheAccessor, 221, 222, 27);

            m_pattern = VwPatternClass.Create();
            m_pattern.MatchOldWritingSystem = false;
            m_pattern.MatchDiacritics       = false;
            m_pattern.MatchWholeWord        = false;
            m_pattern.MatchCase             = false;
            m_pattern.UseRegularExpressions = false;
            m_pattern.Pattern = tsf.MakeString("exit", ws);
            andFilter.Add(new FilterBarCellFilter(oneIndMlPropFinder, new EndMatcher(m_pattern)));

            MultiIndirectMlPropFinder mimlPropFinder = new MultiIndirectMlPropFinder(
                m_cache.MainCacheAccessor, new int[] { 444, 555 }, 666, 87);

            m_pattern = VwPatternClass.Create();
            m_pattern.MatchOldWritingSystem = false;
            m_pattern.MatchDiacritics       = false;
            m_pattern.MatchWholeWord        = false;
            m_pattern.MatchCase             = false;
            m_pattern.UseRegularExpressions = false;
            m_pattern.Pattern = tsf.MakeString("whatever", ws);
            andFilter.Add(new FilterBarCellFilter(mimlPropFinder, new AnywhereMatcher(m_pattern)));

            OneIndirectAtomMlPropFinder oneIndAtomFinder =
                new OneIndirectAtomMlPropFinder(m_cache.MainCacheAccessor, 543, 345, 43);

            andFilter.Add(new FilterBarCellFilter(oneIndAtomFinder, new BlankMatcher()));

            andFilter.Add(new FilterBarCellFilter(oneIndAtomFinder, new NonBlankMatcher()));

            m_pattern = VwPatternClass.Create();
            m_pattern.MatchOldWritingSystem = false;
            m_pattern.MatchDiacritics       = false;
            m_pattern.MatchWholeWord        = false;
            m_pattern.MatchCase             = false;
            m_pattern.UseRegularExpressions = false;
            m_pattern.Pattern = tsf.MakeString("pattern", ws);
            andFilter.Add(new FilterBarCellFilter(oneIndAtomFinder,
                                                  new InvertMatcher(new RegExpMatcher(m_pattern))));

            andFilter.Add(new NullFilter());

            XmlDocument docPaf = new XmlDocument();

            docPaf.LoadXml("<root targetClasses=\"LexEntry, LexSense\"></root>");
            ProblemAnnotationFilter paf = new ProblemAnnotationFilter();

            paf.Init(m_cache, docPaf.DocumentElement);
            andFilter.Add(paf);

            // Save and restore!
            string xml = DynamicLoader.PersistObject(andFilter, "filter");

            XmlDocument doc = new XmlDocument();

            doc.LoadXml(xml);

            // And check all the pieces...
            AndFilter andFilterOut =
                DynamicLoader.RestoreObject(doc.DocumentElement) as AndFilter;

            andFilterOut.Cache = m_cache;

            Assert.IsNotNull(andFilterOut);

            FilterBarCellFilter rangeIntFilterOut =
                andFilterOut.Filters[0] as FilterBarCellFilter;                 // todo

            Assert.IsNotNull(rangeIntFilterOut);

            OwnIntPropFinder ownIntFinderOut = rangeIntFilterOut.Finder as OwnIntPropFinder;

            Assert.IsNotNull(ownIntFinderOut);
            Assert.AreEqual(551, ownIntFinderOut.Flid);

            RangeIntMatcher rangeIntMatchOut = rangeIntFilterOut.Matcher as RangeIntMatcher;

            Assert.IsNotNull(rangeIntMatchOut);
            Assert.AreEqual(5, rangeIntMatchOut.Min);
            Assert.AreEqual(23, rangeIntMatchOut.Max);
            Assert.IsTrue(tssLabel.Equals(rangeIntMatchOut.Label));

            NotEqualIntMatcher notEqualMatchOut = GetMatcher(andFilter, 1) as NotEqualIntMatcher;

            Assert.IsNotNull(notEqualMatchOut);
            Assert.AreEqual(77, notEqualMatchOut.NotEqualValue);

            ExactMatcher exactMatchOut = GetMatcher(andFilter, 2) as ExactMatcher;

            Assert.IsNotNull(exactMatchOut);
            Assert.AreEqual("hello", exactMatchOut.Pattern.Pattern.Text);

            BeginMatcher beginMatchOut = GetMatcher(andFilter, 3) as BeginMatcher;

            Assert.IsNotNull(beginMatchOut);
            Assert.AreEqual("goodbye", beginMatchOut.Pattern.Pattern.Text);

            EndMatcher endMatchOut = GetMatcher(andFilter, 4) as EndMatcher;

            Assert.IsNotNull(endMatchOut);
            Assert.AreEqual("exit", endMatchOut.Pattern.Pattern.Text);

            AnywhereMatcher anywhereMatchOut = GetMatcher(andFilter, 5) as AnywhereMatcher;

            Assert.IsNotNull(anywhereMatchOut);
            Assert.AreEqual("whatever", anywhereMatchOut.Pattern.Pattern.Text);

            BlankMatcher blankMatchOut = GetMatcher(andFilter, 6) as BlankMatcher;

            Assert.IsNotNull(blankMatchOut);

            NonBlankMatcher nonBlankMatchOut = GetMatcher(andFilter, 7) as NonBlankMatcher;

            Assert.IsNotNull(nonBlankMatchOut);

            InvertMatcher invertMatchOut = GetMatcher(andFilter, 8) as InvertMatcher;

            Assert.IsNotNull(invertMatchOut);

            OwnMlPropFinder mlPropFinderOut = GetFinder(andFilter, 2) as OwnMlPropFinder;

            Assert.AreEqual(m_cache.MainCacheAccessor, mlPropFinderOut.DataAccess);
            Assert.AreEqual(788, mlPropFinderOut.Flid);
            Assert.AreEqual(23, mlPropFinderOut.Ws);

            OwnMonoPropFinder monoPropFinderOut = GetFinder(andFilter, 3) as OwnMonoPropFinder;

            Assert.AreEqual(m_cache.MainCacheAccessor, monoPropFinderOut.DataAccess);
            Assert.AreEqual(954, monoPropFinderOut.Flid);

            OneIndirectMlPropFinder oneIndMlPropFinderOut =
                GetFinder(andFilter, 4) as OneIndirectMlPropFinder;

            Assert.AreEqual(m_cache.MainCacheAccessor, oneIndMlPropFinderOut.DataAccess);
            Assert.AreEqual(221, oneIndMlPropFinderOut.FlidVec);
            Assert.AreEqual(222, oneIndMlPropFinderOut.FlidString);
            Assert.AreEqual(27, oneIndMlPropFinderOut.Ws);

            MultiIndirectMlPropFinder mimlPropFinderOut =
                GetFinder(andFilter, 5) as MultiIndirectMlPropFinder;

            Assert.AreEqual(m_cache.MainCacheAccessor, mimlPropFinderOut.DataAccess);
            Assert.AreEqual(444, mimlPropFinderOut.VecFlids[0]);
            Assert.AreEqual(555, mimlPropFinderOut.VecFlids[1]);
            Assert.AreEqual(666, mimlPropFinderOut.FlidString);
            Assert.AreEqual(87, mimlPropFinderOut.Ws);

            OneIndirectAtomMlPropFinder oneIndAtomFinderOut =
                GetFinder(andFilter, 6) as OneIndirectAtomMlPropFinder;

            Assert.AreEqual(m_cache.MainCacheAccessor, oneIndAtomFinderOut.DataAccess);
            Assert.AreEqual(543, oneIndAtomFinderOut.FlidAtom);
            Assert.AreEqual(345, oneIndAtomFinderOut.FlidString);
            Assert.AreEqual(43, oneIndAtomFinderOut.Ws);

            // 7, 8 are duplicates

            NullFilter nullFilterOut = andFilter.Filters[9] as NullFilter;

            Assert.IsNotNull(nullFilterOut);

            ProblemAnnotationFilter pafOut = andFilter.Filters[10] as ProblemAnnotationFilter;

            Assert.IsNotNull(pafOut);
            Assert.AreEqual(5002, pafOut.ClassIds[0]);
            Assert.AreEqual(5016, pafOut.ClassIds[1]);
        }