예제 #1
0
        public void PerformanceTest()
        {
            const int n1 = 100, n2 = 500, n3 = 1800, n4 = 1850, n5 = 3500;

            Counter          counter = new Counter();
            MatchCollection2 coll    = Factory.CreateMatchCollection(getMatches(0, counter));

            IEnumerable <Match2> seq1 = coll.Take(n1),
                                 seq2 = coll.Take(n2);

            Assert.AreEqual(0, counter.Value, "Start.");

            Assert.AreEqual(n1 - 1, seq1.Last().Index, "First/n1");
            Assert.AreEqual(n1, counter.Value, "First/counter/1");
            Assert.AreEqual(n2 - 1, seq2.Last().Index, "First/n2");
            Assert.AreEqual(n2, counter.Value, "First/counter/2");

            Assert.AreEqual(n1 - 1, seq1.Last().Index, "Second/n1");
            Assert.AreEqual(n2, counter.Value, "Second/counter/1");
            Assert.AreEqual(n2 - 1, seq2.Last().Index, "Second/n2");
            Assert.AreEqual(n2, counter.Value, "Second/counter/2");

            IEnumerable <Match2> seq3 = coll.Take(n3),
                                 seq4 = coll.Take(n4),
                                 seq5 = coll.Take(n5);

            Assert.AreEqual(n3 - 1, seq3.Last().Index, "First/n3");
            Assert.AreEqual(n3, counter.Value, "First/counter/3");
            Assert.AreEqual(n4 - 1, seq4.Last().Index, "First/n4");
            Assert.AreEqual(n4, counter.Value, "First/counter/4");
            Assert.AreEqual(n5 - 1, seq5.Last().Index, "First/n5");
            Assert.AreEqual(n5, counter.Value, "First/counter/5");
        }
예제 #2
0
        public static void NextMatchTest()
        {
            const int n1 = 5000, n2 = 5300, n3 = 5500, n4 = 7000;

            Counter          counter = new Counter();
            MatchCollection2 coll    = Factory.CreateMatchCollection(getMatches(n1, counter));

            Assert.AreEqual(0, counter.Value);

            for (Match2 match = coll.First(); match.Index < n2; match = match.NextMatch())
            {
                ;
            }
            Assert.AreEqual(n2 - n1 + 1, counter.Value);

            for (Match2 match = coll.First(); match.Index < n3; match = match.NextMatch())
            {
                ;
            }
            Assert.AreEqual(n3 - n1 + 1, counter.Value);

            for (Match2 match = coll.First(); match.Index < n4; match = match.NextMatch())
            {
                ;
            }
            Assert.AreEqual(n4 - n1 + 1, counter.Value);

            for (Match2 match = coll.First(); match.Index < n2; match = match.NextMatch())
            {
                ;
            }
            Assert.AreEqual(n4 - n1 + 1, counter.Value);
        }
예제 #3
0
        private static void testRegexMatches(string input, string pattern, RegexOptions options, int times)
        {
            Console.WriteLine("Pattern: {0}", pattern.ShowVerbatim());

            if (options != RegexOptions.None)
            {
                Console.WriteLine("Options: [{0}]", options.ToString());
            }

            MemoryProfiler memoryProfiler;

            if (useMemoryProfiler)
            {
                memoryProfiler = MemoryProfiler.StartNew();
            }

            Stopwatch stopwatch = Stopwatch.StartNew();

            MatchCollection2 matches = null;

            //Msoft.MatchCollection matches = null;

            for (int i = 0; i < times; i++)
            {
                matches = new Regex2(pattern, AlgorithmType.Backtracking, options).Matches(input);
            }
            //matches = new Msoft.Regex(pattern, RegexAssert.ToMsoftRegexOptions(options)).Matches(input);

            if (useMemoryProfiler)
            {
                memoryProfiler.Reset();
            }

            Console.WriteLine("Matches: {0:#,##0}", matches.Count);

            //string v;
            //foreach (var m in matches.Cast<Match2>())
            ////foreach (var m in matches.Cast<Msoft.Match>())
            //    v = m.Value;

            decimal elapsed = ((decimal)stopwatch.ElapsedMilliseconds) / 1000;

            if (useMemoryProfiler)
            {
                long deltaBefore = memoryProfiler.DeltaValue;
                memoryProfiler.CollectGC();
                long deltaAfter = memoryProfiler.DeltaValue;

                if (matches.Count > 0)
                {
                    Console.WriteLine("Last:    {0:#,##0} chars", matches[matches.Count - 1].Value.Length);
                }

                Console.WriteLine("Memory:  {0,10:#,##0} bytes", deltaBefore);
                Console.WriteLine("AfterGC: {0,10:#,##0} bytes", deltaAfter);
            }

            Console.WriteLine("Time:    {0:#0.000} sec.\n", elapsed);
        }
예제 #4
0
        public static void MatchCollections()
        {
            MemoryProfiler memoryProfiler = MemoryProfiler.StartNew();
            int            itemCount      = 10000000;

            MatchCollection2 matches1 = Factory.CreateMatchCollection(Enumerable.Range(1, itemCount)
                                                                      .Select(i => Factory.CreateMatch(i, i, "x")));

            memoryProfiler.CollectGC();
            Console.WriteLine("Matches: {0:#,##0}", matches1.Count);
            displayMemoryProfiler(memoryProfiler, itemCount);
            // 41   bytes/match (itemCount = 10,000,000)
            // 36.9 bytes/match (itemCount = 13,000,000)


            memoryProfiler.Reset();
            Match2[] matches2 = Enumerable.Range(1, itemCount)
                                .Select(i => Factory.CreateMatch(i, i, "x"))
                                .ToArray();
            memoryProfiler.CollectGC();
            Console.WriteLine("Matches: {0:#,##0}", matches2.Length);
            displayMemoryProfiler(memoryProfiler, itemCount);
            // 36 bytes/match (itemCount = 10,000,000)
            // 36 bytes/match (itemCount = 13,000,000)


            memoryProfiler.Reset();
            List <Match2> matches3 = Enumerable.Range(1, itemCount)
                                     .Select(i => Factory.CreateMatch(i, i, "x"))
                                     .ToList();

            memoryProfiler.CollectGC();
            Console.WriteLine("Matches: {0:#,##0}", matches3.Count);
            displayMemoryProfiler(memoryProfiler, itemCount);
            // 38.7 bytes/match (itemCount = 10,000,000)
            // 37.2 bytes/match (itemCount = 13,000,000)


            memoryProfiler.Reset();
            List <int> ints1 = Enumerable.Range(1, itemCount)
                               .ToList();

            memoryProfiler.CollectGC();
            Console.WriteLine("Ints:    {0:#,##0}", ints1.Count);
            displayMemoryProfiler(memoryProfiler, itemCount);
            // 6.7 bytes/match (itemCount = 10,000,000)
            // 5.2 bytes/match (itemCount = 13,000,000)


            memoryProfiler.Reset();
            int[] ints2 = Enumerable.Range(1, itemCount)
                          .ToArray();
            memoryProfiler.CollectGC();
            Console.WriteLine("Ints:    {0:#,##0}", ints2.Length);
            displayMemoryProfiler(memoryProfiler, itemCount);
            // 4 bytes/match (itemCount = 10,000,000)
            // 4 bytes/match (itemCount = 13,000,000)
        }
예제 #5
0
        public void OneMatch()
        {
            MatchCollection2 coll = Factory.CreateMatchCollection(new[] { Factory.CreateMatch(0, 0, "") });

            Assert.AreEqual(1, coll.Count, "Empty.");

            coll = Factory.CreateMatchCollection(new[] { Match2.Empty });
            Assert.AreEqual(1, coll.Count, "Match2.Empty.");
        }
예제 #6
0
        public void Empty()
        {
            MatchCollection2 coll = Factory.CreateMatchCollection(getMatches(0, -1));

            Assert.AreEqual(0, coll.Count, "Empty/IEnumerable.");

            coll = Factory.CreateMatchCollection(new Match2[] { });
            Assert.AreEqual(0, coll.Count, "Empty/Array.");
        }
예제 #7
0
        public void ManyMatches()
        {
            MatchCollection2 coll = Factory.CreateMatchCollection(getMatches(1, 0));

            Assert.AreEqual(0, coll.Count, "1 to 0.");

            coll = Factory.CreateMatchCollection(getMatches(0, 0));
            Assert.AreEqual(1, coll.Count, "From 0 to 0.");

            coll = Factory.CreateMatchCollection(getMatches(5, 5));
            Assert.AreEqual(1, coll.Count, "From 5 to 5.");

            coll = Factory.CreateMatchCollection(getMatches(1, 10));
            Assert.AreEqual(10, coll.Count, "From 1 to 10.");

            int from = 1000, to = 4000;

            coll = Factory.CreateMatchCollection(getMatches(from, to));
            Assert.AreEqual(to - from + 1, coll.Count, string.Format("From {0} to {1}.", from, to));

            Assert.AreEqual(to, coll[to - from].Index, "Index");
            Assert.AreEqual(to, coll[to - from].Length, "Length");
            Assert.AreEqual("Match" + to.ToString(), coll[to - from].Value, "Value");
        }