public static object Reload(PythonModule module)
{
if (module.Filename == null)
{
return(Importer.ReloadBuiltin(module));
}
CompilerContext cc = new CompilerContext(module.Filename);
Parser parser = Parser.FromFile(module.SystemState, cc);
Stmt s = parser.ParseFileInput();
PythonModule pmod = OutputGenerator.GenerateModule(module.SystemState, cc, s, module.ModuleName, "__" + System.Threading.Interlocked.Increment(ref reloadCounter));
foreach (KeyValuePair <object, object> attr in module.__dict__)
{
if (pmod.__dict__.ContainsObjectKey(attr.Key))
{
continue;
}
pmod.__dict__.AddObjectKey(attr.Key, attr.Value);
}
module.UpdateForReload(pmod);
return(module);
}
public void OutputGenerator_ShouldGenerateListOfStrings_WhenPassedWordCountAndPrimes()
{
//Arrange
var outputGenerator = new OutputGenerator();
var wordCountResults = new Dictionary <string, int> {
{ "compare", 22 },
{ "the", 13 },
{ "market", 10 },
{ "codeTest", 7 }
};
var listOfPrimes = new Dictionary <int, bool> {
{ 13, true },
{ 7, true },
{ 5, true }
};
var expectedOutput = new List <string>
{
"compare, 22, False",
"the, 13, True",
"market, 10, False",
"codeTest, 7, True"
};
//Act
var actualOutput = outputGenerator.GenerateOutput(wordCountResults, listOfPrimes);
//Assert
CollectionAssert.AreEquivalent(expectedOutput, actualOutput);
}
public void CompareTheTextFile_ShouldReturnCorrectResults_WhenPassedRailwayChildren()
{
//Arrange
IFileReader fileReader = new FileReader();
IWordCounter wordCounter = new WordCounter();
IPrimeNumberCalculator primeNumberCalculator = new PrimeNumberCalculator();
IOutputGenerator outputGenerator = new OutputGenerator();
var compareTheWords = new CompareTheWords(fileReader, wordCounter, primeNumberCalculator, outputGenerator);
var input = "RailwayChildren.txt";
var expectedOutput = new []
{
"the, 3344, False",
"and, 2390, False",
"to, 1525, False",
"a, 1157, False",
"said, 1141, False",
};
//Act
var actualOutput = compareTheWords.Compare(input);
var actualOutputTop5 = actualOutput.Take(5).ToList();
//Assert
CollectionAssert.AreEquivalent(expectedOutput, actualOutputTop5);
}
public void CompareTheTextFile_ShouldReturnWordFrequencyAndIsPrime_WhenPassedTwoCopiesOfWarAndPeace()
{
//Arrange
IFileReader fileReader = new FileReader();
IWordCounter wordCounter = new WordCounter();
IPrimeNumberCalculator primeNumberCalculator = new PrimeNumberCalculator();
IOutputGenerator outputGenerator = new OutputGenerator();
var compareTheWords = new CompareTheWords(fileReader, wordCounter, primeNumberCalculator, outputGenerator);
var input = "TwoCopiesOfWarAndPeace.txt";
var expectedOutput = new []
{
"the, 69124, False",
"and, 44296, False",
"to, 33418, False",
"of, 29980, False",
"a, 21026, False",
};
//Act
var actualOutput = compareTheWords.Compare(input);
var actualOutputTop5 = actualOutput.Take(5).ToList();
//Assert
CollectionAssert.AreEquivalent(expectedOutput, actualOutputTop5);
}
public void CompareTheTextFile_ShouldReturnCorrectResult_WhenPassedWarAndPeace()
{
//Arrange
IFileReader fileReader = new FileReader();
IWordCounter wordCounter = new WordCounter();
IPrimeNumberCalculator primeNumberCalculator = new PrimeNumberCalculator();
IOutputGenerator outputGenerator = new OutputGenerator();
var compareTheWords = new CompareTheWords(fileReader, wordCounter, primeNumberCalculator, outputGenerator);
var input = "WarAndPeace.txt";
var expectedOutput = new []
{
"the, 34562, False",
"and, 22148, False",
"to, 16709, False",
"of, 14990, False",
"a, 10513, True",
};
//Act
var actualOutput = compareTheWords.Compare(input);
var actualOutputTop5 = actualOutput.Take(5).ToList();
//Assert
CollectionAssert.AreEquivalent(expectedOutput, actualOutputTop5);
}
public Output ProcessOutput(Input input)
{
if (!CheckOutputForNullValues(input))
{
return(null);
}
var passengerData = ProcessPassengersData(input.Passenger, input.Route);
if (passengerData == null)
{
return(null);
}
var output = new Output();
output.Passengers = input.Passenger.Count;
output.GeneralPassengers = GetPassengersSum(input.Passenger, MembershipType.general);
output.LoyaltyPassengers = GetPassengersSum(input.Passenger, MembershipType.loyalty);
output.AirlinePassengers = GetPassengersSum(input.Passenger, MembershipType.airline);
output.Bags = GetTotalBags(passengerData);
output.LoyaltyPointsUsed = GetTotalUsedLoyaltyPoints(passengerData);
output.CostOfFlight = GetTotalFlightCost(input.Passenger.Count, input.Route.CostToAirline);
output.RevenueBeforeDiscount = GetRevenueBeforeDiscount(input.Passenger.Count, input.Route.TicketPrice);
output.RevenueAfterDiscount = GetRevenueAfterDiscount(output.RevenueBeforeDiscount,
output.AirlinePassengers,
output.LoyaltyPointsUsed,
input.Route.TicketPrice);
output.CanFlightProceed = output.RevenueAfterDiscount > output.CostOfFlight;
OutputGenerator.GenerateJsonOutput(output);
//The return output can be processed further for responses to the client
//It is not implemented due to remain in the scope of the project
return(output);
}
//Another integration test
public void GetResults_ShouldReturnCorrectCount_WhenPassedThePlacesYoullGo()
{
//Arrange
IFileReader fileReader = new FileReader();
IWordCounter wordCounter = new WordCounter();
IPrimeNumberCalculator primeNumberCalculator = new PrimeNumberCalculator();
IOutputGenerator outputGenerator = new OutputGenerator();
var compareTheWords = new CompareTheWords(fileReader, wordCounter, primeNumberCalculator, outputGenerator);
var input = "ThePlacesYou'llGo.txt";
var expectedOutput = new List <string>() //Used http://www.writewords.org.uk/word_count.asp to verify the results
{
"you, 22, False",
"and, 16, False",
"youll, 15, False",
"your, 13, True",
"to, 10, False",
"the, 9, False",
"go, 8, False",
"be, 6, False",
"of, 6, False",
"great, 5, True"
};
//Act
var actualOutput = compareTheWords.Compare(input);
//Assert
CollectionAssert.AreEquivalent(expectedOutput, actualOutput.Take(10));
}
public void WriteOutput_ScanResultsMultipleErrors_TwoPatterns_TwoProperties_VerbosityIsVerbose_WritesBannerAndSummaryAndDetails()
{
SetOptions(verbosityLevel: VerbosityLevel.Verbose);
WriteCall[] expectedCalls =
{
new WriteCall(AppTitleStart, WriteSource.WriteLineOneParam),
new WriteCall(ErrorCountGeneralStart, WriteSource.WriteLineOneParam),
new WriteCall(ErrorVerboseCountStart, WriteSource.WriteLineTwoParams),
new WriteCall(ErrorVerbosePropertiesHeaderStart, WriteSource.WriteLineStringOnly),
new WriteCall(ErrorVerbosePropertyPairStart, WriteSource.WriteLineTwoParams),
new WriteCall(ErrorVerbosePropertyPairStart, WriteSource.WriteLineTwoParams),
new WriteCall(ErrorVerbosePatternsHeaderStart, WriteSource.WriteLineStringOnly),
new WriteCall(ErrorVerbosePatternIndex, WriteSource.WriteLineOneParam),
new WriteCall(ErrorVerbosePatternIndex, WriteSource.WriteLineOneParam),
new WriteCall(ErrorVerboseSeparatorStart, WriteSource.WriteLineStringOnly),
new WriteCall(ErrorVerboseCountStart, WriteSource.WriteLineTwoParams),
new WriteCall(ErrorVerbosePropertiesHeaderStart, WriteSource.WriteLineStringOnly),
new WriteCall(ErrorVerbosePropertyPairStart, WriteSource.WriteLineTwoParams),
new WriteCall(ErrorVerbosePropertyPairStart, WriteSource.WriteLineTwoParams),
new WriteCall(ErrorVerbosePatternsHeaderStart, WriteSource.WriteLineStringOnly),
new WriteCall(ErrorVerbosePatternIndex, WriteSource.WriteLineOneParam),
new WriteCall(ErrorVerbosePatternIndex, WriteSource.WriteLineOneParam),
new WriteCall(ErrorVerboseSeparatorStart, WriteSource.WriteLineStringOnly),
new WriteCall(OutputFileStart, WriteSource.WriteLineOneParam),
};
TextWriterVerifier textWriterVerifier = new TextWriterVerifier(_writerMock, expectedCalls);
IOutputGenerator generator = new OutputGenerator(_writerMock.Object);
ScanResults scanResults = BuildTestScanResults(errorCount: 2, a11yTestFile: TestA11yTestFile,
patternCount: 2, propertyCount: 2);
generator.WriteOutput(_optionsMock.Object, scanResults, null);
textWriterVerifier.VerifyAll();
VerifyAllMocks();
}
public void TestClassGenericToIntf()
{
var rg = new ReflectionGenerator();
rg.NamingStrategy.InterfacePrefixForClasses = "i";
rg.GenerateInterface(typeof(PagedAminUser));
rg.GenerateInterface(typeof(PagedCompany));
var g = new OutputGenerator();
g.Generate(rg.GenerationStrategy.TargetModule);
Assert.AreEqual(
@"
module GeneratedModule {
interface iPagedModel<T> {
TotalCount: number;
Values: T[];
}
interface iPagedAminUser extends iPagedModel<iAdminUser> {
}
interface iAdminUser {
Name: string;
Login: string;
}
interface iPagedCompany extends iPagedModel<iCompanyModel> {
}
interface iCompanyModel {
VAT: string;
Name: string;
}
}".Trim(), g.Output.Trim());
}
public void GeneratesOutputForAllRovers([Frozen] Mock <IEnumerable <IRover> > rovers,
[Frozen] Mock <IRover> rover, OutputGenerator sut)
{
sut.GenerateOutput(rovers.Object);
rover.VerifyGet(p => p.Location, Times.Exactly(rovers.Object.Count()));
rover.VerifyGet(p => p.Direction, Times.Exactly(rovers.Object.Count()));
}
public void Translate(string word)
{
if (word == "hello")
{
OutputGenerator.WriteIt("hallo");
}
}
public void TestModule()
{
var m = new TypescriptModule("testModule");
var cls = new ClassType("class1");
cls.Members.Add(new PropertyMember("Property1")
{
MemberType = PrimitiveType.Boolean
});
m.Members.Add(cls);
m.Members.Last().IsExporting = true;
m.Members.Add(new RawStatements()
{
Statements = { "function test() : ", cls, " { return null; }" }
});
var g = new OutputGenerator();
g.Generate(m);
Assert.AreEqual(@"
module testModule {
export class class1 {
Property1: boolean;
}
function test() : class1 { return null; }
}
".Trim(), g.Output.Trim());
}
public bool DoOneInteractive(Frame topFrame)
{
bool continueInteraction;
Stmt s = ReadStatement(out continueInteraction);
if (continueInteraction == false)
{
return(false);
}
// 's' is null when we parse a line composed only of a NEWLINE (interactive_input grammar);
// we don't generate anything when 's' is null
if (s != null)
{
FrameCode code = OutputGenerator.GenerateSnippet(context, s, true);
if (ExecWrapper != null)
{
CallTarget0 t = delegate() {
try { code.Run(topFrame); } catch (Exception e) { DumpException(e); }
return(null);
};
object callable = new Function0(topFrame.__module__, "wrapper", t, new string[0], new object[0]);
Ops.Call(ExecWrapper, callable);
}
else
{
code.Run(topFrame);
}
}
return(true);
}
private static void PrintQuote(LoanQuote quote)
{
var outputGenerator = new OutputGenerator();
string output = outputGenerator.Generate(quote);
Console.WriteLine(output);
}
public void TestRawStatements()
{
var c = new ClassType("test");
var x2 = "a" + new RawStatement("b");
var x3 = new RawStatement("a") + "b";
var s1 = new RawStatements()
{
Statements = { "xxx" }
};
var s2 = new RawStatements("asd", new RawStatement("tttt"));
s1.Add(s2);
s1.Add(new TypescriptTypeReference(c));
s1.Add(":");
s1.Add(c);
var g = new OutputGenerator();
g.Generate(s1);
Assert.AreEqual("xxxasdtttttest:test", g.Formatter.Output.ToString());
var test2 = new RawStatements("t1 ", c, " t2");
g.Formatter.Output.Clear();
g.Generate(test2);
Assert.AreEqual("t1 test t2", g.Output);
}
public void TestKoInheritance()
{
var kogen = new KnockoutReflectionGenerator();
kogen.GenerateFromType(typeof(Test3));
var o = new OutputGenerator();
o.GenerateModuleContent(kogen.Module, null);
Assert.AreEqual(null, Helper.StringCompare(@"
class test3A implements IObservableITest3A {
prop1 = ko.observable<number>();
}
class test3 extends test3A implements IObservableITest3B, IObservableITest3C {
prop2 = ko.observable<string>();
prop3 = ko.observable<string>();
prop4 = ko.observable<IObservableITest3A>();
propOwn = ko.observable<test3A>();
}
interface IObservableITest3A {
prop1: KnockoutObservable<number>;
}
interface IObservableITest3B extends IObservableITest3A {
prop2: KnockoutObservable<string>;
}
interface IObservableITest3C extends IObservableITest3A, IObservableITest3B {
prop3: KnockoutObservable<string>;
prop4: KnockoutObservable<IObservableITest3A>;
}
", o.Output));
}
public object Compile(string text, bool printExprStatements)
{
Parser p = Parser.FromString(engineContext.SystemState, context, text);
Stmt s = p.ParseFileInput();
return(OutputGenerator.GenerateSnippet(context, s, printExprStatements));
}
private string testGen(ClassType cls)
{
var g = new OutputGenerator();
g.Generate(cls);
return(g.Formatter.Output.ToString());
}
public static void Main(string[] args)
{
var spec = new Specification.Specification();
{
var specParserXml = new SpecificationReaderXml(spec);
foreach (var xml in Directory.GetFiles(InputDirectoryXml))
{
if (xml.EndsWith(".xml", StringComparison.OrdinalIgnoreCase))
{
specParserXml.Read(XDocument.Load(xml));
}
}
}
SpecificationOverrides.OverrideSpecification(spec);
{
var specParserTxt = new SpecificationReaderTxt(spec);
foreach (var txt in Directory.EnumerateFiles(InputDirectoryText, "*.txt", SearchOption.AllDirectories))
{
using (var stream = File.OpenText(txt))
specParserTxt.Read(stream);
}
}
using (var gen = new OutputGenerator(spec, OutputDirectory, "VulkanLibrary"))
gen.Write();
}
public void StartGame()
{
OutputGenerator.FirstUserPrompt();
while (_gameData.GetTurn() < _gameData.GetTurnLimit())
{
var currentUserInput = Console.ReadLine();
if (currentUserInput == null)
{
continue;
}
var errorCode = InputValidator.CheckInputForErrors(currentUserInput.ToLower().Trim(), _gameData.GetColoursPicked());
if (errorCode == "valid")
{
var currentGuess = InputFormatter(currentUserInput, _gameData.GetColoursPicked());
_gameData.SetCurrentColourList(currentGuess);
var result = CalculateResult();
if (ConvertStringArrayToString(result).Equals(ConvertStringArrayToString(_winningOutput)))
{
OutputGenerator.GenerateWin();
return;
}
_turnCounter++;
_gameData.SetTurn(_turnCounter);
OutputGenerator.PromptUser(result, _gameData.GetTurn());
}
else
{
OutputGenerator.PromptUser(errorCode, _gameData.GetTurn());
}
}
OutputGenerator.GenerateLoss(_gameData.GetTurnLimit());
}
public void TestGenerics2()
{
var rg = new ReflectionGenerator();
rg.NamingStrategy.InterfacePrefixForClasses = "i";
//nonsense?!? rg.GenerateInterface(typeof(Test1<int>));
rg.GenerateInterface(typeof(Test1 <>));
var g = new OutputGenerator();
g.Generate(rg.GenerationStrategy.TargetModule);
Assert.AreEqual(
@"
module GeneratedModule {
interface iTest1<T> {
T1: iGenList<string>;
T2: iGenList<number>;
T3: iGenList<iGenList<boolean>>;
T4: iGenList<T[]>[];
}
interface iGenList<TI> {
Values: iGenTest<TI>[];
}
interface iGenTest<T> {
Value: T;
}
}".Trim(), g.Output.Trim());
}
private static Tuple <string, string> runTest(bool sourceClasses, bool destClasses, bool optimize, bool optimizeSource = false)
{
var rg = new ReflectionGenerator();
rg.GenerationStrategy.GenerateClasses = sourceClasses;
rg.NamingStrategy.InterfacePrefixForClasses = "";
rg.NamingStrategy.InterfacePrefix = "";
rg.GenerateTypes(new[] { typeof(Test3), typeof(Test3A) });
var models = rg.Module;
if (optimizeSource)
{
models = Optimizer.RemoveEmptyDeclarations(models);
}
var o1 = new OutputGenerator();
o1.Generate(models);
var o1Output = o1.Output;
var ko = new KnockoutGenerator();
var observables = new TypescriptModule("Observables");
ko.GenerateObservableModule(models, observables, !destClasses);
if (optimize)
{
observables = Optimizer.RemoveEmptyDeclarations(observables);
}
var o2 = new OutputGenerator();
o2.Generate(observables);
return(Tuple.Create(o1.Output, o2.Output));
}
public void TestComments()
{
var m = new TypescriptModule("testModule")
{
Comment = "module"
};
var cls = new ClassType("class1");
cls.Members.Add(new PropertyMember("Property1")
{
MemberType = PrimitiveType.Boolean, Comment = "property\nsecond line"
});
m.Members.Add(cls);
m.Members.Last().Comment = "class";
m.Members.Last().IsExporting = true;
m.Members.Add(new RawStatements()
{
Statements = { "function test() : ", cls, " { return null; }" }
});
m.Members.Last().Comment = "raw";
cls.Members.Add(new FunctionMember("fn",
new RawStatements("/*comment*/\n", "dosomething();\n", "//comment"))
{
Comment = "function",
Parameters =
{
new FunctionParameter("x")
{
ParameterType = PrimitiveType.Boolean, Comment = "param"
}
}
});
cls.Members.Last().Comment = "function";
var g = new OutputGenerator();
g.GenerateComments = true;
g.Generate(m);
Assert.AreEqual(null,
Helper.StringCompare(@"
/* module */
module testModule {
/* class */
export class class1 {
/* property
* second line
*/
Property1: boolean;
/* function */
fn(/* param */x: boolean) {
/*comment*/
dosomething();
//comment
}
}
/* raw */
function test() : class1 { return null; }
}
", g.Output));
}
public void Test_example_outputs(byte xpos, byte ypos, Direction dir, string expected)
{
IOutputGenerator outputGenerator = new OutputGenerator();
string actual = outputGenerator.GenerateOutput(new Piece(byte.MaxValue, xpos, ypos, dir));
Assert.Equal(expected, actual);
}
public void WriteBanner_OptionsIsNull_ThrowsArgumentNullException()
{
IOutputGenerator generator = new OutputGenerator(_writerMock.Object);
ArgumentNullException e = Assert.ThrowsException <ArgumentNullException>(
() => generator.WriteBanner(null));
Assert.AreEqual("options", e.ParamName);
}
public void WriteBanner_VerbosityIsQuiet_IsSilent()
{
_optionsMock.Setup(x => x.VerbosityLevel).Returns(VerbosityLevel.Quiet);
IOutputGenerator generator = new OutputGenerator(_writerMock.Object);
generator.WriteBanner(_optionsMock.Object);
VerifyAllMocks();
}
public WordFrequencyCounterIntegrationTests()
{
IFileReader fileReader = new FileReader();
IWordCounter wordCounter = new WordCounter();
IPrimeNumberCalculator primeNumberCalculator = new PrimeNumberCalculator();
IOutputGenerator outputGenerator = new OutputGenerator();
_compareTheWords = new CompareTheWords(fileReader, wordCounter, primeNumberCalculator, outputGenerator);
}
private void AnalyzeProducts()
{
OutputGenerator = new OutputGenerator(m_commandSequence, m_puzzle.Products);
AddGenerator(OutputGenerator);
m_reagentElements.UnionWith(m_puzzle.Reagents.SelectMany(p => p.Atoms.Select(a => a.Element)));
AddGeneratedElements(m_reagentElements);
AddNeededElements(m_puzzle.Products.SelectMany(p => p.Atoms.Select(a => a.Element)));
}
static void Main(string[] args)
{
var zeichenermittlung = new Zeichenermittlung();
var outputter = new OutputGenerator();
var symbolMatrix = zeichenermittlung.SymboleErmitteln();
outputter.MatrixVisualisieren(symbolMatrix);
}
public void DumpDebugInfo()
{
if (PythonEngine.options.EngineDebug)
{
PerfTrack.DumpStats();
try {
OutputGenerator.DumpSnippets();
} catch (NotSupportedException) { } //!!! usually not important info...
}
}
