RegexParser/RegexParser.Tests/Transforms/RegexOptionsASTTransformTests.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
using NUnit.Framework;
using RegexParser.Patterns;
using RegexParser.Tests.Asserts;
using RegexParser.Transforms;

namespace RegexParser.Tests.Transforms
{
    [TestFixture]
    public class RegexOptionsASTTransformTests
    {
        [Test]
        public void Singleline_False()
        {
            string patternText = ".+";

            BasePattern expected = new GroupPattern(
                                        true,
                                        new QuantifierPattern(
                                            new AnyCharPattern(false),
                                            1, null, true));

            RegexAssert.IsASTTransformCorrect(expected, patternText,
                                              new RegexOptionsASTTransform(RegexOptions.None));
        }

        [Test]
        public void Singleline_True()
        {
            string patternText = ".+";

            BasePattern expected = new GroupPattern(
                                        true,
                                        new QuantifierPattern(
                                            new AnyCharPattern(true),
                                            1, null, true));

            RegexAssert.IsASTTransformCorrect(expected, patternText,
                                              new RegexOptionsASTTransform(RegexOptions.Singleline));
        }

        [Test]
        public void IgnoreCase()
        {
            string patternText = @"aA7 :.[a-m]\w\D\s.+";

            BasePattern expected = new GroupPattern(
                                        true,
                                        new CaseInsensitiveCharPattern(new CharEscapePattern('a')),
                                        new CaseInsensitiveCharPattern(new CharEscapePattern('A')),
                                        new CharEscapePattern('7'),
                                        new CharEscapePattern(' '),
                                        new CharEscapePattern(':'),
                                        new AnyCharPattern(false),
                                        new CaseInsensitiveCharPattern(
                                            new CharGroupPattern(true, new [] { new CharRangePattern('a', 'm') })),
                                        CharGroupPattern.WordChar,
                                        CharGroupPattern.DigitChar.Negated,
                                        CharGroupPattern.WhitespaceChar,
                                        new QuantifierPattern(
                                            new AnyCharPattern(false),
                                            1, null, true));

            RegexAssert.IsASTTransformCorrect(expected, patternText,
                                              new RegexOptionsASTTransform(RegexOptions.IgnoreCase));
        }

        [Test]
        public void Multiline_False()
        {
            string patternText = @"^\b\B\z\Z\A\G$";

            BasePattern expected = new GroupPattern(
                                        true,
                                        new AnchorPattern(AnchorType.StartOfString),
                                        new AnchorPattern(AnchorType.WordBoundary),
                                        new AnchorPattern(AnchorType.NonWordBoundary),
                                        new AnchorPattern(AnchorType.EndOfString),
                                        new AnchorPattern(AnchorType.EndOfStringOrBeforeEndingNewline),
                                        new AnchorPattern(AnchorType.StartOfString),
                                        new AnchorPattern(AnchorType.ContiguousMatch),
                                        new AnchorPattern(AnchorType.EndOfStringOrBeforeEndingNewline));

            RegexAssert.IsASTTransformCorrect(expected, patternText,
                                              new RegexOptionsASTTransform(RegexOptions.None));
        }

        [Test]
        public void Multiline_True()
        {
            string patternText = @"^\b\B\z\Z\A\G$";

            BasePattern expected = new GroupPattern(
                                        true,
                                        new AnchorPattern(AnchorType.StartOfLine),
                                        new AnchorPattern(AnchorType.WordBoundary),
                                        new AnchorPattern(AnchorType.NonWordBoundary),
                                        new AnchorPattern(AnchorType.EndOfString),
                                        new AnchorPattern(AnchorType.EndOfStringOrBeforeEndingNewline),
                                        new AnchorPattern(AnchorType.StartOfString),
                                        new AnchorPattern(AnchorType.ContiguousMatch),
                                        new AnchorPattern(AnchorType.EndOfLine));

            RegexAssert.IsASTTransformCorrect(expected, patternText,
                                              new RegexOptionsASTTransform(RegexOptions.Multiline));
        }
    }
}