/// <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 SpecScreen Clone()
{
logger.Info("SpecScreen thread: " + System.Threading.Thread.CurrentThread.ManagedThreadId);
SpecScreen re = new SpecScreen();
if (mappingAliasWithNode != null)
{
re.MappingAliasWithNode = new Dictionary <string, string>(mappingAliasWithNode);
}
if (listSpecNodes != null)
{
re.ListSpecNodes = new List <SpecNode>();
foreach (var specNode in listSpecNodes)
{
re.ListSpecNodes.Add(specNode.Clone() as SpecNode);
}
}
if (listValidationUserCode != null)
{
re.ListValidationUserCode = new List <Tuple <int, int> >(listValidationUserCode);
}
CopyAttributes(this, re);
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>
/// generate user code, main file, etc
/// </summary>
/// <param name="additionScripts"></param>
/// <param name="additionClasses"></param>
/// <param name="aScreen"></param>
/// <param name="myLog"></param>
/// <param name="folderPath"></param>
/// <param name="repoFilePath"></param>
/// <param name="imageCapFilePath"></param>
/// <param name="appFilePath"></param>
/// <param name="classRepoName"></param>
/// <param name="name_space"></param>
/// <param name="mainClassInstance"></param>
/// <param name="instanceName"></param>
/// <param name="runningFilePath"></param>
/// <returns></returns>
protected List <string> GenerateAdditionClassses(List <UserCodeScriptsExpression> additionScripts, List <ClassExpression> additionClasses,
SpecScreen aScreen, 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 = new List <string>();
otherFilePath.AddRange(GenerateAdditionScripts(additionScripts, folderPath, name_space, aScreen.AllUIElements,
aScreen.MappingAliasWithNode, myLog, instanceName));
otherFilePath.AddRange(GenerateClassExpScripts(additionClasses, folderPath, name_space, aScreen.AllUIElements,
aScreen.MappingAliasWithNode, myLog, instanceName));
GenerateOthers(myLog, folderPath, repoFilePath, imageCapFilePath, appFilePath, classRepoName, name_space,
mainClassInstance, instanceName, mapFilePathAndId, otherFilePath);
return(otherFilePath);
}
public TestSpecificationScreen parse(TestSpecificationSheet testSpecSheet,
ListUIElements elementsAndIndicator, MyLog myLog, List <ClassExpression> classExpressions)
{
NormalSheetParser normalSheetParser = new NormalSheetParser();
SpecScreen screen = normalSheetParser.Parse(testSpecSheet, elementsAndIndicator, myLog);
if (screen == null)
{
return(null);
}
TestSpecificationScreen re = new TestSpecificationScreen();
re.AllUIElements = elementsAndIndicator;
re.ListSpecNodes = screen.ListSpecNodes;
re.ListValidationUserCode = screen.ListValidationUserCode;
re.MappingAliasWithNode = screen.MappingAliasWithNode;
re.Name = testSpecSheet.getFeatureName();
re.Scenarios = screen.Scenarios;
re.ClassExpressions = classExpressions;
return(re);
}
/// <summary>
/// process for a screen
/// </summary>
/// <param name="specScreen"></param>
/// <param name="aScreen"></param>
/// <param name="runningFilePath"></param>
/// <param name="additionScrips"></param>
/// <param name="additionClasses"></param>
/// <param name="folderPath"></param>
/// <param name="repoFilePath"></param>
/// <param name="imageCapFilePath"></param>
/// <param name="appFilePath"></param>
/// <param name="classRepoName"></param>
/// <param name="name_space"></param>
/// <param name="mainClassInstance"></param>
/// <param name="myLog"></param>
/// <param name="instanceName"></param>
public void ProcessScreen(SpecScreen specScreen, Dictionary <string, string> mapFilePathAndId,
List <UserCodeScriptsExpression> additionScrips, List <ClassExpression> additionClasses,
string folderPath, string repoFilePath, string imageCapFilePath, string appFilePath, string classRepoName,
string name_space, string mainClassInstance, MyLog myLog, string instanceName = INSTANCE_NAME)
{
//Dictionary<string, string> mapFilePathAndId = new Dictionary<string, string>();
//List<string> listFilePath = new List<string>();
foreach (IScenario scenario in specScreen.Scenarios)
{
if (scenario is SpecScenario specScenario)
{
HandleWaitActions(specScenario);
Tuple <string, List <UserCodeScriptsExpression> > pair = GenerateAScenario(specScenario, myLog, instanceName);
if (pair == null)
{
continue;
}
var fileAndGuid = CreateNewRunCsFile(pair.Item1, pair.Item2,
folderPath, specScreen.Name, repoFilePath, imageCapFilePath,
appFilePath, classRepoName, name_space, specScenario.Id, mainClassInstance, instanceName);
string filePath = fileAndGuid.Item1;
string guid = fileAndGuid.Item2;
mapFilePathAndId.Add(filePath, guid);
if (pair.Item2 != null && pair.Item2.Count > 0)
{
Utils.MergeUcScriptsEpx(additionScrips, pair.Item2);
additionScrips.AddRange(pair.Item2);
}
}
else
{
logger.Error("Not handled yet");
}
}
//runningFilePath.AddRange(listFilePath);
if (specScreen is TestSpecificationScreen testSpecScreen)
{
Utils.MergeClassesExpression(additionClasses, testSpecScreen.ClassExpressions);
}
}
/// <summary>
///
/// </summary>
/// <param name="sheet"></param>
/// <param name="elementsAndIndicator">indication to determine root elements or list of all elements</param>
/// <param name="myLog"></param>
/// <returns></returns>
private SpecScreen parserOneSheet(Excel._Worksheet sheet,
ListUIElements elementsAndIndicator,
MyLog myLog)
{
Excel.Range xlRange = sheet.UsedRange;
int rowCount = xlRange.Rows.Count;
int columnCount = xlRange.Columns.Count;
SpecScreen screen = new SpecScreen();
// get mapping alias
Dictionary <string, string> mapAliasWithNode = getMappingAlias(sheet, rowCount, columnCount);
screen.MappingAliasWithNode = mapAliasWithNode;
/**
* read first row to get all element Nodes
*/
//Row firstRow = sheet.getRow(ROW_TITLE_TESTCASE);
string no = getCellValue(sheet, ROW_TITLE_TESTCASE, 1);
//if (searchElement(no, null, allUIElements) == null && !no.Equals(NO, stringComparison.OrdinalIgnoreCase))
//{
// logWarnings.add("First column must numbered column!");
// logger.error("First column must numbered column!");
//}
List <SpecNode> listSpecNodes = new List <SpecNode>();
// <start, end>-s
List <Tuple <int, int> > listValidationUsercode = new List <Tuple <int, int> >();
// get each node element
//int lastColumn = firstRow.getLastCellNum();
bool link = false;
int startColumnIdx = 2;
for (int fi = startColumnIdx; fi <= columnCount; fi++)
{
string value = getCellValue(sheet, ROW_TITLE_TESTCASE, fi);
if (value == null || value.Trim().Equals(""))
{
if (checkLastColumn(sheet, fi, rowCount))
{
columnCount = fi - 1;
break;
}
else
{
if (listValidationUsercode.Count == 0)
{
listValidationUsercode.Add(new Tuple <int, int>(fi - 1 - startColumnIdx, fi - startColumnIdx));
}
else
{
Tuple <int, int> lastPair = listValidationUsercode[listValidationUsercode.Count - 1];
if ((fi - lastPair.Item2 - startColumnIdx) == 1)
{
listValidationUsercode.RemoveAt(listValidationUsercode.Count - 1);
listValidationUsercode.Add(new Tuple <int, int>(lastPair.Item1, fi - startColumnIdx));
}
else
{
listValidationUsercode.Add(new Tuple <int, int>(fi - 1 - startColumnIdx, fi - startColumnIdx));
}
}
listSpecNodes.Add(listSpecNodes.Last());
}
}
else
{
if (Regex.IsMatch(value, AbstractSpecUserAction.LINKS))
{
columnCount = fi - 1;
link = true;
break;
}
else
{
SpecNode specNode = parseNode(value, elementsAndIndicator, mapAliasWithNode, myLog);
if (specNode == null)
{
return(null);
}
listSpecNodes.Add(specNode);
}
}
}
screen.Name = sheet.Name;
screen.AllUIElements = elementsAndIndicator;
screen.ListSpecNodes = listSpecNodes;
screen.ListValidationUserCode = listValidationUsercode;
/**
* parseOneFile each scenario
*/
for (int fi = ROW_TITLE_TESTCASE + 1; fi <= rowCount; fi++)
{
//Row row = sheet.getRow(fi);
bool isRowNotTest = true;
if (getCellValue(sheet, fi, 1) == null || getCellValue(sheet, fi, 2) == null)
{
rowCount = fi - 1;
break;
}
SpecScenario scenario = new SpecScenario();
for (int se = 2; se <= columnCount; se++)
{
Color color = Color.Empty;
string value = getCellValue(sheet, fi, se);
/**
* check if result indicate 'not_test'
*/
if (listSpecNodes[se - 2].Expression.Equals(AbstractSpecUserAction.RESULT))
{
if (value.Equals(AbstractSpecUserAction.NOT_TEST))
{
isRowNotTest = true;
break;
}
else if (value.Equals(AbstractSpecUserAction.TEST) || value.Equals(""))
{
;
}
else
{
myLog.Warn("[WARNING] Result must be 'Test' or 'Not Test', not " + value +
", it will be treated as 'Test' by default", logger);
}
}
color = getCellBgColor(sheet, fi, se);
if (color.Equals(Color.Empty) || (
!color.Equals(AbstractSpecUserAction.NOT_TEST_COLOR1) &&
!color.Equals(AbstractSpecUserAction.NOT_TEST_COLOR2)))
{
isRowNotTest = false;
}
scenario.UserActionsInString.Add(value);
scenario.Colors.Add(color);
}
if (isRowNotTest)
{
continue;
}
/**
* pre-condition
*/
string linkExpress = "";
string lastCellValue = getCellValue(sheet, fi, columnCount + 1);
if (link && lastCellValue != null && !lastCellValue.Equals(""))
{
linkExpress = lastCellValue;
string[] preConsExp = linkExpress.Split(',');
foreach (string preConExp in preConsExp)
{
scenario.PreConditionsExpression.Add(preConExp.Trim());
}
}
scenario.Id = fi - ROW_TITLE_TESTCASE;
//scenario.ScreenName = screen.Name;
if (screen.Scenarios == null)
{
screen.Scenarios = new List <IScenario>();
}
screen.Scenarios.Add(scenario);
}
//release com objects to fully kill excel process from running in the background
Marshal.ReleaseComObject(xlRange);
Marshal.ReleaseComObject(sheet);
return(screen);
}
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>
///
/// </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);
}
