// ------------------------------------------------------------------------------------
// TestViewer
// Setup viewer tabs
public override TestViewerTabData[] GetViewerTabs(ResultsBase resultsObject)
{
var typedSettings = (FrameComparisonSettings)logic.GetModel().settings; // Set settings to local type
TestViewerTabData[] output = new TestViewerTabData[1]; // Create empty output (mandatory)
switch (logic.baselineExists) // Switch on baseline exists
{
case false:
var localResultData = (FrameComparisonResults)resultsObject; // Convert the input results object to this types class (mandatory)
output = new TestViewerTabData[2] // Want two tabs
{
new TestViewerTabData("Results Texture", TestViewerTabType.Texture, Common.ConvertStringToTexture("Tab_ResultsFrame", localResultData.resultFrame), null), // And the results texture
new TestViewerTabData("Live Camera", TestViewerTabType.Camera, typedSettings.captureCamera, null) // Live camera showing capture camera
};
break;
case true:
var comparisonData = (FrameComparisonLogic.ComparisonData)logic.GetComparisonData(resultsObject); // Get the comparison data for this test in this types class (mandatory)
SetupMaterial(comparisonData.baselineTex, comparisonData.resultsTex); // Setup the material
output = new TestViewerTabData[3] // Want three tabs
{
new TestViewerTabData("Results", TestViewerTabType.TextureSlider, new TestViewer.TextureSliderContext(comparisonData.resultsTex, "Result", comparisonData.baselineTex, "Baseline"), new TestViewerTabData.TestViewerTabStatistic[] // Create slider tab for results/baseline
{
new TestViewerTabData.TestViewerTabStatistic("Diff", comparisonData.DiffPercentage.ToString()) // Enable the statistics window and display the diff
}),
new TestViewerTabData("Comparison", TestViewerTabType.Material, material, new TestViewerTabData.TestViewerTabStatistic[] // And the material for the comparison display
{
new TestViewerTabData.TestViewerTabStatistic("Diff", comparisonData.DiffPercentage.ToString()) // Enable the statistics window and display the diff
}),
new TestViewerTabData("Live Camera", TestViewerTabType.Camera, typedSettings.captureCamera, null) // Live camera showing capture camera
};
break;
}
return(output); // Return
}
// ------------------------------------------------------------------------------------
// Test Execution
// Use local result in Manual mode if it exists
public override void UseLocalResult(ResultsIOData localResult)
{
ResultsBase typedResult = (R)DeserializeResults(localResult); // Deserialize result to typed
activeResultData = typedResult; // Set to active results
EndTest(); // End test
}
// ------------------------------------------------------------------------------------
// TestViewer
// Setup viewer tabs
public override TestViewerTabData[] GetViewerTabs(ResultsBase resultsObject)
{
TestViewerTabData[] output = new TestViewerTabData[1]; // Create empty output (mandatory)
var localResultData = (AverageFrameTimeResults)resultsObject; // Convert the input results object to this types class (mandatory)
switch (logic.baselineExists) // Switch on baseline exists
{
case false:
output = new TestViewerTabData[1] // Only want one tab
{
new TestViewerTabData("Live Camera", TestViewerTabType.DefaultCamera, null, new TestViewerTabData.TestViewerTabStatistic[1] // Set the tab to use the default camera
{
new TestViewerTabData.TestViewerTabStatistic("Average Frame Time", localResultData.avgFrameTime.ToString("N4")) // Enable the statistics window and display the avg frame time
})
};
break;
case true:
var comparisonData = (AverageFrameTimeComparison)logic.ProcessComparison(resultsObject); // Get the comparison data for this test in this types class (mandatory)
output = new TestViewerTabData[1] // Only want one tab
{
new TestViewerTabData("Live Camera", TestViewerTabType.DefaultCamera, null, new TestViewerTabData.TestViewerTabStatistic[2] // Set the tab to use the default camera
{
new TestViewerTabData.TestViewerTabStatistic("Average Frame Time", localResultData.avgFrameTime.ToString("N4")), // Enable the statistics window and display the avg frame time
new TestViewerTabData.TestViewerTabStatistic("Delta", comparisonData.delta.ToString("N4")) // Also display the delta from the comparison
})
};
break;
}
return(output); // Return the tabs
}
// Initialize results structure
public override void SetResults()
{
results = typeof(R); // Set type
ResultsBase newData = (R)Activator.CreateInstance(results); // Create instance
newData.common = new ResultsDataCommon(); // Initialize common
activeResultData = newData; // Set as active
}
// Enable test viewer
public override void EnableTestViewer(ResultsBase resultsObject, TestViewerToolbar.State toolbarState)
{
Console.Instance.Write(DebugLevel.Full, MessageLevel.Log, this.GetType().Name + " enabling test viewer"); // Write to console
string breadcrumbLabel = logic.suiteName + " - " + logic.testTypeName + " - " + resultsObject.common.GroupName + " - " + resultsObject.common.TestName; // Build breadcrumb label
ProgressScreen.Instance.SetState(false, ProgressType.LocalSave, ""); // Disable ProgressScreen
TestViewer.Instance.SetState(true); // Set test viewer state
TestViewer.Instance.UpdateBars(GetViewerTabs(resultsObject), GetResultsTimeDisplay(resultsObject), breadcrumbLabel, toolbarState); // Set test viewer state
}
// Logic for comparison process (mandatory)
// TODO - Will use last run test model, need to get this for every call from Viewers?
public override object ProcessComparison(ResultsBase baselineData, ResultsBase resultsData)
{
ComparisonData newComparison = new ComparisonData(); // Create new ComparisonData instance (mandatory)
AverageFrameTimeResults baselineDataTyped = (AverageFrameTimeResults)baselineData; // Set baseline data to local type
AverageFrameTimeResults resultsDataTyped = (AverageFrameTimeResults)resultsData; // Set results data to local type
newComparison.delta = resultsDataTyped.avgFrameTime - baselineDataTyped.avgFrameTime; // Perform comparison logic (logic specific)
return(newComparison); // Return (mandatory)
}
// Build results after main test logic is completed
public void BuildResultsStruct(ResultsBase input)
{
if (input != null) // Null check
{
Console.Instance.Write(DebugLevel.Full, MessageLevel.Log, this.GetType().Name + " building results for test " + activeTestEntry.testName); // Write to console
activeResultData = input; // Set active results data
}
TestPostProcess(); // Start post-process
}
// Logic for comparison process (mandatory)
// TODO - Will use last run test model, need to get this for every call from Viewers?
public override object ProcessComparison(ResultsBase baselineData, ResultsBase resultsData)
{
ComparisonData newComparison = new ComparisonData(); // Create new ComparisonData instance (mandatory)
ExampleResults baselineDataTyped = (ExampleResults)baselineData;
ExampleResults resultsDataTyped = (ExampleResults)resultsData;
newComparison.SomeFloatDiff = resultsDataTyped.SomeFloat - baselineDataTyped.SomeFloat; // Perform comparison logic (logic specific)
return(newComparison); // Return (mandatory)
}
// ------------------------------------------------------------------------------------
// Initialization
// Setup the results structs every test
public override void SetupResultsStructs()
{
ResultsBase newResultsData = (R)Activator.CreateInstance(results); // Create instance
newResultsData.common = Common.GetCommonResultsData(); // Initialize common
newResultsData.common.GroupName = activeTestEntry.groupName; // Set scene name
newResultsData.common.TestName = activeTestEntry.testName; // Set test name
newResultsData.common.Custom += Common.CustomEntry("runID", TestRunner.runUUID);
activeResultData = newResultsData; // Set as active
}
// Logic for comparison process (mandatory)
// TODO - Will use last run test model, need to get this for every call from Viewers?
public override object ProcessComparison(ResultsBase baselineData, ResultsBase resultsData)
{
FrameComparisonComparison newComparison = new FrameComparisonComparison(); // Create new ComparisonData instance (mandatory)
FrameComparisonResults baselineDataTyped = (FrameComparisonResults)baselineData; // Set baseline data to local type
FrameComparisonResults resultsDataTyped = (FrameComparisonResults)resultsData; // Set results data to local type
newComparison.baselineTex = Common.ConvertStringToTexture(resultsDataTyped.common.TestName + "_Reference", baselineDataTyped.resultFrame); // Convert baseline frame to Texture2D (logic specific)
newComparison.resultsTex = Common.ConvertStringToTexture(resultsDataTyped.common.TestName + "_Results", resultsDataTyped.resultFrame); // Convert result frame to Texture2D (logic specific)
newComparison.DiffPercentage = Common.GetTextureComparisonValue(newComparison.baselineTex, newComparison.resultsTex); // Calculate diff percentage (logic specific)
return(newComparison); // Return (mandatory)
}
// ------------------------------------------------------------------------------------
// Comparison Methods
// Get comparison data
public object GetComparisonData(ResultsBase resultsData)
{
ResultsIOData baselineFetch = ResultsIO.Instance.RetrieveBaseline(suiteName, testTypeName, resultsData.common); // Get baseline data
if (baselineFetch != null) // If successful
{
ResultsBase baselineData = (ResultsBase)DeserializeResults(baselineFetch); // Convert to results class
return(ProcessComparison(baselineData, resultsData)); // Process comparison
}
else
{
return(null); // Return fail
}
}
// Get a comparison result from any given result and baseline
public override bool GetComparisonResult(ResultsBase results, ResultsBase baseline)
{
FrameComparisonComparison comparisonData = (FrameComparisonComparison)ProcessComparison(baseline, results); // Prrocess comparison (mandatory)
bool output = false;
if (comparisonData.DiffPercentage < model.settings.passFailThreshold) // Pass/fail decision logic (logic specific)
{
output = true;
}
else
{
output = false;
}
comparisonData = null; // Null comparison (mandatory)
return(output);
}
// ------------------------------------------------------------------------------------
// Comparison Methods
// Get comparison data
public object ProcessComparison(ResultsBase resultsData)
{
AltBaselineSettings altBaselineSettings = Master.Instance.GetCurrentPlatformAPI(); // current chosen API/plafrom
ResultsDataCommon m_BaselineData = resultsData.common.SwitchPlatformAPI(altBaselineSettings.Platform, altBaselineSettings.API); // makes new ResultsDataCommon to grab baseline
ResultsIOData baselineFetch = ResultsIO.Instance.RetrieveEntry(suiteName, testTypeName, m_BaselineData, true, true); // Get baseline data
if (baselineFetch != null) // If successful
{
ResultsBase baselineData = (ResultsBase)DeserializeResults(baselineFetch); // Convert to results class
return(ProcessComparison(baselineData, resultsData)); // Process comparison
}
else
{
return(null); // Return fail
}
}
// ------------------------------------------------------------------------------------
// Serialization
// TODO - Clean and comment (DANGER)
// Deserialize ResultsIOData(string arrays) to ResultsData(class)
public override object DeserializeResults(ResultsIOData resultsIOData)
{
//var resultData = Convert.ChangeType(activeBaselineData, results); // Create instance (Old - Used from base class)
ResultsBase resultData = (R)Activator.CreateInstance(results); // Create instance
var common = new ResultsDataCommon(); //blank common data
BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static;
FieldInfo[] commonFields = typeof(ResultsDataCommon).GetFields(bindingFlags);
FieldInfo[] customFields = results.GetFields(bindingFlags);
List <string> commonDataRaw = resultsIOData.resultsRow[0].resultsColumn.GetRange(0, commonFields.Length);
List <string> resultsDataRaw = resultsIOData.resultsRow[0].resultsColumn.GetRange(commonFields.Length, resultsIOData.resultsRow[0].resultsColumn.Count - (commonFields.Length));
for (int f = 0; f < customFields.Length; f++)
{
if (f == 0)
{
//do the common class
for (int cf = 0; cf < commonFields.Length; cf++)
{
string value = commonDataRaw[cf];
FieldInfo fieldInfo = common.GetType().GetField(commonFields[cf].Name);
fieldInfo.SetValue(common, Convert.ChangeType(value, fieldInfo.FieldType));
}
}
else
{
var value = resultsDataRaw[(f) - 1];
FieldInfo fieldInfo = resultData.GetType().GetField(customFields[0].Name); // TODO - Why did this become 0?
if (fieldInfo.FieldType.IsArray) // This handles arrays
{
Type type = resultData.GetType().GetField(customFields[f].Name).FieldType.GetElementType();
GenerateGenericArray(fieldInfo, resultData.GetType(), resultData, type, value);
}
else // Non array types
{
fieldInfo.SetValue(resultData, Convert.ChangeType(value, fieldInfo.FieldType));
}
}
}
resultData.common = common; // Assign common
return(resultData);
}
// Get time since results
public string GetResultsTimeDisplay(ResultsBase resultsObject)
{
string output = ""; // Create output
System.DateTime resultTime = System.DateTime.Parse(resultsObject.common.DateTime); // Parse result time
System.DateTime now = System.DateTime.UtcNow; // Get time now
Common.TimePeriod period = Common.TimePeriod.Closest; // Create time period
float result = Common.GetTimeDifference(resultTime, now, ref period); // Get time difference
if (period == Common.TimePeriod.Second) // If seconds dont return details
{
output = "just now"; // Set output
}
else
{
output = result.ToString() + " " + period.ToString().ToLower() + "s ago"; // Set output
}
return("Results created " + output); // Return
}
// ------------------------------------------------------------------------------------
// TestViewer
// Return default camera tab only
public virtual TestViewerTabData[] GetViewerTabs(ResultsBase resultsObject)
{
return(new TestViewerTabData[1] {
new TestViewerTabData("Default", TestViewerTabType.DefaultCamera, null, null)
});
}
// Enable test viewer
public virtual void EnableTestViewer(ResultsBase resultsObject, TestViewerToolbar.State toolbarState)
{
}
public abstract object ProcessComparison(ResultsBase baselineData, ResultsBase resultsData);
public abstract bool GetComparisonResult(ResultsBase results, ResultsBase baseline);