Skip to content

Commit b79e70a

Browse files
RomanSoloweowRomanSoloweow
committed
Fix tests
1 parent c151d40 commit b79e70a

24 files changed

+287
-146
lines changed

‎src/SimpleStateMachine.StructuralSearch.Tests/FindTemplateParserTests.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ public static void SourceParsingBeFindTemplateShouldBeSuccess(string templatePat
3737
var match = matches.First();
3838

3939
Assert.NotNull(findParser);
40-
Assert.Equal(match.Match.Lenght, source.Length);
40+
Assert.Equal(match.Match.Length, source.Length);
4141
}
4242

4343
[Theory]

‎src/SimpleStateMachine.StructuralSearch.Tests/GrammarTests.cs‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
using Pidgin;
2+
using SimpleStateMachine.StructuralSearch.Helper;
3+
using SimpleStateMachine.StructuralSearch.StructuralSearch;
4+
using Xunit;
5+
6+
namespace SimpleStateMachine.StructuralSearch.Tests;
7+
8+
public class GrammarTests
9+
{
10+
[Theory]
11+
[InlineData("123")]
12+
[InlineData("\\\"abc\\\"")]
13+
[InlineData("\\\"\\\"")]
14+
[InlineData("\\\\\\\"\\\\\\\"")]
15+
public static void StringLiteralParsingShouldBeSuccess(string input)
16+
{
17+
input = $"\"{input}\"";
18+
var result = Grammar.StringLiteral.Before(CommonParser.Eof).ParseOrThrow(input);
19+
result = $"\"{EscapeHelper.Escape(result, Constant.StringLiteralCharsToEscape)}\"";
20+
Assert.Equal(input, result);
21+
}
22+
}

‎src/SimpleStateMachine.StructuralSearch.Tests/LogicalExpressionParserTests.cs‎

Lines changed: 81 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@
22
using System.Collections.Generic;
33
using System.Linq;
44
using Pidgin;
5+
using SimpleStateMachine.StructuralSearch.Extensions;
56
using SimpleStateMachine.StructuralSearch.Operator.Logical.Type;
67
using SimpleStateMachine.StructuralSearch.StructuralSearch;
78
using Xunit;
@@ -10,75 +11,126 @@ namespace SimpleStateMachine.StructuralSearch.Tests;
1011

1112
public static class LogicalExpressionParserTests
1213
{
14+
public static IEnumerable<string> StringCompareOperationCases()
15+
{
16+
// var parameters = ["$var$", "\"123\"", "$var$.Len"]
17+
foreach (var @operator in Enum.GetNames<StringCompareOperator>())
18+
{
19+
yield return $"{@operator} $var$";
20+
yield return $"{@operator} $var$";
21+
yield return $"{@operator} \"123\"";
22+
yield return $"{@operator} \"123\"";
23+
yield return $"{@operator} $var$";
24+
}
25+
}
26+
1327
[Theory]
14-
[InlineData("Equals $var$")]
15-
[InlineData("Contains $var$")]
16-
[InlineData("StartsWith $var$")]
17-
[InlineData("EndsWith $var$")]
28+
[StringMemberData(nameof(StringCompareOperationCases))]
1829
public static void StringCompareOperationParsingShouldBeSuccess(string input)
1930
{
2031
LogicalExpressionParser.StringCompareOperation.Before(CommonParser.Eof).ParseOrThrow(input);
2132
}
2233

23-
public static IEnumerable<object[]> GetParameterTypeNames()
24-
=> Enum.GetNames<ParameterType>().Select(x => new object[] { $"Is {x}" });
34+
public static IEnumerable<string> IsOperationCases()
35+
{
36+
foreach (var type in Enum.GetNames<ParameterType>())
37+
{
38+
yield return $"Is {type}";
39+
yield return $"Is {type}";
40+
}
41+
}
2542

2643
[Theory]
27-
[MemberData(nameof(GetParameterTypeNames))]
44+
[StringMemberData(nameof(IsOperationCases))]
2845
public static void IsOperationParsingShouldBeSuccess(string input)
2946
{
3047
LogicalExpressionParser.IsOperation.Before(CommonParser.Eof).ParseOrThrow(input);
3148
}
3249

3350
[Theory]
34-
[InlineData("Match [a-z]")]
51+
[InlineData("Match \"[a-z]\"")]
3552
public static void MatchOperationParsingShouldBeSuccess(string input)
3653
{
3754
LogicalExpressionParser.MatchOperation.Before(CommonParser.Eof).ParseOrThrow(input);
3855
}
3956

4057
[Theory]
41-
[InlineData("In 123, 456, 789")]
42-
[InlineData("In 123,456,789")]
58+
[InlineData("In \"123\",\"456\",\"789\"")]
59+
[InlineData("In \"123\",\"456\",\"789\"")]
60+
[InlineData("In \"123\", \"456\", \"789\"")]
61+
[InlineData("In \"123\", \"456\", \"789\"")]
62+
[InlineData("In \"123\", \"456\", \"789\"")]
63+
[InlineData("In \"123\", \"456\", \"789\"")]
4364
public static void InOperationParsingShouldBeSuccess(string input)
4465
{
4566
LogicalExpressionParser.InOperation.Before(CommonParser.Eof).ParseOrThrow(input);
4667
}
47-
68+
4869
[Theory]
49-
[InlineData("Not 123 Equals 789")]
70+
[InlineData("Not \"123\" Equals \"789\"")]
5071
public static void NotOperationParsingShouldBeSuccess(string input)
5172
{
5273
LogicalExpressionParser.NotOperation.Before(CommonParser.Eof).ParseOrThrow(input);
5374
}
5475

76+
public static IEnumerable<string> BinaryOperationCases()
77+
{
78+
foreach (var @operator in Enum.GetNames<LogicalBinaryOperator>())
79+
{
80+
yield return $"{@operator} $var$ Equals $var$";
81+
yield return $"{@operator} $var$ Equals $var$";
82+
yield return $"{@operator} $var$ Equals $var$";
83+
yield return $"{@operator} $var$ Equals $var$";
84+
}
85+
}
86+
87+
[Theory]
88+
[StringMemberData(nameof(BinaryOperationCases))]
89+
public static void BinaryOperationParsingShouldBeSuccess(string input)
90+
{
91+
LogicalExpressionParser.BinaryOperation.Before(CommonParser.Eof).ParseOrThrow(input);
92+
}
93+
94+
// public static IEnumerable<string> BinaryOperationCases()
95+
// {
96+
// foreach (var access in ParametersParserTests.PropertyAccessCases())
97+
// {
98+
// foreach (var VARIABLE in COLLECTION)
99+
// {
100+
//
101+
// }
102+
// yield return $"{@operator} $var$ Equals $var$";
103+
// yield return $"{@operator} $var$ Equals $var$";
104+
// yield return $"{@operator} $var$ Equals $var$";
105+
// yield return $"{@operator} $var$ Equals $var$";
106+
// }
107+
// }
108+
55109
[Theory]
56110
[InlineData("$var$ equals $var$")]
57111
[InlineData("$var$ equals \"$\"")]
58-
[InlineData("Not $var$ equals $var$.Lenght")]
112+
[InlineData("Not $var$ equals $var$.Length")]
59113
[InlineData("Not $var$ equals $var$.offset.Start")]
60-
[InlineData("$var$ equals $var$.Lenght and Not $var$ StartsWith \"123\"")]
61-
[InlineData("Not $var$ equals $var$.Lenght and $var$ StartsWith \"123\"")]
62-
[InlineData("$var$ Contains $var$.Lenght")]
114+
[InlineData("$var$ equals $var$.Length and Not $var$ StartsWith \"123\"")]
115+
[InlineData("Not $var$ equals $var$.Length and $var$ StartsWith \"123\"")]
116+
[InlineData("$var$ Contains $var$.Length")]
63117
[InlineData("not $var$ Contains \"123\"")]
64-
[InlineData("$var1$.Lenght Contains $var2$.Lenght")]
118+
[InlineData("$var1$.Length Contains $var2$.Length")]
65119
[InlineData("$var$ Contains \"123\"")]
66-
[InlineData("$var$ StartsWith $var$.Lenght")]
67-
[InlineData("$var$.Lenght Equals $var$.Lenght")]
120+
[InlineData("$var$ StartsWith $var$.Length")]
121+
[InlineData("$var$.Length Equals $var$.Length")]
68122
[InlineData("$var$ StartsWith \"123\"")]
69-
[InlineData("$var$ EndsWith $var$.Lenght")]
123+
[InlineData("$var$ EndsWith $var$.Length")]
70124
[InlineData("$var$ EndsWith \"123\"")]
71125
[InlineData("$var$ Is Int")]
72126
[InlineData("$var$ Is DateTime")]
73127
[InlineData("$var$ equals $var1$ or $var2$ equals $var1$")]
74-
[InlineData("$var$ match [a-b]+")]
75-
public static void FindRuleExprParsingShouldBeSuccess(string input)
128+
[InlineData("$var$ match \"[a-b]+\"")]
129+
public static void LogicalExpressionParsingShouldBeSuccess(string input)
76130
{
77-
var t = TemplatesParser.Template;
78-
var rule = LogicalExpressionParser.LogicalExpression.Before(CommonParser.Eof).ParseOrThrow(input);
79-
var _ruleStr = rule.ToString()?.ToLower();
80-
Assert.NotNull(rule);
81-
Assert.Equal(input.ToLower(), _ruleStr);
131+
var operation = LogicalExpressionParser.LogicalExpression.Before(CommonParser.Eof).ParseOrThrow(input);
132+
var result = operation.ToString()!;
133+
Assert.Equal(input.ToLower(), result.ToLower());
82134
}
83135

84136
// [Theory]
@@ -96,8 +148,8 @@ public static void FindRuleExprParsingShouldBeSuccess(string input)
96148
// [InlineData("$var$ In( \"Is\",\"==\",\"!=\",\"is not\" ) ", "$var$ In \"Is\",\"==\",\"!=\",\"is not\"")]
97149
// [InlineData("$var$ In( \"Is\",\"==\",\"!=\",\"is not\" )", "$var$ In \"Is\",\"==\",\"!=\",\"is not\"")]
98150
// [InlineData("$var$ In( \"Is\",\"==\",\"!=\",\"is not\") ", "$var$ In \"Is\",\"==\",\"!=\",\"is not\"")]
99-
// [InlineData("Not ($var$ equals $var$.Lenght and $var$ StartsWith \"123\")", "Not $var$ equals $var$.Lenght and $var$ StartsWith \"123\"")]
100-
// [InlineData("Not ($var$ equals $var$.Lenght)", "Not $var$ equals $var$.Lenght")]
151+
// [InlineData("Not ($var$ equals $var$.Length and $var$ StartsWith \"123\")", "Not $var$ equals $var$.Length and $var$ StartsWith \"123\"")]
152+
// [InlineData("Not ($var$ equals $var$.Length)", "Not $var$ equals $var$.Length")]
101153
// public static void FindRuleExprParsingShouldBeEqualsCustomResult(string ruleStr, string customResult)
102154
// {
103155
// var rule = LogicalExpressionParser.LogicalExpression.ParseOrThrow(ruleStr);

‎src/SimpleStateMachine.StructuralSearch.Tests/ParametersParserTests.cs‎

Lines changed: 64 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,9 @@
1-
using Pidgin;
2-
using SimpleStateMachine.StructuralSearch.Helper;
1+
using System;
2+
using System.Collections.Generic;
3+
using System.Linq;
4+
using Pidgin;
5+
using SimpleStateMachine.StructuralSearch.Operator.String.Type;
6+
using SimpleStateMachine.StructuralSearch.Parameters.Types;
37
using SimpleStateMachine.StructuralSearch.StructuralSearch;
48
using Xunit;
59

@@ -15,58 +19,86 @@ public static void PlaceholderParsingShouldBeSuccess(string str)
1519
// result = EscapeHelper.Escape(result);
1620
// Assert.Equal(result.ToLower(), str.ToLower());
1721
}
18-
22+
1923
[Theory]
2024
[InlineData("Length")]
2125
public static void PlaceholderLengthParsingShouldBeSuccess(string str)
2226
{
2327
ParametersParser.PlaceholderLength.Before(CommonParser.Eof).ParseOrThrow(str);
2428
}
25-
29+
2630
[Theory]
27-
[InlineData("Input.Lenght")]
31+
[InlineData("Input.Length")]
2832
[InlineData("Input.Extensions")]
2933
public static void PlaceholderInputParsingShouldBeSuccess(string str)
3034
{
3135
ParametersParser.PlaceholderInput.Before(CommonParser.Eof).ParseOrThrow(str);
3236
}
3337

38+
public static IEnumerable<string> PlaceholderPositionCases()
39+
{
40+
foreach (var position in Enum.GetNames<PlaceholderPositionType>())
41+
{
42+
foreach (var subProperty in Enum.GetNames<PlaceholderPositionSubProperty>())
43+
yield return $"{position}.{subProperty}";
44+
}
45+
}
46+
3447
[Theory]
35-
[InlineData("Column.Start")]
36-
[InlineData("Column.End")]
37-
[InlineData("Offset.Start")]
38-
[InlineData("Offset.End")]
39-
[InlineData("Line.Start")]
40-
[InlineData("Line.End")]
48+
[StringMemberData(nameof(PlaceholderPositionCases))]
4149
public static void PlaceholderPositionParsingShouldBeSuccess(string str)
4250
{
4351
ParametersParser.PlaceholderPosition.Before(CommonParser.Eof).ParseOrThrow(str);
4452
}
4553

54+
public static IEnumerable<string> ChainableStringCases()
55+
{
56+
var template = ".{0}";
57+
var names = Enum.GetNames<StringUnaryOperator>().ToList();
58+
foreach (var position in names)
59+
yield return string.Format(template, position);
60+
61+
yield return string.Format(template, string.Join('.', names));
62+
}
63+
4664
[Theory]
47-
[InlineData(".Trim")]
48-
[InlineData(".Trim.Trim.Trim")]
49-
[InlineData(".Trim.TrimEnd.TrimStart.ToUpper.ToLower")]
65+
[StringMemberData(nameof(ChainableStringCases))]
5066
public static void ChainableStringParsingShouldBeSuccess(string str)
5167
{
5268
ParametersParser.ChainableString.Before(CommonParser.Eof).ParseOrThrow(str);
5369
}
54-
70+
71+
public static IEnumerable<string> PropertyAccessCases()
72+
{
73+
var placeholder = "$var$";
74+
foreach (var position in PlaceholderPositionCases())
75+
{
76+
yield return $"{placeholder}.{position}";
77+
78+
foreach (var chainable in ChainableStringCases())
79+
yield return $"{placeholder}.{position}{chainable}";
80+
}
81+
82+
foreach (var chainable in ChainableStringCases())
83+
yield return $"{placeholder}{chainable}";
84+
}
85+
5586
[Theory]
56-
[InlineData("$var$.Column.Start")]
57-
[InlineData("$var$.Column.End")]
58-
[InlineData("$var$.Offset.Start")]
59-
[InlineData("$var$.Offset.End")]
60-
[InlineData("$var$.Line.Start")]
61-
[InlineData("$var$.Line.End")]
62-
[InlineData("$var$.Column.Start.Trim.TrimEnd.TrimStart.ToUpper.ToLower")]
63-
[InlineData("$var$.Column.End.Trim.TrimEnd.TrimStart.ToUpper.ToLower")]
64-
[InlineData("$var$.Offset.Start.Trim.TrimEnd.TrimStart.ToUpper.ToLower")]
65-
[InlineData("$var$.Offset.End.Trim.TrimEnd.TrimStart.ToUpper.ToLower")]
66-
[InlineData("$var$.Line.Start.Trim.TrimEnd.TrimStart.ToUpper.ToLower")]
67-
[InlineData("$var$.Line.End.Trim.TrimEnd.TrimStart.ToUpper.ToLower")]
68-
[InlineData("$var$.Trim")]
69-
[InlineData("$var$.Trim.TrimEnd.TrimStart.ToUpper.ToLower")]
87+
[StringMemberData(nameof(PropertyAccessCases))]
88+
// [InlineData("$var$.Column.Start")]
89+
// [InlineData("$var$.Column.End")]
90+
// [InlineData("$var$.Offset.Start")]
91+
// [InlineData("$var$.Offset.End")]
92+
// [InlineData("$var$.Line.Start")]
93+
// [InlineData("$var$.Line.End")]
94+
// [InlineData("$var$.Column.Start.Trim.TrimEnd.TrimStart.ToUpper.ToLower")]
95+
// [InlineData("$var$.Column.End.Trim.TrimEnd.TrimStart.ToUpper.ToLower")]
96+
// [InlineData("$var$.Offset.Start.Trim.TrimEnd.TrimStart.ToUpper.ToLower")]
97+
// [InlineData("$var$.Offset.End.Trim.TrimEnd.TrimStart.ToUpper.ToLower")]
98+
// [InlineData("$var$.Line.Start.Trim.TrimEnd.TrimStart.ToUpper.ToLower")]
99+
// [InlineData("$var$.Line.End.Trim.TrimEnd.TrimStart.ToUpper.ToLower")]
100+
// [InlineData("$var$.Trim")]
101+
// [InlineData("$var$.Trim.TrimEnd.TrimStart.ToUpper.ToLower")]
70102
public static void PropertyAccessParsingShouldBeSuccess(string str)
71103
{
72104
var parameter = ParametersParser.PropertyAccess.Before(CommonParser.Eof).ParseOrThrow(str);
@@ -75,11 +107,9 @@ public static void PropertyAccessParsingShouldBeSuccess(string str)
75107
}
76108

77109
[Theory]
78-
[InlineData("132")]
79-
[InlineData(" ")]
80-
[InlineData("(132)")]
81-
[InlineData("[(132)]")]
82-
[InlineData("( )")]
110+
[InlineData("\"132\"")]
111+
[InlineData("(\"132\")")]
112+
[InlineData("[(\"132\")]")]
83113
[InlineData("$var$")]
84114
[InlineData("$var$.Column.Start")]
85115
[InlineData("$var$.Column.End")]
@@ -89,23 +119,10 @@ public static void PropertyAccessParsingShouldBeSuccess(string str)
89119
[InlineData("$var$.Line.End")]
90120
[InlineData("$var$.Trim")]
91121
[InlineData("$var$.Trim.Trim")]
92-
[InlineData("( )( )")]
93122
public static void StringExpressionParsingShouldBeSuccess(string str)
94123
{
95124
var parameter = ParametersParser.StringExpression.Before(CommonParser.Eof).ParseOrThrow(str);
96125
var result = parameter.ToString()!;
97126
Assert.Equal(result.ToLower(), str.ToLower());
98127
}
99-
100-
[Theory]
101-
[InlineData("$var$.Column")]
102-
[InlineData("$var$.Offset")]
103-
[InlineData("$var$.Line")]
104-
[InlineData("$var$.Lenght.Trim")]
105-
[InlineData("$var$.Lenght.RemoveSubStr(\"123\")")]
106-
[InlineData("$var$.Lenght.Trim.RemoveSubStr(\"123\")")]
107-
public static void StringExpressionParsingShouldBeFailed(string str)
108-
{
109-
Assert.Throws<ParseException<char>>(() => ParametersParser.StringExpression.Before(CommonParser.Eof).ParseOrThrow(str));
110-
}
111128
}

0 commit comments

Comments
 (0)