/// <summary>
/// Set the parameters in the properties storage from a specified xml representation of the data.
/// </summary>
/// <param name="xml">The xml representation of the data.</param>
/// <param name="properties">The global properties storage.</param>
/// <param name="handler">The handler that holds the builder- to parameter-type relation.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
/// <exception cref="InvalidCastException"><c>InvalidCastException</c> Problem building from serialization data.</exception>
public IMemberBuildParameters SetParameters(string xml, IBuildDataDictionary properties, IBuildHandler handler)
{
Guard.NotNull(() => properties, properties);
if (handler == null)
{
// Todo: or throw?
return(new EmptyBuildParameters());
}
// <NStub.CSharp.ObjectGeneration.Builders.PropertyBuilder>
var doc = new XmlDocument();
doc.LoadXml(xml);
IMemberBuildParameters setupPara = null;
foreach (XmlNode child in doc.ChildNodes)
{
//var child = doc.FirstChild;
if (handler.IsMultiBuilder)
{
// Hier HAPERTS !!!!!!!!!!!!!!!!!!! multi fetchen ... document node klappt nicht
// setupPara = SetSingleNode(properties, handler, child, "Multi." + handler.Type.FullName, string.Empty);
setupPara = SetSingleNode(properties, handler, child);
}
else
{
setupPara = SetSingleNode(properties, handler, child);
}
}
return(setupPara);
}
/// <summary>
/// Get the parameters for the specified multi builder type, possibly creating it, if there
/// is not yet one in the build data collection.
/// </summary>
/// <param name="key">The unique identifier for the set of parameter data.</param>
/// <param name="builderType">Type of the builder to request a set of sample data for.</param>
/// <param name="properties">The global properties storage.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
/// <exception cref="KeyNotFoundException">The given <paramref name="builderType"/> was not present in the lookup.</exception>
public IMultiBuildParameters GetMultiParameter(Guid key, Type builderType, IBuildDataDictionary properties)
{
Guard.NotNull(() => properties, properties);
var paraType = this.buildHandlers[builderType].ParameterDataType;
return(((BuilderSerializer)this.serializer).GetMultiParameter(key, builderType, paraType, properties));
}
/// <summary>
/// Get the parameters for the specified builder type, possibly creating it, if there
/// is not yet one in the build data collection.
/// </summary>
/// <param name="builderType">Type of the builder to request a set of sample data for.</param>
/// <param name="properties">The global properties storage.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
/// <exception cref="KeyNotFoundException">The given <paramref name="builderType"/> was not present in the lookup.</exception>
public IMemberBuildParameters GetParameters(Type builderType, IBuildDataDictionary properties)
{
Guard.NotNull(() => builderType, builderType);
Guard.NotNull(() => properties, properties);
var paraType = this.buildHandlers[builderType].ParameterDataType;
return(this.serializer.GetParameters(builderType, paraType, properties));
}
/// <summary>
/// Initializes a new instance of the <see cref="LoadAssemblyWorker"/> class.
/// </summary>
/// <param name="buildSystem">The build system.</param>
/// <param name="buildData">The build properties data storage.</param>
/// <param name="mainform">The application main window.</param>
public LoadAssemblyWorker(IBuildSystem buildSystem, IBuildDataDictionary buildData, MainForm mainform)
{
Guard.NotNull(() => buildSystem, buildSystem);
this.buildSystem = buildSystem;
Guard.NotNull(() => buildData, buildData);
this.buildData = buildData;
Guard.NotNull(() => mainform, mainform);
this.mainform = mainform;
}
/// <summary>
/// Gets the xml data representation of all registered <see cref="IMemberBuilder"/>s parameters.
/// </summary>
/// <param name="properties">The properties storage which stores the <see cref="IMemberBuildParameters"/> data to serialize.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
public string SerializeAllSetupData(IBuildDataDictionary properties)
{
Guard.NotEmpty(() => properties, properties);
var handlers = this.buildHandlers.Values.AsEnumerable();
return(this.serializer.SerializeAllHandlers(properties, handlers));
// return NewMethod(properties, buildHandlers);
}
/// <summary>
/// Initializes a new instance of the <see cref="LoadAssemblyWorker"/> class.
/// </summary>
/// <param name="buildSystem">The build system.</param>
/// <param name="buildData">The build properties data storage.</param>
/// <param name="mainform">The application main window.</param>
public LoadAssemblyWorker(IBuildSystem buildSystem, IBuildDataDictionary buildData, MainForm mainform)
{
Guard.NotNull(() => buildSystem, buildSystem);
this.buildSystem = buildSystem;
Guard.NotNull(() => buildData, buildData);
this.buildData = buildData;
Guard.NotNull(() => mainform, mainform);
this.mainform = mainform;
}
/// <summary>
/// Set the parameters in the properties storage from a specified xml representation of the data.
/// </summary>
/// <param name="xml">The xml representation of the data.</param>
/// <param name="properties">The global properties storage.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
/// <exception cref="InvalidCastException"><c>InvalidCastException</c> Problem building from serialization data.</exception>
public IMemberBuildParameters SetParameters(string xml, IBuildDataDictionary properties)
{
Guard.NotNull(() => properties, properties);
var handlers = this.buildHandlers.Values.AsEnumerable();
IBuildHandler handler = this.serializer.DetermineIMemberBuilderFromXmlFragment(xml, handlers);
return(this.serializer.SetParameters(xml, properties, handler));
}
/// <summary>
/// Initializes a new instance of the <see cref="CodeTypeSetup"/> class.
/// </summary>
/// <param name="namespaceDetector">The namespace detector.</param>
/// <param name="buildData">The build data properties.</param>
/// <param name="testClassDeclaration">The class declaration of the object under test.</param>
public CodeTypeSetup(NamespaceDetector namespaceDetector, IBuildDataDictionary buildData, CodeTypeDeclaration testClassDeclaration)
{
Guard.NotNull(() => namespaceDetector, namespaceDetector);
this.namespaceDetector = namespaceDetector;
Guard.NotNull(() => buildData, buildData);
this.buildData = buildData;
Guard.NotNull(() => testClassDeclaration, testClassDeclaration);
this.testClassDeclaration = testClassDeclaration;
//result = SetUp();
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpTestProjectBuilder"/> class.
/// </summary>
/// <param name="sbs">The system wide build system.</param>
/// <param name="buildData">The build data properties.</param>
/// <param name="projectGenerator">The project generator.</param>
/// <param name="createGeneratorCallback">The callback to create new code
/// generators per test class <see cref="CodeNamespace"/>.</param>
/// <param name="logger">The logging method.</param>
public CSharpTestProjectBuilder(
IBuildSystem sbs,
IBuildDataDictionary buildData,
IProjectGenerator projectGenerator,
Func <IBuildSystem, IBuildDataDictionary, ICodeGeneratorParameters, CodeNamespace, ICodeGenerator> createGeneratorCallback,
Action <string> logger)
: base(sbs, projectGenerator, OldOnCreateCodeGenerator, logger)
{
Guard.NotNull(() => buildData, buildData);
Guard.NotNull(() => createGeneratorCallback, createGeneratorCallback);
this.createGeneratorCallback = createGeneratorCallback;
// properties = SetUpBuildProperties();
this.properties = SetUpBuildProperties(buildData);
}
/// <summary>
/// Get the parameters for the specified builder type, possibly creating it, if there
/// is not yet one in the build data collection.
/// </summary>
/// <param name="builderType">Type of the builder to request a set of sample data for.</param>
/// <param name="paraType">Type of the parameter class.</param>
/// <param name="properties">The global properties storage.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
/// <exception cref="KeyNotFoundException">The given <paramref name="builderType"/> was not present in the lookup.</exception>
public IMemberBuildParameters GetParameters(Type builderType, Type paraType, IBuildDataDictionary properties)
{
Guard.NotNull(() => properties, properties);
IBuilderData result;
var found = properties.TryGetValue(string.Empty + builderType.FullName, out result);
if (found)
{
return(result as IMemberBuildParameters);
}
var paraInstance = Activator.CreateInstance(paraType);
var setupPara = (IMemberBuildParameters)paraInstance;
properties.AddDataItem(string.Empty + builderType.FullName, setupPara);
return(setupPara);
}
/// <summary>
/// Set the parameters in the properties storage from a specified xml representation of the data.
/// </summary>
/// <param name="xml">The xml representation of the data.</param>
/// <param name="properties">The global properties storage.</param>
/// <param name="handlers">The list of existing handlers to investigate.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
/// <exception cref="InvalidCastException"><c>InvalidCastException</c> Problem building from serialization data.</exception>
public IEnumerable<IMemberBuildParameters> DeserializeAllSetupData(
string xml, IBuildDataDictionary properties, IEnumerable<IBuildHandler> handlers)
{
// <NStub.CSharp.ObjectGeneration.Builders.PropertyBuilder>
var plist = new List<IMemberBuildParameters>();
var doc = new XmlDocument();
doc.LoadXml(xml);
foreach(XmlElement item in doc[BuilderConstants.BuildParametersXmlId])
{
IBuildHandler handler = this.DetermineIMemberBuilderFromXmlFragment(item.OuterXml, handlers);
var para = this.SetParameters(item.OuterXml, properties, handler);
plist.Add(para);
// yield return para;
}
return plist;
}
/// <summary>
/// Set the parameters in the properties storage from a specified xml representation of the data.
/// </summary>
/// <param name="xml">The xml representation of the data.</param>
/// <param name="properties">The global properties storage.</param>
/// <param name="handlers">The list of existing handlers to investigate.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
/// <exception cref="InvalidCastException"><c>InvalidCastException</c> Problem building from serialization data.</exception>
public IEnumerable <IMemberBuildParameters> DeserializeAllSetupData(
string xml, IBuildDataDictionary properties, IEnumerable <IBuildHandler> handlers)
{
// <NStub.CSharp.ObjectGeneration.Builders.PropertyBuilder>
var plist = new List <IMemberBuildParameters>();
var doc = new XmlDocument();
doc.LoadXml(xml);
foreach (XmlElement item in doc[BuilderConstants.BuildParametersXmlId])
{
IBuildHandler handler = this.DetermineIMemberBuilderFromXmlFragment(item.OuterXml, handlers);
var para = this.SetParameters(item.OuterXml, properties, handler);
plist.Add(para);
// yield return para;
}
return(plist);
}
/// <summary>
/// Gets the user defined data for <see cref="IMultiBuilder"/> builder types from the specified build data storage.
/// </summary>
/// <param name="properties">The global properties storage.</param>
/// <returns>A lookup collection with the defined parameters.</returns>
public virtual IEnumerable <MultiLookup> MultiParameters(IBuildDataDictionary properties)
{
// public virtual IEnumerable<IReadOnlyDictionary<string, IBuilderData>> MultiParameters(IBuildDataDictionary properties)
var multis = this.buildHandlers.Where(e => e.Value.IsMultiBuilder);
var multiparamsxx = multis
.SelectMany(
e =>
{
// var le = ((BuilderSerializer)serializer).GetMultiParameters(e.Value.Type, e.Value.ParameterDataType, properties)
// .Keys.Select(x => x);
var lox = ((BuilderSerializer)this.serializer)
.GetMultiParameters(e.Value.Type, e.Value.ParameterDataType, properties);
IEnumerable <IBuilderData> lo = new List <IBuilderData>();
if (lox != null)
{
lo = lox.Values.Select(x => x);
}
return(lo);
},
(a, v) => new MultiLookup {
BuilderType = a.Key, Parameters = (IMultiBuildParameters)v
});
/*var multiparams = multis
* .Select((e) =>
* {
* var lo = ((BuilderSerializer)serializer).GetMultiParameters(e.Value.Type, e.Value.ParameterDataType, properties)
* .Values.Select(x=>x);
* // var mlookup = new MultiLookup() { BuilderType = e.Key, Lookup = lo, Key = ((IMultiBuildParameters)e.Value).Id };
* var mlookup = new MultiLookup() { BuilderType = e.Key,
* Parameters = ((IMultiBuildParameters)lo),
* //Key = ((IMultiBuildParameters)e.Value).Id
* };
* return mlookup;
* });*/
// var result = this.buildHandlers.Values.Select(e => e.Type);
return(multiparamsxx);
}
/// <summary>
/// SetUp the default build properties.
/// </summary>
/// <param name="buildData">The incoming build data.</param>
/// <returns>A new <see cref="BuildDataDictionary"/>, merged with the input <paramref name="buildData"/>.</returns>
private static BuildDataDictionary SetUpBuildProperties(IBuildDataDictionary buildData)
{
var props = new BuildDataDictionary();
// ReadOnlyCollection
foreach (var category in buildData.Data())
{
foreach (var item in category.Value)
{
props.AddDataItem(category.Key, item.Key, item.Value);
}
// props.AddDataItem(item.Key, item,);
}
props.AddDataItem("DasGuuuut", new EmptyBuildParameters());
props.AddDataItem("EinTest", new StringConstantBuildParameter("Der Parameter!"));
// Todo: !!!
return(props);
}
/// <summary>
/// Gets the xml data representation of all registered <see cref="IBuildHandler"/>s.
/// </summary>
/// <param name="properties">The properties storage which stores the <see cref="IMemberBuildParameters"/> data to serialize.</param>
/// <param name="handlers">The handlers with the links to the <see cref="IMemberBuilder"/> types.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
public string SerializeAllHandlers(IBuildDataDictionary properties, IEnumerable <IBuildHandler> handlers)
{
var xmlDoc = new XmlDocument();
var root = xmlDoc.CreateElement(BuilderConstants.BuildParametersXmlId);
xmlDoc.AppendChild(root);
foreach (var handler in handlers)
{
if (handler.Type == null || handler.Type.FullName == null)
{
continue;
}
if (handler.IsMultiBuilder)
{
var builderLookup = this.GetMultiParameters(handler.Type, handler.ParameterDataType, properties);
if (builderLookup != null)
{
foreach (var item in builderLookup)
{
var key = item.Key;
var builderData = item.Value;
var multisetupPara = builderData as IMemberBuildParameters;
if (multisetupPara == null)
{
continue;
}
SerializeParameterToXmlDocument(xmlDoc, root, multisetupPara, handler.Type.FullName);
}
}
}
else
{
var setupPara = this.GetParameters(handler.Type, handler.ParameterDataType, properties);
SerializeParameterToXmlDocument(xmlDoc, root, setupPara, handler.Type.FullName);
}
}
return(PrettyPrintXml(xmlDoc.OuterXml));
}
private void GeneratorConfigLoad(IBuildDataDictionary properties)
{
Log("--------- Loading Property Data (Start) ------------");
/* var sampleXmlData =
* @"<NStub.CSharp.ObjectGeneration.Builders.PropertyBuilder>" + Environment.NewLine +
* @" <PropertyBuilderUserParameters>" + Environment.NewLine +
* @" <MethodSuffix>HeuteMalWasNeues</MethodSuffix>" + Environment.NewLine +
* @" <UseDings>true</UseDings>" + Environment.NewLine +
* @" <Moep>0</Moep>" + Environment.NewLine +
* @" <Enabled>false</Enabled>" + Environment.NewLine +
* @" </PropertyBuilderUserParameters>" + Environment.NewLine +
* @"</NStub.CSharp.ObjectGeneration.Builders.PropertyBuilder>";
*/
// IBuildSystem sys;
// sys.
var filename = Path.Combine(Application.StartupPath, this.BuildPropertyFilename);
if (File.Exists(filename))
{
var xml = File.ReadAllText(filename);
Memberfactory.DeserializeAllSetupData(xml, properties);
}
else
{
Log("Build parameter file '" + filename + "' does not exist. Skipped loading.");
HasSkippedLoading = true;
}
// log the parsed data to the logger.
var xmlparsed = Memberfactory.SerializeAllSetupData(BuildProperties);
Log("Property data in property store:");
Log(xmlparsed);
Log("--------- Loading Property Data (End) ------------");
}
private void GeneratorConfigLoad(IBuildDataDictionary properties)
{
Log("--------- Loading Property Data (Start) ------------");
/* var sampleXmlData =
@"<NStub.CSharp.ObjectGeneration.Builders.PropertyBuilder>" + Environment.NewLine +
@" <PropertyBuilderUserParameters>" + Environment.NewLine +
@" <MethodSuffix>HeuteMalWasNeues</MethodSuffix>" + Environment.NewLine +
@" <UseDings>true</UseDings>" + Environment.NewLine +
@" <Moep>0</Moep>" + Environment.NewLine +
@" <Enabled>false</Enabled>" + Environment.NewLine +
@" </PropertyBuilderUserParameters>" + Environment.NewLine +
@"</NStub.CSharp.ObjectGeneration.Builders.PropertyBuilder>";
*/
// IBuildSystem sys;
// sys.
var filename = Path.Combine(Application.StartupPath, this.BuildPropertyFilename);
if (File.Exists(filename))
{
var xml = File.ReadAllText(filename);
Memberfactory.DeserializeAllSetupData(xml, properties);
}
else
{
Log("Build parameter file '" + filename + "' does not exist. Skipped loading.");
HasSkippedLoading = true;
}
// log the parsed data to the logger.
var xmlparsed = Memberfactory.SerializeAllSetupData(BuildProperties);
Log("Property data in property store:");
Log(xmlparsed);
Log("--------- Loading Property Data (End) ------------");
}
/// <summary>
/// Get the parameters for the specified builder type, possibly creating it, if there
/// is not yet one in the build data collection.
/// </summary>
/// <param name="builderType">Type of the builder to request a set of sample data for.</param>
/// <param name="paraType">Type of the parameter class.</param>
/// <param name="properties">The global properties storage.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
/// <exception cref="KeyNotFoundException">The given <paramref name="builderType"/> was not present in the lookup.</exception>
public IReadOnlyDictionary<string, IBuilderData> GetMultiParameters(Type builderType, Type paraType, IBuildDataDictionary properties)
{
Guard.NotNull(() => properties, properties);
Guard.CanBeAssigned(() => paraType, paraType, typeof(IMultiBuildParameters));
//Guard.IsAssignableFrom<IMultiBuildParameters>(() => paraType, paraType);
IReadOnlyDictionary<string, IBuilderData> category;
var catfound = properties.Data().TryGetValue("Multi." + builderType.FullName, out category);
if (catfound)
{
}
return category;
//var paraInstance = Activator.CreateInstance(paraType);
//var setupPara = (IMemberBuildParameters)paraInstance;
//properties.AddDataItem(string.Empty + builderType.FullName, setupPara);
//return setupPara;
}
/// <summary>
/// Set the parameters in the properties storage from a specified xml representation of the data.
/// </summary>
/// <param name="xml">The xml representation of the data.</param>
/// <param name="properties">The global properties storage.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
/// <exception cref="InvalidCastException"><c>InvalidCastException</c> Problem building from serialization data.</exception>
public IEnumerable <IMemberBuildParameters> DeserializeAllSetupData(string xml, IBuildDataDictionary properties)
{
var handlers = this.buildHandlers.Values.AsEnumerable();
return(this.serializer.DeserializeAllSetupData(xml, properties, handlers));
}
/// <summary>
/// Get the parameters for the specified builder type, possibly creating it, if there
/// is not yet one in the build data collection.
/// </summary>
/// <param name="builderType">Type of the builder to request a set of sample data for.</param>
/// <param name="paraType">Type of the parameter class.</param>
/// <param name="properties">The global properties storage.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
/// <exception cref="KeyNotFoundException">The given <paramref name="builderType"/> was not present in the lookup.</exception>
public IMemberBuildParameters GetParameters(Type builderType, Type paraType, IBuildDataDictionary properties)
{
Guard.NotNull(() => properties, properties);
IBuilderData result;
var found = properties.TryGetValue(string.Empty + builderType.FullName, out result);
if (found)
{
return result as IMemberBuildParameters;
}
var paraInstance = Activator.CreateInstance(paraType);
var setupPara = (IMemberBuildParameters)paraInstance;
properties.AddDataItem(string.Empty + builderType.FullName, setupPara);
return setupPara;
}
public void GenerateWithAssemblyAndModuleAndClassesAndMethod()
{
//expected = false;
var outputFolder = "Value ? of ou$tputFol*der";
var generatorType = typeof(object);
var inputAssemblyPath = "Value of inputAssemblyPath";
char directorySeparator = '\\';
var firstModuleName = "TheTestNode";
var firstModuleTag = "FirstModule";
var className1Namespace = "The.Namespace";
var className1 = "VeryPrettyFactory";
var className1FullName = className1Namespace + "." + className1;
var classTag = this.GetType();
var methodName = "MyMethod";
var methodTag = this.GetType().GetMethod("FakeMethod");
var assemblyNode = new TestNode(firstModuleName + ".dll", TestNodeType.Assembly, null)
{
Checked = true
};
var moduleNode = new TestNode(firstModuleName + ".dll", TestNodeType.Module, firstModuleTag)
{
Checked = true
};
var classNode = new TestNode(className1FullName, TestNodeType.Class, classTag)
{
Checked = true
};
var methodNode = new TestNode(methodName, TestNodeType.Method, methodTag)
{
Checked = true
};
assemblyNode.Nodes.Add(moduleNode);
moduleNode.Nodes.Add(classNode);
classNode.Nodes.Add(methodNode);
var mainNodes = new[] { assemblyNode };
var referencedAssemblies = typeof(CSharpTestProjectBuilderTest).Assembly.GetReferencedAssemblies();
var para = new CodeGeneratorParameters(outputFolder);
var runnerData = GeneratorRunnerData.Create(
outputFolder, generatorType, inputAssemblyPath, mainNodes, referencedAssemblies);
Expect.Call(sbs.DirectorySeparatorChar).Return(directorySeparator).Repeat.Any();
Expect.Call(sbs.GetFileNameWithoutExtension(firstModuleName + ".dll")).Return(firstModuleName);
var expectedDirectory = outputFolder + directorySeparator + firstModuleName + ".Tests";
Expect.Call(sbs.CreateDirectory(expectedDirectory)).Return(null);
Expect.Call(sbs.DirectoryExists(expectedDirectory)).Return(true);
var prjReferencedAssemblies = new List <AssemblyName>();
Expect.Call(projectGenerator.ReferencedAssemblies).Return(prjReferencedAssemblies).Repeat.Any();
Expect.Call(projectGenerator.GenerateProjectFile).Repeat.Once();
var classFilesList = new List <string>();
Expect.Call(projectGenerator.ClassFiles).Return(classFilesList).Repeat.Once();
var codeGenerator = mocks.StrictMock <ICodeGenerator>();
CodeNamespace generatorCodeNamespace = null;
IBuildDataDictionary generatorBuildData = null;
Expect.Call(createGeneratorCallback(sbs, null, null, null))
//.Constraints(Is.Same(sbs), Is.TypeOf<CodeGeneratorParameters>(), Is.TypeOf<CodeNamespace>())
.Constraints(
Is.Same(sbs),
Is.TypeOf <IBuildDataDictionary>() && Is.NotNull(),
Is.TypeOf <CodeGeneratorParameters>() && Property.Value("OutputDirectory", expectedDirectory),
Is.TypeOf <CodeNamespace>())
//.Return(codeGenerator)
.Do((Func <IBuildSystem, IBuildDataDictionary, ICodeGeneratorParameters, CodeNamespace, ICodeGenerator>)
delegate(IBuildSystem buildSys, IBuildDataDictionary data, ICodeGeneratorParameters cgp, CodeNamespace cn)
{
Assert.AreEqual(expectedDirectory, cgp.OutputDirectory);
Assert.IsFalse(cgp.UseSetupAndTearDown);
generatorBuildData = data;
generatorCodeNamespace = cn;
return(codeGenerator);
});
Expect.Call(codeGenerator.CodeNamespace = null).PropertyBehavior();
Expect.Call(codeGenerator.OutputDirectory = expectedDirectory);
Expect.Call(codeGenerator.GenerateCode);
// logging
Expect.Call(delegate { this.logger(null); }).Constraints(Is.NotNull()).Repeat.AtLeastOnce();
Expect.Call(projectGenerator.ProjectName).Return(firstModuleName).Repeat.Any();
mocks.ReplayAll();
testObject.GenerateTests(runnerData);
//Assert.AreEqual(expected, actual);
Assert.IsNotEmpty(generatorBuildData);
Assert.Count(1, generatorBuildData);
Assert.IsTrue(generatorBuildData.Contains(this.buildDataItem));
Assert.IsNotEmpty(prjReferencedAssemblies);
Assert.IsNotEmpty(classFilesList);
Assert.IsEmpty(generatorCodeNamespace.Comments);
Assert.IsEmpty(generatorCodeNamespace.Imports);
Assert.AreEqual(className1Namespace, generatorCodeNamespace.Name);
Assert.IsNotEmpty(generatorCodeNamespace.Types);
Assert.IsEmpty(generatorCodeNamespace.UserData);
var classDefinition1 = generatorCodeNamespace.Types[0];
Assert.AreEqual(MemberAttributes.Private | MemberAttributes.Final, classDefinition1.Attributes);
Assert.IsEmpty(classDefinition1.BaseTypes);
Assert.IsEmpty(classDefinition1.Comments);
Assert.IsEmpty(classDefinition1.CustomAttributes);
Assert.AreEqual(className1FullName, classDefinition1.Name);
Assert.IsTrue(classDefinition1.IsClass);
Assert.IsEmpty(classDefinition1.StartDirectives);
Assert.IsEmpty(classDefinition1.TypeParameters);
Assert.IsNotEmpty(classDefinition1.UserData);
Assert.Count(1, classDefinition1.UserData);
Assert.AreEqual(classTag, classDefinition1.UserData[NStubConstants.UserDataClassTypeKey]);
Assert.IsNotEmpty(classDefinition1.Members);
var class1Members = classDefinition1.Members;
// Todo: More checks on the generated types.
mocks.VerifyAll();
}
/// <summary>
/// Get the parameters for the specified builder type, possibly creating it, if there
/// is not yet one in the build data collection.
/// </summary>
/// <param name="key">The unique identifier of the parameter data set.</param>
/// <param name="builderType">Type of the builder to request a set of sample data for.</param>
/// <param name="paraType">Type of the parameter class.</param>
/// <param name="properties">The global properties storage.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
/// <exception cref="KeyNotFoundException">The given <paramref name="builderType"/> was not present in the lookup.</exception>
public IMultiBuildParameters GetMultiParameter(Guid key, Type builderType, Type paraType, IBuildDataDictionary properties)
{
Guard.NotNull(() => properties, properties);
Guard.CanBeAssigned(()=> paraType, paraType, typeof(IMultiBuildParameters));
IBuilderData result;
if (key == null || key == Guid.Empty)
{
key = Guid.NewGuid();
}
else
{
IReadOnlyDictionary<string, IBuilderData> category;
var catfound = properties.Data().TryGetValue("Multi." + builderType.FullName, out category);
if (catfound)
{
var found = category.TryGetValue(key.ToString(), out result);
if (found)
{
return result as IMultiBuildParameters;
}
}
}
var paraInstance = Activator.CreateInstance(paraType);
var setupPara = (IMultiBuildParameters)paraInstance;
properties.AddDataItem("Multi." + builderType.FullName, key.ToString(), setupPara);
setupPara.Id = key;
return setupPara;
//var paraInstance = Activator.CreateInstance(paraType);
//var setupPara = (IMemberBuildParameters)paraInstance;
//properties.AddDataItem(string.Empty + builderType.FullName, setupPara);
//return setupPara;
}
private IMemberBuildParameters SetSingleNode(IBuildDataDictionary properties, IBuildHandler handler,
XmlNode firstChild)
{
Guard.NotNull(() => properties, properties);
Guard.NotNull(() => handler, handler);
var paraType = handler.ParameterDataType;
if (!typeof(IBuilderData).IsAssignableFrom(paraType))
{
throw new ArgumentOutOfRangeException("handler",
"The handler for MemberBuilder '" + handler.Type.FullName +
"' is mapping to a invalid parameter of '" + handler.ParameterDataType.FullName + "' type. " +
"Parameter types have to implement the '" + typeof(IBuilderData).FullName + "' interface.");
}
object paraInstance = null;
if (handler.IsMultiBuilder)
{
if (!typeof(IMultiBuildParameters).IsAssignableFrom(paraType))
{
throw new ArgumentOutOfRangeException("handler",
"Requesting a parameter type of '" + firstChild.Name +
"' (via Xml) for the '" + handler.ParameterDataType.FullName + "' handler assigned type. " +
"Parameter types have to implement the '" + typeof(IMultiBuildParameters).FullName + "' interface.");
}
// null check paraType
var xxx = paraType.BaseType.GetGenericTypeDefinition();
var xxxx = xxx.BaseType.GetGenericTypeDefinition();
// null check xxxx
var serializer2 = xxxx.BaseType.GetGenericTypeDefinition();
// Todo: This strange thingy ... very good checking and logging! :)
// null check serializer2
paraInstance = serializer2
.MakeGenericType(paraType)
.GetMethod("Deserialize", new[] { typeof(string) })
.Invoke(null, new object[] { firstChild.InnerXml });
}
else
{
if (!typeof(IMemberBuildParameters).IsAssignableFrom(paraType))
{
throw new ArgumentOutOfRangeException("handler",
"Requesting a parameter type for '" + firstChild.Name +
"' (via Xml) for the '" + paraType.FullName + "' handler assigned type. " +
"Parameter types have to implement the '" + typeof(IMemberBuildParameters).FullName + "' interface.");
}
// Todo: really need this stuff here? should this be done in the handler construction?
// for example: checking if a multibuilder has IMultiBuildParameters and a
// normal builder has IMemberBuildParameters.
var xmlParaType = firstChild.FirstChild.Name;
if (xmlParaType != paraType.Name)
{
throw new ArgumentOutOfRangeException("firstChild",
"Requesting a parameter type of '" + xmlParaType + "' (via Xml). " +
"Parameter types for the '" + handler.Type.FullName + "' builder have to be of the '" + paraType.FullName + "' kind.");
}
// null check paraType
var xxxx = paraType.BaseType.GetGenericTypeDefinition();
// null check xxxx
var serializer2 = xxxx.BaseType.GetGenericTypeDefinition();
// Todo: This strange thingy ... very good checking and logging! :)
// null check serializer2
paraInstance = serializer2
.MakeGenericType(paraType)
.GetMethod("Deserialize", new[] { typeof(string) })
.Invoke(null, new object[] { firstChild.InnerXml });
}
var setupPara = (IMemberBuildParameters)paraInstance;
try
{
var propertyKey = handler.Type.FullName;
// IBuilderData property;
// var found = properties.TryGetValue(propertyKey, out property);
// if (found)
// {
if (handler.IsMultiBuilder)
{
var multiPara = setupPara as IMultiBuildParameters;
properties.AddDataItem("Multi." + handler.Type.FullName, multiPara.Id.ToString(), setupPara, true);
}
else
{
properties.AddDataItem(propertyKey, setupPara, true);
}
// return setupPara;
// }
// properties.AddDataItem(propertyKey, setupPara);
}
catch (Exception ex)
{
var message = string.Format(
"Problem building {0} from serialization data.{1}{2}{3}",
handler.Type.FullName,
Environment.NewLine,
firstChild.InnerXml,
Environment.NewLine);
throw new InvalidCastException(message, ex);
}
return setupPara;
}
/// <summary>
/// Gets the xml data representation of all registered <see cref="IBuildHandler"/>s.
/// </summary>
/// <param name="properties">The properties storage which stores the <see cref="IMemberBuildParameters"/> data to serialize.</param>
/// <param name="handlers">The handlers with the links to the <see cref="IMemberBuilder"/> types.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
public string SerializeAllHandlers(IBuildDataDictionary properties, IEnumerable<IBuildHandler> handlers)
{
var xmlDoc = new XmlDocument();
var root = xmlDoc.CreateElement(BuilderConstants.BuildParametersXmlId);
xmlDoc.AppendChild(root);
foreach(var handler in handlers)
{
if (handler.Type == null || handler.Type.FullName == null)
{
continue;
}
if (handler.IsMultiBuilder)
{
var builderLookup = this.GetMultiParameters(handler.Type, handler.ParameterDataType, properties);
if (builderLookup != null)
{
foreach (var item in builderLookup)
{
var key = item.Key;
var builderData = item.Value;
var multisetupPara = builderData as IMemberBuildParameters;
if (multisetupPara == null)
{
continue;
}
SerializeParameterToXmlDocument(xmlDoc, root, multisetupPara, handler.Type.FullName);
}
}
}
else
{
var setupPara = this.GetParameters(handler.Type, handler.ParameterDataType, properties);
SerializeParameterToXmlDocument(xmlDoc, root, setupPara, handler.Type.FullName);
}
}
return PrettyPrintXml(xmlDoc.OuterXml);
}
/// <summary>
/// Get the parameters for the specified builder type, possibly creating it, if there
/// is not yet one in the build data collection.
/// </summary>
/// <param name="builderType">Type of the builder to request a set of sample data for.</param>
/// <param name="paraType">Type of the parameter class.</param>
/// <param name="properties">The global properties storage.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
/// <exception cref="KeyNotFoundException">The given <paramref name="builderType"/> was not present in the lookup.</exception>
public IReadOnlyDictionary <string, IBuilderData> GetMultiParameters(Type builderType, Type paraType, IBuildDataDictionary properties)
{
Guard.NotNull(() => properties, properties);
Guard.CanBeAssigned(() => paraType, paraType, typeof(IMultiBuildParameters));
//Guard.IsAssignableFrom<IMultiBuildParameters>(() => paraType, paraType);
IReadOnlyDictionary <string, IBuilderData> category;
var catfound = properties.Data().TryGetValue("Multi." + builderType.FullName, out category);
if (catfound)
{
}
return(category);
//var paraInstance = Activator.CreateInstance(paraType);
//var setupPara = (IMemberBuildParameters)paraInstance;
//properties.AddDataItem(string.Empty + builderType.FullName, setupPara);
//return setupPara;
}
/// <summary>
/// Set the parameters in the properties storage from a specified xml representation of the data.
/// </summary>
/// <param name="xml">The xml representation of the data.</param>
/// <param name="properties">The global properties storage.</param>
/// <param name="handler">The handler that holds the builder- to parameter-type relation.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
/// <exception cref="InvalidCastException"><c>InvalidCastException</c> Problem building from serialization data.</exception>
public IMemberBuildParameters SetParameters(string xml, IBuildDataDictionary properties, IBuildHandler handler)
{
Guard.NotNull(() => properties, properties);
if (handler == null)
{
// Todo: or throw?
return new EmptyBuildParameters();
}
// <NStub.CSharp.ObjectGeneration.Builders.PropertyBuilder>
var doc = new XmlDocument();
doc.LoadXml(xml);
IMemberBuildParameters setupPara = null;
foreach (XmlNode child in doc.ChildNodes)
{
//var child = doc.FirstChild;
if (handler.IsMultiBuilder)
{
// Hier HAPERTS !!!!!!!!!!!!!!!!!!! multi fetchen ... document node klappt nicht
// setupPara = SetSingleNode(properties, handler, child, "Multi." + handler.Type.FullName, string.Empty);
setupPara = SetSingleNode(properties, handler, child);
}
else
{
setupPara = SetSingleNode(properties, handler, child);
}
}
return setupPara;
}
/// <summary>
/// Get the parameters for the specified builder type, possibly creating it, if there
/// is not yet one in the build data collection.
/// </summary>
/// <param name="key">The unique identifier of the parameter data set.</param>
/// <param name="builderType">Type of the builder to request a set of sample data for.</param>
/// <param name="paraType">Type of the parameter class.</param>
/// <param name="properties">The global properties storage.</param>
/// <returns>
/// A new instance of a matching parameter data set for the specified builder.
/// </returns>
/// <exception cref="KeyNotFoundException">The given <paramref name="builderType"/> was not present in the lookup.</exception>
public IMultiBuildParameters GetMultiParameter(Guid key, Type builderType, Type paraType, IBuildDataDictionary properties)
{
Guard.NotNull(() => properties, properties);
Guard.CanBeAssigned(() => paraType, paraType, typeof(IMultiBuildParameters));
IBuilderData result;
if (key == null || key == Guid.Empty)
{
key = Guid.NewGuid();
}
else
{
IReadOnlyDictionary <string, IBuilderData> category;
var catfound = properties.Data().TryGetValue("Multi." + builderType.FullName, out category);
if (catfound)
{
var found = category.TryGetValue(key.ToString(), out result);
if (found)
{
return(result as IMultiBuildParameters);
}
}
}
var paraInstance = Activator.CreateInstance(paraType);
var setupPara = (IMultiBuildParameters)paraInstance;
properties.AddDataItem("Multi." + builderType.FullName, key.ToString(), setupPara);
setupPara.Id = key;
return(setupPara);
//var paraInstance = Activator.CreateInstance(paraType);
//var setupPara = (IMemberBuildParameters)paraInstance;
//properties.AddDataItem(string.Empty + builderType.FullName, setupPara);
//return setupPara;
}
private IMemberBuildParameters SetSingleNode(IBuildDataDictionary properties, IBuildHandler handler,
XmlNode firstChild)
{
Guard.NotNull(() => properties, properties);
Guard.NotNull(() => handler, handler);
var paraType = handler.ParameterDataType;
if (!typeof(IBuilderData).IsAssignableFrom(paraType))
{
throw new ArgumentOutOfRangeException("handler",
"The handler for MemberBuilder '" + handler.Type.FullName +
"' is mapping to a invalid parameter of '" + handler.ParameterDataType.FullName + "' type. " +
"Parameter types have to implement the '" + typeof(IBuilderData).FullName + "' interface.");
}
object paraInstance = null;
if (handler.IsMultiBuilder)
{
if (!typeof(IMultiBuildParameters).IsAssignableFrom(paraType))
{
throw new ArgumentOutOfRangeException("handler",
"Requesting a parameter type of '" + firstChild.Name +
"' (via Xml) for the '" + handler.ParameterDataType.FullName + "' handler assigned type. " +
"Parameter types have to implement the '" + typeof(IMultiBuildParameters).FullName + "' interface.");
}
// null check paraType
var xxx = paraType.BaseType.GetGenericTypeDefinition();
var xxxx = xxx.BaseType.GetGenericTypeDefinition();
// null check xxxx
var serializer2 = xxxx.BaseType.GetGenericTypeDefinition();
// Todo: This strange thingy ... very good checking and logging! :)
// null check serializer2
paraInstance = serializer2
.MakeGenericType(paraType)
.GetMethod("Deserialize", new[] { typeof(string) })
.Invoke(null, new object[] { firstChild.InnerXml });
}
else
{
if (!typeof(IMemberBuildParameters).IsAssignableFrom(paraType))
{
throw new ArgumentOutOfRangeException("handler",
"Requesting a parameter type for '" + firstChild.Name +
"' (via Xml) for the '" + paraType.FullName + "' handler assigned type. " +
"Parameter types have to implement the '" + typeof(IMemberBuildParameters).FullName + "' interface.");
}
// Todo: really need this stuff here? should this be done in the handler construction?
// for example: checking if a multibuilder has IMultiBuildParameters and a
// normal builder has IMemberBuildParameters.
var xmlParaType = firstChild.FirstChild.Name;
if (xmlParaType != paraType.Name)
{
throw new ArgumentOutOfRangeException("firstChild",
"Requesting a parameter type of '" + xmlParaType + "' (via Xml). " +
"Parameter types for the '" + handler.Type.FullName + "' builder have to be of the '" + paraType.FullName + "' kind.");
}
// null check paraType
var xxxx = paraType.BaseType.GetGenericTypeDefinition();
// null check xxxx
var serializer2 = xxxx.BaseType.GetGenericTypeDefinition();
// Todo: This strange thingy ... very good checking and logging! :)
// null check serializer2
paraInstance = serializer2
.MakeGenericType(paraType)
.GetMethod("Deserialize", new[] { typeof(string) })
.Invoke(null, new object[] { firstChild.InnerXml });
}
var setupPara = (IMemberBuildParameters)paraInstance;
try
{
var propertyKey = handler.Type.FullName;
// IBuilderData property;
// var found = properties.TryGetValue(propertyKey, out property);
// if (found)
// {
if (handler.IsMultiBuilder)
{
var multiPara = setupPara as IMultiBuildParameters;
properties.AddDataItem("Multi." + handler.Type.FullName, multiPara.Id.ToString(), setupPara, true);
}
else
{
properties.AddDataItem(propertyKey, setupPara, true);
}
// return setupPara;
// }
// properties.AddDataItem(propertyKey, setupPara);
}
catch (Exception ex)
{
var message = string.Format(
"Problem building {0} from serialization data.{1}{2}{3}",
handler.Type.FullName,
Environment.NewLine,
firstChild.InnerXml,
Environment.NewLine);
throw new InvalidCastException(message, ex);
}
return(setupPara);
}
