public void Match_PatternExpressionsInCalls(string patternData, params int[] matchMethodNumbers)
{
var processor = new DslProcessor();
var patternNode = (PatternNode)processor.Deserialize(patternData, LanguageExt.AllPatternLanguages);
Pattern pattern = new Pattern
{
Data = patternNode,
DebugInfo = patternData
};
patternsRep.Add(patternsConverter.ConvertBack(new List <Pattern>()
{
pattern
}));
WorkflowResult workflowResult = workflow.Process();
MatchingResultDto[] matchingResults = workflowResult.MatchingResults.ToDto(workflow.SourceCodeRepository);
patternsRep.Clear();
Assert.AreEqual(matchMethodNumbers.Contains(0) ? 1 : 0, matchingResults.Count(r => r.MatchedCode.StartsWith("test_call_0")));
Assert.AreEqual(matchMethodNumbers.Contains(1) ? 1 : 0, matchingResults.Count(r => r.MatchedCode.StartsWith("test_call_1")));
Assert.AreEqual(matchMethodNumbers.Contains(2) ? 1 : 0, matchingResults.Count(r => r.MatchedCode.StartsWith("test_call_2")));
Assert.AreEqual(matchMethodNumbers.Contains(3) ? 1 : 0, matchingResults.Count(r => r.MatchedCode.StartsWith("test_call_3")));
Assert.AreEqual(matchMethodNumbers.Contains(4) ? 1 : 0, matchingResults.Count(r => r.MatchedCode.StartsWith("test_call_4")));
}
public static MatchingResultDto[] GetMatchings(string code, string pattern, LanguageFlags analyzedLanguages,
LanguageFlags?patternLanguages = null)
{
var sourceCodeRep = new MemoryCodeRepository(code);
var patternsRep = new MemoryPatternsRepository();
var workflow = new Workflow(sourceCodeRep, analyzedLanguages, patternsRep)
{
Logger = new LoggerMessageCounter()
};
var processor = new DslProcessor();
var patternNode = (PatternNode)processor.Deserialize(pattern, patternLanguages ?? LanguageExt.AllPatternLanguages);
var p = new Pattern
{
Data = patternNode,
DebugInfo = pattern
};
var patternsConverter = new PatternConverter(
new JsonUstNodeSerializer(typeof(UstNode), typeof(PatternVarDef)));
patternsRep.Add(patternsConverter.ConvertBack(new List <Pattern>()
{
p
}));
WorkflowResult workflowResult = workflow.Process();
MatchingResultDto[] matchingResults = workflowResult.MatchingResults.ToDto(workflow.SourceCodeRepository)
.OrderBy(r => r.PatternKey)
.ToArray();
return(matchingResults);
}
public static MatchResultDto[] GetMatches(TextFile source, string pattern,
IEnumerable <Language> analyzedLanguages,
IEnumerable <Language> patternLanguages = null)
{
var sourceRep = new MemorySourceRepository(source.Data, source.FullName)
{
Languages = new HashSet <Language>(analyzedLanguages)
};
var patternsRep = new MemoryPatternsRepository();
var logger = new TestLogger();
var workflow = new Workflow(sourceRep, patternsRep)
{
Logger = logger
};
var processor = new DslProcessor();
PatternRoot patternNode = processor.Deserialize(new TextFile(pattern)
{
PatternKey = pattern
});
patternNode.Languages = new HashSet <Language>(patternLanguages ?? LanguageUtils.PatternLanguages);
patternNode.DebugInfo = pattern;
var patternsConverter = new PatternConverter();
patternsRep.Add(patternsConverter.ConvertBack(new List <PatternRoot> {
patternNode
}));
workflow.Process();
MatchResultDto[] matchResults = logger.Matches.ToDto()
.OrderBy(r => r.PatternKey)
.ToArray();
return(matchResults);
}
public void Process_Dsl_EqualsToHardcoded(string fileName)
{
string data = File.ReadAllText(Path.Combine(TestUtility.TestsDataPath, fileName));
var logger = new TestLogger();
var processor = new DslProcessor {
Logger = logger, PatternExpressionInsideStatement = false
};
PatternRoot result = processor.Deserialize(new TextFile(data)
{
PatternKey = fileName
});
if (fileName == "DebugInfo.pattern")
{
new HashSet <Language> {
Language.Php
};
}
Assert.AreEqual(0, logger.ErrorCount, logger.ErrorsString);
string patternName = Path.GetFileNameWithoutExtension(fileName);
PatternRoot defaultPattern = patterns.FirstOrDefault(p => p.DebugInfo.StartsWith(patternName));
if (defaultPattern == null)
{
Assert.Inconclusive($"Pattern {patternName} does not exists in DefaultPatternRepository");
}
var patternNormalizer = new PatternNormalizer();
defaultPattern = patternNormalizer.Normalize(defaultPattern);
Assert.AreEqual(defaultPattern.Node, result.Node);
}
public void Match_Reduce_CorrectMatchingPosition()
{
var processor = new DslProcessor();
string pattern = "<[ \"\\d+\" ]>";
PatternRoot patternNode = processor.Deserialize(new TextFile(pattern)
{
PatternKey = pattern
});
patternsRepository.Add(patternsConverter.ConvertBack(new List <PatternRoot> {
patternNode
}));
var logger = new TestLogger();
var workflow = new Workflow(sourceRep, patternsRepository)
{
Logger = logger
};
workflow.Process();
List <MatchResultDto> matchResults = logger.Matches.ToDto().ToList();
patternsRepository.Clear();
Assert.AreEqual(2, matchResults.Count);
LineColumnTextSpan textSpan = matchResults[1].LineColumnTextSpan;
Assert.AreEqual(15, textSpan.BeginLine);
Assert.AreEqual(12, textSpan.BeginColumn);
Assert.AreEqual(17, textSpan.EndLine);
Assert.AreEqual(7, textSpan.EndColumn);
}
public void Match_PatternVarWithRegex(string patternData)
{
var processor = new DslProcessor();
PatternRoot patternNode = processor.Deserialize(new TextFile(patternData)
{
PatternKey = patternData
});
patternNode.DebugInfo = patternData;
patternsRepository.Add(patternsConverter.ConvertBack(new List <PatternRoot>()
{
patternNode
}));
var logger = new TestLogger();
var workflow = new Workflow(sourceRep, patternsRepository)
{
Logger = logger
};
workflow.Process();
IEnumerable <MatchResultDto> matchResults = logger.Matches.ToDto();
patternsRepository.Clear();
int expectedMatchingCount = patternData.Contains("password") ? 1 : 0;
Assert.AreEqual(expectedMatchingCount, matchResults.Count());
}
//[TestCase("#(#*, <[~e]>, #*)", new[] { 0, 1, 3 })]
public void Match_PatternExpressionsInCalls(string patternData, params int[] matchMethodNumbers)
{
var processor = new DslProcessor();
PatternRoot patternNode = processor.Deserialize(new TextFile(patternData)
{
PatternKey = patternData
});
patternNode.DebugInfo = patternData;
patternsRepository.Add(patternsConverter.ConvertBack(new List <PatternRoot> {
patternNode
}));
var logger = new TestLogger();
var workflow = new Workflow(sourceRep, patternsRepository)
{
Logger = logger
};
workflow.Process();
IEnumerable <MatchResultDto> matchResults = logger.Matches.ToDto();
patternsRepository.Clear();
Assert.AreEqual(matchMethodNumbers.Contains(0) ? 1 : 0, matchResults.Count(r => r.MatchedCode.StartsWith("test_call_0")));
Assert.AreEqual(matchMethodNumbers.Contains(1) ? 1 : 0, matchResults.Count(r => r.MatchedCode.StartsWith("test_call_1")));
Assert.AreEqual(matchMethodNumbers.Contains(2) ? 1 : 0, matchResults.Count(r => r.MatchedCode.StartsWith("test_call_2")));
Assert.AreEqual(matchMethodNumbers.Contains(3) ? 1 : 0, matchResults.Count(r => r.MatchedCode.StartsWith("test_call_3")));
Assert.AreEqual(matchMethodNumbers.Contains(4) ? 1 : 0, matchResults.Count(r => r.MatchedCode.StartsWith("test_call_4")));
}
public void ProcessDsl_PatternVarAlreadyDefined_HandleErrors(string data)
{
Assert.Throws(typeof(ConversionException), () =>
{
var processor = new DslProcessor();
UstNode result = processor.Deserialize(data, LanguageExt.AllPatternLanguages);
});
}
public void Preprocess_MultiMultiPattern_RemovedDuplicates()
{
UstNode patternWithDuplicateMultiStatementsExpressions = new PatternStatements
{
Statements = new List <Statement>()
{
new ExpressionStatement(
new InvocationExpression
{
Target = new IdToken("test_call"),
Arguments = new PatternExpressions
{
Collection = new List <Expression>
{
new IdToken("a"),
new IdToken("b"),
new PatternMultipleExpressions(),
new PatternMultipleExpressions(),
new IdToken("z")
}
}
}),
new PatternMultipleStatements(),
new PatternMultipleStatements(),
new ExpressionStatement(
new VariableDeclarationExpression
{
Type = new TypeToken("int"),
Variables = new List <AssignmentExpression>()
{
new AssignmentExpression
{
Left = new IdToken("a"),
Right = new IntLiteral {
Value = 42
}
}
}
}
)
}
};
var logger = new LoggerMessageCounter();
var processor = new DslProcessor();
UstPreprocessor preprocessor = new UstPreprocessor()
{
Logger = logger
};
UstNode result = preprocessor.Preprocess(patternWithDuplicateMultiStatementsExpressions);
Assert.AreEqual(1, result.GetAllDescendants().Count(child => child.NodeType == NodeType.PatternMultipleStatements));
Assert.AreEqual(1, result.GetAllDescendants().Count(child => child.NodeType == NodeType.PatternMultipleExpressions));
}
public void JsonSerialize_PatternWithVar_JsonEqualsToDsl()
{
var pwdVar = new PatternVarDef {
Id = "pwd", Values = new List <Expression>()
{
new PatternIdToken("password")
}
};
var patternNode = new PatternNode
{
Vars = new List <PatternVarDef>()
{
pwdVar
},
Node = new PatternStatements(
new ExpressionStatement
{
Expression = new AssignmentExpression
{
Left = new PatternVarRef(pwdVar),
Right = new PatternExpression()
}
},
new PatternMultipleStatements(),
new ExpressionStatement
{
Expression = new InvocationExpression
{
Target = new PatternExpression(),
Arguments = new PatternExpressions(
new PatternMultipleExpressions(),
new PatternVarRef(pwdVar),
new PatternMultipleExpressions())
}
}
)
};
var jsonSerializer = new JsonUstNodeSerializer(typeof(UstNode), typeof(PatternVarDef));
jsonSerializer.Indented = true;
jsonSerializer.IncludeTextSpans = false;
string json = jsonSerializer.Serialize(patternNode);
UstNode nodeFromJson = jsonSerializer.Deserialize(json, LanguageExt.AllPatternLanguages);
var dslSeializer = new DslProcessor()
{
PatternExpressionInsideStatement = false
};
var nodeFromDsl = dslSeializer.Deserialize("<[@pwd:password]> = #; ... #(#*, <[@pwd]>, #*);", LanguageExt.AllPatternLanguages);
Assert.IsTrue(nodeFromJson.Equals(patternNode));
Assert.IsTrue(nodeFromJson.Equals(nodeFromDsl));
}
public void ProcessDsl_PatternVarAlreadyDefined_HandleErrors(string data)
{
Assert.Throws(typeof(ConversionException), () =>
{
var processor = new DslProcessor();
PatternRoot result = processor.Deserialize(new CodeFile(data)
{
IsPattern = true
});
});
}
public void JsonSerialize_PatternWithVar_JsonEqualsToDsl()
{
var patternRoot = new PatternRoot
{
Node = new PatternStatements
{
Statements = new List <PatternUst>
{
new PatternAssignmentExpression
{
Left = new PatternVar("pwd")
{
Value = new PatternIdRegexToken("password")
},
Right = new PatternAny()
},
new PatternInvocationExpression
{
Target = new PatternAny(),
Arguments = new PatternArgs(
new PatternMultipleExpressions(),
new PatternVar("pwd"),
new PatternMultipleExpressions())
}
}
}
};
var jsonSerializer = new JsonPatternSerializer
{
Indented = true,
IncludeTextSpans = false
};
string json = jsonSerializer.Serialize(patternRoot);
PatternRoot nodeFromJson = jsonSerializer.Deserialize(new TextFile(json)
{
PatternKey = "PatternWithVar"
});
var dslSeializer = new DslProcessor()
{
PatternExpressionInsideStatement = false
};
var nodeFromDsl = dslSeializer.Deserialize(
new TextFile("<[@pwd:password]> = #; ... #(#*, <[@pwd]>, #*);")
{
PatternKey = "PatternWithVar2"
});
Assert.IsTrue(nodeFromJson.Node.Equals(patternRoot.Node));
Assert.IsTrue(nodeFromJson.Node.Equals(nodeFromDsl.Node));
}
public void Parse_Dsl_WithoutErrors(string fileName)
{
var data = File.ReadAllText(Path.Combine(TestHelper.TestsDataPath, fileName));
var logger = new LoggerMessageCounter();
var processor = new DslProcessor()
{
Logger = logger
};
UstNode result = processor.Deserialize(data, LanguageExt.AllPatternLanguages);
Assert.AreEqual(0, logger.ErrorCount);
}
public void ProcessDsl_SampleWithSyntaxError_HandleErrors()
{
var logger = new LoggerMessageCounter();
var data = "(?i)password(?-i)]> = <[\"\\w*\" || null]>";
var processor = new DslProcessor()
{
Logger = logger
};
UstNode result = processor.Deserialize(data, LanguageExt.AllPatternLanguages);
Assert.AreEqual(5, logger.ErrorCount);
}
public void Parse_Dsl_WithoutErrors(string fileName)
{
string data = File.ReadAllText(Path.Combine(TestUtility.TestsDataPath, fileName));
var logger = new TestLogger();
var processor = new DslProcessor {
Logger = logger
};
PatternRoot result = processor.Deserialize(new TextFile(data)
{
PatternKey = fileName
});
Assert.AreEqual(0, logger.ErrorCount, logger.ErrorsString);
}
public void ProcessDsl_SampleWithSyntaxError_HandleErrors()
{
var logger = new TestLogger();
var data = "(?i)password(?-i)]> = <[\"\\w*\" || null]>";
var processor = new DslProcessor()
{
Logger = logger
};
PatternRoot result = processor.Deserialize(new TextFile(data)
{
PatternKey = "ErrorneousPattern"
});
Assert.AreEqual(5, logger.ErrorCount);
}
public void ProcessDsl_SampleWithSyntaxError_HandleErrors()
{
var logger = new LoggerMessageCounter();
var data = "(?i)password(?-i)]> = <[\"\\w*\" || null]>";
var processor = new DslProcessor()
{
Logger = logger
};
PatternRoot result = processor.Deserialize(new CodeFile(data)
{
IsPattern = true
});
Assert.AreEqual(5, logger.ErrorCount);
}
public Workflow(ISourceCodeRepository sourceCodeRepository, LanguageFlags languages,
IPatternsRepository patternsRepository = null, Stage stage = Stage.Match)
: base(stage)
{
SourceCodeRepository = sourceCodeRepository;
PatternsRepository = patternsRepository ?? new DefaultPatternRepository();
ParserConverterSets = ParserConverterBuilder.GetParserConverterSets(languages);
UstPatternMatcher = new BruteForcePatternMatcher();
IUstNodeSerializer jsonNodeSerializer = new JsonUstNodeSerializer(typeof(UstNode), typeof(PatternVarDef));
IUstNodeSerializer dslNodeSerializer = new DslProcessor();
PatternConverter = new PatternConverter(new IUstNodeSerializer[] { jsonNodeSerializer, dslNodeSerializer });
Stage = stage;
ThreadCount = 1;
}
public Workflow(SourceRepository sourceRepository = null,
IPatternsRepository patternsRepository = null, Stage stage = Stage.Match)
: base(stage)
{
LogsDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "PT.PM");
DumpDir = LogsDir;
TempDir = Path.Combine(Path.GetTempPath(), "PT.PM");
SourceRepository = sourceRepository;
PatternsRepository = patternsRepository ?? new DefaultPatternRepository();
IPatternSerializer jsonNodeSerializer = new JsonPatternSerializer();
IPatternSerializer dslNodeSerializer = new DslProcessor();
PatternConverter = new PatternConverter(jsonNodeSerializer, dslNodeSerializer);
Stage = stage;
}
public ArkeCall(ISipApiClient sipApiClient, ISipLineApi sipLineApi, ISipBridgingApi sipBridgeApi,
ISipPromptApi sipPromptApi, IRecordingManager recordingmanager)
{
_sipApiClient = sipApiClient;
_sipLineApi = sipLineApi;
_sipBridgeApi = sipBridgeApi;
_logFields = new Dictionary <string, string>();
_promptPlayer = new ArkePromptPlayer(this, sipPromptApi);
_asteriskPhoneInputHandler = new AsteriskPhoneInputHandler(this, _promptPlayer);
_asteriskRecordingManager = recordingmanager;
_dslProcessor = new DslProcessor(this);
_arkeBridgeFactory = new ArkeBridgeFactory(_sipBridgeApi);
_callStateMachine = new CallStateMachine(this, _promptPlayer);
_callStateMachine.SetupFiniteStateMachine();
LanguageSelectionPromptPlayer = new AsteriskLanguageSelectionPromptPlayer(this, sipPromptApi, sipApiClient);
}
public void Sort_PatternVars_CorrectOrder()
{
var unsorted = new PatternOr
(
new PatternStringLiteral("42"),
new PatternIntLiteral(100),
new PatternIntLiteral(42),
new PatternIntLiteral(0),
new PatternStringLiteral("42"),
new PatternNot(new PatternStringLiteral("42")),
new PatternStringLiteral("Hello World!"),
new PatternIdToken("testId"),
new PatternIdToken("42"),
new PatternNot(new PatternStringLiteral("42"))
);
var expectedSorted = new PatternOr
(
new PatternIdToken("42"),
new PatternIdToken("testId"),
new PatternIntLiteral(0),
new PatternIntLiteral(42),
new PatternIntLiteral(100),
new PatternNot(new PatternStringLiteral("42")),
new PatternNot(new PatternStringLiteral("42")),
new PatternStringLiteral("42"),
new PatternStringLiteral("42"),
new PatternStringLiteral("Hello World!")
);
var logger = new TestLogger();
var processor = new DslProcessor();
var normalizer = new PatternNormalizer()
{
Logger = logger
};
var actualPattern = (PatternOr)normalizer.Visit(unsorted);
List <PatternUst> actualAlternatives = actualPattern.Patterns;
List <PatternUst> expectedAlternatives = expectedSorted.Patterns;
Assert.AreEqual(expectedAlternatives.Count, actualAlternatives.Count);
for (int i = 0; i < expectedAlternatives.Count; i++)
{
Assert.IsTrue(expectedAlternatives[i].Equals(actualAlternatives[i]),
$"Not equal at {i} index: expected {expectedAlternatives[i]} not equals to {actualAlternatives[i]}");
}
}
public void Simplify_MultiMultiPattern_RemovedDuplicates()
{
var input = new PatternStatements
{
Statements = new List <PatternUst>()
{
new PatternInvocationExpression
{
Target = new PatternIdToken("test_call"),
Arguments = new PatternArgs
(
new PatternIdToken("a"),
new PatternIdToken("b"),
new PatternMultipleExpressions(),
new PatternMultipleExpressions(),
new PatternIdToken("z")
)
},
new PatternVarOrFieldDeclaration
{
Type = new PatternIdToken("int"),
Assignment = new PatternAssignmentExpression
{
Left = new PatternIdToken("a"),
Right = new PatternIntLiteral(42)
}
}
}
};
var logger = new LoggerMessageCounter();
var processor = new DslProcessor();
var normalizer = new PatternNormalizer()
{
Logger = logger
};
PatternUst result = normalizer.Visit(input);
var statements = ((PatternStatements)result).Statements;
var invocation = (PatternInvocationExpression)statements.ElementAt(0);
Assert.AreEqual(1, ((PatternArgs)invocation.Arguments).Args.Count(child => child is PatternMultipleExpressions));
}
public void Process_Dsl_EqualsToHardcoded(string fileName)
{
var data = File.ReadAllText(Path.Combine(TestHelper.TestsDataPath, fileName));
var logger = new LoggerMessageCounter();
var processor = new DslProcessor()
{
Logger = logger, PatternExpressionInsideStatement = false
};
UstNode result = processor.Deserialize(data, fileName == @"DebugInfo.aipm" ? LanguageFlags.Php : LanguageExt.AllPatternLanguages);
Assert.AreEqual(0, logger.ErrorCount);
string patternName = Path.GetFileNameWithoutExtension(fileName);
Pattern defaultPattern = patterns.FirstOrDefault(p => p.DebugInfo.StartsWith(patternName));
if (defaultPattern == null)
{
Assert.Inconclusive($"Pattern {patternName} does not exists in DefaultPatternRepository");
}
Assert.IsTrue(result.Equals(defaultPattern.Data));
}
public void Match_PatternVarWithRegex(string patternData)
{
var processor = new DslProcessor();
PatternRoot patternNode = processor.Deserialize(new CodeFile(patternData)
{
IsPattern = true
});
patternNode.DebugInfo = patternData;
patternsRepository.Add(patternsConverter.ConvertBack(new List <PatternRoot>()
{
patternNode
}));
WorkflowResult workflowResult = workflow.Process();
IEnumerable <MatchResultDto> matchResults = workflowResult.MatchResults.ToDto();
patternsRepository.Clear();
int expectedMatchingCount = patternData.Contains("password") ? 1 : 0;
Assert.AreEqual(expectedMatchingCount, matchResults.Count());
}
public void Match_PatternVarWithRegex(string patternData)
{
var processor = new DslProcessor();
var patternNode = (PatternNode)processor.Deserialize(patternData, LanguageExt.AllPatternLanguages);
Pattern pattern = new Pattern
{
Data = patternNode,
DebugInfo = patternData
};
patternsRep.Add(patternsConverter.ConvertBack(new List <Pattern>()
{
pattern
}));
WorkflowResult workflowResult = workflow.Process();
MatchingResultDto[] matchingResults = workflowResult.MatchingResults.ToDto(workflow.SourceCodeRepository);
patternsRep.Clear();
int expectedMatchingCount = patternData.Contains("password") ? 1 : 0;
Assert.AreEqual(expectedMatchingCount, matchingResults.Count());
}
public void Match_Reduce_CorrectMatchingPosition()
{
var processor = new DslProcessor();
PatternRoot patternNode = processor.Deserialize(new CodeFile("<[ \"\\d+\" ]>")
{
IsPattern = true
});
patternsRepository.Add(patternsConverter.ConvertBack(new List <PatternRoot>()
{
patternNode
}));
WorkflowResult workflowResult = workflow.Process();
List <MatchResultDto> matchResults = workflowResult.MatchResults.ToDto().ToList();
patternsRepository.Clear();
LineColumnTextSpan textSpan = matchResults[1].LineColumnTextSpan;
Assert.AreEqual(14, textSpan.BeginLine);
Assert.AreEqual(12, textSpan.BeginColumn);
Assert.AreEqual(16, textSpan.EndLine);
Assert.AreEqual(7, textSpan.EndColumn);
}
//[TestCase("#(#*, <[~e]>, #*)", new[] { 0, 1, 3 })]
public void Match_PatternExpressionsInCalls(string patternData, params int[] matchMethodNumbers)
{
var processor = new DslProcessor();
PatternRoot patternNode = processor.Deserialize(new CodeFile(patternData)
{
IsPattern = true
});
patternNode.DebugInfo = patternData;
patternsRepository.Add(patternsConverter.ConvertBack(new List <PatternRoot>()
{
patternNode
}));
WorkflowResult workflowResult = workflow.Process();
IEnumerable <MatchResultDto> matchResults = workflowResult.MatchResults.ToDto();
patternsRepository.Clear();
Assert.AreEqual(matchMethodNumbers.Contains(0) ? 1 : 0, matchResults.Count(r => r.MatchedCode.StartsWith("test_call_0")));
Assert.AreEqual(matchMethodNumbers.Contains(1) ? 1 : 0, matchResults.Count(r => r.MatchedCode.StartsWith("test_call_1")));
Assert.AreEqual(matchMethodNumbers.Contains(2) ? 1 : 0, matchResults.Count(r => r.MatchedCode.StartsWith("test_call_2")));
Assert.AreEqual(matchMethodNumbers.Contains(3) ? 1 : 0, matchResults.Count(r => r.MatchedCode.StartsWith("test_call_3")));
Assert.AreEqual(matchMethodNumbers.Contains(4) ? 1 : 0, matchResults.Count(r => r.MatchedCode.StartsWith("test_call_4")));
}
public static MatchResultDto[] GetMatches(string code, string pattern,
IEnumerable <Language> analyzedLanguages,
IEnumerable <Language> patternLanguages = null)
{
var sourceCodeRep = new MemoryCodeRepository(code)
{
Languages = new HashSet <Language>(analyzedLanguages)
};
var patternsRep = new MemoryPatternsRepository();
var workflow = new Workflow(sourceCodeRep, patternsRep)
{
Logger = new LoggerMessageCounter()
};
var processor = new DslProcessor();
PatternRoot patternNode = processor.Deserialize(new CodeFile(pattern)
{
IsPattern = true
});
patternNode.Languages = new HashSet <Language>(patternLanguages ?? LanguageUtils.PatternLanguages.Values);
patternNode.DebugInfo = pattern;
var patternsConverter = new PatternConverter();
patternsRep.Add(patternsConverter.ConvertBack(new List <PatternRoot>()
{
patternNode
}));
WorkflowResult workflowResult = workflow.Process();
MatchResultDto[] matchResults = workflowResult.MatchResults.ToDto()
.OrderBy(r => r.PatternKey)
.ToArray();
return(matchResults);
}
public void Sort_PatternVars()
{
var unsortedExpressions = new List <Expression>()
{
new IntLiteral {
Value = 100
},
new IntLiteral {
Value = 42
},
new IntLiteral {
Value = 0
},
new StringLiteral {
Text = "42"
},
new StringLiteral {
Text = "Hello World!"
},
new IdToken {
Id = "testId"
},
new IdToken {
Id = "42"
},
new PatternExpression(new StringLiteral {
Text = "42"
}, true),
};
var expectedSortedExpressions = new List <Expression>
{
new StringLiteral {
Text = "42"
},
new PatternExpression(new StringLiteral {
Text = "42"
}, true),
new StringLiteral {
Text = "Hello World!"
},
new IdToken {
Id = "42"
},
new IdToken {
Id = "testId"
},
new IntLiteral {
Value = 0
},
new IntLiteral {
Value = 42
},
new IntLiteral {
Value = 100
},
};
var patternVarDef = new PatternVarDef
{
Id = "testVarDef",
Values = unsortedExpressions
};
var patternVars = new PatternNode
{
Vars = new List <PatternVarDef>()
{
patternVarDef
},
Node = new PatternVarRef(patternVarDef)
};
var logger = new LoggerMessageCounter();
var processor = new DslProcessor();
UstPreprocessor preprocessor = new UstPreprocessor()
{
Logger = logger
};
Expression[] resultSortedExpressions = ((PatternNode)preprocessor.Preprocess(patternVars))
.Vars.First().Values.ToArray();
Assert.AreEqual(expectedSortedExpressions.Count, resultSortedExpressions.Length);
for (int i = 0; i < expectedSortedExpressions.Count; i++)
{
Assert.IsTrue(expectedSortedExpressions[i].Equals(resultSortedExpressions[i]),
$"Not equal at {i} index: expected {expectedSortedExpressions[i]} not equals to {resultSortedExpressions[i]}");
}
}
public static IPatternsRepository CreatePatternsRepository(string patternsString,
IEnumerable <string> patternIds,
ILogger logger)
{
IPatternsRepository patternsRepository;
if (string.IsNullOrEmpty(patternsString) || patternsString == "default")
{
patternsRepository = new DefaultPatternRepository();
}
else if (patternsString.EqualsIgnoreCase("no"))
{
patternsRepository = DummyPatternsRepository.Instance;
}
else if (patternsString.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
{
patternsRepository = new JsonPatternsRepository(FileExt.ReadAllText(patternsString));
}
else
{
TextFile patternsFile;
if (patternsString.EndsWith(".pattern", StringComparison.OrdinalIgnoreCase))
{
patternsFile = new TextFile(FileExt.ReadAllText(patternsString))
{
PatternKey = patternsString,
Name = patternsString
};
}
else
{
patternsFile = new TextFile(patternsString);
}
var processor = new DslProcessor();
if (logger != null)
{
processor.Logger = logger;
}
PatternRoot patternRoot = processor.Deserialize(patternsFile);
var patternConverter = new PatternConverter();
if (logger != null)
{
patternConverter.Logger = logger;
}
List <PatternDto> dtos = patternConverter.ConvertBack(new[] { patternRoot });
var memoryPatternsRepository = new MemoryPatternsRepository();
memoryPatternsRepository.Add(dtos);
patternsRepository = memoryPatternsRepository;
}
if (logger != null)
{
patternsRepository.Logger = logger;
}
patternsRepository.Identifiers = patternIds as List <string> ?? patternIds?.ToList();
return(patternsRepository);
}
