RegexParser/RegexParser.Tests/Performance/PatternPerformanceTests.cs at master · aistrate/RegexParser · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
using System;
using ParserCombinators;
using ParserCombinators.Tests.Performance;
using RegexParser.Patterns;
using Utility.BaseTypes;
using Utility.ConsLists;
using Utility.Tests.Performance;

namespace RegexParser.Tests.Performance
{
    public static class PatternPerformanceTests
    {
        public static void CharClassPatternTest()
        {
            const int times = 200, maxItemCount = 100000;


            string digitChars = EnumerablePerformanceTests.RepeatChars("0123456789", maxItemCount).AsString();

            charTest("always true", c => true,
                     times, maxItemCount, digitChars);
            // 1.28 sec.

            charTest("char.IsDigit", c => char.IsDigit(c),
                     times, maxItemCount, digitChars);
            // 1.38 sec.

            charClassPatternTest(new CharGroupPattern(true, "0123456789"),
                                 times, maxItemCount, digitChars);
            // 2.39 sec.

            charClassPatternTest(new CharGroupPattern(true, new[] { new CharRangePattern('0', '9') }),
                                 times, maxItemCount, digitChars);
            // 1.59 sec.

            charClassPatternTest(parseCharClass(@"\d"),
                                 times, maxItemCount, digitChars);
            // 1.80 sec.

            charClassPatternTest(parseCharClass(@"[\d]"),
                                 times, maxItemCount, digitChars);
            // 2.19 sec.


            string lowercaseChars = EnumerablePerformanceTests.RepeatChars("abcdefghijklmnopqrstuvwxyz", maxItemCount).AsString();

            charTest("char.IsLetter", c => char.IsLetter(c),
                     times, maxItemCount, lowercaseChars);
            // 1.42 sec.

            charClassPatternTest(new CharGroupPattern(true, "abcdefghijklmnopqrstuvwxyz"),
                                 times, maxItemCount, lowercaseChars);
            // 2.55 sec.

            charClassPatternTest(new CharGroupPattern(true, new[] { new CharRangePattern('a', 'z') }),
                                 times, maxItemCount, lowercaseChars);
            // 1.65 sec.

            charClassPatternTest(parseCharClass(@"\w"),
                                 times, maxItemCount, digitChars);
            // 2.06 sec.

            charClassPatternTest(parseCharClass(@"[\w]"),
                                 times, maxItemCount, digitChars);
            // 2.42 sec.

            charClassPatternTest(parseCharClass(@"[\s\x00-\x1F\d\w]"),
                                 times, maxItemCount, digitChars);
            // 3.05 sec.


            charTest("char.IsLetterOrDigit", c => char.IsLetterOrDigit(c),
                     times, maxItemCount, lowercaseChars);
            // 1.64 sec.

            charClassPatternTest(new CharGroupPattern(true, "0123456789abcdefghijklmnopqrstuvwxyz"),
                                 times, maxItemCount, lowercaseChars);
            // 2.80 sec.

            charClassPatternTest(new CharGroupPattern(true, new[] { new CharRangePattern('0', '9'),
                                                                    new CharRangePattern('a', 'z') }),
                                 times, maxItemCount, lowercaseChars);
            // 1.69 sec.

            charClassPatternTest(parseCharClass(@"\w"),
                                 times, maxItemCount, digitChars);
            // 2.02 sec.

            charClassPatternTest(parseCharClass(@"[\w-[A-Z]]"),
                                 times, maxItemCount, digitChars);
            // 3.42 sec.


            string repeatedChar = EnumerablePerformanceTests.RepeatChars("7", maxItemCount).AsString();

            charClassPatternTest(new CharGroupPattern(true, "7"),
                                 times, maxItemCount, repeatedChar);
            // 1.97 sec.

            charClassPatternTest(new CharGroupPattern(true, new[] { new CharRangePattern('7', '7') }),
                                 times, maxItemCount, repeatedChar);
            // 1.61 sec.


            // Negative character classes
            charClassPatternTest(new CharGroupPattern(false, "abcdefghijklmnopqrstuvwxyz"),
                                 times, maxItemCount, digitChars);
            // 2.84 sec.

            charClassPatternTest(new CharGroupPattern(false, new[] { new CharRangePattern('a', 'z') }),
                                 times, maxItemCount, digitChars);
            // 1.64 sec.

            charClassPatternTest(parseCharClass(@"[^a-z]"),
                                 times, maxItemCount, digitChars);
            // 2.09 sec.
        }

        private static CharClassPattern parseCharClass(string pattern)
        {
            return (CharClassPattern)PatternParsers.CharClass(new ArrayConsList<char>(pattern)).Tree;
        }

        private static void charClassPatternTest(CharClassPattern charClassPattern, int times, int maxItemCount, string inputText)
        {
            charTest(charClassPattern.ToString(), c => charClassPattern.IsMatch(c), times, maxItemCount, inputText);
        }

        private static void charTest(string testName, Func<char, bool> predicate, int times, int maxItemCount, string inputText)
        {
            Console.WriteLine(testName);
            CharParsersPerformanceTests.CharParserTest(CharParsers.Satisfy(predicate),
                                                       times, maxItemCount, inputText);

            Console.WriteLine();
        }
    }
}