public ShellCodeMethod AddFunction(string Name, vsCMFunction Kind, object Type, object Position, vsCMAccess Access, object Location) { return (new ShellCodeMethod( _codeClass.AddFunction(Name, Kind, Type, Position, Access, Location) as CodeFunction2)); }
public void FunctionKind_ClassMethod_ReturnsFunctionKind() { CreatePublicFunction("MyClass.MyFunction"); vsCMFunction kind = codeFunction.FunctionKind; Assert.AreEqual(vsCMFunction.vsCMFunctionFunction, kind); }
public void FunctionKind_ClassConstructor_ReturnsConstructorKind() { CreatePublicConstructor("MyClass.MyClass"); vsCMFunction kind = codeFunction.FunctionKind; Assert.AreEqual(vsCMFunction.vsCMFunctionConstructor, kind); }
public CodeFunction AddFunction(string Name, vsCMFunction Kind, object Type, object Position, vsCMAccess Access, object Location) { CodeDomCodeFunction codeFunc = new CodeDomCodeFunction(DTE, this, Name, Kind, Type, Access); CodeObject.Members.Insert(PositionToIndex(Position), codeFunc.CodeObject); CommitChanges(); return(codeFunc); }
/// <summary> /// Adds a function to the Lua class. /// </summary> /// <param name="functionName"></param> /// <param name="kind"></param> /// <param name="returnType"></param> /// <param name="position"></param> /// <param name="functionAccess"></param> /// <param name="functionNode"></param> /// <returns></returns> public CodeFunction AddFunction(string functionName, vsCMFunction kind, object returnType, object position, vsCMAccess functionAccess, object functionNode) { var codeFunction = new LuaCodeFunction( DTE, this, functionName, kind, returnType, Access, functionNode as FunctionDeclaration); AddFunction(codeFunction); return(codeFunction); }
/// <summary> /// Adds a function to the top-level CodeElement. /// </summary> /// <param name="objectName">Name of the object.</param> /// <param name="objectKind">Kind of the object.</param> /// <param name="returnType">Type of the return.</param> /// <param name="function">The function.</param> /// <param name="access">The access.</param> /// <returns></returns> public CodeFunction AddFunction(string objectName, vsCMFunction objectKind, object returnType, object function, vsCMAccess access) { CodeFunction codeFunction = AddFunction(objectName, returnType as LuaDeclaredType, function as FunctionDeclaration); codeFunction.Access = access; return(codeFunction); }
public CodeDomCodeFunction(DTE dte, CodeElement parent, string name, vsCMFunction kind, object type, vsCMAccess access) : base(dte, name) { this.parent = parent; this.CodeObject = new CodeMemberMethod(); this.CodeObject.Name = name; this.CodeObject.ReturnType = new CodeTypeReference(ObjectToClassName(type)); this.CodeObject.Attributes = VSAccessToMemberAccess(access); }
/// <summary> /// Initializes a new instance of the <see cref="LuaCodeFunction"/> class. /// </summary> /// <param name="dte">The DTE.</param> /// <param name="parentElement">The parent element.</param> /// <param name="name">The name.</param> /// <param name="kind">The kind.</param> /// <param name="codeType">Type of the code.</param> /// <param name="access">The access.</param> /// <param name="function">The function.</param> public LuaCodeFunction(DTE dte, CodeElement parentElement, string name, vsCMFunction kind, object codeType, vsCMAccess access, FunctionDeclaration function) : base(dte, name, function) { parent = parentElement; FunctionBody = new LuaCodeElements(dte, this); parameters = new LuaCodeElements(dte, this); FunctionType = kind; Access = access; Type = ObjectToTypeRef(codeType); }
/// <summary> /// Checks if given type belongs to particular list. /// </summary> private static bool IsMethodType(vsCMFunction type, vsCMFunction[] types) { for (int i = 0; i < types.Length; i++) { if (type == types[i]) { return(true); } } return(false); }
/// <summary> /// Adds a function to the top-level namespace. Currently adding functions to namespaces doesn't do anything. /// </summary> public CodeFunction AddFunction(string Name, vsCMFunction Kind, object Type, object Position, vsCMAccess Access) { Initialize(); InitTopNamespace(); CodeFunction cf = vsTopNamespace.AddFunction(Name, Kind, Type, Position, Access); CommitChanges(); return(cf); }
public CodeFunction CreateEventHandler(string codeBehindFile, string className, string objectTypeName, string eventName, string eventHandlerName) { var codeClass = FindClass(className); if (codeClass != null) { if (!string.IsNullOrEmpty(eventHandlerName)) { string str; string[] strArray; string[] strArray2; Type objectType = ResolveType(objectTypeName); GetEventHandlerSignature(objectType, eventName, out str, out strArray2, out strArray); if (string.IsNullOrEmpty(str)) { str = "System.Void"; } vsCMFunction vsCMFunctionFunction = vsCMFunction.vsCMFunctionFunction; if (str == "System.Void") { vsCMFunctionFunction = vsCMFunction.vsCMFunctionSub; } CodeFunction codeFunction = codeClass.AddFunction(eventHandlerName, vsCMFunctionFunction, str, -1, vsCMAccess.vsCMAccessProtected, codeBehindFile); if ((codeFunction != null) && (strArray2 != null)) { for (int i = 0; i < strArray2.Length; i++) { codeFunction.AddParameter("_" + strArray[i], strArray2[i], -1); } } return(codeFunction); } } return(null); }
public CodeFunction AddFunction(string Name, object Location, vsCMFunction Kind, object Type, object Position, vsCMAccess Access) { throw new NotImplementedException(); }
public CodeFunction AddFunction(string name, vsCMFunction kind, object type, object Position = null, vsCMAccess Access = vsCMAccess.vsCMAccessPublic) { var codeGenerator = new ClassCodeGenerator(Class); return codeGenerator.AddPublicMethod(name, (string)type); }
public CodeFunction AddFunction(string name, object location, vsCMFunction kind, object type, object position, vsCMAccess access) { throw new Exception("The method or operation is not implemented."); }
public ShellCodeMethod AddFunction(string Name, vsCMFunction Kind, object Type, object Position, vsCMAccess Access) { return new ShellCodeMethod(_codeInterface.AddFunction(Name, Kind, Type, Position, Access) as CodeFunction2); }
public CodeFunction AddFunction(string name, vsCMFunction kind, object type, object Position = null, vsCMAccess Access = vsCMAccess.vsCMAccessPublic) { var codeGenerator = new ClassCodeGenerator(Class); return(codeGenerator.AddPublicMethod(name, (string)type)); }
/// <summary> /// Adds the function. /// </summary> /// <param name="Name">The name.</param> /// <param name="Location">The location.</param> /// <param name="Kind">The kind.</param> /// <param name="Type">The type.</param> /// <param name="Position">The position.</param> /// <param name="Access">The access.</param> /// <returns></returns> public CodeFunction AddFunction(string Name, object Location, vsCMFunction Kind, object Type, object Position, vsCMAccess Access) { throw new NotImplementedException(); }
public MockedCodeFunction(string name, vsCMFunction functionKind, vsCMAccess access) : base(name, vsCMElement.vsCMElementFunction) { this.functionKind = functionKind; this.access = access; }
public override CodeFunction GenerateTest(CodeClass unitTestCodeClass, CodeFunction originalClassCodeFuntion) { vsCMFunction functionKind = vsCMFunction.vsCMFunctionFunction; object functionType = null; functionKind = vsCMFunction.vsCMFunctionSub; functionType = vsCMTypeRef.vsCMTypeRefVoid; string nextAvailableName = originalClassCodeFuntion.Name; if (!CodeSelectionHandler.CanGenerateHandleCodeFunction(unitTestCodeClass, nextAvailableName)) { nextAvailableName = GetNextAvailableCopyName(unitTestCodeClass, ref nextAvailableName, unitTestCodeClass.ProjectItem.ContainingProject); } CodeFunction unitTestCodeFunction = unitTestCodeClass.AddFunction( nextAvailableName, functionKind, functionType, -1, originalClassCodeFuntion.Access, -1); bool tvIsStatic = originalClassCodeFuntion.IsShared; //add the NUnit attribute to the function unitTestCodeFunction.AddAttribute("NUnit.Framework.Test", "", -1); try { unitTestCodeFunction.Comment = originalClassCodeFuntion.Comment; unitTestCodeFunction.DocComment = originalClassCodeFuntion.DocComment; } catch (Exception ex) { //ignore, for some reason the doc throws in vb Logger.LogException(ex); } string tvFunctionCallTemplate = string.Empty; //"iv{0}Type.{1}("; string tvFunctionReturnTemplate = string.Empty; //"{0} iv{1}Return = "; tvFunctionCallTemplate = "iv{0}Type.{1}("; if (tvIsStatic) { tvFunctionCallTemplate = "{0}.{1}("; } tvFunctionReturnTemplate = "Dim iv{1}Return As {0} = "; string tvTempParameterList = string.Empty; string tvFunctionCall = tvFunctionCallTemplate; string tvFunctionReturn = tvFunctionReturnTemplate; if (!originalClassCodeFuntion.FunctionKind.ToString().Equals("vsCMFunctionConstructor")) { CodeElements tvParameters = originalClassCodeFuntion.Parameters; foreach (CodeElement tvCodeElement in tvParameters) { if (!tvFunctionCall.Equals(tvFunctionCallTemplate)) { tvFunctionCall += ", "; } CodeParameter2 tvCodeParameter = (CodeParameter2)tvCodeElement; string parameterName = tvCodeParameter.Name; CodeTypeRef tvParameterType = tvCodeParameter.Type; vsCMParameterKind tvParameterKind = tvCodeParameter.ParameterKind; string parameterTypeAsString = tvParameterType.AsString; tvTempParameterList += "Dim " + parameterName + " As " + parameterTypeAsString + " = New " + parameterTypeAsString + "()" + Environment.NewLine + StringHelper.GetTabString(); if (tvParameterKind == vsCMParameterKind.vsCMParameterKindRef) { tvFunctionCall += parameterName; } else if (tvParameterKind == vsCMParameterKind.vsCMParameterKindOut) { tvFunctionCall += parameterName; } else if (tvParameterKind == vsCMParameterKind.vsCMParameterKindIn) { tvFunctionCall += parameterName; } else { tvFunctionCall += parameterName; } } tvFunctionCall = string.Format(tvFunctionCall + ")" + Environment.NewLine, ((CodeClass)originalClassCodeFuntion.Parent).Name, originalClassCodeFuntion.Name); } if (originalClassCodeFuntion.Type.TypeKind != vsCMTypeRef.vsCMTypeRefVoid) { tvFunctionReturn = string.Format(tvFunctionReturn, originalClassCodeFuntion.Type.AsString, originalClassCodeFuntion.Name); tvFunctionCall = tvFunctionReturn + tvFunctionCall; } TextPoint bodyStartingPoint = unitTestCodeFunction.GetStartPoint(vsCMPart.vsCMPartBody); EditPoint boydEditPoint = bodyStartingPoint.CreateEditPoint(); if (!originalClassCodeFuntion.FunctionKind.ToString().Equals("vsCMFunctionConstructor")) { boydEditPoint.Insert("\t\t\t' TODO: Update variable/s' defaults to meet test needs" + Environment.NewLine); boydEditPoint.Insert(StringHelper.GetTabString() + tvTempParameterList + Environment.NewLine); boydEditPoint.Insert(StringHelper.GetTabString() + tvFunctionCall + Environment.NewLine); } if (originalClassCodeFuntion.Type.TypeKind != vsCMTypeRef.vsCMTypeRefVoid) { string stringHolder = "iv{0}Return"; stringHolder = string.Format(stringHolder, originalClassCodeFuntion.Name); //FIX ME (tabing) //boydEditPoint.Insert(string.Format("\t\t\tAssert.AreEqual({0}, default({1}));\r\n", stringHolder, originalClassCodeFuntion.Type.AsString)); } boydEditPoint.Insert(Environment.NewLine); boydEditPoint.Insert("\t\t\t'TODO: Update Assert to meet test needs" + Environment.NewLine); boydEditPoint.Insert("\t\t\t'Assert.AreEqual( , )" + Environment.NewLine); boydEditPoint.Insert("\t\t\t" + Environment.NewLine); boydEditPoint.Insert("\t\t\tThrow New Exception 'Not Implemented'" + Environment.NewLine); return(unitTestCodeFunction); }
public MockedCodeFunction(string name, vsCMFunction functionKind) : this(name, functionKind, vsCMAccess.vsCMAccessPublic) { }
/// <summary> /// Adds a function to the top-level CodeElement. /// </summary> /// <param name="objectName">Name of the object.</param> /// <param name="objectKind">Kind of the object.</param> /// <param name="returnType">Type of the return.</param> /// <param name="function">The function.</param> /// <param name="access">The access.</param> /// <returns></returns> public CodeFunction AddFunction(string objectName, vsCMFunction objectKind, object returnType, object function, vsCMAccess access) { CodeFunction codeFunction = AddFunction(objectName, returnType as LuaDeclaredType, function as FunctionDeclaration); codeFunction.Access = access; return codeFunction; }
/// <summary> /// Adds a function to the top-level namespace. Currently adding functions to namespaces doesn't do anything. /// </summary> public CodeFunction AddFunction(string Name, vsCMFunction Kind, object Type, object Position, vsCMAccess Access) { Initialize(); InitTopNamespace(); CodeFunction cf = vsTopNamespace.AddFunction(Name, Kind, Type, Position, Access); CommitChanges(); return cf; }
/// <summary> /// Creates the lua code function. /// </summary> /// <param name="dte">The DTE.</param> /// <param name="parent">The parent.</param> /// <param name="name">The name.</param> /// <param name="returnType">Type of the return.</param> /// <param name="access">The access.</param> /// <param name="kind">The kind.</param> /// <param name="function">The function.</param> /// <returns></returns> public static LuaCodeFunction CreateLuaCodeFunction( DTE dte, CodeElement parent, string name, LuaType returnType, vsCMAccess access, vsCMFunction kind, FunctionDeclaration function) { var result = new LuaCodeFunction(dte, parent, name, kind, new LuaCodeTypeRef(dte, LuaDeclaredType.Find(returnType.ToString())), access, function); return(result); }
public CodeFunction AddFunction(string name, vsCMFunction kind, object type, object position, vsCMAccess access) { return(null); }
public ShellCodeMethod AddFunction(string Name, vsCMFunction Kind, object Type, object Position, vsCMAccess Access) { return(new ShellCodeMethod(_codeInterface.AddFunction(Name, Kind, Type, Position, Access) as CodeFunction2)); }
public CodeFunction AddFunction(string Name, object Location, vsCMFunction Kind, object Type, object Position, vsCMAccess Access) { throw new Exception("The method or operation is not implemented."); }
public ShellCodeMethod AddFunction(string Name, vsCMFunction Kind, object Type, object Position, vsCMAccess Access, object Location) { return new ShellCodeMethod(_struct.AddFunction(Name, Kind, Type, Position, Access, Location) as CodeFunction2); }
CodeFunction FileCodeModel2.AddFunction(string Name, vsCMFunction Kind, object Type, object Position, vsCMAccess Access) => throw new NotImplementedException();
public override CodeFunction GenerateTest(CodeClass unitTestCodeClass, CodeProperty originalClassCodeProperty) { vsCMFunction functionKind = vsCMFunction.vsCMFunctionFunction; object functionType = null; functionKind = vsCMFunction.vsCMFunctionSub; functionType = vsCMTypeRef.vsCMTypeRefVoid; string nextAvailableName = originalClassCodeProperty.Name; if (!CodeSelectionHandler.CanGenerateHandleCodeFunction(unitTestCodeClass, nextAvailableName)) { nextAvailableName = GetNextAvailableCopyName(unitTestCodeClass, ref nextAvailableName, unitTestCodeClass.ProjectItem.ContainingProject); } CodeFunction unitTestCodeFunction = unitTestCodeClass.AddFunction( nextAvailableName, functionKind, functionType, -1, originalClassCodeProperty.Access, -1); unitTestCodeFunction.AddAttribute("NUnit.Framework.Test", "", -1); try { unitTestCodeFunction.Comment = originalClassCodeProperty.Comment; unitTestCodeFunction.DocComment = originalClassCodeProperty.DocComment; } catch (Exception ex) { Logger.LogException(ex); //ignore } TextPoint bodyStartingPoint = unitTestCodeFunction.GetStartPoint(vsCMPart.vsCMPartBody); EditPoint boydEditPoint = bodyStartingPoint.CreateEditPoint(); //Stop here if not read-write type property now... if (originalClassCodeProperty.Setter == null) { boydEditPoint = bodyStartingPoint.CreateEditPoint(); boydEditPoint.Insert(StringHelper.GetTabString() + "' Property is not read-write please add your own code here." + Environment.NewLine); return(unitTestCodeFunction); } string tvFunctionCallTemplate = string.Empty; // "iv{0}Type.{1} = default({2});"; tvFunctionCallTemplate = "iv{0}Type.{1} = New {2}()" + Environment.NewLine; string tvFunctionCall = tvFunctionCallTemplate; CodeTypeRef tvPropertyType = originalClassCodeProperty.Type; string tvPropertyTypeAsString = tvPropertyType.AsString; tvFunctionCall = string.Format(tvFunctionCall, ((CodeClass)originalClassCodeProperty.Parent).Name, originalClassCodeProperty.Name, tvPropertyTypeAsString); bodyStartingPoint = unitTestCodeFunction.GetStartPoint(vsCMPart.vsCMPartBody); boydEditPoint = bodyStartingPoint.CreateEditPoint(); //FIX ME (tabing) boydEditPoint.Insert(StringHelper.GetTabString() + tvFunctionCall + Environment.NewLine); //FIX ME (tabbing) string tvTempString = string.Empty; // "iv{0}Type.{1}, default({2})"; tvTempString = "iv{0}Type.{1}, New {2}()"; tvTempString = string.Format(tvTempString, ((CodeClass)originalClassCodeProperty.Parent).Name, originalClassCodeProperty.Name, tvPropertyTypeAsString); boydEditPoint.Insert(Environment.NewLine); boydEditPoint.Insert("\t\t\t'TODO: Update Assert to meet test needs" + Environment.NewLine); boydEditPoint.Insert("\t\t\t'Assert.AreEqual(" + tvTempString + ")" + Environment.NewLine); boydEditPoint.Insert("\t\t\t" + Environment.NewLine); boydEditPoint.Insert("\t\t\tThrow New Exception 'Not Implemented'" + Environment.NewLine); return(unitTestCodeFunction); }