public void TestSimpleAddition() { MEFUtilities.Compose(new TypeHandlers.TypeHandlerCache()); AggregateFromSeedResultOperator agg = new AggregateFromSeedResultOperator(Expression.Constant(1), Expression.Lambda(Expression.MakeBinary(ExpressionType.Add, Expression.Parameter(typeof(int), "count"), Expression.Constant(1)), Expression.Parameter(typeof(int), "count")), null); ROAggregate processor = new ROAggregate(); GeneratedCode gc = new GeneratedCode(); var result = ProcessResultOperator(processor, agg, null, gc); Assert.AreEqual(typeof(int), result.Type, "Expected the type to be an integer!"); Assert.IsInstanceOfType(result, typeof(DeclarableParameter), "Expected a var simple!"); var vs = result as DeclarableParameter; Assert.AreEqual("1", vs.InitialValue.RawValue, "Incorrect seed value"); /// /// Now make sure the statements came back ok! /// gc.DumpCodeToConsole(); Assert.AreEqual(0, gc.CodeBody.DeclaredVariables.Count(), "Expected no bookings"); Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "expected a statement!"); Assert.IsInstanceOfType(gc.CodeBody.Statements.First(), typeof(Statements.StatementAggregate), "expected an assignment statement!"); var ass = gc.CodeBody.Statements.First() as Statements.StatementAggregate; StringBuilder bld = new StringBuilder(); bld.AppendFormat("{0}+1", ass.ResultVariable.ParameterName); Assert.AreEqual(bld.ToString(), ass.Expression.RawValue, "the raw value of hte expression is not right"); }
public void Setup() { TestUtils.ResetLINQLibrary(); MEFUtilities.AddPart(new QVResultOperators()); MEFUtilities.AddPart(new TypeHandlerCache()); MEFUtilities.AddPart(new DealWithInt32()); MEFUtilities.AddPart(new ArrayArrayInfoFactory()); MEFUtilities.AddPart(new SubQueryArrayTypeFactory()); MEFUtilities.AddPart(new SubQueryExpressionArrayInfoFactory()); MEFUtilities.AddPart(new TranslatedArrayInfoFactory()); MEFUtilities.AddPart(new EnumerableRangeArrayTypeFactory()); MEFUtilities.AddPart(new GroupByFactory()); MEFUtilities.AddPart(new GroupByArrayFactory()); MEFUtilities.AddPart(new MemberAccessArrayTypeFactory()); MEFUtilities.AddPart(new ROTakeSkipOperators()); MEFUtilities.AddPart(new ROFirstLast()); MEFUtilities.AddPart(new ROCount()); GeneratedCode gc = new GeneratedCode(); CodeContext cc = new CodeContext(); var qv = new QueryVisitor(gc, cc, MEFUtilities.MEFContainer); MEFUtilities.Compose(qv); }
public void TestTranslatedArray() { var baseVar = Expression.Variable(typeof(SourceType1), "d"); var jetRef = Expression.MakeMemberAccess(baseVar, typeof(SourceType1).GetMember("jets").First()); ArrayInfoVector vec = new ArrayInfoVector(jetRef); CodeContext cc = new CodeContext(); GeneratedCode gc = new GeneratedCode(); var indexVar = vec.AddLoop(gc, cc, MEFUtilities.MEFContainer); gc.Add(new LINQToTTreeLib.Statements.StatementSimpleStatement("dude")); /// /// Make sure the indexvar is working correctly /// Assert.IsInstanceOfType(indexVar.Item1, typeof(BinaryExpression), "inproper expression variable type"); Assert.AreEqual(typeof(SourceType1SubType), indexVar.Item1.Type, "index var type"); var be = indexVar.Item1 as BinaryExpression; Assert.AreEqual(ExpressionType.ArrayIndex, be.NodeType, "not array index"); Assert.AreEqual(typeof(int), be.Right.Type, "Indexer of array type"); Assert.IsInstanceOfType(be.Left, typeof(MemberExpression), "now the same paraemter, I think!"); Assert.AreEqual(jetRef, be.Left, "array isn't right"); /// /// Now, make sure we got as far as a proper size variable /// var statements = gc.CodeBody.CodeItUp().ToArray(); Assert.IsTrue(statements[1].Contains(".val1).size()"), "size statement incorrect: '" + statements[1] + "'"); }
internal override void Generate() { WriteAutoGeneratedSourceHeader(); Write("from .TpmStructure import *"); Write("from .TpmEnum import *"); Write(""); // First generate enums foreach (var e in TpmTypes.Get <TpmEnum>()) { GenEnum(e); } foreach (var b in TpmTypes.Get <TpmBitfield>()) { GenBitfield(b); } Write("from .Crypt import *" + "\r\n"); // Then generate unions and structures GenUnions(); foreach (var s in TpmTypes.Get <TpmStruct>()) { GenStruct(s); } File.WriteAllText(RootDir + "TpmTypes.py", GeneratedCode.ToString()); GeneratedCode.Clear(); // Now generate the TPM methods GenCommands(); File.WriteAllText(RootDir + "Tpm.py", GeneratedCode.ToString()); GeneratedCode.Clear(); }
public void TestApplyReturnFirstMethodCall() { /// /// Get the method we need to get! :-) /// var clsGeneric = typeof(Helpers).GetMethod("ApplyReturnFirst"); var cls = clsGeneric.MakeGenericMethod(new Type[] { typeof(ROOTNET.NTH1F), typeof(double) }); Expression <Action <ROOTNET.NTH1F, double> > applyIt = (h, item) => h.Fill(item); MethodCallExpression mc = Expression.Call(cls, Expression.Parameter(typeof(ROOTNET.NTH1F), "myhist"), Expression.Constant(10.2), applyIt); /// /// Now do the actual call /// GeneratedCode gc = new GeneratedCode(); var result = ExpressionToCPP.GetExpression(mc, gc, null, MEFUtilities.MEFContainer); /// /// And check the results! /// Assert.AreEqual(typeof(ROOTNET.NTH1F), result.Type, "incorrect result type"); Assert.AreEqual("myhist", result.RawValue, "didn't get back the accumulator!"); Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "Expected a statement body to do the filling!"); Assert.IsInstanceOfType(gc.CodeBody.Statements.First(), typeof(LINQToTTreeLib.Statements.StatementAssign), "incorrect statement saved"); var statement = gc.CodeBody.Statements.First() as LINQToTTreeLib.Statements.StatementAssign; Assert.AreEqual("(*myhist).Fill(10.2)", statement.Expression.RawValue, "incorrect fill statement"); }
internal override void Generate() { WriteAutoGeneratedSourceHeader(); Write("import { TpmMarshaller, TpmBuffer } from \"./TpmMarshaller.js\";\r\n" + "import { TpmStructure, ReqStructure, RespStructure, SessEncInfo } from \"./TpmStructure.js\";\r\n" + "\r\n" + "import { Crypto } from \"./Crypt.js\";\r\n" + "\r\n"); // First generate enums foreach (var e in TpmTypes.Get <TpmEnum>()) { GenEnum(e); } foreach (var b in TpmTypes.Get <TpmBitfield>()) { GenBitfield(b); } // Then generate unions and structures GenUnions(); foreach (var s in TpmTypes.Get <TpmStruct>()) { GenStruct(s); } File.WriteAllText(RootDir + "TpmTypes.ts", GeneratedCode.ToString()); GeneratedCode.Clear(); // Now generate the TPM methods GenCommands(); File.WriteAllText(RootDir + "Tpm.ts", GeneratedCode.ToString()); GeneratedCode.Clear(); }
static List<EventInfo> getEventInfo(string parentEvent, GeneratedCode.EventTypeInfo eventType) { List<EventInfo> events = new List<EventInfo>(); string name = eventType.Name; EventInfo e = new EventInfo(name); e.parentName = parentEvent; e.shouldLog = eventType.Log; e.shouldReplay = eventType.Replay; e.shouldForkReplay = eventType.ForkReplay; e.simCoreSubscribe = eventType.SimCoreSubscribe; e.description = eventType.Description; if (eventType.Parameter != null) { for (int i = 0; i < eventType.Parameter.Length; i++) { string pName = eventType.Parameter[i].Name; string pType = eventType.Parameter[i].DataType.ToString(); string pDescript = eventType.Parameter[i].Value; e.parameters[pName] = new ParameterInfo(pName, pType); e.parameters[pName].description = pDescript; } } events.Add(e); if (eventType.EventType != null) { for (int i = 0; i < eventType.EventType.Length; i++) { events.AddRange(getEventInfo(name, eventType.EventType[i])); } } return events; }
public void TestBasicProcessNew() { /// Test a very simple process new var createTLZ = Expression.New(typeof(ROOTNET.NTLorentzVector).GetConstructor(new Type[0])); var target = new TypeHandlerROOT(); IValue resultOfCall; var gc = new GeneratedCode(); var expr = target.ProcessNew(createTLZ, out resultOfCall, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.AreEqual(createTLZ.ToString(), expr.ToString(), "Returned expression"); Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "# of coded statements"); var s1 = gc.CodeBody.Statements.First(); var s2 = gc.CodeBody.Statements.Skip(1).First(); Assert.IsInstanceOfType(s1, typeof(Statements.StatementSimpleStatement), "s1 type"); Assert.IsInstanceOfType(s2, typeof(Statements.StatementSimpleStatement), "s1 type"); var s1s = s1 as Statements.StatementSimpleStatement; var s2s = s2 as Statements.StatementSimpleStatement; Assert.IsTrue(s1s.Line.Contains("TLorentzVector"), "first line is not that good"); Assert.IsTrue(s2s.Line.Contains("TLorentzVector *"), "second line is not that good"); }
static List<ObjectInfo> getObjectInfo(string parentObject, GeneratedCode.ObjectTypeInfo objectType) { List<ObjectInfo> objects = new List<ObjectInfo>(); string name = objectType.Name; ObjectInfo o = new ObjectInfo(name); o.parentName = parentObject; if (objectType.Attribute != null) { for (int i = 0; i < objectType.Attribute.Length; i++) { string aName = objectType.Attribute[i].Name; string aType = objectType.Attribute[i].DataType.ToString(); bool ownerObservable = objectType.Attribute[i].OwnerObservable; bool otherObservable = objectType.Attribute[i].OtherObservable; bool excludeFromScenario = objectType.Attribute[i].ExcludeFromScenario; o.attributes[aName] = new AttributeInfo(aName, aType,excludeFromScenario,ownerObservable,otherObservable); } } objects.Add(o); if (objectType.ObjectType != null) { for (int i = 0; i < objectType.ObjectType.Length; i++) { objects.AddRange(getObjectInfo(name, objectType.ObjectType[i])); } } return objects; }
public async Task <OperationStatus <SemanticDocument> > ApplyAsync(GeneratedCode generatedCode, CancellationToken cancellationToken) { var document = generatedCode.SemanticDocument; var root = document.Root; var callsiteAnnotation = generatedCode.CallSiteAnnotation; var methodDefinitionAnnotation = generatedCode.MethodDefinitionAnnotation; var callsite = root.GetAnnotatedNodesAndTokens(callsiteAnnotation).SingleOrDefault().AsNode(); var method = root.GetAnnotatedNodesAndTokens(methodDefinitionAnnotation).SingleOrDefault().AsNode(); var annotationResolver = GetAnnotationResolver(callsite, method); var triviaResolver = GetTriviaResolver(method); if (annotationResolver == null || triviaResolver == null) { // bug # 6644 // this could happen in malformed code. return as it was. var status = new OperationStatus(OperationStatusFlag.None, FeaturesResources.can_t_not_construct_final_tree); return(status.With(document)); } return(OperationStatus.Succeeded.With( await document.WithSyntaxRootAsync(_result.RestoreTrivia(root, annotationResolver, triviaResolver), cancellationToken).ConfigureAwait(false))); }
public void TestApplyReturnFirstMethodCall() { /// /// Get the method we need to get! :-) /// var clsGeneric = typeof(Helpers).GetMethod("ApplyReturnFirst"); var cls = clsGeneric.MakeGenericMethod(new Type[] { typeof(ROOTNET.NTH1F), typeof(double) }); Expression<Action<ROOTNET.NTH1F, double>> applyIt = (h, item) => h.Fill(item); MethodCallExpression mc = Expression.Call(cls, Expression.Parameter(typeof(ROOTNET.NTH1F), "myhist"), Expression.Constant(10.2), applyIt); /// /// Now do the actual call /// GeneratedCode gc = new GeneratedCode(); var result = ExpressionToCPP.GetExpression(mc, gc, null, MEFUtilities.MEFContainer); /// /// And check the results! /// Assert.AreEqual(typeof(ROOTNET.NTH1F), result.Type, "incorrect result type"); Assert.AreEqual("myhist", result.RawValue, "didn't get back the accumulator!"); Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "Expected a statement body to do the filling!"); Assert.IsInstanceOfType(gc.CodeBody.Statements.First(), typeof(LINQToTTreeLib.Statements.StatementAssign), "incorrect statement saved"); var statement = gc.CodeBody.Statements.First() as LINQToTTreeLib.Statements.StatementAssign; Assert.AreEqual("(*myhist).Fill(10.2)", statement.Expression.RawValue, "incorrect fill statement"); }
public void CustomObjectStreamToCSVFileGeneratesOutput() { GeneratedCode query1 = GeneratedCodeFor(QueryTupleOurCustomObject); // Check that we have a cout somewhere in the statement. Assert.IsTrue(query1.DumpCode().Where(l => l.Contains("<<") && l.Contains(".run")).Any(), "At least one cout statement."); }
public void Generate() { StringBuilder logs = new StringBuilder(); logs.AppendLine("Following class will be generated:"); GeneratedCode wGeneratedCode = null; _GeneratedCodeList = new List <GeneratedCode>(); Fwk.CodeGenerator.FwkGeneratorHelper.TemplateSetting = FwkGenerator.TemplateSettingFactoty(); TreeNode dacs = Fwk.CodeGenerator.DACGenerator.GenCode(ctrlTreeViewTables1.CheckedTables); IDictionaryService dictionaryService = GetService(typeof(IDictionaryService)) as IDictionaryService; foreach (TreeNode nodeDac in dacs.Nodes) { wGeneratedCode = (GeneratedCode)nodeDac.Tag; _GeneratedCodeList.Add(wGeneratedCode); logs.AppendLine(string.Concat(wGeneratedCode.Id, "DAC")); } dictionaryService.SetValue("GeneratedCodeList", _GeneratedCodeList.ToArray()); txtGenerationResult.Text = logs.ToString(); }
public void QueryAnonymousObjectToTTree() { GeneratedCode query1 = GeneratedCodeFor(QueryTupleAnonyoumsObject); // Check that we have a Fill somewhere in the statement. Assert.IsTrue(query1.DumpCode().Where(l => l.Contains("->Fill()")).Any(), "At least one Fill statement."); }
public override PassageCode PassageToCode(PassageData passage) { _input = passage; _output = new PassageCode(); // Ignore script and stylesheet passages if (passage.Tags.Contains("script") || passage.Tags.Contains("stylesheet")) { _output.Main = "yield break;"; return(_output); } Code = new GeneratedCode(); NoOutput = false; if (passage.Tags.Contains("nobr")) { Code.Collapsed = true; } MatchCollection matches = rx_PassageBody.Matches(_input.Body); GenerateBody(matches); // Get final string string code = Code.Buffer.ToString(); _output.Main = code; return(_output); }
public void GeneratedCodeShouldBeEmpty() { if (ExpectNoCodeShouldBeGenerated) { GeneratedCode.ShouldBeEmpty(); } }
public void TestStringParsing() { StringBuilder bld = new StringBuilder(); bld.AppendLine("#<classtype Name> func(arg1 FullName type, arg2 FullName type) => c++func(cppargtype, cppargtype)"); bld.AppendLine("ParseTest sin(System.Double) => sin(double)"); bld.AppendLine("ParseTest f1(System.Int32, System.Int32) => f1(int, int)"); bld.AppendLine("ParseTest f2(System.Double,System.Double) => f2(double,double)"); var target = new TypeHandlerReplacementCall(); target.Parse(new StringReader(bld.ToString())); var e1 = Expression.Call(null, typeof(ParseTest).GetMethod("sin"), new Expression[] { Expression.Constant((double)10.3) }); var e2 = Expression.Call(null, typeof(ParseTest).GetMethod("f1"), new Expression[] { Expression.Constant((int)10), Expression.Constant((int)20) }); var e3 = Expression.Call(null, typeof(ParseTest).GetMethod("f2"), new Expression[] { Expression.Constant((double)10.3), Expression.Constant((double)20.3) }); var gc = new GeneratedCode(); var context = new CodeContext(); var result = CodeMethodCall(target, e1, gc); Assert.AreEqual("sin((double)10.3)", result.RawValue, "sin incorrect"); result = CodeMethodCall(target, e2, gc); Assert.AreEqual("f1((int)10,(int)20)", result.RawValue, "f1 incorrect"); result = CodeMethodCall(target, e3, gc); Assert.AreEqual("f2((double)10.3,(double)20.3)", result.RawValue, "f2 incorrect"); }
private void PrintException(Exception ex, List <GeneratedCode> generatedCodes) { var frames = new List <Interface.StackFrame>(); var stackTrace = new StackTrace(ex, true); for (int i = 0; i < stackTrace.FrameCount; ++i) { System.Diagnostics.StackFrame diagnosticFrame = stackTrace.GetFrame(i); // Extract method name MethodBase method = diagnosticFrame.GetMethod(); // Note(Maik): Skip internal render methods in case of a stack trace. if (Attribute.IsDefined(method, typeof(HideStackTraceAttribute))) { continue; } Type declaringType = method.DeclaringType; var methodSb = new StringBuilder(); if (declaringType != null) { methodSb.Append(declaringType.FullName).Append("."); } methodSb.Append(method.Name); // Extract original filename, line and column int?line = null; if (diagnosticFrame.GetFileLineNumber() != 0) { line = diagnosticFrame.GetFileLineNumber(); } int?column = null; if (diagnosticFrame.GetFileColumnNumber() != 0) { column = diagnosticFrame.GetFileColumnNumber(); } string filename = diagnosticFrame.GetFileName(); GeneratedCode generatedCode = generatedCodes.FirstOrDefault(gcode => string.Compare(gcode.TemplatePath, filename, StringComparison.OrdinalIgnoreCase) == 0); if ((generatedCode != null) && (line != null)) { var position = new TextPosition(line.Value, column ?? 1); TextFilePosition original = generatedCode.SourceMap.FindSourceByGenerated(position); if (original.IsValid) { filename = original.Name; line = original.Line; column = original.Column; } } var msgFrame = new Interface.StackFrame(methodSb.ToString(), filename, line, column); frames.Add(msgFrame); } // for this.MessageHandler.Message(TraceLevel.Error, $"{ex.GetType().FullName}: {ex.Message}", string.Empty, new TextPosition()); this.MessageHandler.StackTrace(frames); }
public void ObtainCode() { GeneratedCode.Add("usings", GetUsings()); GeneratedCode.Add("classNamespace", GetClassNamespace()); GeneratedCode.Add("superclass", GetSuperClass()); GeneratedCode.Add("defaultConstructor", GetDefaultConstructor()); GeneratedCode.Add("attributes", GetJMSClassAttributes()); }
public void TestObjectArrayToConstNullCompare() { MEFUtilities.Compose(new TypeHandlerCache()); Expression <Func <SourceType2, bool> > lambaExpr = (s) => s.jets[0] == null; GeneratedCode gc = new GeneratedCode(); CodeContext cc = new CodeContext(); var result = ExpressionResolver.Resolve(lambaExpr.Body, gc, cc, MEFUtilities.MEFContainer); }
public async Task <ActionResult> CreateCode([FromBody] Code_Config code_Config) { GeneratedCode code = new GeneratedCode(); code = await CreateCodeRequest.CreateCode(code_Config); return(Ok(code)); }
public void ObtainCode() { GeneratedCode.Add("usings", GetUsings()); GeneratedCode.Add("classNamespace", GetClassNamespace()); GeneratedCode.Add("superclass", GetSuperClass()); GeneratedCode.Add("dataContract", IsDataContractString()); GeneratedCode.Add("attributes", GetJMSClassAttributes()); }
public void TestRightClassBadMethod() { TypeHandlerReplacementCall.AddMethod("SimpleTest", "noArgDude", "noArg"); var e = Expression.Call(null, typeof(SimpleTest).GetMethod("noArg")); var gc = new GeneratedCode(); var context = new CodeContext(); var r = CodeMethodCall(new TypeHandlerReplacementCall(), e, gc); }
public void TestRigthClassMethodBadArgs() { TypeHandlerReplacementCall.AddMethod("SimpleTest", "oneArg", "oneArg"); var e = Expression.Call(null, typeof(SimpleTest).GetMethod("oneArg"), new Expression[] { Expression.Constant((int)1) }); var gc = new GeneratedCode(); var context = new CodeContext(); var r = CodeMethodCall(new TypeHandlerReplacementCall(), e, gc); }
public void TestRigthClassMethodBadArgsDefined() { TypeHandlerReplacementCall.AddMethod("SimpleTest", "noArg", "noArg", new Tuple <string, string>[] { new Tuple <string, string>(typeof(int).FullName, "int") }); var e = Expression.Call(null, typeof(SimpleTest).GetMethod("noArg")); var gc = new GeneratedCode(); var context = new CodeContext(); var r = CodeMethodCall(new TypeHandlerReplacementCall(), e, gc); }
public void TestSameMethodsDifferentArgTypes() { TypeHandlerReplacementCall.AddMethod("SimpleTest", "oneArg", "oneArg", new Tuple <string, string>[] { new Tuple <string, string>(typeof(float).FullName, "float") }); var e = Expression.Call(null, typeof(SimpleTest).GetMethod("oneArg"), new Expression[] { Expression.Constant((int)10) }); var gc = new GeneratedCode(); var context = new CodeContext(); var r = CodeMethodCall(new TypeHandlerReplacementCall(), e, gc); }
}//getUser() public StringBuilder generateWithBootstrap(NameValueCollection nvc) { StringBuilder code = new StringBuilder(); code.Append("<form id=\"form\">\n"); int numberOfSelects = Convert.ToInt32(nvc["numberOfSelects"]); for (int i = 0; i < numberOfSelects; i++) { if (nvc["select" + i] != "radio" && nvc["select" + i] != "checkbox" && nvc["select" + i] != "range") { code.Append(GeneratedCode.simpleField(nvc["select" + i], nvc["input" + i])); } else if (nvc["select" + i] == "radio") { int radioNumber = Convert.ToInt32(nvc["radioNumber" + i]); code.Append("\t<div class=\"form-group\">\n"); code.Append("\t\t<label class=\"control-label\">" + nvc["radioGroupName" + i] + "</label>\n"); for (int j = 0; j < radioNumber; j++) { List <string> radioInputs = new List <string>(); radioInputs.Add(nvc["radio" + i + "input" + j]); if (j == 0) { code.Append(GeneratedCode.radioFieldsChecked(radioInputs, i)); } else { code.Append(GeneratedCode.radioFields(radioInputs, i)); } } code.Append("\t</div>\n"); } else if (nvc["select" + i] == "checkbox") { code.Append("\t<div class=\"form-group\">\n"); code.Append("\t\t<label class=\"control-label\">" + nvc["cboxGroupName" + i] + "</label>\n"); int cboxNumber = Convert.ToInt32(nvc["cboxNumber" + i]); for (int j = 0; j < cboxNumber; j++) { List <string> cboxInputs = new List <string>(); cboxInputs.Add(nvc["cbox" + i + "input" + j]); code.Append(GeneratedCode.cboxFields(nvc["cboxGroupName" + i], cboxInputs, i)); } code.Append("\t</div>\n"); } else if (nvc["select" + i] == "range") { code.Append(GeneratedCode.rangeField(nvc["rangeName" + i], nvc["rangeMin" + i], nvc["rangeMax" + i])); } } code.Append("\t<input id=\"submitBtn\" type=\"submit\" value=\"" + nvc["submitButton"].Replace("\"", "") + "\" class=\"btn\" />\n"); return(code); }//generateWithBootstrap()
public void ObtainCode() { GeneratedCode.Add("usings", GetUsings()); GeneratedCode.Add("classNamespace", GetClassNamespace()); GeneratedCode.Add("superclass", GetSuperClass()); GeneratedCode.Add("dataContract", IsDataContractString()); GeneratedCode.Add("description", GetDescription()); GeneratedCode.Add("defaultConstructor", GetDefaultConstructor()); GeneratedCode.Add("attributes", GetJMSClassAttributes()); }
public void ObtainCode() { GeneratedCode.Add("usings", GetUsings()); GeneratedCode.Add("classNamespace", GetClassNamespace()); GeneratedCode.Add("superclass", GetSuperClass()); GeneratedCode.Add("dataContract", IsDataContractString()); GeneratedCode.Add("declarations", GetJmsJobDeclarations()); GeneratedCode.Add("properties", GetJmsJobProperties()); GeneratedCode.Add("jobMethods", GetJMSJobMethods()); }
internal void ProcessResultOperator( [PexAssumeUnderTest] ROUniqueCombinations target, ResultOperatorBase resultOperator, QueryModel queryModel, CodeContext cc, [PexAssumeNotNull] GeneratedCode codeEnv ) { target.ProcessResultOperator(resultOperator, queryModel, codeEnv, cc, null); }
/// <summary> /// We only support a sub-class of expressions for now - so we'd better make sure we are protected! /// </summary> /// <param name="expression"></param> /// <returns></returns> protected override Expression VisitConditional(ConditionalExpression expression) { // We can support complex sub-expressions so long as they don't leak out of the // comparison. if (expression.Type.IsClass && ( CheckForSubQueries.CheckExpression(expression.IfFalse) || CheckForSubQueries.CheckExpression(expression.IfTrue)) ) { throw new NotSupportedException(string.Format("Complex true/false clauses in a conditional expression are not supported: '{0}'", expression.ToString())); } // If this is a class as a result, then we can't do much extra processing here. So skip. if (expression.Type.IsClass) { return(base.VisitConditional(expression)); } // Run the code for the test, and then create the if/then/else that will support it. var testExpression = base.Visit(expression.Test); var testExpressionEvaluation = ExpressionToCPP.GetExpression(testExpression, GeneratedCode, CodeContext, MEFContainer); var testBoolInCode = testExpressionEvaluation is DeclarableParameter p ? p : DeclarableParameter.CreateDeclarableParameterExpression(typeof(bool)); if (testBoolInCode != testExpressionEvaluation) { GeneratedCode.Add(testBoolInCode); GeneratedCode.Add(new Statements.StatementAssign(testBoolInCode, testExpressionEvaluation)); } // The result var conditionalResult = DeclarableParameter.CreateDeclarableParameterExpression(expression.Type); GeneratedCode.Add(conditionalResult); // Do the if true statement var topScope = GeneratedCode.CurrentScope; GeneratedCode.Add(new Statements.StatementFilter(testBoolInCode)); var iftrueExpression = Visit(expression.IfTrue); GeneratedCode.Add(new Statements.StatementAssign(conditionalResult, ExpressionToCPP.GetExpression(iftrueExpression, GeneratedCode, CodeContext, MEFContainer))); GeneratedCode.CurrentScope = topScope; // Do the if false statement GeneratedCode.Add(new Statements.StatementFilter(ExpressionToCPP.GetExpression(Expression.Not(testBoolInCode), GeneratedCode, CodeContext, MEFContainer))); var ifFalseExpression = Visit(expression.IfFalse); GeneratedCode.Add(new Statements.StatementAssign(conditionalResult, ExpressionToCPP.GetExpression(ifFalseExpression, GeneratedCode, CodeContext, MEFContainer))); GeneratedCode.CurrentScope = topScope; // Consider this expression now transformed, so return the result, not // the conditional expression itself. return(conditionalResult); }
/// <summary> /// Deal with the aggregate operator coming in here. /// </summary> /// <param name="resultOperator"></param> /// <param name="queryModel"></param> /// <param name="_codeEnv"></param> /// <returns></returns> public Expression ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode _codeEnv, ICodeContext context, CompositionContainer container) { /// /// Basic code checks /// AggregateFromSeedResultOperator a = resultOperator as AggregateFromSeedResultOperator; if (a == null) { throw new ArgumentNullException("result Operator must not be null and must be of type AggregateFromSeedResultOperator!"); } if (a.Func.Parameters.Count != 1) { throw new InvalidOperationException("Aggregate only allows for a function with one parameters!"); } if (a.OptionalResultSelector != null) { throw new NotImplementedException("Can't do a selector function yet"); } // We need to declare a variable to hold the seed and its updates - the accumulator // We then need to write the code that does the update to the seed. // Finally, if there is a final function, we need to call that after the loop is done! var accumulator = DeclarableParameter.CreateDeclarableParameterExpression(a.Seed.Type); var newGC = new GeneratedCode(blockShouldBeBraced: false); var newCC = new CodeContext(); accumulator.InitialValue = ExpressionToCPP.GetExpression(a.Seed, newGC, newCC, container); if (newGC.CodeBody.Statements.Count() > 0) { accumulator.InitialValueCode = newGC; } _codeEnv.QueueForTransferFromGC(newGC); /// /// Now, parse the lambda expression, doing a substitution with this guy! Note that the only argument is our /// accumulator - the other arguments have all been replaced with subqueryexpressions and the like! /// var p1 = context.Add(a.Func.Parameters[0].Name, accumulator); var funcResolved = ExpressionToCPP.GetExpression(a.Func.Body, _codeEnv, context, container); p1.Pop(); if (accumulator.RawValue != funcResolved.RawValue) { _codeEnv.Add(new Statements.StatementAggregate(accumulator, funcResolved)); } return(accumulator); }
/// <summary> /// Look through all the code, and dump out everything to an IEnumerable. /// </summary> /// <param name="code"></param> /// <returns></returns> public static IEnumerable <string> DumpCode(this GeneratedCode code, bool dumpQM = true) { yield return("Declared Variables:"); foreach (var var in code.CodeBody.DeclaredVariables) { string initalValue = "default()"; if (var.InitialValue != null && var.InitialValue != null) { initalValue = var.InitialValue.RawValue; } yield return(var.Type.Name + " " + var.ParameterName + " = " + initalValue + ";"); } yield return("Code:"); foreach (var line in code.CodeBody.DumpCode()) { yield return(line); } yield return(""); foreach (var f in code.QMFunctions) { yield return(string.Format("Function: {0}", f.Name)); if (dumpQM) { yield return(string.Format(" -> QM: {0}", f.QueryModelText)); } yield return(string.Format(" {0} {1} ()", f.ResultType, f.Name)); if (f.StatementBlock != null) { foreach (var line in f.StatementBlock.DumpCode()) { yield return(string.Format(" {0}", line)); } } else { yield return(" ** No statements ever set"); } } if (code.ResultValue == null) { yield return("Result Variable: <not set (null)>"); } else { yield return("Result Variable: " + code.ResultValue.ToString()); } }
public void Setup() { TestUtils.ResetLINQLibrary(); MEFUtilities.AddPart(new QVResultOperators()); MEFUtilities.AddPart(new TypeHandlerCache()); MEFUtilities.AddPart(new DealWithMyTypes()); GeneratedCode gc = new GeneratedCode(); CodeContext cc = new CodeContext(); var qv = new QueryVisitor(gc, cc, MEFUtilities.MEFContainer); MEFUtilities.Compose(qv); }
public void GeneratedCode_ctor() { GeneratedCode gc = new GeneratedCode("", new string[0]); Assert.AreEqual(string.Empty, gc.SourceCode); Assert.IsNotNull(gc.References); Assert.AreEqual(0, gc.References.Count()); gc = new GeneratedCode("foo", new string[] {"bar"}); Assert.AreEqual("foo", gc.SourceCode); Assert.IsNotNull(gc.References); Assert.AreEqual(1, gc.References.Count()); Assert.AreEqual("bar", gc.References.First()); }
public void TestLiftSimpleStatement() { var v = new GeneratedCode(); var loopP = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop = new StatementForLoop(loopP, new LINQToTTreeLib.Variables.ValSimple("10", typeof(int))); v.Add(loop); v.Add(new StatementWithNoSideEffects()); StatementLifter.Optimize(v); var firstStatement = v.CodeBody.Statements.First(); Assert.IsInstanceOfType(firstStatement, typeof(StatementWithNoSideEffects), "first statement"); }
public void GeneratedCode_ctor_Illegal() { GeneratedCode gc; ExceptionHelper.ExpectArgumentNullExceptionStandard(delegate { gc = new GeneratedCode(null, new string[0]); }, "sourceCode"); ExceptionHelper.ExpectArgumentNullExceptionStandard(delegate { gc = new GeneratedCode("foo", null); }, "references"); }
public void TestLiftSimpleStatementInFunction() { var v = new StatementInlineBlock(); var loopP = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop = new StatementForLoop(loopP, new LINQToTTreeLib.Variables.ValSimple("10", typeof(int))); v.Add(loop); loop.Add(new StatementWithNoSideEffects()); var f = QMFunctions.QMFuncUtils.GenerateFunction(); f.SetCodeBody(v); var gc = new GeneratedCode(); gc.Add(new StatementSimpleStatement("int i = 10;")); gc.Add(f); StatementLifter.Optimize(gc); Assert.AreEqual(1, gc.Functions.Count(), "# of functions after lifting"); var firstStatement = gc.Functions.First().StatementBlock.Statements.First(); Assert.IsInstanceOfType(firstStatement, typeof(StatementWithNoSideEffects), "first statement"); }
EventModelInfo getEventModelInfo(GeneratedCode.SimulationModelRoot model) { EventModelInfo eventModel = new EventModelInfo(); List<EventInfo> events = null; for (int i = 0; i < model.EventModel.Length; i++) { if (events == null) { events = getEventInfo("", model.EventModel[i]); } else { System.Console.WriteLine("Error: there should only be one EventModel section!"); System.Environment.Exit(1); } foreach (EventInfo e in events) { if (eventModel.events.ContainsKey(e.name)) { System.Console.WriteLine("Error: multiple definition of " + e.name + " event type"); System.Environment.Exit(1); } if (e.parentName != "") { foreach (ParameterInfo p in eventModel.events[e.parentName].parameters.Values) { if (e.parameters.ContainsKey(p.name)) { System.Console.WriteLine("Error: multiple parameters with name:" + p.name + " defined"); System.Environment.Exit(1); } e.parameters[p.name] = p; } } eventModel.events[e.name] = e; } } return eventModel; }
public void TestLiftTwoStatements() { var v = new GeneratedCode(); var loopP = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop = new StatementForLoop(loopP, new LINQToTTreeLib.Variables.ValSimple("10", typeof(int))); v.Add(loop); v.Add(new StatementWithSideEffects(loopP)); v.Add(new StatementWithNoSideEffects()); v.Add(new StatementWithNoSideEffects()); Console.WriteLine("Before optimization"); v.DumpCodeToConsole(); StatementLifter.Optimize(v); Console.WriteLine("After optimization"); v.DumpCodeToConsole(); var firstStatement = v.CodeBody.Statements.First(); Assert.IsInstanceOfType(firstStatement, typeof(StatementWithNoSideEffects), "first statement"); var thirdstatement = v.CodeBody.Statements.Skip(1).First(); Assert.IsInstanceOfType(thirdstatement, typeof(StatementForLoop), "third statement"); }
public async Task<OperationStatus<SemanticDocument>> ApplyAsync(GeneratedCode generatedCode, CancellationToken cancellationToken) { var document = generatedCode.SemanticDocument; var root = document.Root; var callsiteAnnotation = generatedCode.CallSiteAnnotation; var methodDefinitionAnnotation = generatedCode.MethodDefinitionAnnotation; var callsite = root.GetAnnotatedNodesAndTokens(callsiteAnnotation).SingleOrDefault().AsNode(); var method = root.GetAnnotatedNodesAndTokens(methodDefinitionAnnotation).SingleOrDefault().AsNode(); var annotationResolver = GetAnnotationResolver(callsite, method); var triviaResolver = GetTriviaResolver(method); if (annotationResolver == null || triviaResolver == null) { // bug # 6644 // this could happen in malformed code. return as it was. var status = new OperationStatus(OperationStatusFlag.None, FeaturesResources.CantNotConstructFinalTree); return status.With(document); } return OperationStatus.Succeeded.With( await document.WithSyntaxRootAsync(_result.RestoreTrivia(root, annotationResolver, triviaResolver), cancellationToken).ConfigureAwait(false)); }
public void TestSimpleTimesTwo() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var param = Expression.Parameter(typeof(int), "p"); var paramplus = Expression.MakeBinary(ExpressionType.Add, param, Expression.Constant(1)); var expr = Expression.Call(typeof(DoItClass).GetMethod("DoIt"), paramplus); var result = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); var vname = result.RawValue; var st2 = gc.CodeBody.Statements.First().CodeItUp().First(); var expected = new StringBuilder(); expected.AppendFormat("{0} = (p+1)*2;", vname); Assert.AreEqual(expected.ToString(), st2, "statement line incorrect"); }
public void RenameCPPResultVariable() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var param = Expression.Parameter(typeof(int), "p"); var paramplus = Expression.MakeBinary(ExpressionType.Add, param, Expression.Constant(1)); var expr = Expression.Call(typeof(DoItClass).GetMethod("DoIt"), paramplus); var result = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.CodeBody.RenameVariable(result.RawValue, "abogus_1234"); gc.DumpCodeToConsole(); Assert.IsTrue(gc.DumpCode().Where(s => s.Contains("int abogus_1234")).Any(), "Didn't find the variable name in the code"); }
public void TestSimpleCodeAddon() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var param = Expression.Parameter(typeof(int), "p"); var expr = Expression.Call(typeof(DoItClass).GetMethod("DoIt"), param); var result = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.IsNotNull(result, "result!"); var vname = result.RawValue; Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements that came back"); var st1 = gc.CodeBody.Statements.First() as IStatement; var expected = new StringBuilder(); expected.AppendFormat("{0} = p*2;", vname); Assert.AreEqual(expected.ToString(), st1.CodeItUp().First(), "statement line incorrect"); Assert.AreEqual(1, gc.IncludeFiles.Count(), "# of include files"); Assert.AreEqual("TLorentzVector.h", gc.IncludeFiles.First(), "include file name"); }
public void CPPRenameVariables() { // two identical expressions var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_E = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); // Create call var e1 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt_1, p_eta, p_phi, p_E); var e1Value = target.CodeMethodCall(e1, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); // Now, extract the main statement. Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements"); var s1 = gc.CodeBody.Statements.First() as IStatement; // Make sure the variable is there and then isn't. var p_pt_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); Assert.IsTrue(gc.DumpCode().Where(l => l.Contains(p_pt_1.RawValue)).Any(), "the pt variable should be there."); Assert.IsFalse(gc.DumpCode().Where(l => l.Contains(p_pt_2.RawValue)).Any(), "the pt variable should be there."); s1.RenameVariable(p_pt_1.RawValue, p_pt_2.RawValue); Assert.IsFalse(gc.DumpCode().Where(l => l.Contains(p_pt_1.RawValue)).Any(), "the pt variable should be there."); Assert.IsTrue(gc.DumpCode().Where(l => l.Contains(p_pt_2.RawValue)).Any(), "the pt variable should be there."); }
public void CPPTryCombineNotSame() { // two identical expressions var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_E = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); // Create two identical calls var e1 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt_1, p_eta, p_phi, p_E); var e1Value = target.CodeMethodCall(e1, gc, MEFUtilities.MEFContainer); var p_pt_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var e2 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt_2, p_eta, p_phi, p_E); var e2Value = target.CodeMethodCall(e2, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); // Now, extract the two main statements. Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "# of statements"); var s1 = gc.CodeBody.Statements.First() as IStatement; var s2 = gc.CodeBody.Statements.Skip(1).First() as IStatement; // Now, try-combine should just "work", as it were. var opt = new OptTest(); var r = s1.TryCombineStatement(s2, opt); Assert.IsFalse(r); }
public void TestReturnVariableDecl() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZ"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); var declStatement = gc.CodeBody.DeclaredVariables.ToArray(); Assert.AreEqual(1, declStatement.Length); }
public void CodeAddonWithStringArgument() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var param = Expression.Parameter(typeof(string), "p"); var expr = Expression.Call(typeof(DoItClass).GetMethod("DoItWithAString"), param); var result = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.IsNotNull(result, "result!"); var vname = result.RawValue; Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements that came back"); var st1 = gc.CodeBody.Statements.First() as IStatement; var expected = new StringBuilder(); expected.AppendFormat("{0} = strlen(p);", vname); Assert.AreEqual(expected.ToString(), st1.CodeItUp().First(), "statement line incorrect"); }
public void TestArgReplacementAtStartAndEnd() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements total"); var atEnding = gc.CodeBody.Statements.First().CodeItUp().Skip(1).FirstOrDefault(); Assert.IsNotNull(atEnding, "Bad type for 3rd statement"); Assert.IsTrue(atEnding.EndsWith("ptParam"), string.Format("Line '{0}' doesn't ends with parameter replacement", atEnding)); }
public void RenameCPPInputVariableVariable() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var param = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var paramplus = Expression.MakeBinary(ExpressionType.Add, param, Expression.Constant(1)); var expr = Expression.Call(typeof(DoItClass).GetMethod("DoIt"), paramplus); var result = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); // Check the dependents. gc.CodeBody.RenameVariable(param.RawValue, "abogus_1234"); gc.DumpCodeToConsole(); var st = gc.CodeBody.Statements.First() as ICMStatementInfo; Assert.AreEqual(1, st.DependentVariables.Count(), "# of dependents"); Assert.AreEqual("abogus_1234", st.DependentVariables.First()); }
public void TestForMissingResult() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZNoResult"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); }
public void TestScopingBlock() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("TestIF"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); var ifstatement = gc.CodeBody.Statements.First().CodeItUp().First(); Assert.IsFalse(ifstatement.EndsWith(";"), string.Format("Line '{0}' ends with a semicolon", ifstatement)); }
public void TestCMVariables() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi = p_pt; var p_E = p_eta; var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZ"), p_pt, p_eta, p_phi, p_E); var r = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); var ccpstatement = gc.CodeBody.Statements.First(); Assert.IsNotNull(ccpstatement); var cmInfo = ccpstatement as ICMStatementInfo; Assert.IsNotNull(cmInfo); Assert.AreEqual(1, cmInfo.ResultVariables.Count(), "# of result variables"); Assert.AreEqual(r.RawValue, cmInfo.ResultVariables.First(), "Result variable name"); Assert.AreEqual(2, cmInfo.DependentVariables.Count(), "# of dependent variables"); Assert.IsTrue(cmInfo.DependentVariables.Contains(p_pt.RawValue), "doesn't have pt"); Assert.IsTrue(cmInfo.DependentVariables.Contains(p_eta.RawValue), "Doesn't have eta"); }
public void TestTwoUniqueReplacements() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZUniqueTest"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); foreach (var line in gc.CodeBody.Statements.First().CodeItUp()) { Assert.IsNotNull(line, "bad statement type"); Assert.IsFalse(line.Contains("Unique"), string.Format("Line '{0}' contains a reference to a unique variable", line)); } }
public void CPPNotIdentical() { // two identical expressions var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_E = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); // Create two identical calls var e1 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt, p_eta, p_phi, p_E); var e1Value = target.CodeMethodCall(e1, gc, MEFUtilities.MEFContainer); var c2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var e2 = Expression.Call(typeof(DoItClass).GetMethod("DoIt"), c2); var e2Value = target.CodeMethodCall(e2, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); // Now, extract the two main statements. Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "# of statements"); var s1 = gc.CodeBody.Statements.First() as ICMStatementInfo; var s2 = gc.CodeBody.Statements.Skip(1).First() as ICMStatementInfo; // Now, see if we can do the requirement. var r = s1.RequiredForEquivalence(s2); Assert.IsFalse(r.Item1, "We should be able to do the translation"); }
public void CPPNeedSomeReplacements() { // two identical expressions var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_E_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); // Create first call var e1 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt_1, p_eta_1, p_phi_1, p_E_1); var e1Value = target.CodeMethodCall(e1, gc, MEFUtilities.MEFContainer); var p_pt_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_E_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var e2 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt_2, p_eta_2, p_phi_2, p_E_2); var e2Value = target.CodeMethodCall(e2, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); // Now, extract the two main statements. Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "# of statements"); var s1 = gc.CodeBody.Statements.First() as ICMStatementInfo; var s2 = gc.CodeBody.Statements.Skip(1).First() as ICMStatementInfo; // Now, see if we can do the requirement. var renames = new Tuple<string, string>[] { new Tuple<string, string>(p_pt_2.RawValue, p_pt_1.RawValue), new Tuple<string, string>(p_eta_2.RawValue, p_eta_1.RawValue) }; var r = s1.RequiredForEquivalence(s2, renames); Assert.IsTrue(r.Item1, "We should be able to do the translation"); Assert.AreEqual(3, r.Item2.Count(), "# of variable translations required"); }
public void TestComplexArgumentReplacement() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZ"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements total"); var setStatement = gc.CodeBody.Statements.First().CodeItUp().Skip(1).First(); Assert.IsNotNull(setStatement, "Bad type for 3rd statement"); Assert.IsTrue(setStatement.Contains("SetPtEtaPhiE(ptParam, etaParam, phiParam, EParam)"), string.Format("Line '{0}' doesn't have correct set statement.", setStatement)); }
public void TestForUniqueReplacement() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZ"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); var declStatement = gc.CodeBody.Statements.First().CodeItUp().Skip(1).First(); var setStatement = gc.CodeBody.Statements.First().CodeItUp().Skip(2).First(); Assert.IsFalse(declStatement.Contains("Unique"), string.Format("Line '{0}' contains a reference to a unique variable", declStatement)); Assert.IsFalse(setStatement.Contains("Unique"), string.Format("Line '{0}' contains a reference to a unique variable", setStatement)); }