private static void GenericTest(string inputFile, IDictionary <string, string> dependencies, string outputPackageId)
{
string projectFolder = VariousUtil.GetProjectFolder();
string ecorePath = Path.Combine(projectFolder, inputFile);
if (dependencies != null)
{
foreach (KeyValuePair <string, string> dependency in dependencies)
{
// Load dependency using NMF, with a specific URI
string dependencyPath = Path.Combine(projectFolder, dependency.Value);
ModelRepository repository = (ModelRepository)EcoreInterop.Repository;
FileStream depFileStream = new FileInfo(dependencyPath).Open(FileMode.Open);
repository.Serializer.Deserialize(depFileStream,
new Uri(dependency.Key, UriKind.Absolute), repository, true);
depFileStream.Close();
}
}
// Load ecore using NMF
IEPackage package = EcoreInterop.LoadPackageFromFile(ecorePath);
ISet <IEPackage> epackages = new HashSet <IEPackage>()
{
package
};
// Load output EnAr project
Package outputContainerPackage = Ecore2EnArTestSetUp.Loader.GetEnAarPackage(outputPackageId);
// Prepare transformation and start
XsdImport.Ecore2EnAr.Ecore2EnAr importer = new XsdImport.Ecore2EnAr.Ecore2EnAr(outputContainerPackage, Ecore2EnArTestSetUp.Loader.Explorer);
importer.ConstructMetamodel(epackages);
}
public void LoadXMLType()
{
EPackage package = EcoreInterop.LoadPackageFromFile("XMLTypeTest.ecore");
Assert.IsNotNull(package);
var xmlTypeNamespace = EcoreInterop.Transform2Meta(package);
Assert.IsNotNull(xmlTypeNamespace);
var DataTypes = xmlTypeNamespace.Types.OfType <IClass>().FirstOrDefault(t => t.Name == "DataTypes");
Assert.IsNotNull(DataTypes);
AssertAttribute(DataTypes, "AnySimpleType", typeof(object));
AssertAttribute(DataTypes, "AnyURI", typeof(string));
AssertAttribute(DataTypes, "Base64Binary", typeof(byte[]));
AssertAttribute(DataTypes, "Boolean", typeof(bool));
AssertAttribute(DataTypes, "Byte", typeof(byte));
AssertAttribute(DataTypes, "Date", typeof(object));
AssertAttribute(DataTypes, "DateTime", typeof(object));
//AssertAttribute(DataTypes, "Decimal", typeof(java.math.BigDecimal));
AssertAttribute(DataTypes, "Double", typeof(double));
AssertAttribute(DataTypes, "Duration", typeof(object));
//AssertAttribute(DataTypes, "ENTITIES", typeof(java.util.List));
AssertAttribute(DataTypes, "ENTITY", typeof(string));
AssertAttribute(DataTypes, "Float", typeof(float));
AssertAttribute(DataTypes, "GDay", typeof(object));
AssertAttribute(DataTypes, "GMonth", typeof(object));
AssertAttribute(DataTypes, "GMonthDay", typeof(object));
AssertAttribute(DataTypes, "GYear", typeof(object));
AssertAttribute(DataTypes, "GYearMonth", typeof(object));
AssertAttribute(DataTypes, "HexBinary", typeof(byte[]));
AssertAttribute(DataTypes, "ID", typeof(string));
AssertAttribute(DataTypes, "IDREF", typeof(string));
//AssertAttribute(DataTypes, "IDREFS", typeof(java.util.List));
AssertAttribute(DataTypes, "Int", typeof(int));
//AssertAttribute(DataTypes, "Integer", typeof(java.math.BigInteger));
AssertAttribute(DataTypes, "Language", typeof(string));
AssertAttribute(DataTypes, "Long", typeof(long));
AssertAttribute(DataTypes, "Name", typeof(string));
AssertAttribute(DataTypes, "NCName", typeof(string));
//AssertAttribute(DataTypes, "NegativeInteger", typeof(java.math.BigInteger));
AssertAttribute(DataTypes, "NMToken", typeof(string));
//AssertAttribute(DataTypes, "NMTOKENS", typeof(java.util.List));
//AssertAttribute(DataTypes, "NonNegativeInteger", typeof(java.math.BigInteger));
//AssertAttribute(DataTypes, "NonPositiveInteger", typeof(java.math.BigInteger));
AssertAttribute(DataTypes, "NormalizedString", typeof(string));
AssertAttribute(DataTypes, "NOTATION", typeof(object));
//AssertAttribute(DataTypes, "PositiveInteger", typeof(java.math.BigInteger));
AssertAttribute(DataTypes, "QName", typeof(object));
AssertAttribute(DataTypes, "Short", typeof(short));
AssertAttribute(DataTypes, "String", typeof(string));
AssertAttribute(DataTypes, "Time", typeof(object));
AssertAttribute(DataTypes, "Token", typeof(string));
AssertAttribute(DataTypes, "UnsignedByte", typeof(short));
AssertAttribute(DataTypes, "UnsignedInt", typeof(long));
//AssertAttribute(DataTypes, "UnsignedLong", typeof(java.math.BigInteger));
AssertAttribute(DataTypes, "UnsignedShort", typeof(int));
}
private static void GenerateCodeFor(string input, string output, string name)
{
EPackage package = EcoreInterop.LoadPackageFromFile(input);
INamespace nMeta = EcoreInterop.Transform2Meta(package);
CodeCompileUnit code = MetaFacade.CreateCode(nMeta, name);
MetaFacade.GenerateCode(code, new CSharpCodeProvider(), output, true);
}
private void GenerateAndAssertEcore(string modelPath)
{
string log;
string errorLog;
var package = EcoreInterop.LoadPackageFromFile(modelPath);
var ns = EcoreInterop.Transform2Meta(package);
var result = CodeGenerationTest.GenerateAndCompile(ns, null, out errorLog, out log);
Assert.AreEqual(0, result, log + errorLog);
}
public void LoadNMeta()
{
EPackage package;
package = EcoreInterop.LoadPackageFromFile("NMeta.ecore");
Assert.IsNotNull(package);
metaNamespace = EcoreInterop.Transform2Meta(package);
var boolean = metaNamespace.Resolve(new Uri("Boolean", UriKind.Relative));
var isInterface = metaNamespace.Resolve(new Uri("Class/IsInterface", UriKind.Relative)) as IAttribute;
Assert.IsNotNull(metaNamespace);
Assert.AreEqual(20, metaNamespace.Types.OfType <IClass>().Count());
type = GetClass("Type");
@class = GetClass("Class");
structuredType = GetClass("StructuredType");
typedElement = GetClass("ITypedElement");
metaElement = GetClass("MetaElement");
attribute = GetClass("Attribute");
reference = GetClass("Reference");
referenceType = GetClass("ReferenceType");
dataType = GetClass("DataType");
primitiveType = GetClass("PrimitiveType");
@namespace = GetClass("Namespace");
extension = GetClass("Extension");
@event = GetClass("Event");
operation = GetClass("Operation");
parameter = GetClass("Parameter");
enumeration = GetClass("Enumeration");
literal = GetClass("Literal");
modelElement = GetClass("ModelElement");
direction = metaNamespace.Types.OfType <IEnumeration>().FirstOrDefault(en => en.Name == "Direction");
Assert.IsNotNull(direction);
direction.Literals.Select(l => l.Name).AssertSequence("In", "Out", "InOut");
AssertBaseTypes();
AssertProperties();
var model = metaNamespace.Model;
Assert.IsNotNull(model);
Assert.AreSame(type, model.Resolve("#//Type"));
Assert.AreSame(@class, model.Resolve("#//Class"));
Assert.AreSame(structuredType, model.Resolve("#//StructuredType"));
}
public void TestSerializedName()
{
EPackage package = EcoreInterop.LoadPackageFromFile("EcoreXMLSchemaTest.ecore");
Assert.IsNotNull(package);
ns = EcoreInterop.Transform2Meta(package);
Assert.IsNotNull(ns);
/* Check Types */
var AnnotationDefaultsType = ns.Types.OfType <IClass>().FirstOrDefault(t => t.Name == "AnnotationDefaultsType");
AssertSerializationName(AnnotationDefaultsType, "AnnotationDefaults");
var PType = ns.Types.OfType <IClass>().FirstOrDefault(t => t.Name == "PType");
AssertSerializationName(PType, "P");
var ModelInformation = ns.Types.OfType <IClass>().FirstOrDefault(t => t.Name == "ModelInformation");
AssertNoSerializationName(ModelInformation);
/* Check References */
var pRef = AnnotationDefaultsType.References.FirstOrDefault(r => r.Name == "p");
AssertSerializationName(pRef, "P");
/* Check Attributes */
var valueAttr = PType.Attributes.FirstOrDefault(a => a.Name == "value");
AssertDefaultProperty(valueAttr);
var sizeAttr = PType.Attributes.FirstOrDefault(a => a.Name == "size");
AssertSerializationName(sizeAttr, "size");
var mixedAttr = ModelInformation.Attributes.FirstOrDefault(a => a.Name == "mixed");
AssertNoSerializationName(mixedAttr);
}
private void GenerateAndLoadModel(string metamodelPath, string modelPath)
{
string log;
string errorLog;
var package = EcoreInterop.LoadPackageFromFile(metamodelPath);
var ns = EcoreInterop.Transform2Meta(package);
var loadModel = new Action <string, int>((path, buildExit) =>
{
if (buildExit != 0)
{
return;
}
var repository = new ModelRepository();
var assemblyPath = System.IO.Path.Combine(path, "bin", "project.dll");
Assembly.LoadFile(assemblyPath);
repository.Resolve(modelPath);
});
var result = CodeGenerationTest.GenerateAndCompile(ns, loadModel, out errorLog, out log);
Assert.AreEqual(0, result, log + errorLog);
}
public static INamespace LoadPackageFromFiles(IList <string> files, string overallName, IDictionary <Uri, string> resolveMappings)
{
if (files == null || files.Count == 0)
{
return(null);
}
var packages = new List <INamespace>();
var repository = new ModelRepository(EcoreInterop.Repository);
if (resolveMappings != null)
{
repository.Locators.Add(new FileMapLocator(resolveMappings));
}
foreach (var ecoreFile in files)
{
if (Path.GetExtension(ecoreFile) == ".ecore")
{
#if DEBUG
var model = repository.Resolve(ecoreFile);
var ePackages = model.RootElements.OfType <EPackage>();
foreach (var ePackage in ePackages)
{
packages.Add(EcoreInterop.Transform2Meta(ePackage));
}
#else
try
{
var ePackages = repository.Resolve(ecoreFile).RootElements.OfType <EPackage>();
foreach (var ePackage in ePackages)
{
packages.Add(EcoreInterop.Transform2Meta(ePackage));
}
}
catch (Exception ex)
{
Console.WriteLine("An error occurred reading the Ecore file. The error message was: " + ex.Message);
Environment.ExitCode = 1;
}
#endif
}
else if (Path.GetExtension(ecoreFile) == ".nmf" || Path.GetExtension(ecoreFile) == ".nmeta")
{
#if DEBUG
packages.AddRange(repository.Resolve(ecoreFile).RootElements.OfType <INamespace>());
#else
try
{
packages.AddRange(repository.Resolve(ecoreFile).RootElements.OfType <INamespace>());
}
catch (Exception ex)
{
Console.WriteLine("An error occurred reading the NMeta file. The error message was: " + ex.Message);
Environment.ExitCode = 1;
}
#endif
}
}
if (packages.Count == 0)
{
throw new InvalidOperationException("No package could be found.");
}
else if (packages.Count == 1)
{
return(packages.First());
}
else
{
var package = new Namespace()
{
Name = overallName
};
package.ChildNamespaces.AddRange(packages);
return(package);
}
}
