void RunCurrent(Tests.Engine.FeatureDefinitionMode mode)
{
TreeNode node = tvTestCases.SelectedNode;
if (node != null)
{
TestInfo testInfo = (TestInfo)node.Tag;
TestSuiteParameters parameters = _controller.GetParameters();
parameters.FeatureDefinition = mode;
if (testInfo != null)
{
parameters.TestCases.Add(testInfo);
}
else
{
var tests = new List <TestInfo>();
AddChildNodes(node, tests);
parameters.TestCases = new ExecutableTestList(tests.OrderBy(t => t.Order));
}
ClearTestInfo();
_controller.RunSingle(parameters);
}
}
/// <summary>
/// Collects parameters for launching current test/current test group/all selected tests
/// </summary>
/// <returns></returns>
TestSuiteParameters GetParameters()
{
TestSuiteParameters parameters = new TestSuiteParameters();
DiscoveredDevices devices = ContextController.GetDiscoveredDevices();
parameters.Address = devices.ServiceAddress;
parameters.CameraIP = devices.DeviceAddress;
parameters.NetworkInterfaceController = devices.NIC;
if ((devices.Current != null) && (devices.Current.ByDiscovery != null))
{
parameters.CameraUUID = devices.Current.ByDiscovery.UUID;
}
DeviceEnvironment environment = ContextController.GetDeviceEnvironment();
parameters.MessageTimeout = environment.Timeouts.Message;
parameters.RebootTimeout = environment.Timeouts.Reboot;
parameters.TimeBetweenTests = environment.Timeouts.InterTests;
parameters.InteractiveFirst = tsbInteractiveFirst.Checked;
parameters.PTZNodeToken = environment.TestSettings.PTZNodeToken;
parameters.UseEmbeddedPassword = environment.TestSettings.UseEmbeddedPassword;
parameters.Password1 = environment.TestSettings.Password1;
parameters.Password2 = environment.TestSettings.Password2;
parameters.OperationDelay = environment.TestSettings.OperationDelay;
parameters.Features.AddRange(environment.Features);
return(parameters);
}
/// <summary>
/// Raises TestSuiteStarted event if handler is not empty
/// </summary>
/// <param name="parameters"></param>
/// <param name="conformance"></param>
protected void ReportTestSuiteStarted(TestSuiteParameters parameters, bool conformance)
{
if (TestSuiteStarted != null)
{
TestSuiteStarted(parameters, conformance);
}
}
/// <summary>
/// Launches tests.
/// </summary>
/// <param name="parameters">Parameters passed from the View.</param>
/// <param name="single">True if "Run current" button is in use. If "Run current" button has
/// been clicked, results collected by this moment will not be cleared.</param>
/// <param name="conformance"></param>
protected void InternalRun(TestSuiteParameters parameters, bool single, bool conformance)
{
_running = true;
EnableScrolling(true);
if (!single)
{
_testResults.Clear();
_testExecutionTime = DateTime.Now;
}
if (parameters.FeatureDefinition == FeatureDefinitionMode.Define)
{
_testResults.Clear();
}
_conformance = conformance;
_runningSingle = single;
ReportTestSuiteStarted(parameters, conformance);
if (parameters.FeatureDefinition == FeatureDefinitionMode.Define)
{
_td.RequestFeatures(parameters);
}
else
{
_td.Run(parameters);
}
}
/// <summary>
/// Run selected test or tests in selected group.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void tsbRunCurrent_Click(object sender, EventArgs e)
{
TreeNode node = tvTestCases.SelectedNode;
if (node != null)
{
TestInfo testInfo = (TestInfo)node.Tag;
TestSuiteParameters parameters = _controller.GetParameters();
if (testInfo != null)
{
parameters.TestCases.Add(testInfo);
}
else
{
List <TestInfo> tests = new List <TestInfo>();
AddChildNodes(node, tests);
List <TestInfo> allowedTests = new List <TestInfo>();
allowedTests.AddRange(tests);
parameters.TestCases.AddRange(allowedTests.OrderBy(t => t.Order));
}
ClearTestInfo();
_controller.RunSingle(parameters);
}
}
/// <summary>
/// Collects parameters for launching current test/current test group/all selected tests
/// </summary>
/// <returns></returns>
public TestSuiteParameters GetParameters()
{
TestSuiteParameters parameters = new TestSuiteParameters();
DiscoveredDevices devices = ContextController.GetDiscoveredDevices();
parameters.Address = devices.ServiceAddress;
parameters.CameraIP = devices.DeviceAddress;
parameters.NetworkInterfaceController = devices.NIC;
if ((devices.Current != null) && (devices.Current.ByDiscovery != null))
{
parameters.CameraUUID = devices.Current.ByDiscovery.UUID;
}
DeviceEnvironment env = ContextController.GetDeviceEnvironment();
parameters.UserName = env.Credentials.UserName;
parameters.Password = env.Credentials.Password;
parameters.UseUTCTimestamp = env.Credentials.UseUTCTimeStamp;
DeviceEnvironment environment = ContextController.GetDeviceEnvironment();
parameters.MessageTimeout = environment.Timeouts.Message;
parameters.RebootTimeout = environment.Timeouts.Reboot;
parameters.TimeBetweenTests = environment.Timeouts.InterTests;
parameters.PTZNodeToken = environment.TestSettings.PTZNodeToken;
parameters.EnvironmentSettings = new Tests.Common.TestEngine.EnvironmentSettings()
{
DnsIpv4 = env.EnvironmentSettings.DnsIpv4,
NtpIpv4 = env.EnvironmentSettings.NtpIpv4,
DnsIpv6 = env.EnvironmentSettings.DnsIpv6,
NtpIpv6 = env.EnvironmentSettings.NtpIpv6,
DefaultGateway = env.EnvironmentSettings.GatewayIpv4,
DefaultGatewayIpv6 = env.EnvironmentSettings.GatewayIpv6
};
parameters.UseEmbeddedPassword = environment.TestSettings.UseEmbeddedPassword;
parameters.Password1 = environment.TestSettings.Password1;
parameters.Password2 = environment.TestSettings.Password2;
parameters.SecureMethod = environment.TestSettings.SecureMethod;
parameters.VideoSourceToken = environment.TestSettings.VideoSourceToken;
parameters.OperationDelay = environment.TestSettings.OperationDelay;
parameters.RecoveryDelay = environment.TestSettings.RecoveryDelay;
parameters.EventTopic = environment.TestSettings.EventTopic;
parameters.SubscriptionTimeout = environment.TestSettings.SubscriptionTimeout;
parameters.TopicNamespaces = environment.TestSettings.TopicNamespaces;
parameters.RelayOutputDelayTimeMonostable = environment.TestSettings.RelayOutputDelayTimeMonostable;
Dictionary <string, object> advanced = new Dictionary <string, object>();
foreach (object o in environment.TestSettings.AdvancedSettings)
{
advanced.Add(o.GetType().GUID.ToString(), o);
}
parameters.AdvancedPrameters = advanced;
return(parameters);
}
private void btnDiscoveryTest_Click(object sender, EventArgs e)
{
listViewTrace.Items.Clear();
richTextBoxStepRequest.Text = string.Empty;
richTextBoxStepAnswer.Text = string.Empty;
richTextBoxException.Text = string.Empty;
btnDiscoveryTest.Enabled = false;
btnStop.Enabled = true;
btnPause.Enabled = true;
btnHalt.Enabled = true;
_testIsRunning = true;
TestSuiteParameters parameters = new TestSuiteParameters();
foreach (TestInfo ti in _selectedTests)
{
parameters.TestCases.Add(ti.Method);
}
parameters.Address = tbAddress.Text;
try
{
_td = new TestDispatcher();
_td.OnException += new Action<Exception>(_tr_OnException);
_td.OnStepCompleted += ts_OnStepCompleted;
_td.OnTestSuiteCompleted += new Action(_tr_OnTestSuiteCompleted);
_td.Run(parameters);
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
}
}
/// <summary>
/// Launches single test.
/// </summary>
/// <param name="parameters">Test suite parameters.</param>
public void RunSingle(TestSuiteParameters parameters)
{
if (View.ProfilesView != null)
{
View.ProfilesView.ClearProfiles();
}
RunDiagnostic(parameters, true);
}
public void AddTestCases(TestSuiteParameters parameters, bool clear = true)
{
if (clear)
{
parameters.AllTestCases.Clear();
}
parameters.AllTestCases.AddRange(_testInfos.OrderBy(TI => TI.ExecutionOrder).ThenBy(T => T.Category).ThenBy(t => t.Order));
}
/// <summary>
/// Runs tests as in conformance mode
/// </summary>
public void RunAll()
{
_td.ResetFeatures();
Clear(true);
View.SelectTests(new TestInfo[0]);
TestSuiteParameters parameters = GetParameters();
parameters.DefineProfiles = true;
RunDiagnostic(parameters, false);
}
private TestLogFull GetTestLog(TestSuiteParameters testSuiteParameters,
SerializableTestingParameters parameters,
TestController controller)
{
controller.UpdateTestLog();
TestLogFull testLog = new TestLogFull();
Data.TestLog log = ContextController.GetTestLog();
testLog.TestResults = log.TestResults;
testLog.Features = log.Features;
testLog.InitializationData = log.InitializationData;
testLog.FeaturesDefinitionLog = log.FeaturesDefinitionLog;
testLog.DeviceInformation = controller.DeviceInformation;
if (log.TestExecutionTime != DateTime.MinValue)
{
testLog.TestExecutionTime = log.TestExecutionTime;
}
else
{
testLog.TestExecutionTime = DateTime.Now;
}
testLog.Application = new ApplicationInfo();
testLog.DeviceEnvironment = new DeviceEnvironment();
testLog.DeviceEnvironment.Credentials = new Credentials();
testLog.DeviceEnvironment.Credentials.UserName = testSuiteParameters.UserName;
// password not used for REPORTS
testLog.DeviceEnvironment.TestSettings = new TestSettings();
// only two values are user for log
testLog.DeviceEnvironment.TestSettings.OperationDelay = testSuiteParameters.OperationDelay;
testLog.DeviceEnvironment.TestSettings.RecoveryDelay = testSuiteParameters.RecoveryDelay;
testLog.DeviceEnvironment.Timeouts.InterTests = testSuiteParameters.TimeBetweenTests;
testLog.DeviceEnvironment.Timeouts.Message = testSuiteParameters.MessageTimeout;
testLog.DeviceEnvironment.Timeouts.Reboot = testSuiteParameters.RebootTimeout;
if (parameters.Device != null)
{
testLog.ProductName = parameters.Device.Model;
}
if (parameters.SessionInfo != null)
{
testLog.TesterInfo = parameters.SessionInfo.TesterInfo;
testLog.OtherInformation = parameters.SessionInfo.OtherInformation;
testLog.MemberInfo = parameters.SessionInfo.MemberInfo;
}
return(testLog);
}
void RunSelected(FeatureDefinitionMode mode)
{
ClearTestResults(false);
TestSuiteParameters parameters = _controller.GetParameters();
parameters.FeatureDefinition = mode;
parameters.TestCases = tvTestCases.SelectedTests;
tvTestCases.SelectedTests.Prepare();
//parameters.TestCases.AddRange(tvTestCases.SelectedTests.OrderBy(TI => TI.ExecutionOrder).ThenBy(T => T.Category).ThenBy(t => t.Order));
_controller.Run(parameters);
}
void CompleteTestSuite(TestSuiteParameters parameters, bool bCompletedNormally)
{
if (bCompletedNormally)
{
if (parameters.DefineProfiles)
{
Dictionary <TestInfo, TestStatus> results =
new Dictionary <TestInfo, TestStatus>();
foreach (TestInfo info in _testResults.Keys)
{
results.Add(info, _testResults[info].Log.TestStatus);
}
if (View.ProfilesView != null)
{
Dictionary <Functionality, bool> functionalities = ProfilesSupportInfo.CheckTestResults(results);
View.ProfilesView.DisplaySupportedFunctionality(functionalities);
}
bool failed = _testResults.Values.Where(TR => TR.Log.TestStatus == TestStatus.Failed).Count() > 0;
//
List <IProfileDefinition> failedProfiles = new List <IProfileDefinition>();
List <IProfileDefinition> supportedProfiles = new List <IProfileDefinition>();
if (_initializationData.FailedProfiles.Count != 0 && !failed)
{
failedProfiles.AddRange(_initializationData.FailedProfiles);
}
else if (failed)
{
failedProfiles.AddRange(_initializationData.FailedProfiles);
failedProfiles.AddRange(_initializationData.SupportedProfiles);
}
else
{
supportedProfiles.AddRange(_initializationData.SupportedProfiles);
}
if (View.ProfilesView != null)
{
View.ProfilesView.DisplayProfiles(supportedProfiles, failedProfiles,
_initializationData.UnsupportedProfiles);
}
}
UpdateTestLog();
}
}
/// <summary>
/// Runs tests _as_ in conformance mode
/// </summary>
public void RunAll()
{
_td.ResetFeatures();
Clear(true);
if (View.TestTreeView != null)
{
View.TestTreeView.SelectTests(new TestInfo[0]);
}
TestSuiteParameters parameters = GetParameters();
parameters.TestCases = View.TestTreeView.SelectedTests;
parameters.DefineProfiles = true;
RunDiagnostic(parameters, false);
}
/// <summary>
/// Runs process in diagnostic mode (testing or feature definition).
/// </summary>
/// <param name="parameters"></param>
/// <param name="single"></param>
void RunDiagnostic(TestSuiteParameters parameters, bool single)
{
AddTestCases(parameters, false);
parameters.Profiles.AddRange(_onvifProfiles);
_runningSingle = single;
_testsCount = parameters.TestCases.Count;
parameters.Operator = new Utils.Operator(View.Window);
if (_td.FeaturesDefined)
{
parameters.Features.AddRange(_td.Features);
parameters.Features.AddRange(_td.UndefinedFeatures);
}
InternalRun(parameters, single, false);
}
/// <summary>
/// Runs process in diagnostic mode (testing or feature definition).
/// </summary>
/// <param name="parameters"></param>
/// <param name="single"></param>
void RunDiagnostic(TestSuiteParameters parameters, bool single)
{
parameters.AllTestCases.AddRange(_testInfos.OrderBy(TI => TI.ExecutionOrder).ThenBy(T => T.Category).ThenBy(t => t.Order));
parameters.Profiles.AddRange(_onvifProfiles);
_runningSingle = single;
_testsCount = parameters.TestCases.Count;
parameters.Operator = new Utils.Operator(View.Window);
if (_td.FeaturesDefined)
{
parameters.Features.AddRange(_td.Features);
parameters.Features.AddRange(_td.UndefinedFeatures);
}
InternalRun(parameters, single, false);
}
/// <summary>
/// Runs conformance in silent mode
/// </summary>
/// <param name="parameters"></param>
public void RunConformanceSilent(TestSuiteParameters parameters)
{
_td.ResetFeatures();
Clear(true);
AddTestCases(parameters);
parameters.Operator = new SilentProcessing.SilentOperator();
parameters.VideoForm = View.GetVideoForm();
parameters.DefineProfiles = true;
parameters.Profiles.AddRange(_onvifProfiles);
parameters.Conformance = true;
_runningSingle = false;
InternalRun(parameters, false, true);
}
/// <summary>
/// Handles "TestSuiteCompleted" event.
/// </summary>
/// <param name="parameters"></param>
/// <param name="bCompletedNormally">Indicates whether test suite has not been halted.</param>
void _td_TestSuiteCompleted(TestSuiteParameters parameters, bool bCompletedNormally)
{
if (bCompletedNormally && !_conformance)
{
ReportTestSuiteCompleted();
}
CompleteTestSuite(parameters, bCompletedNormally);
if (TestSuiteCompleted != null)
{
TestSuiteCompleted(bCompletedNormally);
}
_running = false;
}
/// <summary>
/// Runs conformance in silent mode
/// </summary>
/// <param name="parameters"></param>
public void RunConformanceSilent(TestSuiteParameters parameters)
{
_td.ResetFeatures();
Clear(true);
parameters.AllTestCases.Clear();
parameters.AllTestCases.AddRange(_testInfos.OrderBy(TI => TI.ExecutionOrder).ThenBy(T => T.Category).ThenBy(t => t.Order));
parameters.Operator = new SilentProcessing.SilentOperator();
parameters.VideoForm = View.GetVideoForm();
parameters.DefineProfiles = true;
parameters.Profiles.AddRange(_onvifProfiles);
parameters.Conformance = true;
_runningSingle = false;
InternalRun(parameters, false, true);
}
/// <summary>
/// Runs conformance for Conformance tab
/// </summary>
public void RunConformance()
{
_td.ResetFeatures();
Clear(true);
View.TestTreeView.SelectTests(new TestInfo[0]);
TestSuiteParameters parameters = GetParameters();
AddTestCases(parameters);
parameters.DefineProfiles = true;
parameters.Profiles.AddRange(_onvifProfiles);
parameters.Conformance = true;
_runningSingle = false;
InternalRun(parameters, false, true);
}
/// <summary>
/// Run all selected tests.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void tsbRunAll_Click(object sender, EventArgs e)
{
ClearTestResults(false);
TestSuiteParameters parameters = GetParameters();
if (parameters.InteractiveFirst)
{
parameters.TestCases.AddRange(_selectedTests.OrderBy(t => !t.Interactive).ThenBy(t => t.Order));
}
else
{
parameters.TestCases.AddRange(_selectedTests.OrderBy(t => t.Order));
}
_controller.Run(parameters);
}
/// <summary>
/// Runs conformance for Conformance tab
/// </summary>
public void RunConformance()
{
_td.ResetFeatures();
Clear(true);
View.TestTreeView.SelectTests(new TestInfo[0]);
TestSuiteParameters parameters = GetParameters();
parameters.AllTestCases.Clear();
parameters.AllTestCases.AddRange(_testInfos.OrderBy(TI => TI.ExecutionOrder).ThenBy(T => T.Category).ThenBy(t => t.Order));
parameters.DefineProfiles = true;
parameters.Profiles.AddRange(_onvifProfiles);
parameters.Conformance = true;
_runningSingle = false;
InternalRun(parameters, false, true);
}
/// <summary>
/// Run all selected tests.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void tsbRunSelected_Click(object sender, EventArgs e)
{
ClearTestResults(false);
TestSuiteParameters parameters = _controller.GetParameters();
//parameters.InteractiveFirst = InteractiveFirst;
//if (parameters.InteractiveFirst)
//{
parameters.TestCases.AddRange(tvTestCases.SelectedTests.OrderBy(TI => TI.ExecutionOrder).ThenBy(T => T.Category).ThenBy(t => t.Order));
//}
//else
//{
// parameters.TestCases.AddRange(tvTestCases.SelectedTests.OrderBy(TI => TI.ExecutionOrder).ThenBy(T => T.Category).ThenBy(t => t.Order));
//}
_controller.Run(parameters);
}
void UpdateDeviceContext(TestSuiteParameters parameters)
{
DeviceEnvironment environment = ContextController.GetDeviceEnvironment();
environment.Timeouts = new Timeouts();
environment.Timeouts.InterTests = parameters.TimeBetweenTests;
environment.Timeouts.Message = parameters.MessageTimeout;
environment.Timeouts.Reboot = parameters.RebootTimeout;
environment.EnvironmentSettings = new EnvironmentSettings();
environment.EnvironmentSettings.DnsIpv4 = parameters.EnvironmentSettings.DnsIpv4;
environment.EnvironmentSettings.NtpIpv4 = parameters.EnvironmentSettings.NtpIpv4;
environment.EnvironmentSettings.DnsIpv6 = parameters.EnvironmentSettings.DnsIpv6;
environment.EnvironmentSettings.NtpIpv6 = parameters.EnvironmentSettings.NtpIpv6;
environment.EnvironmentSettings.GatewayIpv4 = parameters.EnvironmentSettings.DefaultGateway;
environment.EnvironmentSettings.GatewayIpv6 = parameters.EnvironmentSettings.DefaultGatewayIpv6;
environment.TestSettings = new TestSettings();
environment.TestSettings.PTZNodeToken = parameters.PTZNodeToken;
environment.TestSettings.UseEmbeddedPassword = parameters.UseEmbeddedPassword;
environment.TestSettings.Password1 = parameters.Password1;
environment.TestSettings.Password2 = parameters.Password2;
environment.TestSettings.OperationDelay = parameters.OperationDelay;
environment.TestSettings.RecoveryDelay = parameters.RecoveryDelay;
environment.TestSettings.VideoSourceToken = parameters.VideoSourceToken;
environment.TestSettings.FirmwareFilePath = parameters.FirmwareFilePath;
environment.TestSettings.CredentialIdentifierValueFirst = parameters.CredentialIdentifierValueFirst;
environment.TestSettings.CredentialIdentifierValueSecond = parameters.CredentialIdentifierValueSecond;
environment.TestSettings.CredentialIdentifierValueThird = parameters.CredentialIdentifierValueThird;
environment.TestSettings.SecureMethod = parameters.SecureMethod;
environment.TestSettings.SubscriptionTimeout = parameters.SubscriptionTimeout;
environment.TestSettings.EventTopic = parameters.EventTopic;
environment.TestSettings.TopicNamespaces = parameters.TopicNamespaces;
environment.TestSettings.RelayOutputDelayTimeMonostable = parameters.RelayOutputDelayTimeMonostable;
environment.TestSettings.RecordingToken = parameters.RecordingToken;
environment.TestSettings.SearchTimeout = parameters.SearchTimeout;
environment.TestSettings.MetadataFilter = parameters.MetadataFilter;
environment.TestSettings.RetentionTime = parameters.RetentionTime;
}
public void RunTests(Task task)
{
_view.BeginTesting();
TestSuiteParameters parameters = GetTestSuiteParameters(task);
_currentTask = new List <TestCaseSettings>();
if (task.FeatureDefnitionSettings != null)
{
_td.ResetFeatures();
_currentTask.Add(task.FeatureDefnitionSettings);
}
bool testsExist = false;
foreach (TestCaseSettings tc in task.Tests)
{
TestInfo ti = _testInfos.Where(TI => TI.Category == tc.Category && TI.Id == tc.TestID).FirstOrDefault();
if (ti != null)
{
parameters.TestCases.Add(ti);
_currentTask.Add(tc);
testsExist = true;
}
}
if (testsExist)
{
parameters.FeatureDefinition = FeatureDefinitionMode.Default;
}
else
{
parameters.FeatureDefinition = FeatureDefinitionMode.Define;
}
_currentTestIdx = 0;
EnterNextTask();
// setup DUT
_td.Run(parameters);
}
/// <summary>
/// Run selected test or tests in selected group.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void tsbRunSelected_Click(object sender, EventArgs e)
{
TreeNode node = tvTestCases.SelectedNode;
if (node != null)
{
TestInfo testInfo = (TestInfo)node.Tag;
TestSuiteParameters parameters = GetParameters();
if (testInfo != null)
{
parameters.TestCases.Add(testInfo);
}
else
{
List <TestInfo> tests = new List <TestInfo>();
AddChildNodes(node, tests);
List <TestInfo> allowedTests = new List <TestInfo>();
if (_certificationMode)
{
allowedTests.AddRange(tests.Where(t => FeaturesHelper.AllFeaturesSelected(t)));
}
else
{
allowedTests.AddRange(tests);
}
if (parameters.InteractiveFirst)
{
parameters.TestCases.AddRange(allowedTests.OrderBy(t => !t.Interactive).ThenBy(t => t.Order));
}
else
{
parameters.TestCases.AddRange(allowedTests.OrderBy(t => t.Order));
}
}
ClearTestInfo();
_controller.RunSingle(parameters);
}
}
/// <summary>
/// Launches tests.
/// </summary>
/// <param name="parameters">Parameters passed from the View.</param>
/// <param name="single">True if "Run current" button is in use. If "Run current" button has
/// been clicked, results collected by this moment will not be cleared.</param>
void InternalRun(TestSuiteParameters parameters, bool single)
{
_running = true;
_runningSingle = single;
_testsCount = parameters.TestCases.Count;
DeviceEnvironment env = ContextController.GetDeviceEnvironment();
parameters.UserName = env.Credentials.UserName;
parameters.Password = env.Credentials.Password;
parameters.UseUTCTimestamp = env.Credentials.UseUTCTimeStamp;
parameters.Operator = new Utils.Operator(View.Window);
parameters.VideoForm = View.GetVideoForm();
parameters.EnvironmentSettings = new Tests.Common.TestEngine.EnvironmentSettings()
{
DnsIpv4 = env.EnvironmentSettings.DnsIpv4,
NtpIpv4 = env.EnvironmentSettings.NtpIpv4,
DnsIpv6 = env.EnvironmentSettings.DnsIpv6,
NtpIpv6 = env.EnvironmentSettings.NtpIpv6,
DefaultGateway = env.EnvironmentSettings.GatewayIpv4,
DefaultGatewayIpv6 = env.EnvironmentSettings.GatewayIpv6
};
if (!single)
{
_testResults.Clear();
_testExecutionTime = DateTime.Now;
}
if (TestSuiteStarted != null)
{
TestSuiteStarted(parameters);
}
_td.Run(parameters);
}
public void Run(string[] args)
{
if (args.Contains(CommandLineArgs.PARAMETERSFILE))
{
LoadOptions(args);
SerializableTestingParameters parameters = LoadParameters();
if (parameters == null)
{
return;
}
// get test suite parameters;
// get operator's etc. data
// get info about files where to save data;
Controllers.TestController controller = new TestController(_view);
_controller = controller;
AutoResetEvent completed = new AutoResetEvent(false);
bool completedOk = true;
controller.TestSuiteCompleted +=
(normally) =>
{
completedOk = normally;
completed.Set();
};
controller.ConformanceInitializationCompleted += controller_ConformanceInitializationCompleted;
controller.LoadTests();
TestSuiteParameters testSuiteParameters = parameters.GetTestSuiteParameters();
testSuiteParameters.AdvancedParameters = new Dictionary <string, object>();
if (parameters.Advanced != null)
{
List <object> advanced = AdvancedParametersUtils.Deserialize(parameters.Advanced, controller.AdvancedSettingsTypes);
foreach (object p in advanced)
{
testSuiteParameters.AdvancedParameters.Add(p.GetType().GUID.ToString(), p);
}
}
UpdateDeviceContext(testSuiteParameters);
controller.RunConformanceSilent(testSuiteParameters);
completed.WaitOne();
if (!completedOk)
{
return;
}
try
{
// Save documents
Output output = parameters.Output;
// Get directory
string folder = string.Empty;
if (output != null)
{
folder = output.Directory;
}
if (string.IsNullOrEmpty(folder))
{
folder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
folder = Path.Combine(folder, "ONVIF Device Test Tool");
}
string path = folder;
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
// Create nested folder if necessary
if (output != null && output.CreateNestedFolder)
{
string name = DateTime.Now.ToString("yyyy-MM-dd hh-mm");
path = Path.Combine(folder, name);
Directory.CreateDirectory(path);
}
TestLogFull log = GetTestLog(testSuiteParameters, parameters, controller);
// Save Report
string reportFileName = null;
if (output != null)
{
reportFileName = output.Report;
}
if (string.IsNullOrEmpty(reportFileName))
{
if (log.DeviceInformation != null)
{
reportFileName = string.Format("{0} - report.pdf", log.ProductName);
}
}
if (string.IsNullOrEmpty(reportFileName))
{
reportFileName = "report.pdf";
}
reportFileName = Path.Combine(path, reportFileName);
Utils.PdfReportGenerator reportGenerator = new PdfReportGenerator();
reportGenerator.CreateReport(reportFileName, log);
// Save DoC
string docFileName = null;
if (output != null)
{
docFileName = output.DeclarationOfConformance;
}
if (string.IsNullOrEmpty(docFileName))
{
if (log.DeviceInformation != null)
{
docFileName = string.Format("{0} - DoC.pdf", log.ProductName);
}
}
if (string.IsNullOrEmpty(docFileName))
{
docFileName = "DoC.pdf";
}
docFileName = Path.Combine(path, docFileName);
Utils.DoCGenerator docGenerator = new DoCGenerator();
docGenerator.CreateReport(docFileName, log);
// Save log, if required
if (output != null)
{
if (!string.IsNullOrEmpty(output.TestLog))
{
string fileName = Path.Combine(path, output.TestLog);
List <TestResult> results = new List <TestResult>();
foreach (TestTool.Tests.Definitions.Data.TestInfo ti in controller.TestInfos)
{
TestResult tr = controller.GetTestResult(ti);
if (tr != null)
{
results.Add(tr);
}
}
controller.Save(fileName, results);
}
if (!string.IsNullOrEmpty(output.FeatureDefinitionLog))
{
string fileName = Path.Combine(path, output.FeatureDefinitionLog);
TestResult tr = new TestResult();
tr.Log = _controller.GetFeaturesDefinitionLog().Log;
tr.PlainTextLog = _controller.GetFeaturesDefinitionLog().PlainTextLog;
controller.Save(fileName, tr);
}
}
}
catch (Exception exc)
{
SaveErrorLog(string.Format("Failed to create documents: {0}", exc.Message));
}
}
}
/// <summary>
/// Launches features definition process
/// </summary>
/// <param name="parameters"></param>
public void DefineFeatures(TestSuiteParameters parameters)
{
parameters.FeatureDefinition = FeatureDefinitionMode.Define;
RunDiagnostic(parameters, true);
}
void RunDiagnostic(TestSuiteParameters parameters, bool single)
{
RunDiagnostic(parameters, single, false);
}
