private static CompilerResults GenerateSchema(Schema schema)
{
var codegen = new CodeGen();
codegen.AddSchema(schema);
return(GenerateAssembly(codegen));
}
public void TestCollectionImplementation()
{
var codeGen = new CodeGen();
var enumSchema = new EnumSchema("TestEnum", "Test.Namespace", new string[] { "A", "B", "C" });
codeGen.AddSchema(enumSchema);
Assert.AreEqual(1, codeGen.Count);
Assert.AreEqual(1, codeGen.Keys.Count());
Assert.AreEqual(1, codeGen.Values.Count());
Assert.IsTrue(codeGen.ContainsKey("Test.Namespace.TestEnum"));
Assert.IsNotNull(codeGen["Test.Namespace.TestEnum"]);
foreach (var item in codeGen)
{
Assert.IsNotNull(item.Key);
Assert.IsNotNull(item.Value);
}
foreach (var item in (codeGen as IEnumerable))
{
Assert.IsNotNull(item);
}
Assert.IsTrue(codeGen.TryGetValue("Test.Namespace.TestEnum", out var notNullValue));
Assert.NotNull(notNullValue);
Assert.IsFalse(codeGen.TryGetValue("Test.Namespace.XX", out var nullValue));
Assert.Null(nullValue);
}
public override bool Execute()
{
var codegen = new CodeGen();
if (SchemaFiles != null)
{
foreach (var schemaFile in SchemaFiles)
{
var schema = Schema.Parse(System.IO.File.ReadAllText(schemaFile.ItemSpec));
codegen.AddSchema(schema);
}
}
if (ProtocolFiles != null)
{
foreach (var protocolFile in ProtocolFiles)
{
var protocol = Protocol.Parse(System.IO.File.ReadAllText(protocolFile.ItemSpec));
codegen.AddProtocol(protocol);
}
}
var generateCode = codegen.GenerateCode();
var namespaces = generateCode.Namespaces;
for (var i = namespaces.Count - 1; i >= 0; i--)
{
var types = namespaces[i].Types;
for (var j = types.Count - 1; j >= 0; j--)
{
Log.LogMessage("Generating {0}.{1}", namespaces[i].Name, types[j].Name);
}
}
codegen.WriteTypes(OutDir.ItemSpec);
return true;
}
public void ProjectTest()
{
Assert.NotNull(new CodeWriter());
var schema01 = new EnumSchema("TestEnum", "NS.Stuff", new string[] { "A", "B", "C" });
var schema02 = new FixedSchema("TestFixed", "NS.Stuff", 14);
var schema03 = new RecordSchema(
"TestRecord",
"NS.Stuff", new RecordSchema.Field[]
{
new RecordSchema.Field("FieldA", new IntSchema()),
new RecordSchema.Field("FieldB", schema01),
new RecordSchema.Field("FieldC", schema02),
}
);
var codeGen = new CodeGen();
codeGen.AddSchema(schema01);
codeGen.AddSchema(schema02);
codeGen.AddSchema(schema03);
var projectname = "test_project";
var mockFileSystem = new MockFileSystem();
mockFileSystem.AddDirectory(projectname);
var rootDir = mockFileSystem.AllDirectories.First(r => r.EndsWith(projectname));
var codeWriter = new CodeWriter(mockFileSystem);
codeWriter.WriteProject(rootDir, codeGen, projectname);
var class01 = GetCodeFileName(schema01, rootDir);
var class02 = GetCodeFileName(schema02, rootDir);
var class03 = GetCodeFileName(schema03, rootDir);
Assert.IsTrue(mockFileSystem.FileExists(class01));
Assert.IsTrue(mockFileSystem.FileExists(class02));
Assert.IsTrue(mockFileSystem.FileExists(class03));
var projectFile = Path.ChangeExtension(Path.Combine(rootDir, projectname), ".csproj");
Assert.IsTrue(mockFileSystem.FileExists(projectFile));
}
public void TestAddSchema()
{
var codeGen = new CodeGen();
var intSchema = new IntSchema();
codeGen.AddSchema(intSchema);
Assert.AreEqual(0, codeGen.Count);
var enumSchema = new EnumSchema("TestEnum", "Test.Namespace", new string[] { "A", "B", "C" });
codeGen.AddSchema(enumSchema);
Assert.AreEqual(1, codeGen.Count);
var fixedSchema = new FixedSchema("TestFixed", "Test.Namespace", 12);
codeGen.AddSchema(fixedSchema);
Assert.AreEqual(2, codeGen.Count);
var recordSchema = new RecordSchema("TestRecord", "Test.Namespace", new RecordSchema.Field[] { new RecordSchema.Field("A", new IntSchema()) });
codeGen.AddSchema(recordSchema);
Assert.AreEqual(3, codeGen.Count);
var errorSchema = new RecordSchema("TestError", "Test.Namespace", new RecordSchema.Field[] { new RecordSchema.Field("B", enumSchema) });
codeGen.AddSchema(errorSchema);
Assert.AreEqual(4, codeGen.Count);
var unionSchema = new UnionSchema(fixedSchema, new BytesSchema(), new EnumSchema("TestEnum2", "Test.Namespace", new string[] { "D", "E", "F" }));
codeGen.AddSchema(unionSchema);
Assert.AreEqual(5, codeGen.Count);
}
public void TestCodeGenNamespaceMapping(string str, string avroNamespace, string csharpNamespace,
string expectedNamespace)
{
Schema schema = Schema.Parse(str);
var codegen = new CodeGen();
codegen.AddSchema(schema);
if (avroNamespace != null && csharpNamespace != null)
{
codegen.NamespaceMapping[avroNamespace] = csharpNamespace;
}
var results = GenerateAssembly(codegen);
foreach(var type in results.CompiledAssembly.GetTypes())
{
Assert.AreEqual(expectedNamespace, type.Namespace);
}
}
public override bool Execute()
{
var codegen = new CodeGen();
if (SchemaFiles != null)
{
foreach (var schemaFile in SchemaFiles)
{
var schema = Schema.Parse(System.IO.File.ReadAllText(schemaFile.ItemSpec));
codegen.AddSchema(schema);
}
}
if (ProtocolFiles != null)
{
foreach (var protocolFile in ProtocolFiles)
{
var protocol = Protocol.Parse(System.IO.File.ReadAllText(protocolFile.ItemSpec));
codegen.AddProtocol(protocol);
}
}
var generateCode = codegen.GenerateCode();
var namespaces = generateCode.Namespaces;
for (var i = namespaces.Count - 1; i >= 0; i--)
{
var types = namespaces[i].Types;
for (var j = types.Count - 1; j >= 0; j--)
{
Log.LogMessage("Generating {0}.{1}", namespaces[i].Name, types[j].Name);
}
}
codegen.WriteTypes(OutDir.ItemSpec);
return(true);
}
private static CompilerResults GenerateSchema(Schema schema)
{
var codegen = new CodeGen();
codegen.AddSchema(schema);
return GenerateAssembly(codegen);
}
