private Type GenerateTestAssemblyAndGetType(string assemblyName)
{
CompilerResults results = DynamicCompilation.CompileAssemblyFromSource(
@"
using System;
using System.Collections.Generic;
using Microsoft.Practices.Modeling;
using Microsoft.Practices.Modeling.ExtensionProvider.Extension;
using Microsoft.Practices.Modeling.ExtensionProvider.Metadata;
namespace " + assemblyName + @"
{
[ExtensionProviderAttribute(""74ECFD8C-4906-4a71-9B23-DCB43C26928A"", ""TestExt"", ""Test Extension"", typeof(Object))]
public class TestExtensionProvider : ExtensionProviderBase
{
public override IList<Type> ObjectExtenders
{
get { return new List<Type>(); }
}
}
}" ,
assemblyName);
Assert.IsFalse(results.Errors.HasErrors, "Errors in CompileAssemblyFromSource: " + (results.Errors.HasErrors ? results.Errors[0].ErrorText : ""));
Type generatedType = results.CompiledAssembly.GetType(assemblyName + ".TestExtensionProvider", false);
Assert.IsTrue(File.Exists(results.PathToAssembly));
return(generatedType);
}
private Type CompileAndGetType(string content)
{
EnsureNamespace(ref content);
string typeName = DefaultNamespace + ".I" + ServiceContractElementName;
CompilerResults results = DynamicCompilation.CompileAssemblyFromSource(content, new string[] { "System.Web.Services.dll" });
Type generatedType = results.CompiledAssembly.GetType(typeName, false);
Assert.IsNotNull(generatedType, "Invalid type: " + typeName);
return(generatedType);
}
protected Type CompileAndGetType(string content)
{
EnsureNamespace(ref content);
string typeName = DefaultNamespace + "." + ElementName;
CompilerResults results = DynamicCompilation.CompileAssemblyFromSource(content);
Type generatedType = results.CompiledAssembly.GetType(typeName, false);
Assert.IsNotNull(generatedType, "Invalid type: " + typeName);
return(generatedType);
}
public void ShouldGenerateWithXmlSerializerImporterFromData()
{
MyArtifactLinkWithXmlImporterFromData link = new MyArtifactLinkWithXmlImporterFromData("SampleData\\SimpleSchema1.xsd", "element1");
XmlSchemaCodeGenerationStrategy strategy = new XmlSchemaCodeGenerationStrategy();
CodeGenerationResults content = strategy.Generate(link);
Assert.AreEqual <int>(3, content.Count);
Assert.AreEqual <int>(0, strategy.Errors.Count);
CompilerResults results = DynamicCompilation.CompileAssemblyFromSource(JoinContent(content), ((List <string>)strategy.AssemblyReferences).ToArray());
TypeAsserter.AssertAttribute <XmlRootAttribute>(results.CompiledAssembly.GetType("element1"));
}
private string CreateMockImportersAssembly(string assemblyName)
{
CompilerResults results = DynamicCompilation.CompileAssemblyFromSource(
File.ReadAllText(ConfigurationLoader.GetConfigurationFilePath(@"SampleData\DescriptionModel\MockImporters.cs")),
assemblyName);
if (results.PathToAssembly == null)
{
return(null);
}
return(ConfigurationLoader.GetConfigurationFilePath(results.PathToAssembly));
}
/// <summary>
/// Optionally compiles and loads target rules assembly.
/// </summary>
/// <param name="Properties"></param>
/// <param name="TargetsDllFilename"></param>
/// <param name="DoNotCompile"></param>
/// <param name="TargetScripts"></param>
private static void CompileAndLoadTargetsAssembly(ProjectProperties Properties, string TargetsDllFilename, bool DoNotCompile, List <string> TargetScripts)
{
CommandUtils.Log("Compiling targets DLL: {0}", TargetsDllFilename);
if (!DoNotCompile && GlobalCommandLine.NoCodeProject)
{
//throw new AutomationException("Building is not supported when -nocodeproject flag is provided.");
}
var ReferencedAssemblies = new List <string>()
{
"System.dll",
"System.Core.dll",
"System.Xml.dll",
typeof(UnrealBuildTool.UnrealBuildTool).Assembly.Location
};
var TargetsDLL = DynamicCompilation.CompileAndLoadAssembly(TargetsDllFilename, TargetScripts, ReferencedAssemblies, null, DoNotCompile);
var DummyTargetInfo = new TargetInfo(UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
var AllCompiledTypes = TargetsDLL.GetTypes();
foreach (Type TargetType in AllCompiledTypes)
{
// Find TargetRules but skip all "UE4Editor", "UE4Game" targets.
if (typeof(TargetRules).IsAssignableFrom(TargetType))
{
// Create an instance of this type
CommandUtils.LogVerbose("Creating target rules object: {0}", TargetType.Name);
var Rules = Activator.CreateInstance(TargetType, DummyTargetInfo) as TargetRules;
CommandUtils.LogVerbose("Adding target: {0} ({1})", TargetType.Name, Rules.Type);
SingleTargetProperties TargetData;
TargetData.TargetName = GetTargetName(TargetType);
Rules.TargetName = TargetData.TargetName;
TargetData.Rules = Rules;
if (Rules.Type == TargetRules.TargetType.Program)
{
Properties.Programs.Add(TargetData);
}
else
{
Properties.Targets.Add(Rules.Type, TargetData);
}
Properties.bUsesSteam |= Rules.bUsesSteam;
Properties.bUsesCEF3 |= Rules.bUsesCEF3;
Properties.bUsesSlate |= Rules.bUsesSlate;
Properties.bDebugBuildsActuallyUseDebugCRT |= Rules.bDebugBuildsActuallyUseDebugCRT;
Properties.bUsesSlateEditorStyle |= Rules.bUsesSlateEditorStyle;
}
}
}
public void ShouldGenerateOneXmlRootAttribute()
{
MyArtifactLink link = new MyArtifactLink("SampleData\\OneXmlRootAttribute.xsd", "ImplementsAbstractCT");
Utility.SetData(link, true, XmlSchemaCodeGenerationStrategy.UseXmlSerializerDataKey);
XmlSchemaCodeGenerationStrategy strategy = new XmlSchemaCodeGenerationStrategy();
CodeGenerationResults content = strategy.Generate(link);
CompilerResults results = DynamicCompilation.CompileAssemblyFromSource(JoinContent(content), ((List <string>)strategy.AssemblyReferences).ToArray());
TypeAsserter.AssertAttribute <XmlRootAttribute>(results.CompiledAssembly.GetType("ImplementsAbstractCT"));
Type type = results.CompiledAssembly.GetType("MyAbstractCT");
Assert.AreEqual <int>(0, type.GetCustomAttributes(typeof(XmlRootAttribute), true).Length);
}
public void ShouldGenerateTypeWithBaseTypes()
{
XmlSchemaCodeGenerationStrategy strategy = new XmlSchemaCodeGenerationStrategy();
CodeGenerationResults content = strategy.Generate(new MyArtifactLink("SampleData\\BaseTypes.xsd", "GetLandmarkPointsByRectResponse"));
Assert.AreEqual <int>(15, content.Count);
Assert.AreEqual <int>(0, strategy.Errors.Count);
CompilerResults results = DynamicCompilation.CompileAssemblyFromSource(JoinContent(content), ((List <string>)strategy.AssemblyReferences).ToArray());
Assert.IsNotNull(results.CompiledAssembly.GetType("GetLandmarkPointsByRectResponse", false, false));
Assert.IsNotNull(results.CompiledAssembly.GetType("LandmarkPoint", false, false));
Assert.IsNotNull(results.CompiledAssembly.GetType("LandmarkBase", false, false));
Assert.IsNotNull(results.CompiledAssembly.GetType("ShapeType", false, false));
Assert.IsNotNull(results.CompiledAssembly.GetType("LonLatPt", false, false));
}
public void ShouldGenerateTypesRefsFromAttributes()
{
MyArtifactLink link = new MyArtifactLink("SampleData\\TypeRefsInAttributes.wsdl", "AttachmentAddRq");
Utility.SetData(link, true, XmlSchemaCodeGenerationStrategy.UseXmlSerializerDataKey);
XmlSchemaCodeGenerationStrategy strategy = new XmlSchemaCodeGenerationStrategy();
CodeGenerationResults content = strategy.Generate(link);
Assert.AreEqual <int>(69, content.Count);
Assert.AreEqual <int>(0, strategy.Errors.Count);
CompilerResults results = DynamicCompilation.CompileAssemblyFromSource(JoinContent(content), ((List <string>)strategy.AssemblyReferences).ToArray());
Assert.AreEqual <int>(69, results.CompiledAssembly.GetTypes().Length);
Assert.IsNotNull(results.CompiledAssembly.GetType("AddressType", false, false));
}
/// <summary>
/// Optionally compiles and loads target rules assembly.
/// </summary>
/// <param name="Properties"></param>
/// <param name="TargetsDllFilename"></param>
/// <param name="DoNotCompile"></param>
/// <param name="TargetScripts"></param>
private static void CompileAndLoadTargetsAssembly(ProjectProperties Properties, FileReference TargetsDllFilename, bool DoNotCompile, List <FileReference> TargetScripts)
{
CommandUtils.LogVerbose("Compiling targets DLL: {0}", TargetsDllFilename);
var ReferencedAssemblies = new List <string>()
{
"System.dll",
"System.Core.dll",
"System.Xml.dll",
typeof(UnrealBuildTool.PlatformExports).Assembly.Location
};
var TargetsDLL = DynamicCompilation.CompileAndLoadAssembly(TargetsDllFilename, TargetScripts, ReferencedAssemblies, null, DoNotCompile);
var AllCompiledTypes = TargetsDLL.GetTypes();
foreach (Type TargetType in AllCompiledTypes)
{
// Find TargetRules but skip all "UE4Editor", "UE4Game" targets.
if (typeof(TargetRules).IsAssignableFrom(TargetType))
{
string TargetName = GetTargetName(TargetType);
FileReference ProjectFile;
UProjectInfo.TryGetProjectForTarget(TargetName, out ProjectFile);
var DummyTargetInfo = new TargetInfo(TargetName, BuildHostPlatform.Current.Platform, UnrealTargetConfiguration.Development, "", ProjectFile);
// Create an instance of this type
CommandUtils.LogVerbose("Creating target rules object: {0}", TargetType.Name);
var Rules = Activator.CreateInstance(TargetType, DummyTargetInfo) as TargetRules;
CommandUtils.LogVerbose("Adding target: {0} ({1})", TargetType.Name, Rules.Type);
SingleTargetProperties TargetData;
TargetData.TargetName = GetTargetName(TargetType);
TargetData.Rules = Rules;
if (Rules.Type == global::UnrealBuildTool.TargetType.Program)
{
Properties.Programs.Add(TargetData);
}
else
{
Properties.Targets.Add(Rules.Type, TargetData);
}
}
}
}
private static void GenerateTestAssembly(string assemblyName)
{
string path = Path.Combine(LibraryPath, assemblyName + ".dll");
CompilerResults results = DynamicCompilation.CompileAssemblyFromSource(
@"
namespace " + assemblyName + @" {
public class TestClass { public void TestMethod() { } }
public interface ITestInterface { }
public class TestInterfaceClass : ITestInterface { public void TestNewMethod() { } }
}
" ,
path,
new CSharp.CSharpCodeProvider(),
new string[] { });
Assert.IsTrue(File.Exists(path));
}
public void ShouldGenerateContractFromHostWithDataContractSerializerType()
{
ContractGenerationOptions options = new ContractGenerationOptions();
options.OutputConfiguration = ConfigurationLoader.LoadConfiguration(@"SampleData\Empty.config");
options.ClrNamespace = "Test.Namespace1";
ContractGenerator generator = new ContractGenerator(options);
generator.Generate(GetMetadataSet(HostAddress));
string proxyClass = GetClassFromCcu(options.CodeProvider, generator.CodeCompileUnit);
Assert.IsNotNull(proxyClass);
Assert.IsTrue(proxyClass.Contains(options.ClrNamespace), "Contains namespace");
Assert.IsTrue(proxyClass.Contains("MyDataContract"), "Contains MyDataContract class");
CompilerResults results = DynamicCompilation.CompileAssemblyFromSource(proxyClass);
Type generatedType = results.CompiledAssembly.GetType(options.ClrNamespace + ".MyDataContract", false);
Assert.IsNotNull(generatedType);
}
