public void ScopeWithCompositeComponent_ScopeNestedWorkspaceWrapperTearDownTest()
{
MockProgress progress = new MockProgress();
string testExperimentFilepath = System.IO.Path.Combine(AppContext.BaseTestDirectory, "Decision Scope with composite component.teml");
Experiment experiment = ExperimentManager.Load(testExperimentFilepath, AppContext.Components);
using (var dispatcher = ExperimentRunnerHelper.CreateExperimentRunner(experiment, AppContext.WorkspaceInstance, AppContext.Components))
{
dispatcher.ExecuteExperiment(progress);
}
Assert.AreEqual(3, AppContext.WorkspaceInstance.Units.Count);
HashSet <string> expectedUnitNames = new HashSet <string>();
expectedUnitNames.Add("targetArtifacts");
expectedUnitNames.Add("sourceArtifacts");
expectedUnitNames.Add("similarityMatrix");
foreach (WorkspaceUnit unit in AppContext.WorkspaceInstance.Units)
{
bool isCorrect = false;
if (expectedUnitNames.Contains(unit.FriendlyUnitName))
{
isCorrect = true;
}
Assert.IsTrue(isCorrect);
}
}
public void ScopeNestedWorkspaceWrapperTearDownTest()
{
MockProgress progress = new MockProgress();
Experiment experiment = ExperimentManager.Load("DecisionScopeTest.teml", AppContext.Components);
using (var dispatcher = ExperimentRunnerHelper.CreateExperimentRunner(experiment, AppContext.WorkspaceInstance, AppContext.Components))
{
dispatcher.ExecuteExperiment(progress);
}
Assert.AreEqual(2, AppContext.WorkspaceInstance.Units.Count);
foreach (WorkspaceUnit unit in AppContext.WorkspaceInstance.Units)
{
bool isCorrect = false;
if (unit.FriendlyUnitName.Equals("a") && (int)unit.Data == 1)
{
isCorrect = true;
}
else if (unit.FriendlyUnitName.Equals("b") && (int)unit.Data == 7)
{
isCorrect = true;
}
Assert.IsTrue(isCorrect);
}
}
public void OpenExperimentWithNonExistingCompositeComponentTest()
{
// load the experiment to be exported
string experimentFilename = System.IO.Path.Combine(AppContext.BaseTestDirectory, "experiment_with_non_existing_composite_component_bug_75.gml");
Experiment experiment = ExperimentManager.Load(experimentFilename, AppContext.Components);
experiment.Settings = AppContext.Settings;
Assert.IsNotNull(experiment);
Assert.AreEqual(3, experiment.VertexCount);
//find the composite component node
CompositeComponentNode compositeComponentNode = null;
foreach (ExperimentNode node in experiment.Vertices)
{
compositeComponentNode = node as CompositeComponentNode;
if (compositeComponentNode != null)
{
break;
}
}
Assert.IsNotNull(compositeComponentNode); //if fails composite component node has not been found
//once found check if it has error
Assert.IsTrue(compositeComponentNode.HasError);
//Also try to create ExperimentViewModel for the experiment. Assure that it does not crash
var experimentViewModel = new TraceLab.UI.WPF.ViewModels.ExperimentViewModel_Accessor(experiment);
}
public void AddCompositeComponent_Bug77()
{
// load the experiment to be exported
string experimentFilename = System.IO.Path.Combine(AppContext.BaseTestDirectory, "experiment_to_test_bug77.gml");
Experiment experiment = ExperimentManager.Load(experimentFilename, AppContext.Components);
experiment.Settings = AppContext.Settings;
//create ExperimentViewModel for the experiment - the crash happen in the experiment view model, so it has to be initialized
var experimentViewModel = new TraceLab.UI.WPF.ViewModels.ExperimentViewModel_Accessor(experiment);
CompositeComponentMetadataDefinition compositeComponentDefinition = null;
//find the composite component to test bug 77
foreach (MetadataDefinition definition in AppContext.Components.Components)
{
if (definition.Classname.Equals("Component to test bug 77"))
{
compositeComponentDefinition = definition as CompositeComponentMetadataDefinition;
break;
}
}
//check if definition has been found in library
Assert.IsNotNull(compositeComponentDefinition);
Assert.AreEqual(3, experiment.VertexCount);
ExperimentNode node = ((IEditableExperiment)experiment).AddComponentFromDefinition(compositeComponentDefinition, -5, 5);
Assert.IsNotNull(node);
Assert.AreEqual(4, experiment.VertexCount);
Assert.IsTrue(experiment.IsModified);
}
public void SaveExperimentTest()
{
IExperiment experiment = ExperimentManager.New();
Assert.IsNotNull(experiment);
Assert.AreEqual(2, experiment.VertexCount);
Assert.IsTrue(string.IsNullOrEmpty(experiment.ExperimentInfo.FilePath));
string filename = System.IO.Path.Combine(AppContext.BaseTestDirectory, "testSave.gml");
try
{
bool success = ExperimentManager.Save(experiment, filename);
Assert.IsTrue(success);
Assert.IsTrue(File.Exists(filename));
IExperiment loadedExperiment = ExperimentManager.Load(filename, AppContext.Components);
Assert.AreEqual(experiment.ExperimentInfo, loadedExperiment.ExperimentInfo);
}
finally
{
if (File.Exists(filename))
{
//cleanup
File.Delete(filename);
}
}
}
public void ExperimentClone()
{
IExperiment loadedExperiment = ExperimentManager.Load(ExperimentFile, AppContext.Components);
ValidateData(loadedExperiment);
Experiment clone = (Experiment)((BaseExperiment)loadedExperiment).Clone();
ValidateData(clone);
Assert.IsFalse(clone.IsModified);
Dictionary <string, ExperimentNode> clonedNodes = new Dictionary <string, ExperimentNode>();
foreach (ExperimentNode clonedNode in clone.Vertices)
{
clonedNodes[clonedNode.ID] = clonedNode;
}
// Ensure that none of the vertices from the source experiment are in the clone experiment.
// This checks references, since obviously the clone is supposed to have nodes with the same ID.
foreach (ExperimentNode node in loadedExperiment.Vertices)
{
ExperimentNode clonedNode = null;
Assert.IsTrue(clonedNodes.TryGetValue(node.ID, out clonedNode));
Assert.IsFalse(object.ReferenceEquals(node, clonedNode));
Assert.IsFalse(object.ReferenceEquals(node.Data, clonedNode.Data));
Assert.IsFalse(object.ReferenceEquals(node.Data.Metadata, clonedNode.Data.Metadata));
}
}
public void DefineCompositeComponentBasicTestSelectSubraphWithNoEndAndStart()
{
// load the experiment to be exported
string experimentFilename = System.IO.Path.Combine(AppContext.BaseTestDirectory, "experiment_define_composite_component_basic_test.teml");
Experiment experiment = ExperimentManager.Load(experimentFilename, AppContext.Components);
experiment.Settings = AppContext.Settings; //assure that we apply global settings
//select just one node
foreach (ExperimentNode node in experiment.Vertices)
{
if (node.ID == TestImporterID)
{
node.IsSelected = true;
}
}
DefiningCompositeComponentSetup setup = new DefiningCompositeComponentSetup(experiment);
Assert.IsNotNull(setup);
Assert.AreEqual(1, setup.InputSettings.Count);
Assert.AreEqual(1, setup.OutputSettings.Count);
Assert.AreEqual(0, setup.ConfigSettings.Count);
Assert.IsTrue(setup.InputSettings["test1"].Include);
Assert.IsTrue(setup.OutputSettings["test2"].Include);
//rescan library to be sure it is fresh scan
int numberOfComponentsInLibrary = GetCountOfComponentsInLibrary();
//let's export the experiment as composite component
setup.CompositeComponentLocationFilePath = exportFile;
Assert.IsFalse(File.Exists(exportFile));
setup.DefineComponent();
Assert.IsTrue(File.Exists(exportFile));
int updatedNumberOfComponents = GetCountOfComponentsInLibrary();
//after rescan there should be one more component in the library
Assert.AreEqual(numberOfComponentsInLibrary + 1, updatedNumberOfComponents);
//iterate through all components until find new composite component
CompositeComponentMetadataDefinition compositeComponentDefinition = FindCompositeComponent(exportFile);
//assure that composite component definition has been found
Assert.IsNotNull(compositeComponentDefinition); //if fails, composite component has not been found
Assert.AreEqual(setup.Name, compositeComponentDefinition.Label);
Assert.AreEqual(setup.Description, compositeComponentDefinition.Description);
Assert.AreEqual(setup.Author, compositeComponentDefinition.Author);
Assert.IsNotNull(compositeComponentDefinition.ComponentGraph);
//the number of configuration properties should be the same
Assert.AreEqual(setup.ConfigSettings.Count, compositeComponentDefinition.ConfigurationWrapperDefinition.Properties.Count);
Assert.AreEqual(1, compositeComponentDefinition.IOSpecDefinition.Input.Count); //one input was included
Assert.AreEqual(1, compositeComponentDefinition.IOSpecDefinition.Output.Count); //one output was included
}
public void ExperimentLoad()
{
IExperiment loadedExperiment = ExperimentManager.Load(ExperimentFile, AppContext.Components);
Assert.IsNotNull(loadedExperiment);
ValidateData(loadedExperiment);
Assert.IsFalse(loadedExperiment.IsModified);
}
/// <summary>
/// Loads the test experiment file
/// </summary>
/// <param name="filename">The filename.</param>
/// <returns></returns>
private Experiment LoadExperiment(string filename)
{
filename = System.IO.Path.Combine(AppContext.BaseTestDirectory, filename);
if (System.IO.File.Exists(filename) == false)
{
throw new System.IO.FileNotFoundException("Graph file not found", filename);
}
Experiment currentExperiment = ExperimentManager.Load(filename, AppContext.Components);
return(currentExperiment);
}
public void DefineCompositeComponentSerializeDeserializeTest()
{
// load the experiment to be exported
string experimentFilename = System.IO.Path.Combine(AppContext.BaseTestDirectory, "Preprocessor.gml");
Experiment experiment = ExperimentManager.Load(experimentFilename, AppContext.Components);
experiment.Settings = AppContext.Settings; //applying these settings was causing the bug #74
//select all nodes
foreach (ExperimentNode node in experiment.Vertices)
{
node.IsSelected = true;
}
DefiningCompositeComponentSetup setup = new DefiningCompositeComponentSetup(experiment);
setup.CompositeComponentLocationFilePath = exportFile;
var tmpCompositeComponentDefinition = setup.GenerateCompositeComponentDefinition();
XmlSerializer serializer = new XmlSerializer(typeof(TraceLab.Core.Components.CompositeComponentMetadataDefinition));
Assert.IsFalse(File.Exists(exportFile));
using (TextWriter writer = new StreamWriter(exportFile))
{
serializer.Serialize(writer, tmpCompositeComponentDefinition);
writer.Close();
}
//check if file has been created
Assert.IsTrue(System.IO.File.Exists(exportFile));
//deserialize the file to CompositeComponentMetadataDefinition
CompositeComponentMetadataDefinition compositeComponentDefinition;
using (XmlReader reader = XmlReader.Create(exportFile))
{
compositeComponentDefinition = (CompositeComponentMetadataDefinition)serializer.Deserialize(reader);
compositeComponentDefinition.PostProcessReadXml(AppContext.Components, AppContext.BaseTestDirectory);
}
Assert.IsNotNull(compositeComponentDefinition);
Assert.AreEqual(compositeComponentDefinition.ID, tmpCompositeComponentDefinition.ID);
Assert.AreEqual(compositeComponentDefinition.Version, tmpCompositeComponentDefinition.Version);
Assert.AreEqual(compositeComponentDefinition.Classname, tmpCompositeComponentDefinition.Classname); //NAME
Assert.AreEqual(compositeComponentDefinition.Author, tmpCompositeComponentDefinition.Author);
Assert.AreEqual(compositeComponentDefinition.Label, tmpCompositeComponentDefinition.Label);
Assert.AreEqual(compositeComponentDefinition.Description, tmpCompositeComponentDefinition.Description);
Assert.AreEqual(compositeComponentDefinition.IOSpecDefinition, tmpCompositeComponentDefinition.IOSpecDefinition);
Assert.AreEqual(compositeComponentDefinition.ConfigurationWrapperDefinition.Properties.Count, tmpCompositeComponentDefinition.ConfigurationWrapperDefinition.Properties.Count);
Assert.AreEqual(compositeComponentDefinition.ComponentGraph.VertexCount, tmpCompositeComponentDefinition.ComponentGraph.VertexCount);
Assert.AreEqual(compositeComponentDefinition.ComponentGraph.EdgeCount, tmpCompositeComponentDefinition.ComponentGraph.EdgeCount);
}
internal void OpenExperiment(string file)
{
try
{
var experiment = ExperimentManager.Load(file, (TraceLab.Core.Components.ComponentsLibrary)m_viewModel.ComponentLibraryViewModel);
ApplicationViewModel newApplicationViewModel = ApplicationViewModel.CreateNewApplicationViewModel(m_viewModel, experiment);
RecentExperimentsHelper.UpdateRecentExperimentList(TraceLab.Core.Settings.Settings.RecentExperimentsPath, file);
OpenInWindow(newApplicationViewModel);
}
catch (TraceLab.Core.Exceptions.ExperimentLoadException ex)
{
string msg = String.Format("Unable to open the file {0}. Error: {1}", file, ex.Message);
NLog.LogManager.GetCurrentClassLogger().ErrorException(msg, ex);
MessageBox.Show(msg, "Failed to load experiment", MessageBoxButton.OK, MessageBoxImage.Exclamation);
}
}
public void PrepareAndRunBenchmarkExperiment()
{
Assert.Fail("Test temporarily broken. Ignored till contest feature is going to be revisited.");
List <Benchmark> benchmarks = BenchmarkLoader.LoadBenchmarksInfo(BenchmarkDirectory);
Benchmark testBenchmark = benchmarks[0];
// load the experiment to be run against benchmark
string experimentFilename = System.IO.Path.Combine(AppContext.BaseTestDirectory, "experiment_to_be_benchmarked.gml");
Experiment experimentToBeBenchmarked = ExperimentManager.Load(experimentFilename, AppContext.Components);
//prepare matching io
testBenchmark.PrepareMatchingIOByType(experimentToBeBenchmarked);
Assert.AreEqual(2, testBenchmark.BenchmarkInputSetting.Count);
Assert.AreEqual(1, testBenchmark.BenchmarkOutputsSetting.Count);
//match benchmarkSourceArtifact with original source artifacts
foreach (BenchmarkItemSetting <IOItem> pair in testBenchmark.BenchmarkInputSetting)
{
IOItem item = pair.Item;
ItemSettingCollection candidates = pair.CandidateSettings;
if (item.MappedTo.Equals("benchmarkSourceArtifacts"))
{
//we found the item we want to remap
pair.SelectedSetting = candidates["originalSourceArtifacts"];
}
}
//finally prepare benchmark experiment
testBenchmark.PrepareBenchmarkExperiment(experimentToBeBenchmarked, AppContext.Components);
//assert that only two inputs are included in the export settings and one output
int includedInputs = 0;
foreach (KeyValuePair <string, ItemSetting> pair in testBenchmark.Setup.InputSettings)
{
if (pair.Value.Include == true)
{
includedInputs++;
}
}
Assert.AreEqual(2, includedInputs);
int includedOutputs = 0;
foreach (KeyValuePair <string, ItemSetting> pair in testBenchmark.Setup.OutputSettings)
{
if (pair.Value.Include == true)
{
includedOutputs++;
}
}
Assert.AreEqual(1, includedOutputs);
Assert.IsNotNull(testBenchmark.BenchmarkExperiment);
//for debug output file
// string path = System.IO.Path.Combine(AppContext.BaseTestDirectory, "benchmarkTest1.gml");
// AppContext.ExperimentManager.Save(testBenchmark.BenchmarkExperiment, path);
MockProgress progress = new MockProgress();
using (var dispatcher = ExperimentRunnerHelper.CreateExperimentRunner(testBenchmark.BenchmarkExperiment, AppContext.WorkspaceInstance, AppContext.Components))
{
dispatcher.ExecuteExperiment(progress);
Assert.AreEqual(7, progress.NumSteps);
Assert.IsFalse(progress.HasError);
}
}
public void DefiningBenchmarkTest()
{
Assert.Fail("Test temporarily broken. Ignored till contest feature is going to be revisited.");
string baseExperimentFilename = "DefiningBenchmarkTestExperiment.teml";
string testingSolutionFilename = "DefiningBenchmarkTestingSolution.teml";
//create temporary directory for defining benchmark
string benchmarkTemporaryDirectory = System.IO.Path.Combine(AppContext.BaseTestDirectory, "DefiningBenchmarkTest");
System.IO.Directory.CreateDirectory(benchmarkTemporaryDirectory);
string newBenchmarkFilePath = System.IO.Path.Combine(benchmarkTemporaryDirectory, "newDefinedBenchmark.tbml");
//copy the test data into temporary benchmark directory
string testData = System.IO.Path.Combine(AppContext.BaseTestDirectory, "DefiningBenchmarkTestData.xml");
System.IO.File.Copy(testData, System.IO.Path.Combine(benchmarkTemporaryDirectory, "DefiningBenchmarkTestData.xml"));
// load the experiment from which the benchmark is going to be defined from
string baseExperimentFilePath = System.IO.Path.Combine(AppContext.BaseTestDirectory, baseExperimentFilename);
Experiment baseExperimentForDefiningBenchmark = ExperimentManager.Load(baseExperimentFilePath, AppContext.Components);
var benchmarkDefiner = new DefiningBenchmark(baseExperimentForDefiningBenchmark, AppContext.Components, AppContext.WorkspaceInstance, AppContext.PackageManager, AppContext.WorkspaceInstance.TypeDirectories, null);
Assert.AreEqual(1, benchmarkDefiner.TemplatizableComponents.Count);
Assert.AreEqual("Preprocessor", benchmarkDefiner.TemplatizableComponents[0].Data.Metadata.Label);
//select preprocessor template as Component Template for benchmarking
benchmarkDefiner.SelectedTemplateNode = benchmarkDefiner.TemplatizableComponents[0];
//select new benchmark path
benchmarkDefiner.BenchmarkInfo.FilePath = newBenchmarkFilePath;
//set some values for benchmark info
string benchmarkName = "Testing defining new benchmark";
string author = "Re test author";
string contributors = "Re test contributors";
string description = "Re test description";
string shortDescription = "Re test short description";
DateTime deadline = DateTime.Now;
string fakeExperimentResultsUnitname = "fakeunitname";
string webpageLink = "test://test.webpage.link";
benchmarkDefiner.BenchmarkInfo.Name = benchmarkName;
benchmarkDefiner.BenchmarkInfo.Author = author;
benchmarkDefiner.BenchmarkInfo.Contributors = contributors;
benchmarkDefiner.BenchmarkInfo.Description = description;
benchmarkDefiner.BenchmarkInfo.ShortDescription = shortDescription;
benchmarkDefiner.BenchmarkInfo.Deadline = deadline;
benchmarkDefiner.BenchmarkInfo.ExperimentResultsUnitname = fakeExperimentResultsUnitname;
benchmarkDefiner.BenchmarkInfo.WebPageLink = new Uri(webpageLink);
//assure file does not exists prior defining
Assert.IsFalse(System.IO.File.Exists(benchmarkDefiner.BenchmarkInfo.FilePath));
//set some mock experiment results as baseline
TraceLabSDK.Types.Contests.TLExperimentResults fakeBaseline = CreateDummyExperimentResults("FAKE-BASELINE");
benchmarkDefiner.SelectedExperimentResults = fakeBaseline;
//call define benchmark
benchmarkDefiner.Define();
//check if new benchmark has been created
Assert.IsTrue(System.IO.File.Exists(benchmarkDefiner.BenchmarkInfo.FilePath));
//load newly defined benchmark
List <Benchmark> benchmarks = BenchmarkLoader.LoadBenchmarksInfo(benchmarkTemporaryDirectory);
Benchmark testBenchmark = benchmarks[0]; //there should be only 1, since the directory has been just created
//check if new test benchmark has previously defined properties
Assert.AreEqual(benchmarkName, testBenchmark.BenchmarkInfo.Name);
Assert.AreEqual(author, testBenchmark.BenchmarkInfo.Author);
Assert.AreEqual(contributors, testBenchmark.BenchmarkInfo.Contributors);
Assert.AreEqual(description, testBenchmark.BenchmarkInfo.Description);
Assert.AreEqual(shortDescription, testBenchmark.BenchmarkInfo.ShortDescription);
Assert.AreEqual(deadline.ToString(), testBenchmark.BenchmarkInfo.Deadline.ToString());
Assert.AreEqual(fakeExperimentResultsUnitname, testBenchmark.BenchmarkInfo.ExperimentResultsUnitname);
//check if baseline results has been saved properly, by loading it from xml
TraceLabSDK.Types.Contests.TLExperimentResults baseline = BenchmarkLoader.ReadBaseline(benchmarkDefiner.BenchmarkInfo.FilePath);
Assert.AreEqual(fakeBaseline.TechniqueName, baseline.TechniqueName);
Assert.AreEqual(fakeBaseline.Score, baseline.Score);
Assert.AreEqual(fakeBaseline.AcrossAllDatasetsResults, baseline.AcrossAllDatasetsResults);
Assert.IsTrue(fakeBaseline.DatasetsResults.SequenceEqual(baseline.DatasetsResults));
// load the experiment to be run against new defined benchmark
string experimentFilename = System.IO.Path.Combine(AppContext.BaseTestDirectory, testingSolutionFilename);
Experiment testingSolutionExperiment = ExperimentManager.Load(experimentFilename, AppContext.Components);
//finally prepare benchmark experiment
testBenchmark.PrepareBenchmarkExperiment(testingSolutionExperiment, AppContext.Components);
//run benchmark
MockProgress progress = new MockProgress();
using (var dispatcher = CreateExperiment(testBenchmark.BenchmarkExperiment, AppContext.WorkspaceInstance, AppContext.Components))
{
dispatcher.ExecuteExperiment(progress);
Assert.AreEqual(5, progress.NumSteps);
Assert.IsFalse(progress.HasError);
}
}
public void ExperimentLoadNull()
{
IExperiment loadedExperiment = ExperimentManager.Load(null, AppContext.Components);
}
public void ExperimentLoadStructureCorruptedFile()
{
string filename = System.IO.Path.Combine(AppContext.BaseTestDirectory, "tracingGraphStructureCorrupted.teml");
IExperiment loadedExperiment = ExperimentManager.Load(filename, AppContext.Components);
}
public void DefineCompositeComponentFromExperimentWithAnotherCompositeComponentTest()
{
// load the experiment to be exported
string experimentFilename = System.IO.Path.Combine(AppContext.BaseTestDirectory, "experiment_with_composite_component.teml");
Experiment experiment = ExperimentManager.Load(experimentFilename, AppContext.Components);
experiment.Settings = AppContext.Settings; //applying these settings was causing the bug #74
//select all nodes
foreach (ExperimentNode node in experiment.Vertices)
{
node.IsSelected = true;
}
DefiningCompositeComponentSetup setup = new DefiningCompositeComponentSetup(experiment);
Assert.IsNotNull(experiment);
Assert.AreEqual(3, experiment.VertexCount);
Assert.IsNotNull(setup);
Assert.AreEqual(0, setup.InputSettings.Count);
Assert.AreEqual(2, setup.OutputSettings.Count);
Assert.AreEqual(2, setup.ConfigSettings.Count);
//check if default name is the same as experiment info
Assert.IsTrue(setup.OutputSettings["test_x"].Include);
Assert.IsTrue(setup.OutputSettings["test_y"].Include);
Assert.IsTrue(setup.ConfigSettings["Composite Component Test writer Value"].Include);
Assert.IsTrue(setup.ConfigSettings["Composite Component Test writer Value 2"].Include);
//get real names of the config values
string configName1 = setup.ConfigSettings["Composite Component Test writer Value"].PropertyObject.Name;
string configName2 = setup.ConfigSettings["Composite Component Test writer Value 2"].PropertyObject.Name;
//change settings to sth different values
setup.Name = "Complex Composite Component";
setup.Author = "Author XYZ";
setup.Description = "Complex Composite Component to test export";
//don't include following in the export
setup.OutputSettings["test_y"].Include = false;
//change alias
setup.ConfigSettings["Composite Component Test writer Value"].Alias = "Config 1";
setup.ConfigSettings["Composite Component Test writer Value 2"].Alias = "Config 2";
setup.ConfigSettings["Composite Component Test writer Value 2"].Include = false;
//rescan library to be sure it is fresh scan
int numberOfComponentsInLibrary = GetCountOfComponentsInLibrary();
//let's export the experiment as composite component
Assert.IsFalse(File.Exists(exportFile));
setup.CompositeComponentLocationFilePath = exportFile;
setup.DefineComponent();
Assert.IsTrue(File.Exists(exportFile));
//rescan the library
int updatedNumberOfComponents = GetCountOfComponentsInLibrary();
//after rescan there should be one more component in the library
Assert.AreEqual(numberOfComponentsInLibrary + 1, updatedNumberOfComponents);
//iterate through all components until find new composite component
CompositeComponentMetadataDefinition compositeComponentDefinition = FindCompositeComponent(exportFile);
//assure that composite component definition has been found
Assert.IsNotNull(compositeComponentDefinition); //if fails, composite component has not been found
Assert.AreEqual(setup.Name, compositeComponentDefinition.Label);
Assert.AreEqual(setup.Description, compositeComponentDefinition.Description);
Assert.AreEqual(setup.Author, compositeComponentDefinition.Author);
Assert.IsNotNull(compositeComponentDefinition.ComponentGraph);
//the number of configuration properties should be the same
Assert.AreEqual(setup.ConfigSettings.Count, compositeComponentDefinition.ConfigurationWrapperDefinition.Properties.Count);
ConfigPropertyObject config1 = compositeComponentDefinition.ConfigurationWrapperDefinition.Properties[configName1];
ConfigPropertyObject config2 = compositeComponentDefinition.ConfigurationWrapperDefinition.Properties[configName2];
Assert.AreEqual("Config 1", config1.DisplayName);
Assert.AreEqual("Config 2", config2.DisplayName);
Assert.IsTrue(config1.Visible);
Assert.IsFalse(config2.Visible); //config1 should not be visible, because Include was set to false
Assert.AreEqual(0, compositeComponentDefinition.IOSpecDefinition.Input.Count); //none input value were included
Assert.AreEqual(1, compositeComponentDefinition.IOSpecDefinition.Output.Count); //one output value was included
}
public void ExperimentLoadEmpty()
{
IExperiment loadedExperiment = ExperimentManager.Load(string.Empty, AppContext.Components);
}
public void DefineCompositeComponentBasicTestSelectAllNodes()
{
// load the experiment to be exported
string experimentFilename = System.IO.Path.Combine(AppContext.BaseTestDirectory, "experiment_define_composite_component_basic_test.teml");
Experiment experiment = ExperimentManager.Load(experimentFilename, AppContext.Components);
experiment.Settings = AppContext.Settings; //assure that we apply global settings
//in first basic test select all nodes
foreach (ExperimentNode node in experiment.Vertices)
{
node.IsSelected = true;
}
DefiningCompositeComponentSetup setup = new DefiningCompositeComponentSetup(experiment);
Assert.IsNotNull(setup);
Assert.AreEqual(1, setup.InputSettings.Count);
Assert.AreEqual(2, setup.OutputSettings.Count);
Assert.AreEqual(1, setup.ConfigSettings.Count);
Assert.IsTrue(setup.InputSettings["test1"].Include);
Assert.IsTrue(setup.OutputSettings["test1"].Include);
Assert.IsTrue(setup.OutputSettings["test2"].Include);
//note, if there are two components with the same label and same config name, the expected behaviour is to add
Assert.IsTrue(setup.ConfigSettings["Test writer Value"].Include);
//get real names of the config values
string configName1 = setup.ConfigSettings["Test writer Value"].PropertyObject.Name;
//change settings to sth different values
setup.Name = "Test Composite Component";
setup.Author = "Author XYZ";
setup.Description = "Composite Component to test export";
//don't include following in the export
setup.InputSettings["test1"].Include = false;
setup.OutputSettings["test1"].Include = false;
//rescan library to be sure it is fresh scan
int numberOfComponentsInLibrary = GetCountOfComponentsInLibrary();
//set file path to composite component
setup.CompositeComponentLocationFilePath = exportFile;
Assert.IsFalse(File.Exists(setup.CompositeComponentLocationFilePath));
setup.DefineComponent();
Assert.IsTrue(File.Exists(exportFile));
//rescan the library
int updatedNumberOfComponents = GetCountOfComponentsInLibrary();
//after rescan there should be one more component in the library
Assert.AreEqual(numberOfComponentsInLibrary + 1, updatedNumberOfComponents);
//iterate through all components until find new composite component
CompositeComponentMetadataDefinition compositeComponentDefinition = FindCompositeComponent(exportFile);
//assure that composite component definition has been found
Assert.IsNotNull(compositeComponentDefinition); //if fails, composite component has not been found
Assert.AreEqual(setup.Name, compositeComponentDefinition.Label);
Assert.AreEqual(setup.Description, compositeComponentDefinition.Description);
Assert.AreEqual(setup.Author, compositeComponentDefinition.Author);
Assert.IsNotNull(compositeComponentDefinition.ComponentGraph);
//the number of configuration properties should be the same
Assert.AreEqual(setup.ConfigSettings.Count, compositeComponentDefinition.ConfigurationWrapperDefinition.Properties.Count);
ConfigPropertyObject config1 = compositeComponentDefinition.ConfigurationWrapperDefinition.Properties[configName1];
Assert.AreEqual("Test writer Value", config1.DisplayName);
Assert.IsTrue(config1.Visible); //config1 should be visible, because Include was set to false
Assert.AreEqual(0, compositeComponentDefinition.IOSpecDefinition.Input.Count); //no input was included
Assert.AreEqual(1, compositeComponentDefinition.IOSpecDefinition.Output.Count); //only one output was included
}
/// <summary>
/// Prepares the benchmark experiment.
/// </summary>
/// <param name="experimentToBeBenchmarked">The experiment to be benchmarked.</param>
/// <exception cref="TraceLab.Core.Exceptions.ExperimentLoadException">throws if experiment load fails</exception>
/// <param name="library">The library.</param>
public void PrepareBenchmarkExperiment(Experiment experimentToBeBenchmarked, ComponentsLibrary library)
{
//load benchmark experiment
Experiment benchmarkExperiment = ExperimentManager.Load(BenchmarkInfo.FilePath, library);
//update benchmark experiment info, so that it refers to the same benchmark info (LoadExperiment would not read BenchmarkInfo, as it only reads ExperimentInfo)
benchmarkExperiment.ExperimentInfo = BenchmarkInfo;
//2. find template node to be replaced
ExperimentNode templateNode = null;
foreach (ExperimentNode node in benchmarkExperiment.Vertices)
{
if (node.Data.Metadata is ComponentTemplateMetadata)
{
templateNode = node;
break;
}
}
if (templateNode == null)
{
throw new TraceLab.Core.Exceptions.BenchmarkException("Template node has not been found in the benchmark experiment. The benchmark experiment is corrupted.");
}
//3. export current experiment into composite component
foreach (BenchmarkItemSetting <IOItem> item in BenchmarkInputSetting)
{
item.SelectedSetting.Include = true;
}
foreach (BenchmarkItemSetting <IOItem> item in BenchmarkOutputsSetting)
{
item.SelectedSetting.Include = true;
}
//create temporary component source - note it is just a assembly source name file to satisfy Metadata Assembly requirement
//the file is not going to be created (this is UGLY - do refactoring)
string tempSource = System.IO.Path.Combine(BenchmarkInfo.FilePath, "temporary");
m_setup.CompositeComponentLocationFilePath = tempSource;
CompositeComponentMetadataDefinition definition = m_setup.GenerateCompositeComponentDefinition();
//4. Replace template node by removing it from graph, adding the new node, and reconnecting new not
//Add composite component node
ExperimentNode replacementNode = benchmarkExperiment.AddComponentFromDefinition(definition, templateNode.Data.X, templateNode.Data.Y);
//connect replacement node to the same outgoing nodes as template node
foreach (ExperimentNodeConnection nodeConnection in benchmarkExperiment.OutEdges(templateNode))
{
benchmarkExperiment.AddConnection(replacementNode, nodeConnection.Target);
}
//connect replacement node to the same incoming nodes as template node
foreach (ExperimentNodeConnection nodeConnection in benchmarkExperiment.InEdges(templateNode))
{
benchmarkExperiment.AddConnection(nodeConnection.Source, replacementNode);
//if the predecessor is a decision node update its decision code so that it matches new label
FixDecisionCode(templateNode.Data.Metadata.Label, replacementNode.Data.Metadata.Label, nodeConnection.Source as ExperimentDecisionNode);
}
//finally remove the template node
benchmarkExperiment.RemoveVertex(templateNode);
//now remap io according to settings
CompositeComponentMetadata compositeComponentDefinition = (CompositeComponentMetadata)replacementNode.Data.Metadata;
foreach (BenchmarkItemSetting <IOItem> item in BenchmarkInputSetting)
{
item.SelectedSetting.Include = true;
compositeComponentDefinition.IOSpec.Input[item.SelectedSetting.ItemSettingName].MappedTo = item.Item.MappedTo;
}
foreach (BenchmarkItemSetting <IOItem> item in BenchmarkOutputsSetting)
{
item.SelectedSetting.Include = true;
compositeComponentDefinition.IOSpec.Output[item.SelectedSetting.ItemSettingName].MappedTo = item.Item.MappedTo;
}
BenchmarkExperiment = benchmarkExperiment;
}
