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);
}
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.");
}
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);
}
