public void TestAnnotations()
{
lock (testLock)
{
// Get the code namespace for the schema.
string inputFilePath = GetInputFilePath("TestAnnotations.xsd", Resources.TestAnnotations);
var generatorParams = new GeneratorParams {
InputFilePath = inputFilePath
};
GetGeneratorParams(inputFilePath);
generatorParams.Miscellaneous.EnableSummaryComment = true;
generatorParams.TargetFramework = TargetFramework.Net35;
generatorParams.PropertyParams.AutomaticProperties = true;
generatorParams.OutputFilePath = Path.ChangeExtension(generatorParams.InputFilePath,
".TestAnnotations.cs");
var xsdGen = new GeneratorFacade(generatorParams);
var result = xsdGen.Generate();
Assert.IsTrue(result.Success, result.Messages.ToString());
var compileResult = CompileCSFile(generatorParams.OutputFilePath);
Assert.IsTrue(compileResult.Success, compileResult.Messages.ToString());
}
}
public void GenarateVBCS()
{
lock (testLock)
{
// Get the code namespace for the schema.
string inputFilePath = GetInputFilePath("Actor.xsd", Resources.Actor);
var generatorParams = GetGeneratorParams(inputFilePath);
generatorParams.TargetFramework = TargetFramework.Net30;
generatorParams.PropertyParams.AutomaticProperties = true;
generatorParams.GenerateDataContracts = true;
generatorParams.Serialization.GenerateXmlAttributes = true;
generatorParams.OutputFilePath = GetOutputFilePath(inputFilePath);
generatorParams.EnableDataBinding = true;
generatorParams.Miscellaneous.EnableSummaryComment = true;
generatorParams.Language = GenerationLanguage.VisualBasic;
var xsdGen = new GeneratorFacade(generatorParams);
var result = xsdGen.Generate();
Assert.IsTrue(result.Success, result.Messages.ToString());
generatorParams.Language = GenerationLanguage.CSharp;
xsdGen = new GeneratorFacade(generatorParams);
result = xsdGen.Generate();
var canCompile = CompileCSFile(generatorParams.OutputFilePath);
Assert.IsTrue(canCompile.Success, canCompile.Messages.ToString());
}
}
public void ArrayOfArray()
{
lock (testLock)
{
// Copy resource file to the run-time directory
var inputFilePath = GetInputFilePath("ArrayOfArray.xsd", Resources.ArrayOfArray);
var generatorParams = new GeneratorParams
{
GenerateCloneMethod = true,
InputFilePath = inputFilePath,
NameSpace = "MyNameSpace",
CollectionObjectType = CollectionType.Array,
EnableDataBinding = true,
Language = GenerationLanguage.CSharp,
OutputFilePath = Path.ChangeExtension(inputFilePath, ".TestGenerated.cs")
};
generatorParams.PropertyParams.AutomaticProperties = true;
generatorParams.Serialization.Enabled = true;
var xsdGen = new GeneratorFacade(generatorParams);
var result = xsdGen.Generate();
Assert.IsTrue(result.Success, result.Messages.ToString());
var compileResult = CompileCSFile(generatorParams.OutputFilePath);
Assert.IsTrue(compileResult.Success, compileResult.Messages.ToString());
}
}
private void button10_Click(object sender, EventArgs e)
{
GeneratorFacade gen;
gen = new GeneratorFacade(new MarkovGenerator(System.IO.File.ReadAllText("markov_data/data[okeypotolok.su].txt")));
Console.WriteLine(gen.GenerateParagraphs(20));
}
public void UseBaseClass()
{
lock (testLock)
{
// Get the code namespace for the schema.
GetInputFilePath("Actor.xsd", Resources.Actor);
string inputFilePath = GetInputFilePath("dvd.xsd", Resources.dvd);
string outputFilePath = Path.ChangeExtension(inputFilePath, ".baseClass.cs");
var generatorParams = new GeneratorParams
{
InputFilePath = inputFilePath,
TargetFramework = TargetFramework.Net30,
GenerateDataContracts = true,
EnableDataBinding = true,
OutputFilePath = outputFilePath
};
generatorParams.PropertyParams.AutomaticProperties = false;
generatorParams.Miscellaneous.EnableSummaryComment = true;
generatorParams.GenericBaseClass.Enabled = true;
generatorParams.GenericBaseClass.GenerateBaseClass = true;
//generatorParams.GenericBaseClass.BaseClassName = "EntityObject";
var xsdGen = new GeneratorFacade(generatorParams);
var result = xsdGen.Generate();
Assert.IsTrue(result.Success, result.Messages.ToString());
var compileResult = CompileCSFile(generatorParams.OutputFilePath);
Assert.IsTrue(compileResult.Success, compileResult.Messages.ToString());
}
}
public void Nillables()
{
lock (testLock)
{
// Get the code namespace for the schema.
string inputFilePath = GetInputFilePath("nillables.xsd", Resources.nillables);
var generatorParams = GetGeneratorParams(inputFilePath);
GetGeneratorParams(inputFilePath);
generatorParams.Miscellaneous.EnableSummaryComment = true;
generatorParams.TargetFramework = TargetFramework.Net35;
generatorParams.PropertyParams.AutomaticProperties = true;
generatorParams.EnableInitializeFields = true;
generatorParams.CollectionObjectType = CollectionType.List;
var xsdGen = new GeneratorFacade(generatorParams);
var result = xsdGen.Generate();
Assert.IsTrue(result.Success, result.Messages.ToString());
var compileResult = CompileCSFile(generatorParams.OutputFilePath);
Assert.IsTrue(compileResult.Success, compileResult.Messages.ToString());
}
}
public void SeparateFiles()
{
lock (testLock)
{
// Get the code namespace for the schema.
string tvShowInputFilePath = GetInputFilePath("TVShow.xsd", Resources.TVShow);
// copy included/imported files to the test folder
GetInputFilePath("Actor.xsd", Resources.Actor);
GetInputFilePath("Gender.xsd", Resources.Gender);
var tvShowGeneratorParams = GetGeneratorParams(tvShowInputFilePath);
GetGeneratorParams(tvShowInputFilePath);
tvShowGeneratorParams.Miscellaneous.EnableSummaryComment = true;
tvShowGeneratorParams.TargetFramework = TargetFramework.Net35;
tvShowGeneratorParams.PropertyParams.AutomaticProperties = true;
tvShowGeneratorParams.EnableInitializeFields = true;
tvShowGeneratorParams.CollectionObjectType = CollectionType.List;
tvShowGeneratorParams.GenerateSeparateFiles = true;
tvShowGeneratorParams.OutputFilePath = Path.ChangeExtension(tvShowGeneratorParams.InputFilePath, ".separate.cs");
var tvShowXsdGen = new GeneratorFacade(tvShowGeneratorParams);
var tvShowResult = tvShowXsdGen.Generate();
List <string> tvShowOutputFiles = tvShowResult.Entity;
Assert.IsTrue(tvShowResult.Success, tvShowResult.Messages.ToString());
// compile TV show
var compileResult = CompileCSFile(tvShowOutputFiles.ToArray());
Assert.IsTrue(compileResult.Success, compileResult.Messages.ToString());
}
}
public void T_GenerateParagraphs_Validate_Input()
{
GeneratorFacade facade = InitBaseFacade();
Assert.Throws <Exceptions.InvalidArguments>(
delegate { facade.GenerateParagraphs(0); });
Assert.Throws <Exceptions.InvalidArguments>(
delegate { facade.GenerateParagraphs(1, new ParagraphParams {
MaxSentences = 1
}); });
Assert.Throws <Exceptions.InvalidArguments>(
delegate { facade.GenerateParagraphs(1, new ParagraphParams {
MinSentences = -1
}); });
Assert.Throws <Exceptions.InvalidArguments>(
delegate { facade.GenerateParagraphs(1, new ParagraphParams {
MaxSentences = 4,
MinSentences = 5
}); });
Assert.Throws <Exceptions.InvalidArguments>(
delegate { facade.GenerateParagraphs(1, new ParagraphParams {
ParagraphIndent = -1
}); });
Assert.Throws <Exceptions.InvalidArguments>(
delegate { facade.GenerateParagraphs(1, new ParagraphParams {
SentenceIndent = -1
}); });
}
public void AutomaticProperties()
{
lock (testLock)
{
// Get the code namespace for the schema.
GetInputFilePath("Actor.xsd", Resources.Actor);
string inputFilePath = GetInputFilePath("dvd.xsd", Resources.dvd);
var generatorParams = new GeneratorParams {
InputFilePath = inputFilePath
};
GetGeneratorParams(inputFilePath);
generatorParams.TargetFramework = TargetFramework.Net30;
generatorParams.Miscellaneous.EnableSummaryComment = false;
generatorParams.GenerateDataContracts = false;
generatorParams.PropertyParams.AutomaticProperties = true;
generatorParams.Serialization.GenerateXmlAttributes = true;
generatorParams.OutputFilePath = Path.ChangeExtension(generatorParams.InputFilePath, ".autoProp.cs");
var xsdGen = new GeneratorFacade(generatorParams);
var result = xsdGen.Generate();
Assert.IsTrue(result.Success, result.Messages.ToString());
var compileResult = CompileCSFile(generatorParams.OutputFilePath);
Assert.IsTrue(compileResult.Success, compileResult.Messages.ToString());
}
}
public void UseBaseClass()
{
lock (testLock)
{
// Get the code namespace for the schema.
GetInputFilePath("Actor.xsd", Resources.Actor);
string inputFilePath = GetInputFilePath("dvd.xsd", Resources.dvd);
string outputFilePath = Path.ChangeExtension(inputFilePath, ".baseClass.cs");
var generatorParams = new GeneratorParams
{
InputFilePath = inputFilePath,
TargetFramework = TargetFramework.Net30,
GenerateDataContracts = true,
EnableDataBinding = true,
OutputFilePath = outputFilePath
};
generatorParams.PropertyParams.AutomaticProperties = false;
generatorParams.Miscellaneous.EnableSummaryComment = true;
generatorParams.GenericBaseClass.Enabled = true;
generatorParams.GenericBaseClass.GenerateBaseClass = true;
generatorParams.GenericBaseClass.BaseClassName = "EntityObject";
var xsdGen = new GeneratorFacade(generatorParams);
var result = xsdGen.Generate();
Assert.IsTrue(result.Success, result.Messages.ToString());
var compileResult = CompileCSFile(generatorParams.OutputFilePath);
Assert.IsTrue(compileResult.Success, compileResult.Messages.ToString());
// check if autogeneration-parameters are written to file
var lastGenerationParamsFile = Path.ChangeExtension(inputFilePath, "xsd.xsd2code");
if (File.Exists(lastGenerationParamsFile))
{
if (File.GetLastWriteTime(lastGenerationParamsFile) > File.GetLastWriteTime(generatorParams.OutputFilePath))
{
File.Delete(lastGenerationParamsFile);
File.Copy(generatorParams.OutputFilePath, lastGenerationParamsFile);
}
}
else
{
File.Copy(generatorParams.OutputFilePath, lastGenerationParamsFile);
}
var autogenParams = GeneratorParams.LoadFromFile(inputFilePath);
Assert.AreEqual(autogenParams.TargetFramework, generatorParams.TargetFramework);
Assert.AreEqual(autogenParams.GenerateDataContracts, generatorParams.GenerateDataContracts);
Assert.AreEqual(autogenParams.EnableDataBinding, generatorParams.EnableDataBinding);
Assert.AreEqual(autogenParams.PropertyParams.AutomaticProperties, generatorParams.PropertyParams.AutomaticProperties);
Assert.AreEqual(autogenParams.Miscellaneous.EnableSummaryComment, generatorParams.Miscellaneous.EnableSummaryComment);
Assert.AreEqual(autogenParams.GenericBaseClass.Enabled, generatorParams.GenericBaseClass.Enabled);
Assert.AreEqual(autogenParams.GenericBaseClass.GenerateBaseClass, generatorParams.GenericBaseClass.GenerateBaseClass);
Assert.AreEqual(autogenParams.GenericBaseClass.BaseClassName, generatorParams.GenericBaseClass.BaseClassName);
File.Delete(lastGenerationParamsFile);
}
}
private void GenerateAndCompile(GeneratorParams generatorParams, params string[] additionalFiles)
{
var xsdGen = new GeneratorFacade(generatorParams);
var result = xsdGen.Generate();
Assert.IsTrue(result.Success, result.Messages.ToString());
var canCompile = CompileCSFile(generatorParams.OutputFilePath, additionalFiles);
Assert.IsTrue(canCompile.Success, canCompile.Messages.ToString());
}
public void T_GenerateTitle_Length_And_Capitalization()
{
GeneratorFacade facade = InitBaseFacade();
string resultingTitle = facade.GenerateTitle(9);
string[] words = resultingTitle.Split(' ');
Assert.AreEqual(9, words.Length);
foreach (string word in words)
{
Assert.IsTrue(char.IsUpper(word[0]));
}
}
public static void GenerateDomainSpecificInterface()
{
try
{
// Overwrite ParadigmName if DS interface is generated
SolutionGenerator.ParadigmName = GeneratorFacade.main(MgaPath, TargetFolder + @"\" + SolutionName, "GME.CSharp." + SolutionName);
if (GeneratorFacade.Errors.Count != 0)
{
throw new Exception("Error occured during the domain specific interface generation.");
}
}
catch (Exception)
{
object[] args = new object[1];
args[0] = GeneratorFacade.Errors;
if (GeneratorFacade.Errors.Count != 0)
{
SolutionGenerator.mw.Dispatcher.Invoke(SolutionGenerator.mw.errorwindowdel, args);
}
throw;
}
// Add files to the projectfile
string AddString = String.Empty;
foreach (string s in GeneratorFacade.generatedFiles)
{
AddString += "\t<Compile Include=\"" + ParadigmName + @"\";
AddString += System.IO.Path.GetFileName(s);
AddString += "\" />";
AddString += Environment.NewLine;
}
try
{
// Rename filereference in the csproj file
StreamReader FileReadStream = new StreamReader(Path.Combine(TargetFolder, SolutionName) + @"\" + SolutionName + ".csproj");
string ContentString = FileReadStream.ReadToEnd();
FileReadStream.Close();
ContentString = ContentString.Replace(@"<!--$ADDITIONALFILES$-->", AddString);
StreamWriter FileWriteStream = new StreamWriter(Path.Combine(TargetFolder, SolutionName) + @"\" + SolutionName + ".csproj");
FileWriteStream.Write(ContentString);
FileWriteStream.Close();
}
catch (Exception)
{
MessageBox.Show("Error occured: Cannot find the previously generated VS projectfile in the specified folder with the specified solutionname.");
throw;
}
}
public void Throw_Exception_When_Database_Is_Null()
{
Assesment assesment = new Assesment();
assesment.Name = "Test";
assesment.SourcePlatform = "OnPrem";
assesment.Status = "Completed";
assesment.TargetPlatform = "Azure Managed Instance";
//assesment.Databases = new List<Database>();
assesment.ServerInstances = new List <ServerInstance>();
Assert.Throws <InvalidDataException>
(() => GeneratorFacade.Generate(assesment));
}
static void Main(string[] args)
{
Console.WriteLine("Test starting");
GeneratorFacade gen = new GeneratorFacade(TimeMarkovConstructor());
TimeGenerateWords(gen, 10, 10000);
TimeGenerateWords(gen, 10000, 10);
TimeGenerateSentences(gen, 10000);
TimeGenerateParagraphs(gen, 500, 10);
TimeGenerateParagraphs(gen, 10, 500);
Console.WriteLine("Test complete");
Console.ReadLine();
}
public void T_GenerateParagraphs_Length()
{
GeneratorFacade facade = InitBaseFacade();
//seven sentences should be generated
string resultStr = facade.GenerateParagraphs(3, new ParagraphParams
{
MinSentences = 7, MaxSentences = 7
});
string[] splitSentences = resultStr.Split(facade.Generator.SentenceEnd.ToArray(),
StringSplitOptions.RemoveEmptyEntries);
Assert.AreEqual(21, splitSentences.Length);
}
public void Circular()
{
lock (testLock)
{
// Copy resource file to the run-time directory
string inputFilePath = GetInputFilePath("Circular.xsd", Resources.Circular);
var xsdGen = new GeneratorFacade(GetGeneratorParams(inputFilePath));
var result = xsdGen.Generate();
Assert.IsTrue(result.Success, result.Messages.ToString());
}
}
public void Works_Properly_When_Valid_Input_Is_Given()
{
Assesment assesment = new Assesment();
assesment.Name = "Test";
assesment.SourcePlatform = "OnPrem";
assesment.Status = "Completed";
assesment.TargetPlatform = "Azure Managed Instance";
assesment.Databases = new List <Database>();
assesment.ServerInstances = new List <ServerInstance>();
var table = GeneratorFacade.Generate(assesment);
Assert.NotNull(table);
}
static void TimeGenerateSentences(GeneratorFacade gen, int numSentences)
{
Stopwatch timer = new Stopwatch();
timer.Start();
for (int i = 0; i < numSentences; i++)
{
gen.GenerateSentence(3);
}
timer.Stop();
double baseGenTime = timer.ElapsedMilliseconds / 1000.0;
Console.WriteLine(string.Format("Time to generate {0} sentences: {1:0.00} seconds",
numSentences, baseGenTime));
}
private Task <ConcurrentBag <string> > RunGenerator(IGenerator[]?generators = null, bool shareGlobalWriters = false)
{
generators ??= new[] { this.generator };
var generatorSetups = generators.ConvertAll(x =>
new GeneratorSetup(new TypeOrObject <IGenerator>(x), null, false, shareGlobalWriters));
return(GeneratorFacade.RunAsync(
new GeneratorOptions {
ProgressReporter = this.progressReporter
},
new Setup(
new ModelSetup(new TypeOrObject <IModelProvider>(this.modelProvider), typeof(object)),
new[] { new WriterSetup("AnyTarget", new TypeOrObject <IWriter>(this.writer)) },
generatorSetups !)));
}
static void TimeGenerateWords(GeneratorFacade gen, int numIterations, int numWords)
{
Stopwatch timer = new Stopwatch();
timer.Start();
for (int i = 0; i < numIterations; i++)
{
gen.GenerateWords(numWords);
}
timer.Stop();
double baseGenTime = timer.ElapsedMilliseconds / 1000.0;
Console.WriteLine(string.Format("Time to generate {0}x{1} words: {2:0.00} seconds",
numIterations, numWords, baseGenTime));
}
public void Hierarchical()
{
lock (testLock)
{
// Copy resource file to the run-time directory
string inputFilePath = GetInputFilePath("Hierarchical.xsd", Resources.Hierarchical);
var generatorParams = GetGeneratorParams(inputFilePath);
var xsdGen = new GeneratorFacade(generatorParams);
var result = xsdGen.Generate();
Assert.IsTrue(result.Success, result.Messages.ToString());
var compileResult = CompileCSFile(generatorParams.OutputFilePath);
Assert.IsTrue(compileResult.Success, compileResult.Messages.ToString());
}
}
public void HexBinary()
{
lock (testLock)
{
// Copy resource file to the run-time directory
string inputFilePath = GetInputFilePath("hexBinary.xsd", Resources.hexBinary);
var generatorParams = GetGeneratorParams(inputFilePath);
generatorParams.EnableInitializeFields = true;
var xsdGen = new GeneratorFacade(generatorParams);
var result = xsdGen.Generate();
Assert.IsTrue(result.Success, result.Messages.ToString());
var compileResult = CompileCSFile(generatorParams.OutputFilePath);
Assert.IsTrue(compileResult.Success, compileResult.Messages.ToString());
}
}
public void T_GenerateParagraphs_Indentation()
{
GeneratorFacade facade = InitBaseFacade();
ParagraphParams defaultParams = new ParagraphParams {
ParagraphIndent = 8, SentenceIndent = 4
};
string resultStr = facade.GenerateParagraphs(5, defaultParams);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < defaultParams.ParagraphIndent; i++)
{
sb.Append(" ");
}
string paragraphIndent = sb.ToString();
sb.Length = 0;
for (int i = 0; i < defaultParams.SentenceIndent; i++)
{
sb.Append(" ");
}
string sentenceIndent = sb.ToString();
sb.Length = 0;
string[] paragraphSplits = resultStr.Split(new string[] { paragraphIndent }, StringSplitOptions.RemoveEmptyEntries);
//Verify we got 5 paragraphs
Assert.AreEqual(5, paragraphSplits.Length);
foreach (string paragraph in paragraphSplits)
{
string trimmedParagraph = paragraph.TrimEnd();
string[] sentenceSplits = trimmedParagraph.Split(new string[] { sentenceIndent }, StringSplitOptions.RemoveEmptyEntries);
//Check sentences are of appropriate sizes
Assert.GreaterOrEqual(sentenceSplits.Length, defaultParams.MinSentences);
Assert.LessOrEqual(sentenceSplits.Length, defaultParams.MaxSentences);
//Check sentences actually end with a punctuation mark
foreach (string sentence in sentenceSplits)
{
Assert.Contains(sentence[sentence.Length - 1], facade.Generator.SentenceEnd);
}
}
}
public MarkovGen(string path)
{
if (!File.Exists(path))
{
throw new FileNotFoundException("Попробуйте указать правильный путь к файлу!");
}
if ((new FileInfo(path)).Length <= 0)
{
throw new NullReferenceException("Файл пуст!");
}
this.working_dir = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "/" + this.working_dir;
this.gen = new GeneratorFacade(new MarkovGenerator(System.IO.File.ReadAllText(path)));
if (!Directory.Exists(working_dir))
{
Directory.CreateDirectory(working_dir);
}
}
public void LazyLoading()
{
lock (testLock)
{
// Copy resource file to the run-time directory
string inputFilePath = GetInputFilePath("LazyLoading.xsd", Resources.LazyLoading);
var generatorParams = GetGeneratorParams(inputFilePath);
generatorParams.CollectionObjectType = CollectionType.List;
generatorParams.TargetFramework = TargetFramework.Net20;
generatorParams.PropertyParams.EnableLazyLoading = true;
generatorParams.EnableInitializeFields = true;
var xsdGen = new GeneratorFacade(generatorParams);
xsdGen.Generate();
var compileResult = CompileCSFile(generatorParams.OutputFilePath);
Assert.IsTrue(compileResult.Success, compileResult.Messages.ToString());
}
}
public void AlowDebug()
{
lock (testLock)
{
// Copy resource file to the run-time directory
GetInputFilePath("Actor.xsd", Resources.Actor);
string inputFilePath = GetInputFilePath("Dvd.xsd", Resources.dvd);
var generatorParams = GetGeneratorParams(inputFilePath);
generatorParams.Miscellaneous.DisableDebug = false;
generatorParams.OutputFilePath = Path.ChangeExtension(generatorParams.InputFilePath, ".DebugEnabled.cs");
var xsdGen = new GeneratorFacade(generatorParams);
var result = xsdGen.Generate();
Assert.IsTrue(result.Success, result.Messages.ToString());
var compileResult = CompileCSFile(generatorParams.OutputFilePath);
Assert.IsTrue(compileResult.Success, compileResult.Messages.ToString());
}
}
public void Silverlight()
{
lock (testLock)
{
// Get the code namespace for the schema.
GetInputFilePath("Actor.xsd", Resources.Actor);
string inputFilePath = GetInputFilePath("dvd.xsd", Resources.dvd);
var generatorParams = GetGeneratorParams(inputFilePath);
generatorParams.TargetFramework = TargetFramework.Silverlight;
generatorParams.OutputFilePath = Path.ChangeExtension(generatorParams.InputFilePath,
".Silverlight20_01.cs");
generatorParams.Serialization.Enabled = true;
generatorParams.Serialization.EnableEncoding = true;
var xsdGen = new GeneratorFacade(generatorParams);
var result = xsdGen.Generate();
Assert.IsTrue(result.Success, result.Messages.ToString());
}
}
public void WcfAttributes()
{
lock (testLock)
{
// Get the code namespace for the schema.
GetInputFilePath("Actor.xsd", Resources.Actor);
string inputFilePath = GetInputFilePath("dvd.xsd", Resources.dvd);
var generatorParams = GetGeneratorParams(inputFilePath);
generatorParams.GenerateDataContracts = true;
generatorParams.TargetFramework = TargetFramework.Net30;
generatorParams.OutputFilePath = Path.ChangeExtension(generatorParams.InputFilePath, ".wcf.cs");
var xsdGen = new GeneratorFacade(generatorParams);
var result = xsdGen.Generate();
Assert.IsTrue(result.Success, result.Messages.ToString());
var compileResult = CompileCSFile(generatorParams.OutputFilePath);
Assert.IsTrue(compileResult.Success, compileResult.Messages.ToString());
}
}
public void PropertyNameSpecified()
{
lock (testLock)
{
// Copy resource file to the run-time directory
string inputFilePath = GetInputFilePath("PropertyNameSpecified.xsd", Resources.PropertyNameSpecified);
var generatorParams = GetGeneratorParams(inputFilePath);
generatorParams.TargetFramework = TargetFramework.Net20;
generatorParams.Serialization.Enabled = false;
generatorParams.Miscellaneous.HidePrivateFieldInIde = false;
// All
generatorParams.PropertyParams.GeneratePropertyNameSpecified = PropertyNameSpecifiedType.All;
generatorParams.OutputFilePath = Path.ChangeExtension(generatorParams.InputFilePath, ".all.cs");
var xsdGen = new GeneratorFacade(generatorParams);
var result = xsdGen.Generate();
var compileResult = CompileCSFile(generatorParams.OutputFilePath);
Assert.IsTrue(compileResult.Success, compileResult.Messages.ToString());
// none
generatorParams.PropertyParams.GeneratePropertyNameSpecified = PropertyNameSpecifiedType.None;
generatorParams.OutputFilePath = Path.ChangeExtension(generatorParams.InputFilePath, ".none.cs");
xsdGen = new GeneratorFacade(generatorParams);
result = xsdGen.Generate();
compileResult = CompileCSFile(generatorParams.OutputFilePath);
Assert.IsTrue(compileResult.Success, compileResult.Messages.ToString());
// Default
generatorParams.PropertyParams.GeneratePropertyNameSpecified = PropertyNameSpecifiedType.Default;
generatorParams.OutputFilePath = Path.ChangeExtension(generatorParams.InputFilePath, ".default.cs");
xsdGen = new GeneratorFacade(generatorParams);
result = xsdGen.Generate();
compileResult = CompileCSFile(generatorParams.OutputFilePath);
Assert.IsTrue(compileResult.Success, compileResult.Messages.ToString());
}
}
