public void GetBlockById_InvalidId_ThrowsException()
{
Method sampleMethod = TestHelper.GetSample <MethodGraph_ClassSample> ("DeclarationWithReturn");
IMethodGraph methodGraph = BuildMethodGraph(sampleMethod);
methodGraph.GetBasicBlockById(-1);
}
private void ParseSuccessors(int[] successorKeys, Dictionary <int, int> visits, IMethodGraph methodGraph, ISymbolTable adjustedContext)
{
foreach (int successorKey in successorKeys)
{
Dictionary <int, int> branchVisits = new Dictionary <int, int> (visits);
BasicBlock successor = methodGraph.GetBasicBlockById(successorKey);
Parse(methodGraph, adjustedContext, successor, branchVisits);
}
}
public void MethodGraph_TryCatchFinally_FinallyBlockIsParsed()
{
Method sampleMethod = TestHelper.GetSample <MethodGraph_ClassSample> ("TryCatchFinally");
TryNode outerTryNode = (TryNode)sampleMethod.Body.Statements[1];
Block finallyBlock = outerTryNode.Finally.Block;
int finallyBlockUniqueKey = finallyBlock.UniqueKey;
IMethodGraph methodGraph = BuildMethodGraph(sampleMethod);
BasicBlock finallyBasicBlock = methodGraph.GetBasicBlockById(finallyBlockUniqueKey);
Assert.That(finallyBasicBlock, Is.Not.Null);
}
public void MethodGraph_TryCatchFinally_CatchBlockIsParsed()
{
Method sampleMethod = TestHelper.GetSample <MethodGraph_ClassSample> ("TryCatchFinally");
TryNode outerTryNode = (TryNode)sampleMethod.Body.Statements[1];
TryNode innerTryNode = (TryNode)outerTryNode.Block.Statements[0];
CatchNode catchNode = innerTryNode.Catchers[0];
int catchBlockUniqueKey = catchNode.Block.UniqueKey;
IMethodGraph methodGraph = BuildMethodGraph(sampleMethod);
BasicBlock catchBasicBlock = methodGraph.GetBasicBlockById(catchBlockUniqueKey);
Assert.That(catchBasicBlock, Is.Not.Null);
}
public void GetBlockById_FirstBlockIdOfDeclarationWithReturnSample_ReturnsInitialBasicBlock()
{
Method sampleMethod = TestHelper.GetSample <MethodGraph_ClassSample> ("DeclarationWithReturn");
Block initialBlock = sampleMethod.Body.Statements[0] as Block;
if (initialBlock != null)
{
IMethodGraph methodGraph = BuildMethodGraph(sampleMethod);
BasicBlock initialBasicBlock = methodGraph.GetBasicBlockById(initialBlock.UniqueKey);
Assert.That(initialBasicBlock.Id, Is.EqualTo(initialBlock.UniqueKey));
}
else
{
Assert.Ignore("Bad Sample");
}
}
public void MethodGraph_DeclarationWithReturn_ReturnBlockHasNoSuccessors()
{
Method sampleMethod = TestHelper.GetSample <MethodGraph_ClassSample> ("DeclarationWithReturn");
Block returnBlock = sampleMethod.Body.Statements[1] as Block;
if (returnBlock != null)
{
IMethodGraph methodGraph = BuildMethodGraph(sampleMethod);
BasicBlock returnBasicBlock = methodGraph.GetBasicBlockById(returnBlock.UniqueKey);
Assert.That(returnBasicBlock.SuccessorKeys.Length, Is.EqualTo(0));
}
else
{
Assert.Ignore("Bad Sample");
}
}
public void MethodGraph_ForLoop_ReturnsCorrectReturnSuccessors()
{
Method sampleMethod = TestHelper.GetSample <MethodGraph_ClassSample> ("ForLoop");
Block returnBlock = sampleMethod.Body.Statements[4] as Block;
if (returnBlock != null)
{
IMethodGraph methodGraph = BuildMethodGraph(sampleMethod);
BasicBlock returnBasicBlock = methodGraph.GetBasicBlockById(returnBlock.UniqueKey);
Assert.That(returnBasicBlock.SuccessorKeys.Length, Is.EqualTo(0));
}
else
{
Assert.Ignore("Bad Sample");
}
}
public void MethodGraph_DeclarationWithReturn_ReturnsCorrectPostConditions()
{
Method sampleMethod = TestHelper.GetSample <MethodGraph_ClassSample> ("DeclarationWithReturn");
Block initialBlock = sampleMethod.Body.Statements[0] as Block;
if (initialBlock != null)
{
IMethodGraph methodGraph = BuildMethodGraph(sampleMethod);
BasicBlock initialBasicBlock = methodGraph.GetBasicBlockById(initialBlock.UniqueKey);
var postConditionFragmentType = initialBasicBlock.PostConditionSymbolTable.GetFragmentType("local$0");
Assert.That(postConditionFragmentType, Is.EqualTo(Fragment.CreateLiteral()));
}
else
{
Assert.Ignore("Bad Sample");
}
}
public void MethodGraph_IfStatementTrueBlockOnly_ReturnsCorrectReturnSuccessors()
{
TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>();
Method sampleMethod = TestHelper.GetSample <MethodGraph_ClassSample> ("IfStatementTrueBlockOnly", stringTypeNode);
Block returnBlock = sampleMethod.Body.Statements[3] as Block;
if (returnBlock != null)
{
IMethodGraph methodGraph = BuildMethodGraph(sampleMethod);
BasicBlock preReturnBasicBlock = methodGraph.GetBasicBlockById(returnBlock.UniqueKey);
Assert.That(preReturnBasicBlock.SuccessorKeys.Length, Is.EqualTo(0));
}
else
{
Assert.Ignore("Bad Sample");
}
}
public void MethodGraph_DeclarationWithReturn_ReturnBlockHasReturnFragmentPrecondition()
{
Method sampleMethod = TestHelper.GetSample <MethodGraph_ClassSample> ("DeclarationWithReturn");
Block returnBlock = sampleMethod.Body.Statements[1] as Block;
if (returnBlock != null)
{
IMethodGraph methodGraph = BuildMethodGraph(sampleMethod);
BasicBlock returnBasicBlock = methodGraph.GetBasicBlockById(returnBlock.UniqueKey);
var preConditionFragmentType = returnBasicBlock.PreConditions[0].Fragment;
Assert.That(preConditionFragmentType, Is.EqualTo(Fragment.CreateNamed("ReturnFragmentType")));
}
else
{
Assert.Ignore("Bad Sample");
}
}
public void MethodGraph_DeclarationWithReturn_ReturnsCorrectInitialBlockSuccessors()
{
Method sampleMethod = TestHelper.GetSample <MethodGraph_ClassSample> ("DeclarationWithReturn");
Block initialBlock = sampleMethod.Body.Statements[0] as Block;
Block returnBlock = sampleMethod.Body.Statements[1] as Block;
if (initialBlock != null && returnBlock != null)
{
IMethodGraph methodGraph = BuildMethodGraph(sampleMethod);
BasicBlock initialBasicBlock = methodGraph.GetBasicBlockById(initialBlock.UniqueKey);
bool initialBasicBlockConnectedWithReturn = initialBasicBlock.SuccessorKeys.Any(key => key == returnBlock.UniqueKey);
Assert.That(initialBasicBlockConnectedWithReturn, Is.True);
}
else
{
Assert.Ignore("Bad Sample");
}
}
public void MethodGraph_ValidReturnWithIf_ReturnsCorrectPostConditions()
{
TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>();
Method sampleMethod = TestHelper.GetSample <MethodGraph_ClassSample> ("ValidReturnWithIf", stringTypeNode);
Block preReturnBlock = sampleMethod.Body.Statements[2] as Block;
if (preReturnBlock != null)
{
IMethodGraph methodGraph = BuildMethodGraph(sampleMethod);
BasicBlock preReturnBasicBlock = methodGraph.GetBasicBlockById(preReturnBlock.UniqueKey);
var postConditionFragmentType = preReturnBasicBlock.PostConditionSymbolTable.GetFragmentType("local$1");
Assert.That(postConditionFragmentType, Is.EqualTo(Fragment.CreateEmpty()));
}
else
{
Assert.Ignore("Bad Sample");
}
}
public void MethodGraph_ForLoop_ReturnsCorrectPreReturnSuccessors()
{
Method sampleMethod = TestHelper.GetSample <MethodGraph_ClassSample> ("ForLoop");
Block preReturnBlock = sampleMethod.Body.Statements[3] as Block;
Block returnBlock = sampleMethod.Body.Statements[4] as Block;
if (preReturnBlock != null && returnBlock != null)
{
IMethodGraph methodGraph = BuildMethodGraph(sampleMethod);
BasicBlock preReturnBasicBlock = methodGraph.GetBasicBlockById(preReturnBlock.UniqueKey);
bool preReturnBasicBlockSuccessorsCorrect = preReturnBasicBlock.SuccessorKeys.Length == 1 &&
preReturnBasicBlock.SuccessorKeys[0] == returnBlock.UniqueKey;
Assert.That(preReturnBasicBlockSuccessorsCorrect, Is.True);
}
else
{
Assert.Ignore("Bad Sample");
}
}
public void MethodGraph_ForLoop_ReturnsCorrectInnerForSuccessors()
{
Method sampleMethod = TestHelper.GetSample <MethodGraph_ClassSample> ("ForLoop");
Block innerForBlock = sampleMethod.Body.Statements[1] as Block;
Block conditionBlock = sampleMethod.Body.Statements[2] as Block;
if (innerForBlock != null && conditionBlock != null)
{
IMethodGraph methodGraph = BuildMethodGraph(sampleMethod);
BasicBlock innerForBasicBlock = methodGraph.GetBasicBlockById(innerForBlock.UniqueKey);
bool innerForBasicBlockSuccessorsCorrect = innerForBasicBlock.SuccessorKeys.Length == 1 &&
innerForBasicBlock.SuccessorKeys[0] == conditionBlock.UniqueKey;
Assert.That(innerForBasicBlockSuccessorsCorrect, Is.True);
}
else
{
Assert.Ignore("Bad Sample");
}
}
public void MethodGraph_IfStatementTrueBlockOnly_ReturnsCorrectTrueBlockSuccessors()
{
TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>();
Method sampleMethod = TestHelper.GetSample <MethodGraph_ClassSample> ("IfStatementTrueBlockOnly", stringTypeNode);
Block trueBlock = sampleMethod.Body.Statements[1] as Block;
Block preReturnBlock = sampleMethod.Body.Statements[2] as Block;
if (preReturnBlock != null && trueBlock != null)
{
IMethodGraph methodGraph = BuildMethodGraph(sampleMethod);
BasicBlock trueBasicBlock = methodGraph.GetBasicBlockById(trueBlock.UniqueKey);
bool trueBasicBlockSuccessorsOk = trueBasicBlock.SuccessorKeys.Any(key => key == preReturnBlock.UniqueKey);
Assert.That(trueBasicBlockSuccessorsOk, Is.True);
}
else
{
Assert.Ignore("Bad Sample");
}
}
public void MethodGraph_FragmentRefParameterSafeReturn_AddsPreconditionToReturnBlock()
{
TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>();
Method sampleMethod = TestHelper.GetSample <MethodGraph_ClassSample> ("FragmentRefParameterSafeReturn", stringTypeNode.GetReferenceType());
Block returnBlock = sampleMethod.Body.Statements[2] as Block;
if (returnBlock != null)
{
IMethodGraph methodGraph = BuildMethodGraph(sampleMethod);
BasicBlock returnBasicBlock = methodGraph.GetBasicBlockById(returnBlock.UniqueKey);
string preConditionSymbolName = returnBasicBlock.PreConditions[0].Symbol;
var preConditionFragmentType = returnBasicBlock.PreConditions[0].Fragment;
bool correctPreCondition = preConditionSymbolName == "safe" && preConditionFragmentType == Fragment.CreateNamed("SqlFragment");
Assert.That(correctPreCondition, Is.True);
}
else
{
Assert.Ignore("Bad Sample");
}
}
public void Parse_SequencePreconditionsNotViolated_NoProblem()
{
List <AssignabilityPreCondition> preConditions = new List <AssignabilityPreCondition> {
new AssignabilityPreCondition("x", Fragment.CreateNamed("SqlFragment"))
};
SymbolTable postConditions = new SymbolTable(_blacklistManager);
List <int> successors = new List <int> {
1
};
BasicBlock initialNode = new BasicBlock(0, preConditions.ToArray(), postConditions, successors.ToArray(), c_EmptyAssignments);
preConditions = new List <AssignabilityPreCondition> {
new AssignabilityPreCondition("x", Fragment.CreateNamed("SqlFragment"))
};
postConditions = new SymbolTable(_blacklistManager);
successors = new List <int>();
BasicBlock terminatingNode = new BasicBlock(1, preConditions.ToArray(), postConditions, successors.ToArray(), c_EmptyAssignments);
using (_mocks.Record())
{
_methodGraph.IsEmpty();
LastCall.Return(false);
SetupResult.For(_methodGraph.InitialBlock)
.Return(initialNode);
SetupResult.For(_methodGraph.Blocks)
.Return(new BasicBlock[] { initialNode, terminatingNode });
_methodGraph.GetBasicBlockById(1);
LastCall.Return(terminatingNode);
_methodGraphBuilder.GetResult();
LastCall.Return(_methodGraph);
_parameterSymbolTableBuilder.GetResult();
LastCall.Return(_methodPreConditions);
}
ProblemCollection result = ParseGraph();
Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.False);
}
private void ParseSuccessors(int[] successorKeys, Dictionary<int, int> visits, IMethodGraph methodGraph, ISymbolTable adjustedContext)
{
foreach (int successorKey in successorKeys)
{
Dictionary<int, int> branchVisits = new Dictionary<int, int> (visits);
BasicBlock successor = methodGraph.GetBasicBlockById (successorKey);
Parse (methodGraph, adjustedContext, successor, branchVisits);
}
}