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] + "'");
}
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");
}
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 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 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));
}
