private void DoExpand(SpecScreen screen, string pathToApp, MyLog myLog, List <ClassExpression> allClassesExp)
{
for (int fi = 0; fi < screen.Scenarios.Count; fi++)
{
IScenario tempScenario = screen.Scenarios[fi];
if (tempScenario is SpecScenario)
{
SpecScenario scenario = tempScenario as SpecScenario;
List <string> listActionExp = scenario.UserActionsInString;
List <Color> colors = scenario.Colors;
for (int se = 0; se < listActionExp.Count; se++)
{
string actionExp = listActionExp[se];
if (actionExp == null)
{
myLog.Error("NULL at (" + (fi + 1) + "," + (se + 2) + ")");
continue;
}
SpecNode specNode = screen.ListSpecNodes[se];
ScriptGenerationParams _params = null;
AbstractSpecUserAction specUserAction = null;
int lastInd = IsValidationUserCode(se, screen.ListValidationUserCode);
if (lastInd > se)
{
specUserAction = new ValidationUserCodeSpecUserAction();
_params = new ValidationUCScriptGenerationParams();
List <string> listExp = new List <string>();
for (int th = se; th <= lastInd; th++)
{
String tempActionExp = listActionExp[th];
AbstractSpecUserAction temp = handleUserActionExpression(
tempActionExp.Trim(), specNode, colors[th], myLog);
if (!(temp is ValidationSpecUserAction))
{
myLog.Warn("Expression: " + tempActionExp + " must be validation", logger);
screen = null;
return;
}
else
{
if (tempActionExp != null && !tempActionExp.Trim().Equals(""))
{
listExp.Add(tempActionExp.Trim());
}
}
}
(specUserAction as ValidationUserCodeSpecUserAction).ListExps = listExp;
((ValidationUCScriptGenerationParams)_params).ListExps = listExp;
if (screen is TestSpecificationScreen)
{
((ValidationUCScriptGenerationParams)_params).ClassExpressions = allClassesExp;
}
((ValidationUCScriptGenerationParams)_params).ClassName =
AbstractSpecUserAction.GetFolderNameFromScreen(screen) + "_Validation";
((ValidationUCScriptGenerationParams)_params).FunctionName = "Validate_" +
Regex.Replace(specNode.Expression, "[^A-Za-z0-9]", "_");
SetAttributes(scenario, specUserAction, specNode,
screen, pathToApp, colors, _params, se, myLog);
se = lastInd;
}
else
{
string[] listActionsEpx = splitAction(actionExp, AbstractSpecUserAction.AND);
foreach (string action in listActionsEpx)
{
specUserAction = handleUserActionExpression(action.Trim(), specNode, colors[se], myLog);
if (specUserAction != null)
{
if (specUserAction is UserCodeSpecUserAction userCodeExpression)
{
_params = new UserCodeScriptGenerationParams();
((UserCodeScriptGenerationParams)_params).MapAliasWithNode = screen.MappingAliasWithNode;
if (screen is TestSpecificationScreen testSpecScreen)
{
((UserCodeScriptGenerationParams)_params).ClassExpressions = allClassesExp;
}
}
else if (specUserAction is WaitValidateSpecUserAction waitUserAction)
{
_params = new WaitValidateScriptGenerationParams();
}
else
{
_params = new ScriptGenerationParams();
}
SetAttributes(scenario, specUserAction, specNode,
screen, pathToApp, colors, _params, se, myLog);
}
}
}
}
}
}
}
/// <summary>
/// return {function content, List[UserCodeScriptsExpression]}
/// </summary>
/// <param name="specScenario"></param>
/// <param name="instanceName"></param>
/// <param name="countLineBreak">determine new_line with blank line or only break new line</param>
/// <param name="ignoreScenarioIfError">indicate whether ignore current scenario if an error occur</param>
/// <returns></returns>
protected Tuple <string, List <UserCodeScriptsExpression> > GenerateAScenario(SpecScenario specScenario,
MyLog myLog,
string instanceName = INSTANCE_NAME,
int countLineBreak = 1,
bool ignoreScenarioIfError = true)
{
string newLine = string.Concat(Enumerable.Repeat(NEW_LINE, countLineBreak + 1));
string funcContent = "";
List <UserCodeScriptsExpression> listUcScriptExp = new List <UserCodeScriptsExpression>();
List <IScenario> preConditions = specScenario.PreConditions;
if (preConditions != null)
{
foreach (IScenario preCondition in preConditions)
{
if (preCondition is SpecScenario preConditionSpec)
{
if (!funcContent.Equals(""))
{
funcContent += newLine;
}
Tuple <string, List <UserCodeScriptsExpression> > pair = GenerateAScenario(
preConditionSpec, myLog, instanceName, countLineBreak, ignoreScenarioIfError);
funcContent += pair.Item1;
var temp = pair.Item2;
if (temp != null && temp.Count > 0)
{
Utils.MergeUcScriptsEpx(listUcScriptExp, temp);
listUcScriptExp.AddRange(temp);
}
}
else
{
logger.Error("Not handled yet!");
}
}
}
foreach (IUserAction userAction in specScenario.UserActions)
{
if (userAction is AbstractSpecUserAction specUserAction)
{
if (specUserAction.IgnoreGenerateScripts)
{
continue;
}
if (!funcContent.Equals(""))
{
funcContent += newLine;
}
try
{
ScriptsExpression scriptsExpression = GenScriptType(specUserAction, instanceName);
// if error
if (scriptsExpression == null)
{
LogError(specUserAction.Expression, specUserAction.Params.ScreenName,
specUserAction.Params.Id, myLog, specUserAction.NodeAffect.ToString());
if (ignoreScenarioIfError)
{
return(null); // ignore current scenario, process with the next one
}
// in contrast, continue with the remains UserAction-s
continue;
}
funcContent += scriptsExpression.Expression;
if (scriptsExpression is UserCodeScriptsExpression ucScriptsExp)
{
// remove duplicate function
Utils.MergeUcScriptsEpx(listUcScriptExp, ucScriptsExp);
listUcScriptExp.Add(ucScriptsExp);
}
}
catch (NotImplementedException)
{
logger.Error("Not implement with " + userAction.GetType().Name);
}
}
else
{
logger.Error("Not handled yet!");
}
}
return(new Tuple <string, List <UserCodeScriptsExpression> >(funcContent, listUcScriptExp));
}
/// <summary>
///
/// </summary>
/// <param name="normalSheet"></param>
/// <param name="elementsAndIndicator">indication to determine root elements or list of all elements</param>
/// <param name="myLog"></param>
/// <returns></returns>
private SpecScreen parseNormalSheet(NormalSheet normalSheet, ListUIElements elementsAndIndicator, MyLog myLog)
{
NormalSheetParser normalSheetParser = new NormalSheetParser();
return(normalSheetParser.Parse(normalSheet, elementsAndIndicator, myLog));
}
public bool Expand(List <SpecScreen> listScreens, string pathToApp, MyLog myLog)
{
List <IScreen> temp = new List <IScreen>(listScreens);
return(Expand(temp, pathToApp, myLog));
}
/// <summary>
///
/// </summary>
/// <param name="classExpression"></param>
/// <param name="projectPath"></param>
/// <param name="name_space"></param>
/// <param name="listUIElements"></param>
/// <param name="mapAliasWithNode"></param>
/// <param name="myLog"></param>
/// <param name="instanceName"></param>
/// <returns>relative file path</returns>
private string GenerateClassExpScripts(ClassExpression classExpression, string projectPath, string name_space,
ListUIElements listUIElements, Dictionary <string, string> mapAliasWithNode, MyLog myLog, string instanceName)
{
if (classExpression.getName() == null || classExpression.getListFunction() == null ||
classExpression.getListFunction().Count <= 0)
{
return(null);
}
string functionsScripts = "";
foreach (FunctionExpression func in classExpression.getListFunction())
{
if (functionsScripts != "")
{
functionsScripts += NEW_LINE;
}
functionsScripts += GenerateFunctionExpScripts(func, listUIElements, mapAliasWithNode, myLog, instanceName);
}
// create new file
string classContent = GetTemplateUCClassContent()
//.Replace(GLOBAL_REPLACE, "") disabled by @duongtd 05/29
.Replace(CLASS_REPLACE, classExpression.getName())
.Replace(CONTENT_REPLACE, functionsScripts);
string filePath = Path.Combine(classExpression.GetCorrectWorkspace(), classExpression.getName() + ".cs");
string fileContentTemplate = GetTemplateRunCsFileContent()
.Replace(NAMESPACE_REPLACE, name_space);
CreateNewFile(fileContentTemplate, classContent, Path.Combine(projectPath, filePath));
return(filePath);
}
/// <summary>
/// </summary>
/// <param name="params"></param>
/// <param name="listUIElements"></param>
/// <param name="mapAliasWithNode"></param>
/// <param name="myLog"></param>
/// <param name="instanceName"></param>
/// <returns>{params scripts, list of param's name}</returns>
private Tuple <string, List <string> > GetParamsScripts(List <ParameterExpression> @params, ListUIElements listUIElements,
Dictionary <string, string> mapAliasWithNode, MyLog myLog, string instanceName)
{
if (@params == null || @params.Count == 0)
{
return(new Tuple <string, List <string> >("", null));
}
string re = "";
List <string> nameParams = new List <string>();
for (int fi = 1; fi <= @params.Count; fi++)
{
ParameterExpression param = @params[fi - 1];
if (re != "")
{
re += ", ";
}
string varName = "param_" + fi;
nameParams.Add(varName);
re += "object " + varName;
}
return(new Tuple <string, List <string> >(re, nameParams));
}
/// <summary>
/// 'GetAttributeValue<object>("Text")' for Ranorex
/// </summary>
/// <param name="nodeExp"></param>
/// <param name="listUIElements"></param>
/// <param name="mappingAlias"></param>
/// <param name="myLog"></param>
/// <param name="instanceName"></param>
/// <returns></returns>
public static string Node2ParamExp(string nodeExp, ListUIElements listUIElements, Dictionary <string, string> mappingAlias, MyLog myLog, string instanceName, ScriptType scriptType)
{
Tuple <IElement, string> elementAndAttibute = NormalSheetParser.parseNodeAndAttribute(nodeExp, listUIElements, mappingAlias, myLog);
if (elementAndAttibute == null || elementAndAttibute.Item1 == null)
{
myLog.Warn("cannot find node: " + nodeExp);
return("null");
}
if (scriptType == ScriptType.Normal)
{
return(GetScriptAccessElement(elementAndAttibute.Item1, instanceName));
}
//Ranorex scripts
string re = getScriptAccessRanorexElement(
new SpecNode(elementAndAttibute.Item1, elementAndAttibute.Item2, null), instanceName);
if (elementAndAttibute.Item2 != null && !elementAndAttibute.Item2.Equals(""))
{
re += ".GetAttributeValue<object>(\"" + elementAndAttibute.Item2 + "\")";
}
return(re);
}
/// <summary>
///
/// </summary>
/// <param name="screenList"></param>
/// <param name="folderPath">="D:\MyTestProject"</param>
/// <param name="repoFilePath">="D:\ElementsRepo.xml"</param>
/// <param name="imageCapFilePath">="D:\ImageCapture.xml"</param>
/// <param name="appFilePath">="D:\app.exe"</param>
/// <param name="classRepoName">="MyTestProjectDefinition"</param>
/// <param name="name_space">="MyTestProject"</param>
/// <param name="mainClassInstance">="Instance"</param>
/// <param name="myLog"></param>
/// <returns>map (folder_path, list_files_in_folder)</returns>
public Tuple <Dictionary <string, string>, List <string> > Generate(List <IScreen> screenList, string folderPath,
string repoFilePath, string imageCapFilePath, string appFilePath, string classRepoName,
string name_space, string mainClassInstance, MyLog myLog, string instanceName = INSTANCE_NAME)
{
//List<string> runningFilePath = new List<string>();
Dictionary <string, string> mapFilePathAndId = new Dictionary <string, string>();
List <UserCodeScriptsExpression> additionScripts = new List <UserCodeScriptsExpression>();
List <ClassExpression> additionClasses = new List <ClassExpression>();
SpecScreen aScreen = null;
foreach (IScreen screen in screenList)
{
if (screen is SpecScreen specScreen)
{
if (aScreen == null)
{
aScreen = specScreen;
}
ProcessScreen(specScreen, mapFilePathAndId, additionScripts, additionClasses,
folderPath, repoFilePath, imageCapFilePath, appFilePath, classRepoName, name_space,
mainClassInstance, myLog, instanceName);
}
else
{
logger.Error("Not handled yet!");
}
}
List <string> otherFilePath = GenerateAdditionClassses(additionScripts, additionClasses, aScreen, myLog, folderPath, repoFilePath,
imageCapFilePath, appFilePath, classRepoName, name_space, mainClassInstance, instanceName, mapFilePathAndId);
return(new Tuple <Dictionary <string, string>, List <string> >(mapFilePathAndId, otherFilePath));
}
public bool GenerateRanorexProject(List <IElement> listRootElements, List <SpecScreen> screensExpanded,
string repoFilePath, string folderOutPath, string appPath, MyLog myLog)
{
string tempFolderPath = Utils.CreateTempFolder(PROJECT_NAME + "_" +
DateTime.Now.ToString("yyMMdd_HHmmss"));
ZipFile.ExtractToDirectory(PROJECT_TEMPLATE_PATH, tempFolderPath);
string projectTempFolder = Path.Combine(tempFolderPath, PROJECT_NAME);
// generate scripts
Tuple <Dictionary <string, string>, List <string> > pair = null;
if (screensExpanded != null && screensExpanded.Count > 0)
{
RanorexScriptsGeneration scriptsGeneration = new RanorexScriptsGeneration();
pair = scriptsGeneration.Generate(
screensExpanded,
projectTempFolder,
null,
null,
appPath,
PROJECT_NAME + REPOSITORY,
PROJECT_NAME,
INSTANCE,
myLog,
"repo");
if (pair == null)
{
myLog.Error("An error occured when generating C# scripts");
return(false);
}
}
RanorexSolutionGeneration gen = new RanorexSolutionGeneration();
bool rGenCheck = gen.Generate(repoFilePath, folderOutPath, tempFolderPath, projectTempFolder,
pair?.Item1,
pair?.Item2,
appPath,
myLog);
if (!rGenCheck)
{
myLog.Error("An error occured when generating Ranorex project");
return(false);
}
return(true);
}
public bool Generate(List <IElement> listRootElements, List <SpecScreen> screensExpanded,
string folderOutPath, string projectName, string appPath, MyLog myLog)
{
string tempFolderPath = Utils.CreateTempFolder(projectName + "_" +
DateTime.Now.ToString("yyMMdd_HHmmss"));
// generate CSharp code
ElementCSharpCodeGeneration elementCSharpCodeGeneration = new ElementCSharpCodeGeneration();
string repoClassName = projectName + DEFINITION;
FileInfo csFile = elementCSharpCodeGeneration.Generate(
listRootElements, tempFolderPath, repoClassName, projectName);
if (csFile == null)
{
myLog.Error("An error occured when generating C# codes");
return(false);
}
// generate .xml file(s)
ElementXmlGeneration elementXmlGeneration = new ElementXmlGeneration();
string repoFileName = projectName + REPO;
string imgCapFileName = projectName + IMAGE_CAPTURE;
List <FileInfo> listXmlFile = elementXmlGeneration.Store(listRootElements,
Path.Combine(tempFolderPath, repoFileName),
Path.Combine(tempFolderPath, imgCapFileName));
if (listXmlFile == null)
{
myLog.Error("An error occured when generating .xml files");
return(false);
}
// generate scripts
Tuple <Dictionary <string, string>, List <string> > pair = null;
if (screensExpanded != null && screensExpanded.Count > 0)
{
CSharpScriptsGeneration scriptsGeneration = new CSharpScriptsGeneration();
pair = scriptsGeneration.Generate(
screensExpanded,
tempFolderPath,
repoFileName,
imgCapFileName,
appPath,
repoClassName,
projectName,
INSTANCE,
myLog);
if (pair == null)
{
myLog.Error("An error occured when generating C# scripts");
return(false);
}
}
// generate visual studio solution
List <FileInfo> listFiles = new List <FileInfo>();
listFiles.Add(csFile);
listFiles.AddRange(listXmlFile);
//generate text file contain all running class
if (pair != null)
{
File.WriteAllText(Path.Combine(tempFolderPath, RUNNING_TEST_FILE_NAME),
string.Join(CSharpScriptsGeneration.NEW_LINE, pair.Item1));
pair.Item2.Add(RUNNING_TEST_FILE_NAME);
}
VsSolutionGeneration gen = new VsSolutionGeneration();
bool vsGenCheck = gen.Generate(listFiles, projectName, folderOutPath,
// read from user's settings
Properties.Settings.Default.path_GUI_Testing_Automation_ref,
Properties.Settings.Default.path_to_vstemplate_output_proj,
tempFolderPath,
pair?.Item1,
pair?.Item2,
appPath);
if (!vsGenCheck)
{
myLog.Error("An error occured when generating Visual Studio project");
return(false);
}
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="filePath"></param>
/// <param name="elementsAndIndicator">indication to determine root elements or list of all elements</param>
/// <param name="myLog"></param>
/// <returns></returns>
private List <SpecScreen> DoParse(string filePath, ListUIElements elementsAndIndicator, MyLog myLog)
{
string newFilePath = Utils.CreateTempFile(filePath);
//Create COM Objects. Create a COM object for everything that is referenced
Excel.Application xlApp = new Excel.Application();
Excel.Workbook xlWorkbook = xlApp.Workbooks.Open(newFilePath);
//Excel._Worksheet xlWorksheet = xlWorkbook.Sheets[1];
List <AbstractSheet> listAbstractSheets = new List <AbstractSheet>();
for (int fi = 1; fi <= xlWorkbook.Sheets.Count; fi++)
{
Excel._Worksheet sheet = xlWorkbook.Sheets[fi];
string name = sheet.Name;
AbstractSheet abstractSheet = null;
foreach (Tuple <string, string> pairSheetNameRule in SHEET_NAME_TEMPLATE_LIST)
{
Regex regex = new Regex(pairSheetNameRule.Item1);
MatchCollection matches = regex.Matches(name);
if (matches.Count > 0)
{
string featureName = matches[0].Groups[1].Value;
abstractSheet = new TestSpecificationSheet(featureName, sheet);
}
else
{
Regex regex2 = new Regex(pairSheetNameRule.Item2);
MatchCollection matches2 = regex2.Matches(name);
if (matches2.Count > 0)
{
string featureName = matches2[0].Groups[1].Value;
abstractSheet = new FunctionDescriptionSheet(featureName, sheet);
}
}
}
if (abstractSheet == null)
{
abstractSheet = new NormalSheet(name, sheet);
}
listAbstractSheets.Add(abstractSheet);
}
List <NormalSheet> normalSheets = new List <NormalSheet>();
List <Tuple <TestSpecificationSheet, FunctionDescriptionSheet> > pairSheets =
new List <Tuple <TestSpecificationSheet, FunctionDescriptionSheet> >();
foreach (AbstractSheet abstractSheet in listAbstractSheets)
{
if (abstractSheet is NormalSheet)
{
normalSheets.Add((NormalSheet)abstractSheet);
}
else if (abstractSheet is TestSpecificationSheet)
{
FunctionDescriptionSheet funcDescSheet =
findFuncDesc(abstractSheet.getFeatureName(), listAbstractSheets);
pairSheets.Add(new Tuple <TestSpecificationSheet, FunctionDescriptionSheet>(
(TestSpecificationSheet)abstractSheet, funcDescSheet));
}
}
List <SpecScreen> screenList = new List <SpecScreen>();
foreach (Tuple <TestSpecificationSheet, FunctionDescriptionSheet> pairSheet in pairSheets)
{
SpecScreen screen = parsePairSheet(pairSheet, elementsAndIndicator, myLog);
if (screen != null)
{
screenList.Add(screen);
}
}
foreach (NormalSheet normalSheet in normalSheets)
{
SpecScreen screen = parseNormalSheet(normalSheet, elementsAndIndicator, myLog);
if (screen != null)
{
screenList.Add(screen);
}
}
//return screenList;
//cleanup
//GC.Collect();
//GC.WaitForPendingFinalizers();
//rule of thumb for releasing com objects:
// never use two dots, all COM objects must be referenced and released individually
// ex: [somthing].[something].[something] is bad
//close and release
xlWorkbook.Close(false);
Marshal.ReleaseComObject(xlWorkbook);
//quit and release
xlApp.Quit();
Marshal.ReleaseComObject(xlApp);
return(screenList);
}
/// <summary>
///
/// </summary>
/// <param name="filePath"></param>
/// <param name="allElements">a list of all ui elements</param>
/// <param name="myLog"></param>
public List <SpecScreen> ParseWithListAllElements(string filePath, List <IElement> allElements, MyLog myLog)
{
//handleSheetsType(
return(DoParse(filePath, //myLog,
new ListUIElements(ListElementsIndicator.AllElements, allElements), myLog));
}
/// <summary>
///
/// </summary>
/// <param name="filePath"></param>
/// <param name="rootElements">all root elements (not contain children)</param>
/// <param name="myLog"></param>
public List <SpecScreen> ParseWithRootElements(string filePath, List <IElement> rootElements, MyLog myLog)
{
//handleSheetsType(
return(DoParse(filePath, //myLog),
new ListUIElements(ListElementsIndicator.OnlyRootElements, rootElements), myLog));
}
/// <summary>
/// only retrieve MapClassAndFuncsAddition
/// </summary>
/// <param name="listUcScriptsExp"></param>
private List <string> GenerateAdditionScripts(List <UserCodeScriptsExpression> listUcScriptsExp, string projectPath, string name_space,
ListUIElements listUIElements, Dictionary <string, string> mapAliasWithNode, MyLog myLog, string instanceName)
{
Dictionary <string, List <FunctionExpression> > mapClassFunc = new Dictionary <string, List <FunctionExpression> >();
foreach (var ucScriptsExp in listUcScriptsExp)
{
var newMapClassFunc = ucScriptsExp.MapClassAndFuncsAddition;
foreach (var pair in newMapClassFunc)
{
if (mapClassFunc.ContainsKey(pair.Key))
{
mapClassFunc[pair.Key].AddRange(pair.Value);
}
else
{
mapClassFunc.Add(pair.Key, pair.Value);
}
}
}
return(GenerateAdditionScripts(mapClassFunc, projectPath, name_space, listUIElements, mapAliasWithNode, myLog, instanceName));
}
public static string ParamExp2String(string param, ListUIElements listUIElements,
Dictionary <string, string> mapAliasWithNode, MyLog myLog, string instanceName, ScriptType scriptType)
{
string tempParamExp = "";
// Variable_ControlCPUStatus
if (Regex.IsMatch(param, USER_CODE_WITH_VARIABLE_DECLARE))
{
tempParamExp += param;
}
// Text Box One.Text
else
{
tempParamExp += Node2ParamExp(param, listUIElements, mapAliasWithNode, myLog, instanceName, scriptType);
}
return(tempParamExp);
}
/// <summary>
///
/// </summary>
/// <param name="mapClassFunc">(classname, list of functions)</param>
private List <string> GenerateAdditionScripts(Dictionary <string, List <FunctionExpression> > mapClassFunc, string projectPath,
string name_space, ListUIElements listUIElements, Dictionary <string, string> mapAliasWithNode, MyLog myLog, string instanceName)
{
List <string> listRelativeFilePath = new List <string>();
string fileContentTemplate = GetTemplateRunCsFileContent()
.Replace(NAMESPACE_REPLACE, name_space);
foreach (var pair in mapClassFunc)
{
string className = pair.Key;
List <FunctionExpression> listFunctions = pair.Value;
string functionsScripts = "";
foreach (FunctionExpression func in listFunctions)
{
if (functionsScripts != "")
{
functionsScripts += NEW_LINE;
}
functionsScripts += GenerateFunctionExpScripts(func, listUIElements, mapAliasWithNode, myLog, instanceName);
}
// create new file
string classContent = GetTemplateUCClassContent()
//.Replace(GLOBAL_REPLACE, "") modified by @duong 05/29
.Replace(CLASS_REPLACE, className)
.Replace(CONTENT_REPLACE, functionsScripts);
string filePath = Path.Combine("UserCode", className + ".cs");
listRelativeFilePath.Add(filePath);
CreateNewFile(fileContentTemplate, classContent, Path.Combine(projectPath, filePath));
}
return(listRelativeFilePath);
}
private void SetAttributes(SpecScenario scenario, AbstractSpecUserAction specUserAction, SpecNode specNode,
IScreen screen, string pathToApp, List <Color> colors, ScriptGenerationParams _params, int se, MyLog myLog)
{
// importance: must create on the same thread with UI thread
try
{
Application.Current.Dispatcher.Invoke((Action) delegate
{
specUserAction.BgColor = new System.Windows.Media.SolidColorBrush(
System.Windows.Media.Color.FromArgb(
255, colors[se].R, colors[se].G, colors[se].B));
});
}
catch (Exception)
{
specUserAction.BgColor = new System.Windows.Media.SolidColorBrush(
System.Windows.Media.Color.FromArgb(
255, colors[se].R, colors[se].G, colors[se].B));
}
_params.Color = colors[se];
_params.Id = scenario.Id;
_params.ListUIElements = screen.AllUIElements;
_params.MyLog = myLog;
_params.ScreenName = screen.Name;
_params.SpecNode = specNode;
_params.PathToApp = pathToApp;
specUserAction.Params = _params;
specUserAction.NodeAffect = specNode;
if (scenario.UserActions == null)
{
scenario.UserActions = new List <IUserAction>();
}
scenario.UserActions.Add(specUserAction);
}
/// <summary>
///
/// </summary>
/// <param name="classesExpression"></param>
/// <param name="projectPath"></param>
/// <param name="name_space"></param>
/// <param name="listUIElements"></param>
/// <param name="mapAliasWithNode"></param>
/// <param name="myLog"></param>
/// <param name="instanceName"></param>
/// <returns>a list of relative file path</returns>
private List <string> GenerateClassExpScripts(List <ClassExpression> classesExpression, string projectPath, string name_space,
ListUIElements listUIElements, Dictionary <string, string> mapAliasWithNode, MyLog myLog, string instanceName)
{
List <string> re = new List <string>();
foreach (ClassExpression classExp in classesExpression)
{
re.Add(GenerateClassExpScripts(classExp, projectPath, name_space, listUIElements, mapAliasWithNode, myLog, instanceName));
}
return(re);
}
/// <summary>
/// add pre-conditions to each screnario
/// </summary>
/// <param name="screen"></param>
/// <param name="mapNameAndScreens"></param>
/// <param name="myLog"></param>
private void AddPreCondition(SpecScreen screen, Dictionary <string, SpecScreen> mapNameAndScreens, MyLog myLog)
{
foreach (IScenario scenario in screen.Scenarios)
{
if (scenario is SpecScenario specScenario)
{
if (specScenario.PreConditionsExpression != null &&
specScenario.PreConditionsExpression.Count > 0)
{
foreach (string preConditionExp in specScenario.PreConditionsExpression)
{
if (preConditionExp == null || preConditionExp.Equals(""))
{
continue;
}
int idx = preConditionExp.LastIndexOf("_");
if (idx < 0)
{
myLog.Warn("Can not find the pre-condiction: " + preConditionExp);
}
else
{
string preScreen = preConditionExp.Substring(0, idx);
try
{
int preScenarioIdx = Int32.Parse(preConditionExp.Substring(idx + 1));
SpecScreen preConditionScreen = mapNameAndScreens[preScreen];
SpecScenario preConditonScenario = getScenarioByIndex(
preScenarioIdx, preConditionScreen.Scenarios);
if (preConditionScreen == null ||
preScenarioIdx > preConditionScreen.Scenarios.Count ||
preConditonScenario == null)
{
myLog.Warn("Can not find the pre-condiction: " + preConditionExp);
}
else
{
specScenario.PreConditions.Add(preConditonScenario);
}
}
catch (FormatException e)
{
myLog.Warn("Invalid pre-condiction: " + preConditionExp);
}
}
}
}
}
else
{
myLog.Warn("Not implement this type");
}
}
}
/// <summary>
/// scripts content for a function
/// </summary>
/// <param name="functionExpression"></param>
/// <param name="listUIElements"></param>
/// <param name="mapAliasWithNode"></param>
/// <param name="myLog"></param>
/// <param name="instanceName"></param>
/// <returns></returns>
private string GenerateFunctionExpScripts(FunctionExpression functionExpression, ListUIElements listUIElements,
Dictionary <string, string> mapAliasWithNode, MyLog myLog, string instanceName)
{
string accessibility = functionExpression.GetCorrectAccessibility();
string summary = functionExpression.getSummary();
List <ParameterExpression> @params = functionExpression.getParams();
string name = functionExpression.getName();
string returnDes = functionExpression.getReturnDescription();
string content = functionExpression.getContent();
string re = "";
if (summary != null)
{
re += "/// <summary>" + NEW_LINE;
string[] listLines = summary.Split('\n');
foreach (string line in listLines)
{
re += "/// " + line + NEW_LINE;
}
re += "/// </summary>";
}
var pair = GetParamsScripts(@params, listUIElements, mapAliasWithNode, myLog, instanceName);
if (pair.Item2 != null && pair.Item2.Count > 0)
{
for (int fi = 0; fi < pair.Item2.Count; fi++)
{
string paramName = pair.Item2[fi];
string paramDesc = @params[fi].getDescription();
if (paramDesc == null)
{
paramDesc = "";
}
if (re != "")
{
re += NEW_LINE;
}
re += "/// <param name=\"" + paramName + "\">" + paramDesc + "</param>";
}
}
string returnType = functionExpression.GetCorrectReturnType();
if (returnType != FunctionExpression.VOID)
{
if (re != "")
{
re += NEW_LINE;
}
re += "/// <returns>" + (returnDes ?? "") + "</returns>";
}
if (re != "")
{
re += NEW_LINE;
}
// Ranorex need to insert annotation
re += InsertAnnotation();
re += accessibility + " static " + returnType + " " + name + "(";
re += pair.Item1;
re += ")" + NEW_LINE;
re += "{" + NEW_LINE;
if (content != null)
{
string[] listLines = content.Split('\n');
foreach (string line in listLines)
{
string line1 = line.Trim().StartsWith("//") ? line.Trim() : "// " + line.Trim();
re += line1 + NEW_LINE;
}
}
if (returnType != FunctionExpression.VOID)
{
re += "return null;" + NEW_LINE;
}
re += "}" + NEW_LINE;
return(re);
}
/// <summary>
/// type expression
/// </summary>
/// <param name="actionEpx"></param>
/// <param name="specNode"></param>
/// <param name="color"></param>
/// <param name="myLog"></param>
/// <returns></returns>
private AbstractSpecUserAction handleUserActionExpression(String actionEpx,
SpecNode specNode,
Color color,
MyLog myLog)
{
if (actionEpx == null || actionEpx.Equals("") ||
actionEpx.Equals(AbstractSpecUserAction.NA) ||
actionEpx.Equals(AbstractSpecUserAction.DO_NOTHING) ||
actionEpx.Equals(AbstractSpecUserAction.EMPTY) ||
color.Equals(AbstractSpecUserAction.NOT_TEST_COLOR1) ||
color.Equals(AbstractSpecUserAction.NOT_TEST_COLOR2)) // ||
// color.Equals(AbstractSpecUserAction.NOT_TEST_COLOR3))
{
return(null);
}
/**
* determine if delay, wait, keyboard press
*/
if (specNode.UIElement == null)
{
// delay
if (Regex.IsMatch(specNode.Expression, AbstractSpecUserAction.DELAY_TITLE_EXPRESSION))
{
DelaySpecUserAction delaySpecUserAction = new DelaySpecUserAction();
delaySpecUserAction.Expression = actionEpx;
return(delaySpecUserAction);
}
// wait
else if (Regex.IsMatch(specNode.Expression, AbstractSpecUserAction.PRE_WAIT + "(_\\d*)*"))
{
PreWaitValidateSpecUserAction waitValidateSpecUserAction = new PreWaitValidateSpecUserAction();
waitValidateSpecUserAction.Expression = actionEpx;
return(waitValidateSpecUserAction);
}
else if (Regex.IsMatch(specNode.Expression, AbstractSpecUserAction.POST_WAIT + "(_\\d*)*"))
{
PostWaitValidateSpecUserAction waitValidateSpecUserAction = new PostWaitValidateSpecUserAction();
waitValidateSpecUserAction.Expression = actionEpx;
return(waitValidateSpecUserAction);
}
//keyboard press
else if (Regex.IsMatch(specNode.Expression, AbstractSpecUserAction.KEYBOARD_PRESS_REGEX))
{
KeyboardSpecUserAction keyboardPressSpecUserAction = new KeyboardSpecUserAction();
keyboardPressSpecUserAction.Expression = actionEpx;
return(keyboardPressSpecUserAction);
}
//test - not test
else if (Regex.IsMatch(specNode.Expression, AbstractSpecUserAction.RESULT))
{
return(null);
}
// usercode
else if (Regex.IsMatch(specNode.Expression, AbstractSpecUserAction.USER_CODE) ||
Regex.IsMatch(specNode.Expression, AbstractSpecUserAction.USER_CODE_WITH_VARIABLE_DECLARE))
{
UserCodeSpecUserAction userCodeExpression = new UserCodeSpecUserAction();
userCodeExpression.Expression = actionEpx;
return(userCodeExpression);
}
}
AbstractSpecUserAction specUserAction = null;
string attribute = specNode.Attribute;
if (actionEpx.Equals(AbstractSpecUserAction.OPEN))
{
specUserAction = new OpenAppSpecUserAction();
}
else if (actionEpx.Equals(AbstractSpecUserAction.CLOSE))
{
specUserAction = new CloseAppSpecUserAction();
}
else if (actionEpx.StartsWith(AbstractSpecUserAction.CLICK))
{
specUserAction = new ClickSpecUserAction();
}
else if (actionEpx.StartsWith(AbstractSpecUserAction.DOUBLE_CLICK))
{
specUserAction = new DoubleClickSpecUserAction();
}
else if (actionEpx.StartsWith(AbstractSpecUserAction.RIGHT_CLICK))
{
specUserAction = new RightClickSpecUserAction();
}
else if (actionEpx.StartsWith(AbstractSpecUserAction.WAIT_EXIST) ||
actionEpx.StartsWith(AbstractSpecUserAction.WAIT_NOT_EXIST))
{
specUserAction = new WaitExistSpecUserAction();
}
else if (actionEpx.StartsWith(AbstractSpecUserAction.EXIST) ||
actionEpx.StartsWith(AbstractSpecUserAction.NOT_EXIST))
{
specUserAction = new CheckExistSpecUserAction();
}
else if (actionEpx.StartsWith(AbstractSpecUserAction.DELAY))
{
specUserAction = new DelaySpecUserAction();
}
else if (actionEpx.StartsWith(AbstractSpecUserAction.GET))
{
specUserAction = new GetSpecUserAction();
}
else if (actionEpx.StartsWith(AbstractSpecUserAction.CAPTURE))
{
specUserAction = new CaptureSpecUserAction();
}
else if (actionEpx.StartsWith(AbstractSpecUserAction.DROP))
{
specUserAction = new DropSpecUserAction();
}
//else if (actionEpx.StartsWith(AbstractSpecUserAction.COMPARE_IMAGE))
//{
// specUserAction = new ImageComparativeSpecUserAction();
// specUserAction.Expression = actionEpx;
//}
else if (actionEpx.StartsWith(AbstractSpecUserAction.ATTRIBUTE_CONTAIN) ||
actionEpx.StartsWith(AbstractSpecUserAction.ATTRIBUTE_NOT_CONTAIN))
{
specUserAction = new ContainSpecUserAction();
}
else if (color.Equals(AbstractSpecUserAction.VALIDATION_COLOR) ||
color.Equals(AbstractSpecUserAction.ENVIRONMENT_COLOR))
{
specUserAction = new ValidationSpecUserAction();
}
else if (color.Equals(AbstractSpecUserAction.PROCEDURES_COLOR) ||
color.Equals(AbstractSpecUserAction.PRE_CONDITION_COLOR))
{
if (attribute != null && !attribute.Equals("") &&
(Regex.IsMatch(attribute, "^\\w+$") ||
Regex.IsMatch(attribute, ".*\\..*")))
{
specUserAction = new SetSpecUserAction();
}
else if (attribute == null || attribute.Equals("") ||
Regex.IsMatch(attribute, "Cell\\s*\\((\\d+?),\\s*(\\d+?)\\)") ||
Regex.IsMatch(attribute, "Row\\s*\\((\\d+?)\\)"))
{
specUserAction = new PressSpecUserAction();
}
}
// add new case to handle here
else
{
myLog.Warn("Incorrect expression: " + actionEpx);
}
if (specUserAction != null)
{
specUserAction.Expression = actionEpx;
}
return(specUserAction);
}
protected override void GenerateOthers(MyLog myLog, string folderPath, string repoFilePath, string imageCapFilePath,
string appFilePath, string classRepoName, string name_space, string mainClassInstance, string instanceName,
Dictionary <string, string> mapFilePathAndId, List <string> otherFilePath)
{
// do nothing
}
/// <summary>
///
/// </summary>
/// <param name="pairSheet"></param>
/// <param name="elementsAndIndicator">indication to determine root elements or list of all elements</param>
/// <param name="myLog"></param>
/// <returns></returns>
private TestSpecificationScreen parsePairSheet(Tuple <TestSpecificationSheet, FunctionDescriptionSheet> pairSheet,
ListUIElements elementsAndIndicator, MyLog myLog)
{
FunctionSheetParser functionSheetParser = new FunctionSheetParser();
List <ClassExpression> classExpressions = functionSheetParser.parse(pairSheet.Item2, myLog);
TestSpecSheetParser testSpecSheetParser = new TestSpecSheetParser();
return(testSpecSheetParser.parse(pairSheet.Item1, elementsAndIndicator, myLog, classExpressions));
}
