//Case 8: 1.3.7_SetPresentationStateDescription_Normal
public void Run_PS_SetPresentationStateDescription_Normal_Case8()
{
int runCount = 0;
foreach (InputDataSet ids in this.Input.DataSets)
{
runCount++;
Round r = this.NewRound(runCount.ToString(), ids.Description);
try
{
#region Parameter initialize
bool isImportImage = false;
string psID = null;
string imageID = null;
//Input parameters
string p_Import_patientId = null;
string p_Import_objectFileFullPath = null;
XMLParameter p_setPresentationState = new XMLParameter("presentationstate");
for (int i = 0; i < ids.InputParameters.Count; i++)
{
if (ids.InputParameters.GetParameter(i).Step == "import")
{
isImportImage = true;
if (ids.InputParameters.GetParameter(i).Key == "patientInternalId")
{
p_Import_patientId = ids.InputParameters.GetParameter(i).Value;
}
else if (ids.InputParameters.GetParameter(i).Key == "objectFileFullPath")
{
p_Import_objectFileFullPath = ids.InputParameters.GetParameter(i).Value;
}
}
else if (ids.InputParameters.GetParameter(i).Step == "setPresentationState")
{
if (ids.InputParameters.GetParameter(i).Key == "presentationStateInternalID")
{
psID = ids.InputParameters.GetParameter(i).Value;
}
else
{
p_setPresentationState.AddParameter(ids.InputParameters.GetParameter(i).Key, ids.InputParameters.GetParameter(i).Value);
}
}
}
// Output value
bool ep_isSetPSReturnOK = true;
string ep_ReturnValue = string.Empty;
XMLParameter ep_getPresentationState = new XMLParameter();
for (int i = 0; i < ids.ExpectedValues.Count; i++)
{
if (ids.ExpectedValues.GetParameter(i).Step == "setPresentationState")
{
switch (ids.ExpectedValues.GetParameter(i).Key)
{
case "returnState":
{
if (ids.ExpectedValues.GetParameter(i).Value.ToLower().Equals("pass"))
{
ep_isSetPSReturnOK = true;
}
else if (ids.ExpectedValues.GetParameter(i).Value.ToLower().Equals("fail"))
{
ep_isSetPSReturnOK = false;
}
break;
}
case "returnMessage":
{
ep_ReturnValue = ids.ExpectedValues.GetParameter(i).Value;
break;
}
}
}
else if (ids.ExpectedValues.GetParameter(i).Step == "getPresentationState")
{
ep_getPresentationState.AddParameter(ids.ExpectedValues.GetParameter(i).Key, ids.ExpectedValues.GetParameter(i).Value);
}
}
#endregion
ImportService importService = new ImportService();
PresentationStateService psService = new PresentationStateService();
if (isImportImage)
{
#region Step 1: Call ImportService.ImportObject to import an image and create a PS
CheckPoint cp_Import = new CheckPoint("Import Image", "Call ImportService.ImportObject to import an image");
r.CheckPoints.Add(cp_Import);
XMLResult rt_Import = importService.importObject(p_Import_patientId, null, p_Import_objectFileFullPath, null, true, "FALSE");
if (rt_Import.IsErrorOccured)
{
cp_Import.Result = TestResult.Fail;
cp_Import.Outputs.AddParameter("import", "Import image returns error", rt_Import.Message);
SaveRound(r);
continue; // Error happens, end current Test Set
}
else
{
cp_Import.Result = TestResult.Pass;
cp_Import.Outputs.AddParameter("import", "Import image returns success as expected", rt_Import.Message);
imageID = rt_Import.MultiResults[0].Parameters[0].ParameterValue; // This one is the ImageID
psID = rt_Import.MultiResults[1].Parameters[0].ParameterValue; // This one is the PS ID
}
#endregion
}
#region Step 2: Call PresentationStateService.SetPresentationState to set the PS for the image
CheckPoint cp_SetPresentationState = new CheckPoint("Set PS", "Call PresentationStateService.SetPresentationState to set ps info");
r.CheckPoints.Add(cp_SetPresentationState);
XMLResult rt_SetPresentationState = psService.setPresentationState(p_setPresentationState, psID);
if (ep_isSetPSReturnOK) // Expect the call returns OK
{
if (rt_SetPresentationState.IsErrorOccured)
{
cp_SetPresentationState.Result = TestResult.Fail;
cp_SetPresentationState.Outputs.AddParameter("state", "Set PresentationState returns error", rt_SetPresentationState.Message);
SaveRound(r);
continue; // Error happens, end current Test Set
}
else
{
cp_SetPresentationState.Result = TestResult.Pass;
cp_SetPresentationState.Outputs.AddParameter("state", "Set PresentationState returns success as expected", rt_SetPresentationState.Message);
}
#region Step 3: Call PresentationStateService.GetPresentationState to get the PS for the image
CheckPoint cp_GetPresentationState = new CheckPoint("Get PS", "Call PresentationStateService.GetPresentationState and check the return state");
r.CheckPoints.Add(cp_GetPresentationState);
XMLResult rt_GetPresentationState = psService.getPresentationState(psID);
if (rt_GetPresentationState.IsErrorOccured)
{
cp_GetPresentationState.Result = TestResult.Fail;
cp_GetPresentationState.Outputs.AddParameter("state", "Get PS returns error", rt_GetPresentationState.Message);
SaveRound(r);
continue; // Error happens, end current Test Get
}
else
{
cp_GetPresentationState.Result = TestResult.Pass;
cp_GetPresentationState.Outputs.AddParameter("state", "Get PS returns succeed", rt_GetPresentationState.Message);
// Check the return value is correct
#region Step 4: Check the values in PresentationStateService.getPresentationState return are correct
CheckPoint cp_getPSReturnValues = new CheckPoint("Get PS", "Check the values in PresentationStateService.GetPresentationState return");
r.CheckPoints.Add(cp_getPSReturnValues);
bool isValueEqual = true; // Set defult to true to deal with the case no ep_getPresentationState need check
bool isKeyShow = true; // Set defult to true to deal with the case no ep_getPresentationState need check
foreach (XMLParameterNode psNode in ep_getPresentationState.Parameters)
{
isValueEqual = false;
isKeyShow = false;
int i = 0;
for (i = 0; i < rt_GetPresentationState.MultiResults[0].Parameters.Count; i++)
{
if (psNode.ParameterName == rt_GetPresentationState.MultiResults[0].Parameters[i].ParameterName)
{
isKeyShow = true;
isValueEqual = string.Equals(psNode.ParameterValue, rt_GetPresentationState.MultiResults[0].Parameters[i].ParameterValue.Replace("\r", "").Replace("\n", ""));
break; // Find the node, end current for loop to search node
}
}
if (!isValueEqual) // There value is not matched or not found, log fail and then end the compare progress
{
cp_getPSReturnValues.Result = TestResult.Fail;
if (isKeyShow)
{
System.Diagnostics.Debug.Print("The return value in getPresentationState does not match the expected.");
cp_getPSReturnValues.Outputs.AddParameter("PS Info", "Check the values in PresentationStateService.getPresentationState return", "The value does not match the expected for node: " + psNode.ParameterName + ". Expect: " + psNode.ParameterValue + ". Actually: " + rt_GetPresentationState.MultiResults[0].Parameters[i].ParameterValue);
}
else
{
System.Diagnostics.Debug.Print("The return value in getPresentationState does not contain the node: " + psNode.ParameterName);
cp_getPSReturnValues.Outputs.AddParameter("PS Info", "Check the values in PresentationStateService.getPresentationState return", "The return value does not contain the node: " + psNode.ParameterName);
}
break; // End current foreach loop, not compare the follwing nodes
}
}
if (isValueEqual)
{
cp_getPSReturnValues.Result = TestResult.Pass;
System.Diagnostics.Debug.Print("The return values in getPresentationStateInfo all match the expected.");
cp_getPSReturnValues.Outputs.AddParameter("PS Info", "Check the values in PresentationStateService.getPresentationStateInfo return", "The return values all match the expected");
}
#endregion
}
#endregion
}
else // Expect the call return error
{
if (rt_SetPresentationState.IsErrorOccured) // There is error
{
if (rt_SetPresentationState.Message.ToLower().Contains(ep_ReturnValue.ToLower()))
{
cp_SetPresentationState.Result = TestResult.Pass;
cp_SetPresentationState.Outputs.AddParameter("state", "Set PS returns error as expected", rt_SetPresentationState.Message);
}
else
{
cp_SetPresentationState.Result = TestResult.Fail;
cp_SetPresentationState.Outputs.AddParameter("state", "Set PS returns error message not match the expected. ", "Expect: " + ep_ReturnValue + "; Actually returns: " + rt_SetPresentationState.Message);
SaveRound(r);
continue; // Error happens, end current Test Get
}
}
else // There is no error
{
cp_SetPresentationState.Result = TestResult.Fail;
cp_SetPresentationState.Outputs.AddParameter("state", "Set PS not returns error as expected. ", "Actually returns: " + rt_SetPresentationState.Message);
SaveRound(r);
continue; // Error happens, end current Test Get
}
}
#endregion
if (isImportImage)
{
#region Step 4: Call ImageService.deleteImage to delete the created image
ImageService imageService = new ImageService();
CheckPoint cp_DeleteImage = new CheckPoint("Delete Image", "Call imageService.deleteImage to delete the image");
r.CheckPoints.Add(cp_DeleteImage);
XMLResult rt_DeleteImage = imageService.deleteImage(imageID, new XMLParameter("preferences"));
if (rt_DeleteImage.IsErrorOccured)
{
cp_DeleteImage.Result = TestResult.Fail;
cp_DeleteImage.Outputs.AddParameter("delete image", "Delete image returns error", rt_DeleteImage.Message);
SaveRound(r);
continue; // End current test set
}
else
{
cp_DeleteImage.Result = TestResult.Pass;
cp_DeleteImage.Outputs.AddParameter("delete image", "Delete image returns success", rt_DeleteImage.Message);
}
#endregion
}
SaveRound(r);
}
catch (Exception ex)
{
CheckPoint cp = new CheckPoint();
r.CheckPoints.Add(cp);
cp.Outputs.AddParameter("Exception thrown", "Exception Message", ex.Message);
cp.Result = TestResult.Fail;
SaveRound(r);
}
}
Output();
}
//Case 76: 1.3.7_GetPresentationStateDescription_Exception
public void Run_PS_GetPresentationStateDescription_Exception_Case76()
{
int runCount = 0;
foreach (InputDataSet ids in this.Input.DataSets)
{
runCount++;
Round r = this.NewRound(runCount.ToString(), "Test PresentationState Service: getPresentationState");
try
{
#region Parameter initialize
//Input parameters
string presentationStateInternalID = null;
for (int i = 0; i < ids.InputParameters.Count; i++)
{
if (ids.InputParameters.GetParameter(i).Step == "getPresentationState")
{
if (ids.InputParameters.GetParameter(i).Key == "presentationStateInternalID")
{
presentationStateInternalID = ids.InputParameters.GetParameter(i).Value;
}
}
}
// Oupput value
bool ep_isReturnOK = true;
string ep_ReturnValue = string.Empty;
string ep_imageID = string.Empty;
for (int i = 0; i < ids.ExpectedValues.Count; i++)
{
if (ids.ExpectedValues.GetParameter(i).Step == "getPresentationState")
{
switch (ids.ExpectedValues.GetParameter(i).Key)
{
case "returnState":
{
if (ids.ExpectedValues.GetParameter(i).Value.ToLower().Equals("pass"))
{
ep_isReturnOK = true;
}
else if (ids.ExpectedValues.GetParameter(i).Value.ToLower().Equals("fail"))
{
ep_isReturnOK = false;
}
break;
}
case "returnMessage":
{
ep_ReturnValue = ids.ExpectedValues.GetParameter(i).Value;
break;
}
case "image_internal_id":
{
ep_imageID = ids.ExpectedValues.GetParameter(i).Value; ;
break;
}
//default:
// {
// ep_getPresentationState.AddParameter(ids.ExpectedValues.GetParameter(i).Key, ids.ExpectedValues.GetParameter(i).Value);
// break;
// }
}
}
}
#endregion
PresentationStateService psService = new PresentationStateService();
#region Step 1: Call PresentationStateService.GetPresentationState to get a PS for the image
CheckPoint cp_GetPresentationState = new CheckPoint("Get PS", "Call PresentationStateService.GetPresentationState to get a new ps");
r.CheckPoints.Add(cp_GetPresentationState);
XMLResult rt_GetPresentationState = psService.getPresentationState(presentationStateInternalID);
if (true == ep_isReturnOK) // Expect the call returns OK
{
if (rt_GetPresentationState.IsErrorOccured)
{
cp_GetPresentationState.Result = TestResult.Fail;
cp_GetPresentationState.Outputs.AddParameter("get", "Get PS returns error", rt_GetPresentationState.Message);
}
else
{
// Check the return value is correct
// 1: check the "general.xml" is present
// 2. check the "processing.xml" is present
// 3. check the "annotation.xml" is present
// 4. check the image id is correct
if (false == rt_GetPresentationState.MultiResults[0].Parameters[0].ParameterName.Equals("general.xml"))
{
cp_GetPresentationState.Result = TestResult.Fail;
cp_GetPresentationState.Outputs.AddParameter("get", "Get PS returns not contain the general.xml info", "Actually return:" + rt_GetPresentationState.Message);
}
else if (false == rt_GetPresentationState.MultiResults[0].Parameters[1].ParameterName.Equals("processing.xml"))
{
cp_GetPresentationState.Result = TestResult.Fail;
cp_GetPresentationState.Outputs.AddParameter("get", "Get PS returns not contain the processing.xml info", "Actually return:" + rt_GetPresentationState.Message);
}
else if (false == rt_GetPresentationState.MultiResults[0].Parameters[2].ParameterName.Equals("annotation.xml"))
{
cp_GetPresentationState.Result = TestResult.Fail;
cp_GetPresentationState.Outputs.AddParameter("get", "Get PS returns not contain the annotation.xml info", "Actually return:" + rt_GetPresentationState.Message);
}
else if (false == rt_GetPresentationState.MultiResults[0].Parameters[3].ParameterValue.Equals(ep_imageID))
{
cp_GetPresentationState.Result = TestResult.Fail;
cp_GetPresentationState.Outputs.AddParameter("get", "Get PS returns wrong image ID", "Expect: " + ep_imageID + ". Actually get: " + rt_GetPresentationState.MultiResults[0].Parameters[3].ParameterValue);
}
else
{
cp_GetPresentationState.Result = TestResult.Pass;
cp_GetPresentationState.Outputs.AddParameter("get", "Get PS returns success, all values are correct", rt_GetPresentationState.Message);
}
}
}
else // Expect the call return error
{
if (rt_GetPresentationState.IsErrorOccured) // There is error
{
if (rt_GetPresentationState.Message.ToLower().Contains(ep_ReturnValue.ToLower()))
{
cp_GetPresentationState.Result = TestResult.Pass;
cp_GetPresentationState.Outputs.AddParameter("get", "Get PS returns error as expected", rt_GetPresentationState.Message);
}
else
{
cp_GetPresentationState.Result = TestResult.Fail;
cp_GetPresentationState.Outputs.AddParameter("get", "Get PS returns error message not match the expected. ", "Expect: " + ep_ReturnValue + "; Actually returns: " + rt_GetPresentationState.Message);
}
}
else // There is no error
{
cp_GetPresentationState.Result = TestResult.Fail;
cp_GetPresentationState.Outputs.AddParameter("get", "Get PS not returns error as expected. ", "Actually returns: " + rt_GetPresentationState.Message);
}
}
#endregion
SaveRound(r);
}
catch (Exception ex)
{
CheckPoint cp = new CheckPoint();
r.CheckPoints.Add(cp);
cp.Outputs.AddParameter("Exception thrown", "Exception Message", ex.Message);
cp.Result = TestResult.Fail;
SaveRound(r);
}
}
Output();
}
//Case 980: 1.3.17_workflow_CSI select a patient, open an image and then close it
public void Run_WorkFlow_CSIOpenImageAndClose_Case980()
{
// Test Case added for work flow: CSI select a patient to list all the image, click to open one of them and then save and close it.
PatientService patientService = new PatientService();
AcquisitionService acquisitionService = new AcquisitionService();
PresentationStateService presentationStateService = new PresentationStateService();
AnalysisService analysisService = new AnalysisService();
string patientUID = null;
XMLParameter setAsynAcqPatientInfoParam = new XMLParameter("acq_info");
XMLParameter listObjectForPSParam = new XMLParameter("filter");
XMLParameterCollection getPresentionStateInfoParam = new XMLParameterCollection();
XMLParameter listObjectForVolumeParam = new XMLParameter("filter");
XMLParameter listObjectForFMSParam = new XMLParameter("filter");
XMLParameter listObjectForOtherParam = new XMLParameter("filter");
XMLParameter setPresentationStateParam = new XMLParameter("presentationstate");
XMLParameter setPresentationStateInfoParam = new XMLParameter("presentationstate");
XMLParameter listObjectForAnalysisParam = new XMLParameter("filter");
XMLParameter setAnalysisInfoParam = new XMLParameter("analysis");
foreach (InputDataSet ids in this.Input.DataSets)
{
Round r = new Round();
try
{
for (int i = 0; i < ids.InputParameters.Count; i++)
{
if (ids.InputParameters.GetParameter(i).Step == "getPatient")
{
if (ids.InputParameters.GetParameter(i).Key == "patientInternalID")
{
patientUID = ids.InputParameters.GetParameter(i).Value;
}
}
if (ids.InputParameters.GetParameter(i).Step == "setAsynAcqPatientInfo")
{
setAsynAcqPatientInfoParam.AddParameter(ids.InputParameters.GetParameter(i).Key, ids.InputParameters.GetParameter(i).Value);
}
if (ids.InputParameters.GetParameter(i).Step == "listObjectForPS")
{
listObjectForPSParam.AddParameter(ids.InputParameters.GetParameter(i).Key, ids.InputParameters.GetParameter(i).Value);
}
if (ids.InputParameters.GetParameter(i).Step == "listObjectForVolume")
{
listObjectForVolumeParam.AddParameter(ids.InputParameters.GetParameter(i).Key, ids.InputParameters.GetParameter(i).Value);
}
if (ids.InputParameters.GetParameter(i).Step == "listObjectForFMS")
{
listObjectForFMSParam.AddParameter(ids.InputParameters.GetParameter(i).Key, ids.InputParameters.GetParameter(i).Value);
}
if (ids.InputParameters.GetParameter(i).Step == "listObjectForOther")
{
listObjectForOtherParam.AddParameter(ids.InputParameters.GetParameter(i).Key, ids.InputParameters.GetParameter(i).Value);
}
if (ids.InputParameters.GetParameter(i).Step == "listObjectForAnalysis")
{
listObjectForAnalysisParam.AddParameter(ids.InputParameters.GetParameter(i).Key, ids.InputParameters.GetParameter(i).Value);
}
if (ids.InputParameters.GetParameter(i).Step == "setPresentationStateInfo")
{
setPresentationStateInfoParam.AddParameter(ids.InputParameters.GetParameter(i).Key, ids.InputParameters.GetParameter(i).Value);
}
if (ids.InputParameters.GetParameter(i).Step == "setAnalysisInfo")
{
setAnalysisInfoParam.AddParameter(ids.InputParameters.GetParameter(i).Key, ids.InputParameters.GetParameter(i).Value);
}
}
#region Step 1: Check the specific patient exists in Database
CheckPoint pGetPatient = new CheckPoint("getPatient", "Step 1: Get the specific patient info");
r.CheckPoints.Add(pGetPatient);
XMLResult getPatientResult = patientService.getPatient(patientUID);
if (getPatientResult.IsErrorOccured)
{
pGetPatient.Result = TestResult.Fail;
System.Diagnostics.Debug.Print("Get the specific patient info fail:");
pGetPatient.Outputs.AddParameter("getPatient", "get the specific patient info", getPatientResult.Message);
SaveRound(r);
break;
}
else
{
pGetPatient.Result = TestResult.Pass;
System.Diagnostics.Debug.Print("Get the specific patient info succeed:");
pGetPatient.Outputs.AddParameter("getPatient", "get the specific patient info", getPatientResult.Message);
}
#endregion
// Step 2 - Step 7 are what to do after select a patient
#region Step 2: set asyn acq patient with the specific patient
CheckPoint pSetAsynAcqPatientInfo = new CheckPoint("setAsynAcqPatientInfo", "Step 2: call setAsynAcqPatientInfo to set asyn acq patient info");
r.CheckPoints.Add(pSetAsynAcqPatientInfo);
XMLResult setAsynAcqPatientInfoResult = acquisitionService.setAsynAcqPatientInfo(setAsynAcqPatientInfoParam);
if (setAsynAcqPatientInfoResult.IsErrorOccured)
{
pSetAsynAcqPatientInfo.Result = TestResult.Fail;
System.Diagnostics.Debug.Print("Set asyn acq PatientInfo fail:");
pSetAsynAcqPatientInfo.Outputs.AddParameter("setAsynAcqPatientInfo", "set asyn acq patient info", setAsynAcqPatientInfoResult.Message);
SaveRound(r);
break;
}
else
{
pSetAsynAcqPatientInfo.Result = TestResult.Pass;
System.Diagnostics.Debug.Print("Set asyn acq PatientInfo succeed:");
pSetAsynAcqPatientInfo.Outputs.AddParameter("setAsynAcqPatientInfo", "set asyn acq patient info", setAsynAcqPatientInfoResult.Message);
}
#endregion
#region Step 3: Call listObject to get the presentation state list of the patient
CheckPoint pListObjectForPS = new CheckPoint("listObjectForPS", "Step 3: call listObject to get PS info");
r.CheckPoints.Add(pListObjectForPS);
XMLResult listObjectForPSResult = patientService.listObjects(listObjectForPSParam);
if (listObjectForPSResult.IsErrorOccured)
{
pListObjectForPS.Result = TestResult.Fail;
System.Diagnostics.Debug.Print("Call listObject to get PS info fail:");
pListObjectForPS.Outputs.AddParameter("listObject", "listObject to get PS", listObjectForPSResult.Message);
SaveRound(r);
break;
}
else
{
pListObjectForPS.Result = TestResult.Pass;
System.Diagnostics.Debug.Print("Call listObject to get PS info succeed:");
pListObjectForPS.Outputs.AddParameter("listObject", "listObject to get PS", listObjectForPSResult.Message);
}
#endregion
#region Step 4: Call getPresentationStateInfo to get the presentationstate info according to the presentationstate internal_id
CheckPoint pGetPresentionStateInfo = new CheckPoint("getPresentionStateInfo", "Step 4: call getPresentationStateInfo to get presention state info");
r.CheckPoints.Add(pGetPresentionStateInfo);
foreach (XMLParameter param in listObjectForPSResult.MultiResults)
{
getPresentionStateInfoParam.Add(param);
}
XMLResult getPresentationStateInfoResult = presentationStateService.getPresentationStateInfo(getPresentionStateInfoParam);
if (getPresentationStateInfoResult.IsErrorOccured)
{
pGetPresentionStateInfo.Result = TestResult.Fail;
System.Diagnostics.Debug.Print("Call getPresentationStateInfo to get PS info fail:");
pGetPresentionStateInfo.Outputs.AddParameter("getPresentationStateInfo", "getPresentationStateInfo to get PS info", getPresentationStateInfoResult.Message);
SaveRound(r);
break;
}
else
{
pGetPresentionStateInfo.Result = TestResult.Pass;
System.Diagnostics.Debug.Print("Call getPresentationStateInfo to get PS info succeed:");
pGetPresentionStateInfo.Outputs.AddParameter("getPresentationStateInfo", "getPresentationStateInfo to get PS info", getPresentationStateInfoResult.Message);
}
#endregion
#region Step 5: Call listObject to get the volume list of the patient
CheckPoint pListObjectForVolume = new CheckPoint("listObjectForVolume", "Step 5: call listObject to get volume info");
r.CheckPoints.Add(pListObjectForVolume);
XMLResult listObjectForVolumeResult = patientService.listObjects(listObjectForVolumeParam);
if (listObjectForVolumeResult.IsErrorOccured)
{
pListObjectForVolume.Result = TestResult.Fail;
System.Diagnostics.Debug.Print("Call listObject to get volume info fail:");
pListObjectForVolume.Outputs.AddParameter("listObject", "listObject to get volume", listObjectForVolumeResult.Message);
SaveRound(r);
break;
}
else
{
pListObjectForVolume.Result = TestResult.Pass;
System.Diagnostics.Debug.Print("Call listObject to get volume info succeed:");
pListObjectForVolume.Outputs.AddParameter("listObject", "listObject to get volume", listObjectForVolumeResult.Message);
}
#endregion
#region Step 6: Call listObject to get the FMS list of the patient
CheckPoint pListObjectForFMS = new CheckPoint("listObjectForFMS", "Step 6: call listObject to get FMS info");
r.CheckPoints.Add(pListObjectForFMS);
XMLResult listObjectForFMSResult = patientService.listObjects(listObjectForFMSParam);
if (listObjectForFMSResult.IsErrorOccured)
{
pListObjectForFMS.Result = TestResult.Fail;
System.Diagnostics.Debug.Print("Call listObject to get FMS info fail:");
pListObjectForFMS.Outputs.AddParameter("listObject", "listObject to get FMS", listObjectForFMSResult.Message);
SaveRound(r);
break;
}
else
{
pListObjectForFMS.Result = TestResult.Pass;
System.Diagnostics.Debug.Print("Call listObject to get FMS info succeed:");
pListObjectForFMS.Outputs.AddParameter("listObject", "listObject to get FMS", listObjectForFMSResult.Message);
}
#endregion
#region Step 7: Call listObject to get the other info of the patient
CheckPoint pListObjectForOther = new CheckPoint("listObjectForOther", "Step 7: call listObject to get other info");
r.CheckPoints.Add(pListObjectForOther);
XMLResult listObjectForOtherResult = patientService.listObjects(listObjectForOtherParam);
if (listObjectForOtherResult.IsErrorOccured)
{
pListObjectForOther.Result = TestResult.Fail;
System.Diagnostics.Debug.Print("Call listObject to get other info fail:");
pListObjectForOther.Outputs.AddParameter("listObject", "listObject to get other", listObjectForOtherResult.Message);
SaveRound(r);
break;
}
else
{
pListObjectForOther.Result = TestResult.Pass;
System.Diagnostics.Debug.Print("Call listObject to get other info succeed:");
pListObjectForOther.Outputs.AddParameter("listObject", "listObject to get other", listObjectForOtherResult.Message);
}
#endregion
// After double click an image to open it, it will repeat step 3 to step 7
// When open image, it will call getPresentationState to get the presentation state, which can be used in setPresentationState step later
string presentationStateInternalID = null;
XMLParameterCollection setPresentationStateParamList = new XMLParameterCollection();
foreach (XMLParameterNode psNode in listObjectForPSResult.ArrayResult.Parameters)
{
presentationStateInternalID = psNode.ParameterValue;
XMLResult getPresentationStateResult = presentationStateService.getPresentationState(presentationStateInternalID);
setPresentationStateParam = getPresentationStateResult.ArrayResult;
setPresentationStateParamList.Add(setPresentationStateParam);
}
// Close the image, it will do step 8 to step 10
#region Step 8: Call setPresentationState to set presentation state, not change the presentation state value, just set it back
CheckPoint pSetPresentationState = new CheckPoint("setPresentationState", "Step 8: call setPresentationState to set the presentation state after close the image");
r.CheckPoints.Add(pSetPresentationState);
XMLResult setPresentationStateResult = new XMLResult();
foreach (XMLParameter presentationStateInfo in setPresentationStateParamList)
{
setPresentationStateResult = presentationStateService.setPresentationState(presentationStateInfo, presentationStateInternalID);
if (setPresentationStateResult.IsErrorOccured)
{
pSetPresentationState.Result = TestResult.Fail;
break;
}
else
{
pSetPresentationState.Result = TestResult.Pass;
}
}
if (pSetPresentationState.Result == TestResult.Fail)
{
System.Diagnostics.Debug.Print("Call setPresentationState to set presentation state fail:");
pSetPresentationState.Outputs.AddParameter("setPresentationState", "setPresentationState to set presentation state", setPresentationStateResult.Message);
SaveRound(r);
break;
}
else
{
System.Diagnostics.Debug.Print("Call setPresentationState to set presentation state succeed:");
pSetPresentationState.Outputs.AddParameter("setPresentationState", "setPresentationState to set presentation state", setPresentationStateResult.Message);
}
#endregion
#region Step 9: Call setPresentationStateInfo to set the presentation state info
CheckPoint pSetPresentationStateInfo = new CheckPoint("setPresentationStateInfo", "Step 9: call setPresentationStateInfo to set the presentation state info after close the image");
r.CheckPoints.Add(pSetPresentationStateInfo);
XMLResult setPresentationStateInfoResult = new XMLResult();
foreach (XMLParameter presentationStateInfoParam in getPresentationStateInfoResult.MultiResults)
{
presentationStateInternalID = presentationStateInfoParam.GetParameterValueByName("internal_id");
setPresentationStateInfoResult = presentationStateService.setPresentationStateInfo(setPresentationStateInfoParam, presentationStateInternalID);
if (setPresentationStateInfoResult.IsErrorOccured)
{
pSetPresentationStateInfo.Result = TestResult.Fail;
break;
}
else
{
pSetPresentationStateInfo.Result = TestResult.Pass;
}
}
if (pSetPresentationStateInfo.Result == TestResult.Fail)
{
System.Diagnostics.Debug.Print("Call setPresentationStateInfo to set presentation state info fail:");
pSetPresentationStateInfo.Outputs.AddParameter("setPresentationStateInfo", "setPresentationState to set presentation state info", setPresentationStateInfoResult.Message);
SaveRound(r);
break;
}
else
{
System.Diagnostics.Debug.Print("Call setPresentationStateInfo to set presentation state info succeed:");
pSetPresentationStateInfo.Outputs.AddParameter("setPresentationState", "setPresentationState to set presentation state info", setPresentationStateInfoResult.Message);
}
#endregion
#region Step 10: Call listObject to get the presentation state
CheckPoint pListObjectForPS2 = new CheckPoint("listObjectForPS", "Step 10: call listObject to get PS info after close image");
r.CheckPoints.Add(pListObjectForPS2);
XMLResult listObjectForPSResult2 = patientService.listObjects(listObjectForPSParam);
if (listObjectForPSResult2.IsErrorOccured)
{
pListObjectForPS.Result = TestResult.Fail;
System.Diagnostics.Debug.Print("Call listObject to get PS info fail:");
pListObjectForPS2.Outputs.AddParameter("listObject", "listObject to get PS", listObjectForPSResult2.Message);
SaveRound(r);
break;
}
else
{
pListObjectForPS2.Result = TestResult.Pass;
System.Diagnostics.Debug.Print("Call listObject to get PS info succeed:");
pListObjectForPS2.Outputs.AddParameter("listObject", "listObject to get PS", listObjectForPSResult2.Message);
}
#endregion
#region Step 11: Call getPresentationStateInfo to get the presentation state info
CheckPoint pGetPresentionStateInfo2 = new CheckPoint("getPresentionStateInfo", "Step 11: call getPresentationStateInfo to get presention state info after close image");
r.CheckPoints.Add(pGetPresentionStateInfo2);
XMLResult getPresentationStateInfoResult2 = presentationStateService.getPresentationStateInfo(getPresentionStateInfoParam);
if (getPresentationStateInfoResult2.IsErrorOccured)
{
pGetPresentionStateInfo2.Result = TestResult.Fail;
System.Diagnostics.Debug.Print("Call getPresentationStateInfo to get PS info fail:");
pGetPresentionStateInfo2.Outputs.AddParameter("getPresentationStateInfo", "getPresentationStateInfo to get PS info", getPresentationStateInfoResult2.Message);
SaveRound(r);
break;
}
else
{
pGetPresentionStateInfo2.Result = TestResult.Pass;
System.Diagnostics.Debug.Print("Call getPresentationStateInfo to get PS info succeed:");
pGetPresentionStateInfo2.Outputs.AddParameter("getPresentationStateInfo", "getPresentationStateInfo to get PS info", getPresentationStateInfoResult2.Message);
}
#endregion
// Close the viewer
#region Step 12: Call listObject to get the analysis
CheckPoint pListObjectForAnalysis = new CheckPoint("listObjectForAnalysis", "Step 12: call listObject to get analysis info");
r.CheckPoints.Add(pListObjectForAnalysis);
XMLResult listObjectForAnalysisResult = patientService.listObjects(listObjectForAnalysisParam);
if (listObjectForAnalysisResult.IsErrorOccured)
{
pListObjectForAnalysis.Result = TestResult.Fail;
System.Diagnostics.Debug.Print("Call listObject to get analysis info fail:");
pListObjectForAnalysis.Outputs.AddParameter("listObject", "listObject to get analysis", listObjectForAnalysisResult.Message);
SaveRound(r);
break;
}
else
{
pListObjectForAnalysis.Result = TestResult.Pass;
System.Diagnostics.Debug.Print("Call listObject to get analysis info succeed:");
pListObjectForAnalysis.Outputs.AddParameter("listObject", "listObject to get analysis", listObjectForAnalysisResult.Message);
}
#endregion
string analysisId = null;
analysisId = listObjectForAnalysisResult.SingleResult;
if (analysisId == null || analysisId == string.Empty)
{
// Below Step are excuted when there is no analysis before
#region Step 13: createAnalysis
CheckPoint pCreateAnalysis = new CheckPoint("createAnalysis", "Step 13: call createAnalysis to create new analysis");
r.CheckPoints.Add(pCreateAnalysis);
XMLResult createAnalysisResult = new XMLResult();
XMLParameter analysisXml = new XMLParameter("analysis");
XMLParameterCollection uidsXml = new XMLParameterCollection();
XMLParameter presentationStateUids = new XMLParameter("presentationstate");
XMLParameter fmsUids = new XMLParameter("fms");
uidsXml.Add(presentationStateUids);
uidsXml.Add(fmsUids);
createAnalysisResult = analysisService.createAnalysis(analysisXml.GenerateXML().ToString(), true, true, patientUID, null, uidsXml);
// public XMLResult createAnalysis(string analysisXml, bool current, bool currentSpecified, string patientInternalID, string thumbnail, XMLParameterCollection uidsXml);
if (createAnalysisResult.IsErrorOccured)
{
System.Diagnostics.Debug.Print("Call createAnalysis to create analysis fail:");
pCreateAnalysis.Outputs.AddParameter("createAnalysis", "createAnalysis to create analysis", createAnalysisResult.Message);
SaveRound(r);
break;
}
else
{
System.Diagnostics.Debug.Print("Call createAnalysis to create analysis succeed:");
pCreateAnalysis.Outputs.AddParameter("createAnalysis", "createAnalysis to create analysis", createAnalysisResult.Message);
}
#endregion
#region Step 14: Call AnalysisService.setAnalysisInfo to set the analysis info
CheckPoint pSetAnalysisInfo = new CheckPoint("setAnalysisInfo", "Step 14: call setAnalysisInfo to set the analysis info");
r.CheckPoints.Add(pSetAnalysisInfo);
XMLResult setAnalysisInfoResult = new XMLResult();
analysisId = createAnalysisResult.MultiResults[0].GetParameterValueByName("internal_id");
setAnalysisInfoResult = analysisService.setAnalysisInfo(analysisId, setAnalysisInfoParam);
if (setAnalysisInfoResult.IsErrorOccured)
{
System.Diagnostics.Debug.Print("Call setAnalysisInfo to set analysis info fail:");
pSetAnalysisInfo.Outputs.AddParameter("setAnalysisInfo", "setAnalysisInfo to set analysis info", setAnalysisInfoResult.Message);
SaveRound(r);
break;
}
else
{
System.Diagnostics.Debug.Print("Call setAnalysisInfo to set analysis info succeed:");
pSetAnalysisInfo.Outputs.AddParameter("setAnalysisInfo", "setAnalysisInfo to set analysis info", setAnalysisInfoResult.Message);
}
#endregion
}
else
{
// Below Step 15 to Step 17 are excuted when there is analysis exist before...
#region Step 15: Call AnalysisService.getAnalysisInfo to get the analysis info
CheckPoint pGetAnalysisInfo = new CheckPoint("getAnalysisInfo", "Step 15: call getAnalysisInfo to get the analysis info");
r.CheckPoints.Add(pGetAnalysisInfo);
XMLResult getAnalysisInfoResult = new XMLResult();
getAnalysisInfoResult = analysisService.getAnalysisInfo(analysisId);
if (getAnalysisInfoResult.IsErrorOccured)
{
pGetAnalysisInfo.Result = TestResult.Fail;
System.Diagnostics.Debug.Print("Call getAnalysisInfo to get analysis info fail:");
pGetAnalysisInfo.Outputs.AddParameter("getAnalysisInfo", "getAnalysisInfo to get analysis info", getAnalysisInfoResult.Message);
SaveRound(r);
break;
}
else
{
pGetAnalysisInfo.Result = TestResult.Pass;
System.Diagnostics.Debug.Print("Call getAnalysisInfo to get analysis info succeed:");
pGetAnalysisInfo.Outputs.AddParameter("getAnalysisInfo", "getAnalysisInfo to get analysis info", getAnalysisInfoResult.Message);
}
#endregion
#region Step 16: Call AnalysisService.setAnalysisDescription to set analysis description
CheckPoint pSetAnalysisDescription = new CheckPoint("setAnalysisDescription", "Step 16: call setAnalysisDescription to set the analysis description");
r.CheckPoints.Add(pSetAnalysisDescription);
XMLResult setAnalysisDescriptionResult = new XMLResult();
XMLParameter analysisXml = new XMLParameter("analysis");
XMLParameterCollection uidsXml = new XMLParameterCollection();
XMLParameter presentationStateUids = new XMLParameter("presentationstate");
XMLParameter fmsUids = new XMLParameter("fms");
uidsXml.Add(presentationStateUids);
uidsXml.Add(fmsUids);
setAnalysisDescriptionResult = analysisService.setAnalysisDescription(analysisId, analysisXml.GenerateXML(), false, uidsXml);
if (setAnalysisDescriptionResult.IsErrorOccured)
{
pSetAnalysisDescription.Result = TestResult.Fail;
System.Diagnostics.Debug.Print("Call setAnalysisDescription to set the analysis description fail:");
pSetAnalysisDescription.Outputs.AddParameter("setAnalysisDescription", "call set the analysis description", setAnalysisDescriptionResult.Message);
SaveRound(r);
break;
}
else
{
pSetAnalysisDescription.Result = TestResult.Pass;
System.Diagnostics.Debug.Print("Call setAnalysisDescription to set the analysis description succeed:");
pSetAnalysisDescription.Outputs.AddParameter("setAnalysisDescription", "call set the analysis description", setAnalysisDescriptionResult.Message);
}
#endregion
#region Step 17: Call AnalysisService.setAnalysisInfo to set the analysis info
CheckPoint pSetAnalysisInfo = new CheckPoint("setAnalysisInfo", "Step 17: call setAnalysisInfo to set the analysis info");
r.CheckPoints.Add(pSetAnalysisInfo);
XMLResult setAnalysisInfoResult = new XMLResult();
setAnalysisInfoResult = analysisService.setAnalysisInfo(analysisId, setAnalysisInfoParam);
if (setAnalysisInfoResult.IsErrorOccured)
{
pSetAnalysisInfo.Result = TestResult.Fail;
System.Diagnostics.Debug.Print("Call setAnalysisInfo to set analysis info fail:");
pSetAnalysisInfo.Outputs.AddParameter("setAnalysisInfo", "setAnalysisInfo to set analysis info", setAnalysisInfoResult.Message);
SaveRound(r);
break;
}
else
{
pSetAnalysisInfo.Result = TestResult.Pass;
System.Diagnostics.Debug.Print("Call setAnalysisInfo to set analysis info succeed:");
pSetAnalysisInfo.Outputs.AddParameter("setAnalysisInfo", "setAnalysisInfo to set analysis info", setAnalysisInfoResult.Message);
}
#endregion
}
SaveRound(r);
}
catch (Exception ex)
{
CheckPoint cp = new CheckPoint();
r.CheckPoints.Add(cp);
cp.Outputs.AddParameter("Exception thrown", "Exception Message", ex.Message);
cp.Result = TestResult.Fail;
SaveRound(r);
}
}
Output();
}
//Case 992: 1.3.7_GetPresentationStateDescription_N02_WhenPSNotExist
public void Run_PS_GetPresentationStateDescription_PSNotExist_Case992()
{
int runCount = 0;
string patientUID = string.Empty;
bool isCreatePatient = false;
bool isDeletePatient = false;
foreach (InputDataSet ids in this.Input.DataSets)
{
isCreatePatient = false;
isDeletePatient = false;
runCount++;
Round r = this.NewRound(runCount.ToString(), "Import image");
CheckPoint pCreate = new CheckPoint("Create Patient", "Test create");
r.CheckPoints.Add(pCreate);
PatientService ps = new PatientService();
ImportService ims = new ImportService();
PresentationStateService pss = new PresentationStateService();
XMLParameter pa = new XMLParameter("patient");
XMLParameter ia = new XMLParameter("import");
//XMLParameter psa = new XMLParameter("presentationstate");
for (int i = 0; i < ids.InputParameters.Count; i++)
{
if (ids.InputParameters.GetParameter(i).Step == "create")
{
pa.AddParameter(ids.InputParameters.GetParameter(i).Key, ids.InputParameters.GetParameter(i).Value);
isCreatePatient = true;
}
if (ids.InputParameters.GetParameter(i).Step == "import")
{
ia.AddParameter(ids.InputParameters.GetParameter(i).Key, ids.InputParameters.GetParameter(i).Value);
}
if (ids.InputParameters.GetParameter(i).Step == "delete")
{
isDeletePatient = true;
}
}
if (isCreatePatient)
{
XMLResult result = ps.createPatient(pa);
if (!result.IsErrorOccured)
{
patientUID = result.SingleResult;
pCreate.Result = TestResult.Pass;
pCreate.Outputs.AddParameter("create", "Create patient UID", patientUID);
}
}
CheckPoint pImport = new CheckPoint("Import Image", "Test import");
r.CheckPoints.Add(pImport);
string filePath = string.Empty;
string archivePath = string.Empty;
bool move = false;
for (int c = 0; c < ia.Length; c++)
{
if (ia.GetParameterName(c) == "path")
filePath = ia.GetParameterValue(c);
if (ia.GetParameterName(c) == "archivePath")
archivePath = ia.GetParameterValue(c);
if (ia.GetParameterName(c) == "move")
{
if (ia.GetParameterValue(c) == "true")
move = true;
}
}
XMLResult rslImport = ims.importObject(patientUID, "", filePath, archivePath, move, "false");
if (rslImport.IsErrorOccured)
{
pImport.Result = TestResult.Fail;
pImport.Outputs.AddParameter("import", "Import image fail", rslImport.Message);
pImport.Outputs.AddParameter("import", "Import image error code", rslImport.Code.ToString());
}
else
{
pImport.Result = TestResult.Pass;
pImport.Outputs.AddParameter("import", "Import image OK", rslImport.Message);
for (int findPs = 0; findPs < rslImport.MultiResults.Count; findPs++)
{
if (rslImport.MultiResults[findPs].Name == "presentationstate")
{
string psUID = rslImport.MultiResults[findPs].Parameters[0].ParameterValue;
XMLResult psreturn = pss.getPresentationState(psUID);
CheckPoint pGetPS = new CheckPoint("Get Presentation State", "PS Desc");
r.CheckPoints.Add(pGetPS);
if (psreturn.MultiResults.Count == 1 && !string.IsNullOrEmpty(psreturn.MultiResults[0].GetParameterValueByName("image_internal_id")) && string.IsNullOrEmpty(psreturn.MultiResults[0].GetParameterValueByName("general.xml")) && string.IsNullOrEmpty(psreturn.MultiResults[0].GetParameterValueByName("processing.xml")) && string.IsNullOrEmpty(psreturn.MultiResults[0].GetParameterValueByName("annotation.xml")))
{
pGetPS.Result = TestResult.Pass;
pGetPS.Outputs.AddParameter("get presentation state", "get presentation state as expect", psreturn.ResultContent);
}
else
{
pGetPS.Result = TestResult.Fail;
pGetPS.Outputs.AddParameter("get presentation state", "get presentation state not as expect", psreturn.ResultContent);
}
}
}
}
if (isDeletePatient)
{
XMLResult rltDelete = ps.deletePatient(patientUID);
if (!rltDelete.IsErrorOccured)
{
pCreate.Outputs.AddParameter("Delete created patient", "Delete Patient", rltDelete.Message);
}
}
SaveRound(r);
}
Output();
}
public override void Run()
{
string newPatientId = string.Empty;
string psId = string.Empty;
string PsInfoString = string.Empty;
PresentationStateService ps = new PresentationStateService();
try
{
//create a new patient and import a new image to get a new ps id.
newPatientId = CommonLib.CreatePatient();
ImportService import = new ImportService();
XMLResult importResult = import.importObject(newPatientId, string.Empty, @"c:\PASPerformance\001.png", null, true, string.Empty);
psId = importResult.MultiResults[1].GetParameterValueByIndex(0);
//Get PS info string.
PsInfoString = ps.getPresentationState(psId).ArrayResult.GenerateXML();
}
catch (Exception ex)
{
LogRecordType lr = new LogRecordType();
lr.FunctionName = this.mFunctionName;
lr.Lable = this.mLabel;
string innerText = ex.InnerException == null ? string.Empty : ex.InnerException.Message;
lr.Message = ex.Message + innerText == string.Empty ? string.Empty : "(" + innerText + ")";
lr.Passed = false;
Log.AddRecord(lr);
this.RiseSingleCallCompleteEvent(lr.ResponseTime, lr.Passed, true);
this.RiseTestCaseCompleteEvent();
this.mExecuted = this.mRepeat;
this.mFailed = this.mRepeat;
return;
}
for (int i = 1; i <= this.mRepeat; i++)
{
LogRecordType lr = new LogRecordType();
lr.Lable = this.mLabel;
lr.FunctionName = this.mFunctionName;
double userCaseResponse = 0;
try
{
//get ps
XMLResult getPsResult = ps.getPresentationState(psId);
if (getPsResult.IsErrorOccured)
{
lr.Passed = false;
lr.Message = getPsResult.Message;
lr.ResponseTime = ps.ResponseTime;
Log.AddRecord(lr);
this.mFailed++;
continue;
}
else
userCaseResponse = ps.ResponseTime;
//set ps
XMLResult setPsResult = new XMLResult(ps.InvokeMethod("setPresentationState", new object[] { PsInfoString, psId }));
if (setPsResult.IsErrorOccured)
{
lr.Passed = false;
lr.Message = setPsResult.Message;
lr.ResponseTime = ps.ResponseTime;
Log.AddRecord(lr);
this.mFailed++;
continue;
}
else
userCaseResponse += ps.ResponseTime;
//if no exception.
lr.Passed = true;
lr.ResponseTime = userCaseResponse;
this.mExectuedTime += userCaseResponse;
}
catch (Exception ex)
{
lr.Passed = false;
string innerText = ex.InnerException == null ? string.Empty : ex.InnerException.Message;
lr.Message = ex.Message + innerText == string.Empty ? string.Empty : "(" + innerText + ")";
this.mFailed++;
}
Log.AddRecord(lr);
this.mExecuted = i;
this.RiseSingleCallCompleteEvent(lr.ResponseTime, lr.Passed);
}
this.RiseTestCaseCompleteEvent();
}
//Case 512: 1.2.3_ImportZip_Normal
public void Run_Import_Zip_Case512()
{
int runCount = 0;
string patientUID = string.Empty;
bool isCreatePatient = false;
bool isDeletePatient = false;
foreach (InputDataSet ids in this.Input.DataSets)
{
isCreatePatient = false;
isDeletePatient = false;
runCount++;
Round r = this.NewRound(runCount.ToString(), "Import image");
CheckPoint pCreate = new CheckPoint("Create Patient", "Test create");
r.CheckPoints.Add(pCreate);
PatientService ps = new PatientService();
ImportService ims = new ImportService();
PresentationStateService pss = new PresentationStateService();
XMLParameter pa = new XMLParameter("patient");
XMLParameter ia = new XMLParameter("import");
XMLParameter ObjFilter = new XMLParameter("filter");
for (int i = 0; i < ids.InputParameters.Count; i++)
{
if (ids.InputParameters.GetParameter(i).Step == "create")
{
pa.AddParameter(ids.InputParameters.GetParameter(i).Key, ids.InputParameters.GetParameter(i).Value);
isCreatePatient = true;
}
if (ids.InputParameters.GetParameter(i).Step == "import")
{
ia.AddParameter(ids.InputParameters.GetParameter(i).Key, ids.InputParameters.GetParameter(i).Value);
}
if (ids.InputParameters.GetParameter(i).Step == "delete")
{
isDeletePatient = true;
}
}
if (isCreatePatient)
{
XMLResult result = ps.createPatient(pa);
if (!result.IsErrorOccured)
{
patientUID = result.SingleResult;
pCreate.Outputs.AddParameter("create", "Create patient UID", patientUID);
pCreate.Result = TestResult.Pass;
}
}
CheckPoint pImport = new CheckPoint("Import Image", "Test import");
r.CheckPoints.Add(pImport);
string filePath = string.Empty;
string archivePath = string.Empty;
bool move = false;
for (int c = 0; c < ia.Length; c++)
{
if (ia.GetParameterName(c) == "path")
filePath = ia.GetParameterValue(c);
if (ia.GetParameterName(c) == "archivePath")
archivePath = ia.GetParameterValue(c);
if (ia.GetParameterName(c) == "move")
{
if (ia.GetParameterValue(c) == "true")
move = true;
}
}
XMLResult rslImport = ims.importObject(patientUID, "", filePath, archivePath, move, "false");
if (rslImport.IsErrorOccured)
{
pImport.Result = TestResult.Fail;
pImport.Outputs.AddParameter("import", "Import image fail", rslImport.Message);
pImport.Outputs.AddParameter("import", "Import image error code", rslImport.Code.ToString());
}
else
{
pImport.Result = TestResult.Pass;
pImport.Outputs.AddParameter("import", "Import image OK", rslImport.Message);
ObjFilter.AddParameter("patient_internal_id", patientUID);
ObjFilter.AddParameter("type", "presentationstate");
ObjFilter.AddParameter("current", "true");
XMLResult listObjcetRsl = ps.listObjects(ObjFilter);
CheckPoint pListObject = new CheckPoint("List Image", "Test list object");
r.CheckPoints.Add(pListObject);
if (listObjcetRsl.IsErrorOccured)
{
pListObject.Result = TestResult.Fail;
pListObject.Outputs.AddParameter("Erron in List Object", "List Object", "List Patient Presentation State Error");
}
else
{
pListObject.Outputs.AddParameter("List Object return content", "List Object", listObjcetRsl.ResultContent);
if (listObjcetRsl.ArrayResult.Length == 3)
{
bool isMatchXML = true;
for (int index = 0; index < listObjcetRsl.ArrayResult.Parameters.Count; index++)
{
XMLResult getPSRsl = pss.getPresentationState(listObjcetRsl.ArrayResult.Parameters[index].ParameterValue);
if (getPSRsl.ArrayResult.Parameters.Count != 4)
{
isMatchXML = false;
pListObject.Outputs.AddParameter("Get PS return content", "Get PS Description", getPSRsl.ResultContent);
break;
}
}
if (isMatchXML)
{
pListObject.Result = TestResult.Pass;
}
else
{
pListObject.Result = TestResult.Fail;
pListObject.Outputs.AddParameter("Get PS description error", "Get PS Description", "Not return all xml and image id");
}
}
else
{
pListObject.Result = TestResult.Fail;
pListObject.Outputs.AddParameter("The PS count not match", "Get All PS Description", "Not three PS be retrieve.");
}
}
}
if (isDeletePatient)
{
XMLResult rslDelete = ps.deletePatient(patientUID);
if (!rslDelete.IsErrorOccured)
{
pImport.Outputs.AddParameter("Delete created patient", "Delete Patient", rslDelete.ResultContent);
}
}
SaveRound(r);
}
Output();
}
//Case 1598: 1.1.06.21_ImportDir_MainDirectory_N01
public void Run_Import_ImportDir_MainDirectory_Case1598()
{
int runCount = 0;
NotificationSim.ReceiveNotification rn = new ReceiveNotification();
System.Collections.Generic.List<string> topics = new System.Collections.Generic.List<string>();
topics.Add("topic.postImportCompleted");
string stopTopic = "teststop";
string stopContent = "teststop";
rn.startListon(topics, stopTopic, stopContent);
foreach (InputDataSet ids in this.Input.DataSets)
{
runCount++;
Round r = this.NewRound(runCount.ToString(), "ImportMainDir");
CheckPoint pimp = new CheckPoint("ImportDir", "Import Additional Dir");
r.CheckPoints.Add(pimp);
//create patient for import
PatientService ps = new PatientService();
XMLParameter cInputPatient = new XMLParameter("patient");
cInputPatient.AddParameter("first_name", "test");
cInputPatient.AddParameter("last_name", "importmaindir");
XMLResult rslCreate = ps.createPatient(cInputPatient);
if (rslCreate.IsErrorOccured)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "Create Patient Fail", rslCreate.Message);
SaveRound(r);
continue;
}
string patientid = rslCreate.SingleResult;
try
{
string kdis6dir = ids.InputParameters.GetParameter("kdis6_dir").Value;
int retrynum = int.Parse(ids.InputParameters.GetParameter("retrynum").Value);
string flag = "import";
ImportService imps = new ImportService();
XMLResult rslimport = imps.importDir(patientid, kdis6dir, flag);
if (rslimport.Code != 800)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "Import Fail", rslimport.Message);
SaveRound(r);
ps.deletePatient(patientid);
continue;
}
int n = 0;
while (rn.getRecievedNumber() == 0)
{
n++;
if (n < retrynum)
{
System.Threading.Thread.Sleep(5000);
}
else
{
break;
}
}
if (n == retrynum)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "Notification Fail", "No notification recieved after retry " + n.ToString() + " times.");
SaveRound(r);
ps.deletePatient(patientid);
continue;
}
ApplicationService app = new ApplicationService();
app.sendGenericNotification(stopTopic, stopContent);
System.Threading.Thread.Sleep(1000);
System.Collections.Generic.List<string> mmm = rn.getNotificationContent();
System.Collections.Generic.List<string> imageids = PAS.AutoTest.TestUtility.Utility.parsePostImportResult("Image", mmm[0]);
System.Collections.Generic.List<string> fmsids = PAS.AutoTest.TestUtility.Utility.parsePostImportResult("FMS", mmm[0]);
System.Collections.Generic.List<string> analysisids = PAS.AutoTest.TestUtility.Utility.parsePostImportResult("Analysis", mmm[0]);
int expectedimgcount = int.Parse(ids.ExpectedValues.GetParameter("imgnum").Value);
int expectedfmscount = int.Parse(ids.ExpectedValues.GetParameter("fmsnum").Value);
int expectedanalysiscount = int.Parse(ids.ExpectedValues.GetParameter("analysisnum").Value);
//check counts
if (imageids.Count != expectedimgcount)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "Image Count is not correct", "Actual:" + imageids.Count.ToString() + ",Expected:" + expectedimgcount.ToString());
SaveRound(r);
ps.deletePatient(patientid);
continue;
}
if (fmsids.Count != expectedfmscount)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "FMS Count is not correct", "Actual:" + fmsids.Count.ToString() + ",Expected:" + expectedfmscount.ToString());
SaveRound(r);
ps.deletePatient(patientid);
continue;
}
if (analysisids.Count != expectedanalysiscount)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "Analysis Count is not correct", "Actual:" + analysisids.Count.ToString() + ",Expected:" + expectedanalysiscount.ToString());
SaveRound(r);
ps.deletePatient(patientid);
continue;
}
//get image info
ImageService imgs = new ImageService();
foreach (string imgid in imageids)
{
XMLParameter cInputImage = new XMLParameter("image");
cInputImage.AddParameter("internal_id", imgid);
XMLResult rslget = imgs.getImageInfo(cInputImage);
if (rslget.IsErrorOccured)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "GetImage Fail", rslget.Message);
SaveRound(r);
ps.deletePatient(patientid);
goto error;
}
}
//get FMS info
FMSService fmss = new FMSService();
foreach (string fmsid in fmsids)
{
XMLResult rslget = fmss.getFMSInfo(fmsid);
if (rslget.IsErrorOccured)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "GetFMS Fail", rslget.Message);
SaveRound(r);
ps.deletePatient(patientid);
goto error;
}
rslget = fmss.getFMSDescription(fmsid);
if (rslget.IsErrorOccured)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "GetFMS Fail", rslget.Message);
SaveRound(r);
ps.deletePatient(patientid);
goto error;
}
}
//get Analysis info
AnalysisService anas = new AnalysisService();
foreach (string analysisid in analysisids)
{
XMLResult rslget = anas.getAnalysisInfo(analysisid);
if (rslget.IsErrorOccured)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "GetAnalysis Fail", rslget.Message);
SaveRound(r);
ps.deletePatient(patientid);
goto error;
}
rslget = anas.getAnalysisDescription(analysisid);
if (rslget.IsErrorOccured)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "GetAnalysis Fail", rslget.Message);
SaveRound(r);
ps.deletePatient(patientid);
goto error;
}
}
//check list object
NewPatientService nps = new NewPatientService();
PatientListObjectsRequestType request = new PatientListObjectsRequestType();
request.currentSpecified = true;
request.current = true;
request.patientInternalId = patientid;
request.type = PatientListObjectsType.all;
PatientListObjectsResponseType response = nps.listObjects(request);
//to refresh code 800 to 0
response = nps.listObjects(request);
if (!nps.LastReturnXMLValidateResult.isValid)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "list object fail", "Response is not complied with schema");
SaveRound(r);
ps.deletePatient(patientid);
continue;
}
if (response.status.code != 0)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "list object fail,message: ", response.status.message);
SaveRound(r);
ps.deletePatient(patientid);
continue;
}
int expectedcurrentps = int.Parse(ids.ExpectedValues.GetParameter("curpsnum").Value);
int expectedcurrentfms = int.Parse(ids.ExpectedValues.GetParameter("curfmsnum").Value);
int expectedcurrentanalysis = int.Parse(ids.ExpectedValues.GetParameter("curanalysisnum").Value);
if (response.presentationStates.Length != expectedcurrentps)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "list object fail,current image count not correct: ", "actural:" + response.presentationStates.Length.ToString() + " expect:" + expectedcurrentps.ToString());
SaveRound(r);
ps.deletePatient(patientid);
continue;
}
//get PS
PresentationStateService pss = new PresentationStateService();
foreach (PresentationStateType pst in response.presentationStates)
{
XMLResult rslget = pss.getPresentationState(pst.uid);
if (rslget.IsErrorOccured)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "get PS fail: ", rslget.Message);
SaveRound(r);
ps.deletePatient(patientid);
goto error;
}
}
if (response.analysiss != null)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "list object fail,current analysis count not correct: ", "Expect no analysis will be returned");
SaveRound(r);
ps.deletePatient(patientid);
continue;
}
if (response.fmss.Length != expectedcurrentfms)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "list object fail,current fms count not correct: ", "actural:" + response.fmss.Length.ToString() + " expect:" + expectedcurrentfms.ToString());
SaveRound(r);
ps.deletePatient(patientid);
continue;
}
//list noncurrent objects
request.currentSpecified = true;
request.current = false;
request.patientInternalId = patientid;
request.type = PatientListObjectsType.all;
response = nps.listObjects(request);
int expectednoncurrentps = int.Parse(ids.ExpectedValues.GetParameter("noncurpsnum").Value);
int expectednoncurrentfms = int.Parse(ids.ExpectedValues.GetParameter("noncurfmsnum").Value);
int expectednoncurrentanalysis = int.Parse(ids.ExpectedValues.GetParameter("noncuranalysisnum").Value);
if (response.presentationStates.Length != expectednoncurrentps)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "list object fail, non current ps count not correct: ", "actual:" + response.presentationStates.Length.ToString() + " expect:" + expectednoncurrentanalysis.ToString());
SaveRound(r);
ps.deletePatient(patientid);
continue;
}
//get PS
foreach (PresentationStateType pst in response.presentationStates)
{
XMLResult rslget = pss.getPresentationState(pst.uid);
if (rslget.IsErrorOccured)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "get PS fail: ", rslget.Message);
SaveRound(r);
ps.deletePatient(patientid);
goto error;
}
}
//check 3d object
if (response.volumes.Length != int.Parse(ids.ExpectedValues.GetParameter("expect3dnum").Value))
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "Import 3d objects fail: ", "Count is " + response.volumes.Length.ToString() + ",expect:" + ids.ExpectedValues.GetParameter("expect3dnum").Value);
SaveRound(r);
ps.deletePatient(patientid);
continue;
}
if (response.analysiss.Length != expectednoncurrentanalysis)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "list object fail,non current analysis count not correct: ", "actual:" + response.analysiss.Length.ToString() + " expect:" + expectednoncurrentanalysis.ToString());
SaveRound(r);
ps.deletePatient(patientid);
continue;
}
if (response.fmss.Length != expectednoncurrentfms)
{
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "list object fail,non current fms count not correct: ", "actual:" + response.fmss.Length.ToString() + " expect:" + expectednoncurrentfms.ToString());
SaveRound(r);
ps.deletePatient(patientid);
continue;
}
//Finally the test success
pimp.Result = TestResult.Pass;
pimp.Outputs.AddParameter("Import Main Dir", "Success", "OK");
SaveRound(r);
ps.deletePatient(patientid);
}
catch (Exception e)
{
ps.deletePatient(patientid);
pimp.Result = TestResult.Fail;
pimp.Outputs.AddParameter("Import Main Dir", "Fail", "Exception caught,message:" + e.Message);
SaveRound(r);
}
}
error:
Output();
}
// Case 1203: 1.3.10_ImportImage_N07_Import single 8100 dicom thin layer slice
public void Run_Import_8100Slice_Case1203()
{
int runCount = 0;
string patientUID = string.Empty;
bool isCreatePatient = false;
bool isDeletePatient = true;
foreach (InputDataSet ids in this.Input.DataSets)
{
isCreatePatient = false;
runCount++;
Round r = this.NewRound(runCount.ToString(), "Import image");
ImportService ims = new ImportService();
XMLParameter pa = new XMLParameter("patient");
XMLParameter ia = new XMLParameter("import");
for (int i = 0; i < ids.InputParameters.Count; i++)
{
if (ids.InputParameters.GetParameter(i).Step == "create")
{
pa.AddParameter(ids.InputParameters.GetParameter(i).Key, ids.InputParameters.GetParameter(i).Value);
isCreatePatient = true;
}
if (ids.InputParameters.GetParameter(i).Step == "import")
{
ia.AddParameter(ids.InputParameters.GetParameter(i).Key, ids.InputParameters.GetParameter(i).Value);
}
}
string epGetImageInfoImageType = null;
string epGetImageInfoAnatomicRegion = null;
string epGetImageInfoAnatomicRegionModifiers = null;
string epGetPSInfoImageType = null;
string epGetPSInfoAnatomicRegion = null;
string epGetPSInfoAnatomicRegionModifiers = null;
for (int i = 0; i < ids.ExpectedValues.Count; i++)
{
if (ids.ExpectedValues.GetParameter(i).Step == "getImageInfo")
{
switch (ids.ExpectedValues.GetParameter(i).Key)
{
case "image_type":
epGetImageInfoImageType = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_anatomic_region":
epGetImageInfoAnatomicRegion = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_anatomic_region_modifiers":
epGetImageInfoAnatomicRegionModifiers = ids.ExpectedValues.GetParameter(i).Value;
break;
default:
break;
}
}
else if (ids.ExpectedValues.GetParameter(i).Step == "getPresentationStateInfo")
{
switch (ids.ExpectedValues.GetParameter(i).Key)
{
case "image_type":
epGetPSInfoImageType = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_anatomic_region":
epGetPSInfoAnatomicRegion = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_anatomic_region_modifiers":
epGetPSInfoAnatomicRegionModifiers = ids.ExpectedValues.GetParameter(i).Value;
break;
default:
break;
}
}
}
try
{
PatientService patientSvc = new PatientService();
if (isCreatePatient)
{
CheckPoint pCreate = new CheckPoint("Create Patient", "Test create");
r.CheckPoints.Add(pCreate);
XMLResult result = patientSvc.createPatient(pa);
if (!result.IsErrorOccured)
{
patientUID = result.SingleResult;
pCreate.Result = TestResult.Pass;
pCreate.Outputs.AddParameter("Create patient UID", "Create Patient", patientUID);
}
else
{
pCreate.Result = TestResult.Fail;
pCreate.Outputs.AddParameter("Create patient returns error", "Create Patient", result.ResultContent);
}
}
CheckPoint pImport = new CheckPoint("Import Image", "Test import");
r.CheckPoints.Add(pImport);
string filePath = string.Empty;
string archivePath = string.Empty;
bool move = false;
for (int c = 0; c < ia.Length; c++)
{
if (ia.GetParameterName(c) == "path")
filePath = ia.GetParameterValue(c);
if (ia.GetParameterName(c) == "archivePath")
archivePath = ia.GetParameterValue(c);
if (ia.GetParameterName(c) == "move")
{
if (ia.GetParameterValue(c) == "true")
move = true;
}
}
XMLResult rslImport = ims.importObject(patientUID, "", filePath, archivePath, move, "false");
//import return sample:
// <trophy type="result" version="1.0">
// <status code="0" message="ok" />
// <image><parameter key="internal_id" value="2bfb416b-037e-41e7-aaef-8d2bd08b1ae7" /></image>
// <presentationstate><parameter key="internal_id" value="75675345-a164-4088-b6d3-1b2ae86b703b" /></presentationstate>
// </trophy>
if (rslImport.IsErrorOccured)
{
pImport.Result = TestResult.Fail;
pImport.Outputs.AddParameter("Import image fail", "Import", rslImport.Message);
pImport.Outputs.AddParameter("Import image returns error code", "Import", rslImport.Code.ToString());
}
else
{
// Check the return contiains image id and ps id
string imageID = null;
imageID = rslImport.MultiResults[0].GetParameterValueByName("internal_id"); // image internal_id
if (imageID == null || imageID == string.Empty)
{
pImport.Result = TestResult.Fail;
pImport.Outputs.AddParameter("Import image returns wrong image internal id", "Import", rslImport.ResultContent);
}
string psID = null;
psID = rslImport.MultiResults[1].GetParameterValueByName("internal_id"); // ps internal_id
if (psID == null || psID == string.Empty)
{
pImport.Result = TestResult.Fail;
pImport.Outputs.AddParameter("import image returns wrong ps internal id", "Import", rslImport.ResultContent);
}
else
{
pImport.Result = TestResult.Pass;
pImport.Outputs.AddParameter("import image returns OK", "Import", rslImport.ResultContent);
}
#region Call getImageInfo to check image_type and anatomic_region
ImageService imageSvc = new ImageService();
PresentationStateService psSvc = new PresentationStateService();
XMLParameter pGetImageInfo = new XMLParameter("image");
pGetImageInfo.AddParameter("internal_id", imageID);
CheckPoint cpGetImageInfo = new CheckPoint("GetImageInfo", "Call GetImageInfo to check the dcm_anatomic_region value");
r.CheckPoints.Add(cpGetImageInfo);
XMLResult rtGetImageInfo = imageSvc.getImageInfo(pGetImageInfo);
if (rtGetImageInfo.IsErrorOccured)
{
cpGetImageInfo.Result = TestResult.Fail;
cpGetImageInfo.Outputs.AddParameter("Get Image Info return error", "getImageInfo", rtGetImageInfo.ResultContent);
}
else
{
cpGetImageInfo.Outputs.AddParameter("Get Image Info return success", "getImageInfo", rtGetImageInfo.Message);
// Check the image_type, anatomic_region values in return are correct
if (!rtGetImageInfo.ResultContent.Contains("parameter key=\"image_type\" value=\"" + epGetImageInfoImageType + "\"")) //parameter key="image_type" value="PANOV6"
{
cpGetImageInfo.Result = TestResult.Fail;
cpGetImageInfo.Outputs.AddParameter("Get Image Info return wrong image_type info", "getImageInfo", rtGetImageInfo.ResultContent);
}
else if (!rtGetImageInfo.ResultContent.Contains("parameter key=\"dcm_anatomic_region\" value=\"" + epGetImageInfoAnatomicRegion + "\"")) // parameter key="dcm_anatomic_region" value="Jaw region"
{
cpGetImageInfo.Result = TestResult.Fail;
cpGetImageInfo.Outputs.AddParameter("Get Image Info return wrong dcm_anatomic_region info", "getImageInfo", rtGetImageInfo.ResultContent);
}
else if (!rtGetImageInfo.ResultContent.Contains("parameter key=\"dcm_anatomic_region_modifiers\" value=\"" + epGetImageInfoAnatomicRegionModifiers + "\"")) // parameter key="dcm_anatomic_region_modifiers" value="Molar 1"
{
cpGetImageInfo.Result = TestResult.Fail;
cpGetImageInfo.Outputs.AddParameter("Get Image Info return wrong dcm_anatomic_region_modifiers info", "getImageInfo", rtGetImageInfo.ResultContent);
}
else
{
cpGetImageInfo.Result = TestResult.Pass;
cpGetImageInfo.Outputs.AddParameter("Get Image Info return correct info", "getImageInfo", rtGetImageInfo.ResultContent);
}
}
XMLParameterCollection pGetPSInfo = new XMLParameterCollection();
XMLParameter psList = new XMLParameter("presentationstate");
psList.AddParameter("internal_id", psID);
pGetPSInfo.Add(psList);
CheckPoint cpGetPSInfo = new CheckPoint("GetPSInfo", "Call GetPSInfo to check the dcm_anatomic_region value");
r.CheckPoints.Add(cpGetPSInfo);
XMLResult rtGetPSInfo = psSvc.getPresentationStateInfo(pGetPSInfo);
if (rtGetPSInfo.IsErrorOccured)
{
cpGetPSInfo.Result = TestResult.Fail;
cpGetPSInfo.Outputs.AddParameter("Get PS Info return error", "GetPSInfo", rtGetPSInfo.ResultContent);
}
else
{
cpGetPSInfo.Outputs.AddParameter("Get PS Info return success", "GetPSInfo", rtGetPSInfo.Message);
// Check the image_type, anatomic_region values in return are correct
if (!rtGetPSInfo.ResultContent.Contains("parameter key=\"image_type\" value=\"" + epGetPSInfoImageType + "\"")) //parameter key="image_type" value="PANOV6"
{
cpGetPSInfo.Result = TestResult.Fail;
cpGetPSInfo.Outputs.AddParameter("Get PS Info return wrong image_type info", "GetPSInfo", rtGetPSInfo.ResultContent);
}
else if (!rtGetPSInfo.ResultContent.Contains("parameter key=\"dcm_anatomic_region\" value=\"" + epGetPSInfoAnatomicRegion + "\"")) // parameter key="dcm_anatomic_region" value="Jaw region"
{
cpGetPSInfo.Result = TestResult.Fail;
cpGetPSInfo.Outputs.AddParameter("Get PS Info return wrong dcm_anatomic_region info", "GetPSInfo", rtGetPSInfo.ResultContent);
}
else if (!rtGetPSInfo.ResultContent.Contains("parameter key=\"dcm_anatomic_region_modifiers\" value=\"" + epGetPSInfoAnatomicRegionModifiers + "\"")) // parameter key="dcm_anatomic_region_modifiers" value="Molar 1"
{
cpGetPSInfo.Result = TestResult.Fail;
cpGetPSInfo.Outputs.AddParameter("Get PS Info return wrong dcm_anatomic_region_modifiers info", "GetPSInfo", rtGetPSInfo.ResultContent);
}
else
{
cpGetPSInfo.Result = TestResult.Pass;
cpGetPSInfo.Outputs.AddParameter("Get PS Info return correct info", "GetPSInfo", rtGetPSInfo.ResultContent);
}
}
CheckPoint cpGetPS = new CheckPoint("GetPS", "Call GetPS to check the ps xml info");
r.CheckPoints.Add(cpGetPS);
XMLResult rtGetPS = psSvc.getPresentationState(psID);
if (rtGetPS.IsErrorOccured)
{
cpGetPS.Result = TestResult.Fail;
cpGetPS.Outputs.AddParameter("Get PS return error", "GetPS", rtGetPS.ResultContent);
}
else
{
cpGetPS.Outputs.AddParameter("Get PS return success", "GetPS", rtGetPS.Message);
if (rtGetPS.ResultContent.Contains("parameter key=\"general.xml\"") && rtGetPS.ResultContent.Contains("parameter key=\"processing.xml\"") && rtGetPS.ResultContent.Contains("parameter key=\"annotation.xml\"")) // Should return empty ps info for this case as there is not
{
cpGetPS.Result = TestResult.Pass;
cpGetPS.Outputs.AddParameter("Get PS return correct info", "GetPS", rtGetPS.ResultContent);
}
else
{
cpGetPS.Result = TestResult.Fail;
cpGetPS.Outputs.AddParameter("Get PS return wrong content", "GetPS", rtGetPS.ResultContent);
}
}
#endregion
}
if (isDeletePatient)
{
CheckPoint cpDelete = new CheckPoint("Delete Patient", "Test delete patient");
r.CheckPoints.Add(cpDelete);
XMLResult rltDelete = patientSvc.deletePatient(patientUID);
if (rltDelete.IsErrorOccured)
{
cpDelete.Outputs.AddParameter("Delete created patient returns error", "Delete Patient", rltDelete.Message);
cpDelete.Result = TestResult.Fail;
}
else
{
cpDelete.Outputs.AddParameter("Delete created patient returns OK", "Delete Patient", rltDelete.Message);
cpDelete.Result = TestResult.Pass;
}
}
SaveRound(r);
}
catch (Exception ex)
{
CheckPoint cp = new CheckPoint();
r.CheckPoints.Add(cp);
cp.Outputs.AddParameter("Exception thrown", "Exception Message", ex.Message);
cp.Result = TestResult.Fail;
SaveRound(r);
}
}
Output();
}
public void Run_Acquisition_RotateAdjustRetaken_Case1640()
{
int runCount = 0;
foreach (InputDataSet ids in this.Input.DataSets)
{
runCount++;
ReceiveNotification rn = new ReceiveNotification();
List<string> topics = new List<string>();
topics.Add("topic.imageCreated");
string stopTopic = "teststop";
string stopContent = "teststop";
rn.startListon(topics, stopTopic, stopContent);
string acqType = string.Empty;
Round r = this.NewRound(runCount.ToString(), "7600CR Acquisition");
CheckPoint pAcq = new CheckPoint("Acquire Image", "Acquisition CR7600");
r.CheckPoints.Add(pAcq);
AcquisitionService acqs = new AcquisitionService();
XMLParameter acq = new XMLParameter("acq_info");
for (int i = 0; i < ids.InputParameters.Count; i++)
{
if (ids.InputParameters.GetParameter(i).Step == "acquire")
{
acq.AddParameter(ids.InputParameters.GetParameter(i).Key, ids.InputParameters.GetParameter(i).Value);
}
if (ids.InputParameters.GetParameter(i).Step == "acquireType")
{
acqType = ids.InputParameters.GetParameter(i).Value;
}
}
XMLResult rslAcq = acqs.startAcquisition(acq);
if (rslAcq.IsErrorOccured)
{
System.Diagnostics.Debug.Print("Acquire fail:");
pAcq.Result = TestResult.Fail;
pAcq.Outputs.AddParameter("Acquire image error", "startAcquisition", rslAcq.Message);
SaveRound(r);
continue;
}
System.Threading.Thread.Sleep(15000);
System.Diagnostics.Process p = new System.Diagnostics.Process();
switch (acqType)
{
case "rotate":
p.StartInfo.FileName = "7600helperRotate.exe";
break;
case "adjust":
p.StartInfo.FileName = "7600helperAdjust.exe";
break;
case "retaken":
p.StartInfo.FileName = "7600helperRetaken.exe";
break;
}
p.Start();
p.WaitForExit();
int retrynum = 24;
int n = 0;
while (rn.getRecievedNumber() == 0)
{
n++;
if (n < retrynum)
{
System.Threading.Thread.Sleep(5000);
}
else
break;
}
if (n == retrynum)
{
pAcq.Result = TestResult.Fail;
pAcq.Outputs.AddParameter("Acquire 7600", "Notification Fail", @"Recieve Notification Timeout(120 seconds)");
SaveRound(r);
continue;
}
System.Threading.Thread.Sleep(15000);
ApplicationService apps = new ApplicationService();
apps.sendGenericNotification(stopTopic, stopContent);
System.Threading.Thread.Sleep(1000);
List<string> mmm = rn.getNotificationContent();
ImageService imgs = new ImageService();
if (acqType == "retaken")
{
int notificationNum = mmm.Count;
if (notificationNum != 3)
{
pAcq.Result = TestResult.Fail;
pAcq.Outputs.AddParameter("Acquire 7600", "Notification number not correct", " Actual:" + notificationNum.ToString() + "Expect:3");
SaveRound(r);
continue;
}
foreach (string msg in mmm)
{
string[] token = msg.Split('=');
string imageid = token[token.Length - 1];
XMLParameter cImg = new XMLParameter("image");
cImg.AddParameter("internal_id", imageid);
XMLResult rslGetRetaken = imgs.getImageInfo(cImg);
if (rslGetRetaken.IsErrorOccured)
{
pAcq.Result = TestResult.Fail;
pAcq.Outputs.AddParameter("Acquire 7600", "Get Retaken Image Fail", rslGetRetaken.Message);
SaveRound(r);
goto error;
}
}
goto retaken;
error:
continue;
}
string[] token1 = mmm[0].Split('=');
string imageid1 = token1[token1.Length - 1];
XMLParameter img = new XMLParameter("image");
img.AddParameter("internal_id", imageid1);
XMLResult rslGet = imgs.getImageInfo(img);
if (rslGet.IsErrorOccured)
{
pAcq.Result = TestResult.Fail;
pAcq.Outputs.AddParameter("Acquire 7600", "GetImage Fail", rslGet.Message);
SaveRound(r);
continue;
}
XMLParameter filter = new XMLParameter("filter");
filter.AddParameter("current", "true");
XMLResult rslListPS = imgs.listPresentationState(filter, imageid1);
string psid = rslListPS.SingleResult;
PresentationStateService pss = new PresentationStateService();
XMLResult rslget = pss.getPresentationState(psid);
string processingXml = rslget.MultiResults[0].Parameters[0].ParameterValue.Trim();
ProcessingXMLParser parser = new ProcessingXMLParser(processingXml);
ProcessingXMLInfo pinfo = parser.parse();
if (acqType == "rotate" && pinfo.Rotate180Enabled != "true")
{
pAcq.Result = TestResult.Fail;
pAcq.Outputs.AddParameter("Acquire 7600", "ProcessingXML not correct", "Rotate180 is " + pinfo.Rotate180Enabled);
SaveRound(r);
continue;
}
if (acqType == "adjust" && pinfo.BrightnessEnabled != "true" && pinfo.BrightnessValue == "0")
{
pAcq.Result = TestResult.Fail;
pAcq.Outputs.AddParameter("Acquire 7600", "ProcessingXML not correct", "BrightnessValue is 0");
SaveRound(r);
continue;
}
retaken:
pAcq.Result = TestResult.Pass;
pAcq.Outputs.AddParameter("Acquire 7600", "Success", "OK");
SaveRound(r);
}
Output();
}
