/**
* Checks a global function to determine if it is the main() function.
*
* @param element the function handle to be checked.
*/
private void CheckForMain(VCCodeFunction function)
{
if (function.Name == "main")
{
mainExists = true;
}
}
public IClassMethodElement GetMethodFromFilePos(int lineNum, int linePos)
{
VCCodeFunction targetFunc = GetMethodFromFilePos(projItem.FileCodeModel, lineNum, linePos);
if (targetFunc != null)
{
ClassMethodElement method = new ClassMethodElement(targetFunc, this);
return(method);
}
return(null);
}
public TestSuiteGenerator(HierarchyItem project,
string suiteName, HierarchyItem headerUnderTest,
string superclass, bool createSetUp, bool createTearDown,
VCCodeFunction[] functions)
{
this.project = project;
this.suiteName = suiteName;
this.headerUnderTest = headerUnderTest;
this.superclass = superclass;
this.createSetUp = createSetUp;
this.createTearDown = createTearDown;
this.functions = functions;
GenerateUniqueStubNames();
}
private bool IsElementAcceptableType(VCCodeElement element)
{
switch (element.Kind)
{
case vsCMElement.vsCMElementFunction:
VCCodeFunction function = (VCCodeFunction)element;
if (element.Name.StartsWith("~") ||
function.Access != vsCMAccess.vsCMAccessPublic)
{
return(false);
}
else
{
return(true);
}
case vsCMElement.vsCMElementClass:
VCCodeClass klass = (VCCodeClass)element;
if (klass.Access != vsCMAccess.vsCMAccessPublic)
{
return(false);
}
else
{
return(true);
}
case vsCMElement.vsCMElementNamespace:
return(true);
case vsCMElement.vsCMElementStruct:
VCCodeStruct strukt = (VCCodeStruct)element;
if (strukt.Access != vsCMAccess.vsCMAccessPublic)
{
return(false);
}
else
{
return(true);
}
default:
return(false);
}
}
private VCCodeFunction GetMethodFromFilePos(FileCodeModel fcm, int lineNum, int linePos)
{
if (fcm == null)
{
return(null);
}
foreach (CodeElement codeElem in fcm.CodeElements)
{
VCCodeFunction theMethod = GetMethodFromFilePos(codeElem, lineNum, linePos);
if (theMethod != null)
{
return(theMethod);
}
}
return(null);
}
/**
* A convenience function to check if a function takes no arguments
* (CDT's DOM treats a function with no arguments differently from one
* with a single "void" argument).
*
* @param element the method handle to check.
*
* @return true if the function has no arguments; otherwise, false.
*/
private bool IsMethodParameterless(VCCodeFunction function)
{
if (function.Parameters.Count == 0)
{
return(true);
}
else if (function.Parameters.Count > 1)
{
return(false);
}
else
{
VCCodeParameter parameter =
(VCCodeParameter)function.Parameters.Item(1);
return(parameter.Type.AsString == "void");
}
}
private VCCodeFunction GetMethodFromFilePos(CodeElement codeElem, int lineNum, int linePos)
{
if (codeElem.Kind == vsCMElement.vsCMElementFunction)
{
VCCodeFunction targetFunc = codeElem as VCCodeFunction;
if (targetFunc != null)
{
TextPoint startFuncBody = targetFunc.StartPointOf[vsCMPart.vsCMPartBody, vsCMWhere.vsCMWhereDefinition];
TextPoint endFuncBody = targetFunc.EndPointOf[vsCMPart.vsCMPartBody, vsCMWhere.vsCMWhereDefinition];
EditPoint startPnt = startFuncBody.CreateEditPoint();
EditPoint endPnt = endFuncBody.CreateEditPoint();
startPnt.FindPattern("{", (int)vsFindOptions.vsFindOptionsBackwards);
endPnt.FindPattern("}");
if ((lineNum > startPnt.Line && lineNum < endPnt.Line) ||
(lineNum == startPnt.Line && linePos >= startPnt.LineCharOffset) ||
(lineNum == endPnt.Line && linePos <= endPnt.LineCharOffset))
{
return(targetFunc);
}
}
//if ((lineNum > codeElem.StartPoint.Line && lineNum < codeElem.EndPoint.Line) ||
// (lineNum == codeElem.StartPoint.Line && linePos >= codeElem.StartPoint.LineCharOffset) ||
// (lineNum == codeElem.EndPoint.Line && linePos <= codeElem.EndPoint.LineCharOffset))
//{
// VCCodeFunction targetFunc = (VCCodeFunction)codeElem;
// if (targetFunc != null)
// return targetFunc;
//}
}
else
{
foreach (CodeElement classCodeElem in codeElem.Children)
{
VCCodeFunction theMethod = GetMethodFromFilePos(classCodeElem, lineNum, linePos);
if (theMethod != null)
{
return(theMethod);
}
}
}
return(null);
}
/**
* Checks a method inside a test suite class to determine if it
* is a valid test method (void return value, no arguments, name
* begins with "test"). If so, it is added to the suite's list of
* tests.
*
* @param element the method handle to be checked.
*/
private void CheckMethod(VCCodeFunction function)
{
string name = function.Name;
int lineNum = function.StartPoint.Line;
bool isStatic = function.IsShared;
if (name.StartsWith("Test") || name.StartsWith("test"))
{
if (function.Type.AsString == "void" &&
IsMethodParameterless(function))
{
testCases.Add(new TestCase(function));
}
}
else if (name == "createSuite")
{
if (isStatic &&
function.Type.AsString.IndexOf('*') >= 0 &&
IsMethodParameterless(function))
{
createLineNumber = lineNum;
}
}
else if (name == "destroySuite")
{
CodeElements parameters = function.Parameters;
if (parameters.Count == 1)
{
VCCodeParameter parameter =
(VCCodeParameter)parameters.Item(1);
if (isStatic &&
parameter.Type.AsString.IndexOf('*') >= 0 &&
function.Type.AsString == "void")
{
destroyLineNumber = lineNum;
}
}
}
}
public void CalcInjectionPoints(CPClassLayout cpClassLayout, CPTraceVar traceVar, bool needDeclare)
{
if (needDeclare)
{
// find all places, where this file included
CodeElement theFunc = null;
// find & store all constructors init points of this class
foreach (CodeElement _func in ent.Functions)
{
if (_func.Name == ent.Name)
{
theFunc = _func;
VCCodeFunction vcFunc = (VCCodeFunction)_func;
EditPoint pnt = _func.StartPoint.CreateEditPoint();
if (pnt.FindPattern("{"))
{
traceVar.traceVarInitPos.Add(new FilePosPnt()
{
fileName = _func.ProjectItem.Name,
pos = { lineNum = pnt.Line - 1, linePos = pnt.LineCharOffset }
});
}
}
}
// if no constructor found add default one
if (traceVar.traceVarInitPos.Count == 0)
{
EditPoint pnt = ent.StartPoint.CreateEditPoint();
if (pnt.FindPattern("{"))
{
traceVar.injConstructorPos = new FilePosPnt()
{
fileName = ent.ProjectItem.Name,
pos = { lineNum = pnt.Line - 1, linePos = pnt.LineCharOffset }
};
}
}
}
}
private TreeNode FindNodeForTestCase(object parent, VCCodeFunction function)
{
TreeNode suiteNode = FindNodeForTestSuite(parent);
if (suiteNode == null)
{
return(null);
}
string testName = ((CodeElement2)function).Name;
foreach (TreeNode testNode in suiteNode.Nodes)
{
TestCase testCase = (TestCase)testNode.Tag;
if (testCase.Name == testName)
{
return(testNode);
}
}
return(null);
}
public void DeleteElement(object parent, CodeElement element)
{
if (element is VCCodeClass || element is VCCodeStruct)
{
TreeNode node = FindNodeForTestSuite(element);
if (node != null)
{
node.Remove();
}
}
else if (element is VCCodeFunction)
{
VCCodeFunction function = (VCCodeFunction)element;
TreeNode node = FindNodeForTestCase(parent, function);
if (node != null)
{
node.Remove();
}
}
}
public void AddElement(CodeElement element)
{
if (testsTreeView.Nodes.Count == 0)
{
return;
}
if (element is VCCodeClass || element is VCCodeStruct)
{
TestSuiteCollector collector = new TestSuiteCollector();
collector.Process(element);
foreach (TestSuite suite in collector.Suites)
{
AddTestSuiteToNode(suite, testsTreeView.Nodes[0], null);
}
testsTreeView.Sort();
}
else if (element is VCCodeFunction)
{
VCCodeFunction function = (VCCodeFunction)element;
TreeNode suiteNode = FindNodeForTestSuite(function.Parent);
TestCaseCollector collector = new TestCaseCollector();
collector.Process((CodeElement)function);
foreach (TestCase testCase in collector.TestCases)
{
AddTestCaseToNode((TestSuite)suiteNode.Tag, testCase, suiteNode, null);
}
testsTreeView.Sort();
}
}
public ICheckCPPoint CheckCursorPos()
{
ICheckCPPoint checkPnt = null;
Document activeDoc = ChartPoints.Globals.dte.ActiveDocument;
string projName = activeDoc.ProjectItem.ContainingProject.Name;
TextSelection sel = (TextSelection)activeDoc.Selection;
TextPoint caretPnt = (TextPoint)sel.ActivePoint;
VCCodeElement targetClassElem;
for (;;)
{
// checks if we are in text document
if (activeDoc == null)
{
break;
}
var textDoc = activeDoc.Object() as TextDocument;
if (textDoc == null)
{
break;
}
// we work only with project items
ProjectItem projItem = activeDoc.ProjectItem;
if (projItem == null)
{
break;
}
// only c++ items
FileCodeModel fcModel = projItem.FileCodeModel;
if (fcModel == null)
{
break;
}
if (fcModel.Language != CodeModelLanguageConstants.vsCMLanguageVC)
{
break;
}
vcCodeModel.Synchronize();// !!! MOVE TO METHOD ???
// chartpoint allowed only in class methods
CodeElement elem = fcModel.CodeElementFromPoint(caretPnt, vsCMElement.vsCMElementFunction);
if (elem == null)
{
break;
}
if (elem.Kind != vsCMElement.vsCMElementFunction)
{
break;
}
VCCodeFunction targetFunc = (VCCodeFunction)elem;
if (targetFunc == null)
{
break;
}
// check that we are in method definition (not declaration) in case of declaration in one file & definition in other
if (!targetFunc.File.Equals(activeDoc.FullName, StringComparison.OrdinalIgnoreCase))
{
break;
}
// we are working only with class methods not global function
targetFunc.CodeModel.Synchronize();
targetFunc.CodeModel.SynchronizeFiles();
foreach (CodeElement _cl in targetFunc.CodeModel.Classes)
{
foreach (CodeElement _f in _cl.Children)
{
if (targetFunc.FullName.Equals(_f.FullName, StringComparison.OrdinalIgnoreCase))
{
targetFunc = (VCCodeFunction)_f;
break;
}
}
}
targetClassElem = (VCCodeElement)targetFunc.Parent;
if (targetClassElem == null)
{
break;
}
if (targetClassElem.Kind != vsCMElement.vsCMElementClass)
{
targetClassElem = null;
break;
}
VCCodeClass ownerClass = (VCCodeClass)targetClassElem;
TextPoint startFuncBody = targetFunc.StartPointOf[vsCMPart.vsCMPartBody, vsCMWhere.vsCMWhereDefinition];
TextPoint endFuncBody = targetFunc.EndPointOf[vsCMPart.vsCMPartBody, vsCMWhere.vsCMWhereDefinition];
EditPoint startPnt = startFuncBody.CreateEditPoint();
EditPoint endPnt = endFuncBody.CreateEditPoint();
startPnt.FindPattern("{", (int)vsFindOptions.vsFindOptionsBackwards);
endPnt.FindPattern("}");
if ((caretPnt.Line > startPnt.Line && caretPnt.Line < endPnt.Line) ||
(caretPnt.Line == startPnt.Line && caretPnt.LineCharOffset >= startPnt.LineCharOffset) ||
(caretPnt.Line == endPnt.Line && caretPnt.LineCharOffset <= endPnt.LineCharOffset))
{
// Oh, oh you're in the body, now.. (c)
int linePos = (caretPnt.Line == startPnt.Line ? startPnt.LineCharOffset + 1 : 1 /*0*/);
checkPnt = new CheckCPPoint(ownerClass, projName, activeDoc.Name, System.IO.Path.GetFullPath(activeDoc.FullName).ToLower(), caretPnt.Line, linePos);
return(checkPnt);
}
break;
}
return(checkPnt);
}
/**
* A convenience function to check if a function takes no arguments
* (CDT's DOM treats a function with no arguments differently from one
* with a single "void" argument).
*
* @param element the method handle to check.
*
* @return true if the function has no arguments; otherwise, false.
*/
private bool IsMethodParameterless(VCCodeFunction function)
{
if (function.Parameters.Count == 0)
{
return true;
}
else if (function.Parameters.Count > 1)
{
return false;
}
else
{
VCCodeParameter parameter =
(VCCodeParameter)function.Parameters.Item(1);
return (parameter.Type.AsString == "void");
}
}
//~ Constructor ......................................................
// ------------------------------------------------------
/// <summary>
/// Creates a new test case from the specified code model function.
/// </summary>
/// <param name="function">
/// The VC code model function object from which to create the test
/// case.
/// </param>
public TestCase(VCCodeFunction function)
{
this.function = function;
}
/**
* Checks a method inside a test suite class to determine if it
* is a valid test method (void return value, no arguments, name
* begins with "test"). If so, it is added to the suite's list of
* tests.
*
* @param element the method handle to be checked.
*/
private void CheckMethod(VCCodeFunction function)
{
string name = function.Name;
int lineNum = function.StartPoint.Line;
bool isStatic = function.IsShared;
if (name.StartsWith("Test") || name.StartsWith("test"))
{
if (function.Type.AsString == "void" &&
IsMethodParameterless(function))
{
testCases.Add(new TestCase(function));
}
}
else if (name == "createSuite")
{
if (isStatic &&
function.Type.AsString.IndexOf('*') >= 0 &&
IsMethodParameterless(function))
{
createLineNumber = lineNum;
}
}
else if (name == "destroySuite")
{
CodeElements parameters = function.Parameters;
if (parameters.Count == 1)
{
VCCodeParameter parameter =
(VCCodeParameter)parameters.Item(1);
if (isStatic &&
parameter.Type.AsString.IndexOf('*') >= 0 &&
function.Type.AsString == "void")
{
destroyLineNumber = lineNum;
}
}
}
}
//~ Constructor ......................................................
// ------------------------------------------------------
/// <summary>
/// Creates a new test case from the specified code model function.
/// </summary>
/// <param name="function">
/// The VC code model function object from which to create the test
/// case.
/// </param>
public TestCase(VCCodeFunction function)
{
this.function = function;
}
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
{
try
{
if (VsShellUtilities.IsInAutomationFunction(m_provider.ServiceProvider))
{
return(m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut));
}
// make a copy of this so we can look at it after forwarding some commands
uint commandID = nCmdID;
char typedChar = char.MinValue;
// make sure the input is a char before getting it
if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR)
{
typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn);
}
// check for the triple slash
if (typedChar == '!' && m_dte != null)
{
var currentILine = m_textView.TextSnapshot.GetLineFromPosition(
m_textView.Caret.Position.BufferPosition.Position);
int len = m_textView.Caret.Position.BufferPosition.Position - currentILine.Start.Position;
string currentLine = m_textView.TextSnapshot.GetText(currentILine.Start.Position, len);
string currentLineFull = currentILine.GetText();
if ((currentLine + typedChar).Trim() == "/*!")
{
// Calculate how many spaces
string spaces = currentLine.Replace(currentLine.TrimStart(), "");
TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection;
int oldLine = ts.ActivePoint.Line;
int oldOffset = ts.ActivePoint.LineCharOffset;
if (!currentLineFull.Contains("*/"))
{
ts.Insert("*/");
}
ts.LineDown();
ts.EndOfLine();
CodeElement codeElement = null;
FileCodeModel fcm = m_dte.ActiveDocument.ProjectItem.FileCodeModel;
if (fcm != null)
{
while (codeElement == null)
{
codeElement = fcm.CodeElementFromPoint(ts.ActivePoint, vsCMElement.vsCMElementFunction);
if (codeElement == null)
{
ts.LineDown();
}
}
}
var cls = codeElement as VCCodeClass;
var cls2 = codeElement as CodeClass;
var fnc = codeElement as VCCodeFunction;
var kind = codeElement.Kind;
if (codeElement != null && codeElement is CodeFunction)
{
VCCodeFunction function = codeElement as VCCodeFunction;
StringBuilder sb = new StringBuilder("!\r\n" + spaces + " * \r\n" + spaces + " * ");
foreach (CodeElement child in codeElement.Children)
{
CodeParameter parameter = child as CodeParameter;
if (parameter != null)
{
sb.AppendFormat("\r\n" + spaces + " * \\param {0}", parameter.Name);
}
}
if (function.Type.AsString != "void")
{
sb.AppendFormat("\r\n" + spaces + " * \\return ");
}
sb.AppendFormat("\r\n" + spaces + " ");
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.Insert(sb.ToString());
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.LineDown();
ts.EndOfLine();
return(VSConstants.S_OK);
}
else if (codeElement != null && codeElement is VCCodeClass)
{
VCCodeClass function = codeElement as VCCodeClass;
StringBuilder sb = new StringBuilder("!\r\n" + spaces + " * \r\n" + spaces + " * ");
foreach (CodeElement child in function.TemplateParameters)
{
CodeParameter parameter = child as CodeParameter;
if (parameter != null)
{
sb.AppendFormat("\r\n" + spaces + " * \\tparam {0}", parameter.Name);
}
}
sb.AppendFormat("\r\n" + spaces + " ");
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.Insert(sb.ToString());
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.LineDown();
ts.EndOfLine();
return(VSConstants.S_OK);
}
else
{
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.Insert("!\r\n" + spaces + " * \r\n" + spaces + " * \r\n" + spaces + " ");
ts.MoveToLineAndOffset(oldLine, oldOffset);
ts.LineDown();
ts.EndOfLine();
return(VSConstants.S_OK);
}
}
}
if (m_session != null && !m_session.IsDismissed)
{
// check for a commit character
if (nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN ||
nCmdID == (uint)VSConstants.VSStd2KCmdID.TAB)
{
// check for a selection
// if the selection is fully selected, commit the current session
if (m_session.SelectedCompletionSet.SelectionStatus.IsSelected)
{
string selectedCompletion = m_session.SelectedCompletionSet.SelectionStatus.Completion.DisplayText;
m_session.Commit();
// also, don't add the character to the buffer
return(VSConstants.S_OK);
}
else
{
// if there is no selection, dismiss the session
m_session.Dismiss();
}
}
}
else
{
if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN)
{
string currentLine = m_textView.TextSnapshot.GetLineFromPosition(
m_textView.Caret.Position.BufferPosition.Position).GetText();
if (currentLine.TrimStart().StartsWith("*"))
{
TextSelection ts = m_dte.ActiveDocument.Selection as TextSelection;
string spaces = currentLine.Replace(currentLine.TrimStart(), "");
ts.Insert("\r\n" + spaces + "* ");
return(VSConstants.S_OK);
}
}
}
// pass along the command so the char is added to the buffer
int retVal = m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
if (typedChar == '\\')
{
string currentLine = m_textView.TextSnapshot.GetLineFromPosition(
m_textView.Caret.Position.BufferPosition.Position).GetText();
if (currentLine.TrimStart().StartsWith("*"))
{
if (m_session == null || m_session.IsDismissed) // If there is no active session, bring up completion
{
if (this.TriggerCompletion())
{
m_session.SelectedCompletionSet.SelectBestMatch();
m_session.SelectedCompletionSet.Recalculate();
return(VSConstants.S_OK);
}
}
}
}
else if (
commandID == (uint)VSConstants.VSStd2KCmdID.BACKSPACE ||
commandID == (uint)VSConstants.VSStd2KCmdID.DELETE ||
char.IsLetter(typedChar))
{
if (m_session != null && !m_session.IsDismissed) // the completion session is already active, so just filter
{
m_session.SelectedCompletionSet.SelectBestMatch();
m_session.SelectedCompletionSet.Recalculate();
return(VSConstants.S_OK);
}
}
return(retVal);
}
catch
{
}
return(VSConstants.E_FAIL);
}
private TreeNode FindNodeForTestCase(object parent, VCCodeFunction function)
{
TreeNode suiteNode = FindNodeForTestSuite(parent);
if (suiteNode == null)
return null;
string testName = ((CodeElement2)function).Name;
foreach (TreeNode testNode in suiteNode.Nodes)
{
TestCase testCase = (TestCase)testNode.Tag;
if (testCase.Name == testName)
return testNode;
}
return null;
}
/**
* Checks a global function to determine if it is the main() function.
*
* @param element the function handle to be checked.
*/
private void CheckForMain(VCCodeFunction function)
{
if (function.Name == "main")
mainExists = true;
}
