public static void CodeTransmit_Action_DataSet(Case.BasicTestCase refTestCase, CodeLine activeSelectLine)
{
if (refTestCase != null && activeSelectLine.KeyCode == Container.KeyWordMap.DataSet)
{
if (!activeSelectLine.ParamsPool.ContainsKey("dataname"))
{
refTestCase.SingleInterrupt = true;
refTestCase.ActiveTestCaseReport.InsertFaildItem(activeSelectLine.CodeIndex, "Fail to transmit : Data Set : missing dataname.", true);
return;
}
else
{
if (!activeSelectLine.ParamsPool.ContainsKey("value"))
{
refTestCase.SingleInterrupt = true;
refTestCase.ActiveTestCaseReport.InsertFaildItem(activeSelectLine.CodeIndex, "Fail to transmit : Data Set : missing data value.", true);
return;
}
else
{
string dataName = activeSelectLine.ParamsPool["dataname"];
string dataValue = activeSelectLine.ParamsPool["value"];
if (refTestCase.ActiveDataBuffer.ContainsKey(dataName))
refTestCase.ActiveDataBuffer[dataName] = dataValue;
else
refTestCase.ActiveDataBuffer.Add(dataName, dataValue);
}
}
}
}
public static void CodeTransmit_Action_ImportDB(Case.BasicTestCase refTestCase, CodeLine activeSelectLine)
{
if (refTestCase != null && activeSelectLine.KeyCode == Container.KeyWordMap.ImportDB)
{
if (activeSelectLine.ParamsPool.ContainsKey("name") && activeSelectLine.ParamsPool.ContainsKey("server") && activeSelectLine.ParamsPool.ContainsKey("table") && activeSelectLine.ParamsPool.ContainsKey("db") && activeSelectLine.ParamsPool.ContainsKey("uid") && activeSelectLine.ParamsPool.ContainsKey("pwd"))
{
try
{
string sourceName = activeSelectLine.ParamsPool["name"];
string server = activeSelectLine.ParamsPool["server"];
string db = activeSelectLine.ParamsPool["db"];
string uid = activeSelectLine.ParamsPool["uid"];
string pwd = activeSelectLine.ParamsPool["pwd"];
string table = activeSelectLine.ParamsPool["table"];
Buffalo.Basic.Data.Data_SqlConnectionHelper _ConnectionObj = new Basic.Data.Data_SqlConnectionHelper();
_ConnectionObj.Set_NewConnectionItem(sourceName, server, uid, pwd, db);
Buffalo.Basic.Data.Data_SqlDataHelper _SqlDataHelper = new Basic.Data.Data_SqlDataHelper();
_SqlDataHelper.ActiveConnection = _ConnectionObj.Get_ActiveConnection(sourceName);
DataTable activeDataTable = new DataTable();
_SqlDataHelper.Action_ExecuteForDT("select * from " + table, out activeDataTable);
XmlDocument sourceDataDoc = new XmlDocument();
sourceDataDoc.LoadXml("<root></root>");
List<string> columnNameList = new List<string>();
foreach (DataColumn dc in activeDataTable.Columns)
{
columnNameList.Add(dc.ColumnName);
}
int rowIndex = 1;
foreach (DataRow dr in activeDataTable.Rows)
{
XmlNode newRowItem = Buffalo.Basic.Data.XmlHelper.CreateNode(sourceDataDoc, "row", "");
Buffalo.Basic.Data.XmlHelper.SetAttribute(newRowItem, "index", rowIndex.ToString());
foreach (string columnName in columnNameList)
{
string result = "";
_SqlDataHelper.Static_GetColumnData(dr, columnName, out result);
Buffalo.Basic.Data.XmlHelper.SetAttribute(newRowItem, "column_" + columnName, result);
}
sourceDataDoc.SelectSingleNode("/root").AppendChild(newRowItem);
}
}
catch (Exception err)
{
refTestCase.SingleInterrupt = true;
refTestCase.ActiveTestCaseReport.InsertFaildItem(activeSelectLine.CodeIndex, "Fail to transmit : Import DB : " + err.Message, true);
}
}
else
{
refTestCase.SingleInterrupt = true;
refTestCase.ActiveTestCaseReport.InsertFaildItem(activeSelectLine.CodeIndex, "Fail to transmit : Import DB : invalidate word.", true);
}
}
}
public void Get_Content_Store(Case.BasicTestCase refTestCase, string DataPonitName)
{
string value = _selectedElementItem.refElement.Text;
if (refTestCase.ActiveDataBuffer.ContainsKey(DataPonitName))
{
refTestCase.ActiveDataBuffer[DataPonitName] = value;
}
else
{
refTestCase.ActiveDataBuffer.Add(DataPonitName, value);
}
}
public static void CodeTransmit_Action_ImportExcel(Case.BasicTestCase refTestCase, CodeLine activeSelectLine)
{
if (refTestCase != null && activeSelectLine.KeyCode == Container.KeyWordMap.ImportExcel)
{
if (activeSelectLine.ParamsPool.ContainsKey("name") && activeSelectLine.ParamsPool.ContainsKey("excel") && activeSelectLine.ParamsPool.ContainsKey("sheet") && activeSelectLine.ParamsPool.ContainsKey("rows") && activeSelectLine.ParamsPool.ContainsKey("columns"))
{
try
{
string sourceName = activeSelectLine.ParamsPool["name"];
Buffalo.Basic.Data.ExcelConnectionHelper _ConnectionObj = new Basic.Data.ExcelConnectionHelper();
string guid = Guid.NewGuid().ToString();
_ConnectionObj.AddNewExcelConnection(guid, activeSelectLine.ParamsPool["excel"], Basic.Data.ExcelConnectionType.NPOI, false);
Buffalo.Basic.Data.ExcelConnection_NPIO activeExcelConnection = (Buffalo.Basic.Data.ExcelConnection_NPIO)_ConnectionObj.GetConnection(guid);
string str_maxRow = activeSelectLine.ParamsPool["rows"];
string str_maxColumn = activeSelectLine.ParamsPool["columns"];
int i_maxRow = 0;
int i_maxColumn = 0;
Int32.TryParse(str_maxRow, out i_maxRow);
Int32.TryParse(str_maxColumn, out i_maxColumn);
XmlDocument sourceDataDoc = new XmlDocument();
sourceDataDoc.LoadXml("<root></root>");
for (int i = 1; i <= i_maxRow; i++)
{
XmlNode rowNode = Buffalo.Basic.Data.XmlHelper.CreateNode(sourceDataDoc, "row", "");
Buffalo.Basic.Data.XmlHelper.SetAttribute(rowNode, "index", i.ToString());
for (int y = 1; y <= i_maxColumn; y++)
{
string value = activeExcelConnection.GetCellValue(activeSelectLine.ParamsPool["sheet"], i, y);
Buffalo.Basic.Data.XmlHelper.SetAttribute(rowNode, "column_" + y, value);
}
sourceDataDoc.SelectSingleNode("/root").AppendChild(rowNode);
}
if (!refTestCase.ActiveCaseDataSourcePool.ContainsKey(sourceName))
{
refTestCase.ActiveCaseDataSourcePool.Add(sourceName, sourceDataDoc);
}
else
{
refTestCase.ActiveCaseDataSourcePool[sourceName] = sourceDataDoc;
}
}
catch (Exception err)
{
refTestCase.SingleInterrupt = true;
refTestCase.ActiveTestCaseReport.InsertFaildItem(activeSelectLine.CodeIndex, "Fail to transmit : Import Excel : " + err.Message, true);
}
}
}
}
public static void CodeTransmit_Action_Case(Case.BasicTestCase refTestCase, CodeLine activeSelectLine)
{
if (activeSelectLine.KeyCode == Container.KeyWordMap.Case)
{
foreach (string paramName in activeSelectLine.ParamsPool.Keys)
{
switch (paramName)
{
case "casename":
refTestCase.CaseName = activeSelectLine.ParamsPool[paramName];
break;
}
}
}
}
public void Action_FetchConsoleMessage(object testCase)
{
while (true)
{
Case.BasicTestCase activeTestCase = (Case.BasicTestCase)testCase;
if (activeTestCase.ActiveTestCaseReport.reportMessageItems.Count > 0)
{
Case.CaseReportMessageItem activeItem = activeTestCase.ActiveTestCaseReport.reportMessageItems.Dequeue();
Console.WriteLine(">| Buffalo Core |< - >| " + activeItem.CodeIndex + ":" + activeItem.CodeMessage);
}
else
{
Thread.Sleep(500);
}
}
}
public void Action_InvokeTestCase()
{
while (true)
{
if (_RunningTaskPool.Count > 0)
{
Case.BasicTestCase activeCase = _RunningTaskPool.Dequeue();
if (activeCase != null)
{
Thread newThread = new Thread(new ParameterizedThreadStart(Action_CallExecuteTestCase));
_ExecuteThreadsPool.Add(newThread);
newThread.Start(activeCase);
}
}
Thread.Sleep(100);
}
}
public void Action_ExecuteTestCase(Case.BasicTestCase activeCase)
{
ElementActions.ElementItem activeSelectedElement = null;
for (int codeIndex = 1; codeIndex <= activeCase.CaseCodeLineCount; codeIndex++)
{
try
{
if (activeCase.ActiveCaseContentPool.ContainsKey(codeIndex))
{
activeSelectedElement = activeCase.ActiveCaseContentPool[codeIndex].ActiveElementItem;
continue;
}
else if (activeCase.ActiveCaseMethodPool.ContainsKey(codeIndex))
{
if (activeSelectedElement != null)
{
object[] consParams = new object[] { activeSelectedElement };
activeCase.ActiveCaseMethodPool[codeIndex].ActiveMethod.DoInvoke(consParams);
continue;
}
}
else if (activeCase.ActiveCaseWebBrowserPool.ContainsKey(codeIndex))
{
object[] conParam = new object[] { activeCase.ActiveWebBrowserDriverObject.ActiveWebDriver };
activeCase.ActiveCaseWebBrowserPool[codeIndex].ActiveMethod.DoInvoke(conParam);
continue;
}
else if (activeCase.ActiveCaseSelectorPool.ContainsKey(codeIndex))
{
object[] conParam = new object[] { activeCase.ActiveWebBrowserDriverObject.ActiveWebDriver };
activeCase.ActiveCaseSelectorPool[codeIndex].ActiveMethod.DoInvoke(conParam);
activeSelectedElement = (ElementActions.ElementItem)activeCase.ActiveCaseSelectorPool[codeIndex].ActiveMethod.MethodReturnValue;
continue;
}
}
catch
{
activeCase.ActiveTestCaseReport.InsertFaildItem(codeIndex, "Faild Execut : Code Line : " + codeIndex, true);
return;
}
}
activeCase.ActionWebBrowserActionsObject.Action_CloseAllWindow();
activeCase.ActionWebBrowserActionsObject.Action_Close();
}
public void Action_TransmitTask(string Code)
{
Buffalo.Core.CodeProcessor.CodeScaner _Obj_Scaner = new CodeProcessor.CodeScaner();
_Obj_Scaner.Action_Scan(Code);
Case.BasicTestCase testCase = new Case.BasicTestCase();
testCase.CaseName = "";
testCase.CaseCodeLineCount = _Obj_Scaner.CodePool.Count;
string idCase = Guid.NewGuid().ToString();
testCase.CaseID = idCase;
if (testCase.CaseName == "")
{
testCase.CaseName = Guid.NewGuid().ToString();
}
testCase.ActiveTestCaseReport = Case.CaseReport.CreateInstance(testCase.CaseName);
testCase.SingleInterrupt = false;
Thread newThreadFetchMessage = new Thread(new ParameterizedThreadStart(Action_FetchConsoleMessage));
_FetchMessageThreadsPool.Add(newThreadFetchMessage);
newThreadFetchMessage.Start(testCase);
foreach (int codeIndex in _Obj_Scaner.CodePool.Keys)
{
Case.CaseContentItem caseContent = Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_CreateContentInstance();
Case.CaseMethodItem caseMethod = Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_CreateMethodInstance();
Case.CaseMethodItem caseSelectMethod = Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_CreateMethodInstance();
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_Case(testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_Connect(testCase, _Obj_WebBrowserDriver, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_WebBrowser(caseMethod, testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_Select(caseSelectMethod, testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_ElementAction(caseMethod, testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_ImportXML(testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_ImportDB(testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_ImportExcel(testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_DataFill(testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_DataSet(testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_FillExistedData(testCase, _Obj_Scaner.CodePool[codeIndex]);
if (testCase.SingleInterrupt == true)
{
return;
}
}
_RunningTaskPool.Enqueue(testCase);
}
public static void CodeTransmit_Action_ImportXML(Case.BasicTestCase refTestCase, CodeLine activeSelectLine)
{
if (refTestCase != null && activeSelectLine.KeyCode == Container.KeyWordMap.ImportDB)
{
if (activeSelectLine.ParamsPool.ContainsKey("name") && activeSelectLine.ParamsPool.ContainsKey("source"))
{
string sourceFile = activeSelectLine.ParamsPool["source"];
XmlDocument tmpDoc = new XmlDocument();
XmlDocument sourceDataDoc = new XmlDocument();
sourceDataDoc.LoadXml("<root></root>");
try
{
tmpDoc.Load(sourceFile);
XmlNodeList rowNodes = tmpDoc.SelectNodes("/root/row");
int rowIndex = 1;
foreach (XmlNode rowNode in rowNodes)
{
XmlNode newRowNode = Buffalo.Basic.Data.XmlHelper.CreateNode(sourceDataDoc, "row", "");
Buffalo.Basic.Data.XmlHelper.SetAttribute(newRowNode, "index", rowIndex.ToString());
foreach (XmlAttribute activeAttr in rowNode.Attributes)
{
string value = Buffalo.Basic.Data.XmlHelper.GetNodeValue("@" + activeAttr.Name, rowNode);
Buffalo.Basic.Data.XmlHelper.SetAttribute(newRowNode, "column_" + activeAttr.Name, value);
}
sourceDataDoc.SelectSingleNode("/root").AppendChild(newRowNode);
rowIndex++;
}
}
catch (Exception err)
{
refTestCase.SingleInterrupt = true;
refTestCase.ActiveTestCaseReport.InsertFaildItem(activeSelectLine.CodeIndex, "Fail to transmit : Import XML : " + err.Message, true);
}
}
else
{
refTestCase.SingleInterrupt = true;
refTestCase.ActiveTestCaseReport.InsertFaildItem(activeSelectLine.CodeIndex, "Fail to transmit : Import XML : invalidate word namd or source.", true);
}
}
}
public static void CodeTransmit_Action_FillExistedData(Case.BasicTestCase refTestCase, CodeLine activeSelectLine)
{
foreach (string paramName in activeSelectLine.ParamsPool.Keys)
{
string paramValue = activeSelectLine.ParamsPool[paramName];
if (paramValue.Contains("%D"))
{
string dataName = paramValue.Replace("%D", "");
if (refTestCase.ActiveDataBuffer.ContainsKey(dataName))
activeSelectLine.ParamsPool[paramName] = refTestCase.ActiveDataBuffer[dataName];
else
{
refTestCase.SingleInterrupt = true;
refTestCase.ActiveTestCaseReport.InsertFaildItem(activeSelectLine.CodeIndex, "Fail to transmit : No data : " + dataName, true);
return;
}
}
}
}
public static void CodeTransmit_Action_Connect(Case.BasicTestCase refTestCase, WebDriver.WebBrowserDriver refWebBrowserDriver, CodeLine activeSelectLine)
{
if (activeSelectLine.KeyCode == Container.KeyWordMap.Connect)
{
try
{
foreach (string paramName in activeSelectLine.ParamsPool.Keys)
{
if (paramName == "type")
{
switch (activeSelectLine.ParamsPool[paramName])
{
case "Chrome":
case "chrome":
case "CHROME":
default:
refWebBrowserDriver = WebDriver.WebBrowserDriver.CreateInstanceForWebDriver(WebDriver.WebBrowserType.Chrome);
break;
case "IE":
case "ie":
refWebBrowserDriver = WebDriver.WebBrowserDriver.CreateInstanceForWebDriver(WebDriver.WebBrowserType.InternetExplorer);
break;
case "firefox":
case "Firefox":
refWebBrowserDriver = WebDriver.WebBrowserDriver.CreateInstanceForWebDriver(WebDriver.WebBrowserType.FireFox);
break;
}
}
}
refTestCase.ActionWebBrowserActionsObject = new WebDriver.WebBrowserActions(refWebBrowserDriver.ActiveWebDriver);
refTestCase.ActiveWebBrowserDriverObject = refWebBrowserDriver;
refTestCase.ActiveElementSelectorObject = new ElementActions.ElementSelector(refWebBrowserDriver.ActiveWebDriver);
}
catch (Exception err)
{
refTestCase.SingleInterrupt = true;
refTestCase.ActiveTestCaseReport.InsertFaildItem(activeSelectLine.CodeIndex, "Fail to transmit : Connect : " + err.Message, true);
}
}
}
public void Action_CallExecuteTestCase(Object activeCase)
{
Case.BasicTestCase activeBasicCase = (Case.BasicTestCase)activeCase;
Action_ExecuteTestCase(activeBasicCase);
}
public void Action_TransmitTask(string Code)
{
Buffalo.Core.CodeProcessor.CodeScaner _Obj_Scaner = new CodeProcessor.CodeScaner();
_Obj_Scaner.Action_Scan(Code);
Case.BasicTestCase testCase = new Case.BasicTestCase();
testCase.CaseName = "";
testCase.CaseCodeLineCount = _Obj_Scaner.CodePool.Count;
string idCase = Guid.NewGuid().ToString();
testCase.CaseID = idCase;
if (testCase.CaseName == "")
testCase.CaseName = Guid.NewGuid().ToString();
testCase.ActiveTestCaseReport = Case.CaseReport.CreateInstance(testCase.CaseName);
testCase.SingleInterrupt = false;
Thread newThreadFetchMessage = new Thread(new ParameterizedThreadStart(Action_FetchConsoleMessage));
_FetchMessageThreadsPool.Add(newThreadFetchMessage);
newThreadFetchMessage.Start(testCase);
foreach (int codeIndex in _Obj_Scaner.CodePool.Keys)
{
Case.CaseContentItem caseContent = Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_CreateContentInstance();
Case.CaseMethodItem caseMethod = Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_CreateMethodInstance();
Case.CaseMethodItem caseSelectMethod = Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_CreateMethodInstance();
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_Case(testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_Connect(testCase, _Obj_WebBrowserDriver, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_WebBrowser(caseMethod, testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_Select(caseSelectMethod, testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_ElementAction(caseMethod, testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_ImportXML(testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_ImportDB(testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_ImportExcel(testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_DataFill(testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_DataSet(testCase, _Obj_Scaner.CodePool[codeIndex]);
Core.CodeProcessor.CodeTransmitor.CodeTransmit_Action_FillExistedData(testCase, _Obj_Scaner.CodePool[codeIndex]);
if (testCase.SingleInterrupt == true)
return;
}
_RunningTaskPool.Enqueue(testCase);
}
public static void CodeTransmit_Action_WebBrowser(Case.CaseMethodItem refCaseMethodItemObj, Case.BasicTestCase refActiveCase, CodeLine activeSelectLine)
{
if (refCaseMethodItemObj != null && activeSelectLine.KeyCode == Container.KeyWordMap.WBAction)
{
try
{
refCaseMethodItemObj.Index = activeSelectLine.CodeIndex;
refCaseMethodItemObj.ActiveMethod = new ElementActions.MethodItem();
refCaseMethodItemObj.ActiveMethod.ActiveType = typeof(WebDriver.WebBrowserActions);
refActiveCase.ActiveCaseWebBrowserPool.Add(refCaseMethodItemObj.Index, refCaseMethodItemObj);
object[] methodParam;
foreach (string paramName in activeSelectLine.ParamsPool.Keys)
{
switch (paramName)
{
case WebDriver.WebBrowserActionsMap.Method_Action_WB_Action_StartBrowser:
refCaseMethodItemObj.ActiveMethod.ActiveMethod = refCaseMethodItemObj.ActiveMethod.ActiveType.GetMethod(WebDriver.WebBrowserActionsMap.Method_Action_WB_Action_StartBrowser);
if (activeSelectLine.ParamsPool[paramName] != Container.KeyWordMap.Null)
{
methodParam = new object[] { activeSelectLine.ParamsPool[paramName] };
refCaseMethodItemObj.ActiveMethod.MethodParams = methodParam;
}
break;
case WebDriver.WebBrowserActionsMap.Method_Action_WB_Action_SwitchToWindow:
refCaseMethodItemObj.ActiveMethod.ActiveMethod = refCaseMethodItemObj.ActiveMethod.ActiveType.GetMethod(WebDriver.WebBrowserActionsMap.Method_Action_WB_Action_SwitchToWindow);
if (activeSelectLine.ParamsPool[paramName] != Container.KeyWordMap.Null)
{
methodParam = new object[] { activeSelectLine.ParamsPool[paramName] };
refCaseMethodItemObj.ActiveMethod.MethodParams = methodParam;
}
break;
case WebDriver.WebBrowserActionsMap.Method_Action_WB_Action_CloseWindow:
refCaseMethodItemObj.ActiveMethod.ActiveMethod = refCaseMethodItemObj.ActiveMethod.ActiveType.GetMethod(WebDriver.WebBrowserActionsMap.Method_Action_WB_Action_CloseWindow);
break;
case WebDriver.WebBrowserActionsMap.Method_Action_WB_Action_Action_IsAlert:
refCaseMethodItemObj.ActiveMethod.ActiveMethod = refCaseMethodItemObj.ActiveMethod.ActiveType.GetMethod(WebDriver.WebBrowserActionsMap.Method_Action_WB_Action_Action_IsAlert);
break;
case WebDriver.WebBrowserActionsMap.Method_Action_WB_Action_GetCurrentWindowHandle:
refCaseMethodItemObj.ActiveMethod.ActiveMethod = refCaseMethodItemObj.ActiveMethod.ActiveType.GetMethod(WebDriver.WebBrowserActionsMap.Method_Action_WB_Action_SwitchToWindow);
break;
case WebDriver.WebBrowserActionsMap.Method_Action_WB_Action_GetSourceOfPage:
refCaseMethodItemObj.ActiveMethod.ActiveMethod = refCaseMethodItemObj.ActiveMethod.ActiveType.GetMethod(WebDriver.WebBrowserActionsMap.Method_Action_WB_Action_SwitchToWindow);
<<<<<<< HEAD
break;
=======
break;
public static void CodeTransmit_Action_DataFill(Case.BasicTestCase refTestCase, CodeLine activeSelectLine)
{
if (refTestCase != null && activeSelectLine.KeyCode == Container.KeyWordMap.DataFill)
{
if (!activeSelectLine.ParamsPool.ContainsKey("sourcename"))
{
refTestCase.SingleInterrupt = true;
refTestCase.ActiveTestCaseReport.InsertFaildItem(activeSelectLine.CodeIndex, "Fail to transmit : Data Fill : missing sourcename.", true);
return;
}
else
{
if (!activeSelectLine.ParamsPool.ContainsKey("dataname"))
{
refTestCase.SingleInterrupt = true;
refTestCase.ActiveTestCaseReport.InsertFaildItem(activeSelectLine.CodeIndex, "Fail to transmit : Data Fill : missing dataname.", true);
return;
}
else
{
string sourcename = activeSelectLine.ParamsPool["sourcename"];
if (!refTestCase.ActiveCaseDataSourcePool.ContainsKey(sourcename))
{
refTestCase.SingleInterrupt = true;
refTestCase.ActiveTestCaseReport.InsertFaildItem(activeSelectLine.CodeIndex, "Fail to transmit : Data Fill : can not foune datasource : " + sourcename + ".", true);
return;
}
XmlDocument sourceDoc = refTestCase.ActiveCaseDataSourcePool[sourcename];
if (sourceDoc != null)
{
if (activeSelectLine.ParamsPool.ContainsKey("row") && activeSelectLine.ParamsPool.ContainsKey("column"))
{
XmlNodeList rowNodes = sourceDoc.SelectNodes("/root/row");
int MaxRow = rowNodes.Count;
if (MaxRow <= 0)
{
refTestCase.SingleInterrupt = true;
refTestCase.ActiveTestCaseReport.InsertFaildItem(activeSelectLine.CodeIndex, "Fail to transmit : Data Fill : no data row in data source.", true);
return;
}
string RowValue = activeSelectLine.ParamsPool["row"];
string ColumnName = activeSelectLine.ParamsPool["column"];
int RowIndex = 1;
if (RowValue == "rand")
{
Random rnd = new Random();
RowIndex = rnd.Next(1, MaxRow);
}
else
{
int.TryParse(activeSelectLine.ParamsPool["row"], out RowIndex);
}
XmlNode selectedRowNode = sourceDoc.SelectSingleNode("/root/row[@index='" + RowIndex + "']");
if (selectedRowNode != null)
{
string value = Buffalo.Basic.Data.XmlHelper.GetNodeValue("@column_" + ColumnName, selectedRowNode);
string dataname = activeSelectLine.ParamsPool["dataname"];
if (refTestCase.ActiveDataBuffer.ContainsKey(dataname))
refTestCase.ActiveDataBuffer[dataname] = value;
else
refTestCase.ActiveDataBuffer.Add(dataname, value);
}
else
{
refTestCase.SingleInterrupt = true;
refTestCase.ActiveTestCaseReport.InsertFaildItem(activeSelectLine.CodeIndex, "Fail to transmit : Data Fill : can not found row node.", true);
return;
}
}
else
{
refTestCase.SingleInterrupt = true;
refTestCase.ActiveTestCaseReport.InsertFaildItem(activeSelectLine.CodeIndex, "Fail to transmit : Data Fill : missing row or column paramter.", true);
return;
}
}
else
{
refTestCase.SingleInterrupt = true;
refTestCase.ActiveTestCaseReport.InsertFaildItem(activeSelectLine.CodeIndex, "Fail to transmit : Data Fill : datasource : " + sourcename + " is Null.", true);
return;
}
}
}
}
}
