public static void Throws <TException> (TestCode code, string message)
{
Count++;
TotalCount++;
bool failed = false;
try {
code();
failed = true;
} catch (Exception ex) {
if (!(ex.GetType() == typeof(TException)))
{
log.Text += string.Format(" Expected '{0}', got '{1}'. {2}\n", typeof(TException).FullName, ex.GetType().FullName, message);
Failures++;
TotalFailures++;
return;
}
}
if (failed)
{
log.Text += string.Format(" Expected '{0}', but got no exception. {1}\n", typeof(TException).FullName, message);
Failures++;
TotalFailures++;
}
}
/// <summary>
/// Checks whether specified code throws exception.
/// </summary>
public static void Throws(
TestCode action,
Type exceptionType = null)
{
bool throwed = false;
try
{
action();
}
catch (Exception exception)
{
if (exceptionType == null)
{
throwed = true;
}
else if (exception.GetType() == exceptionType)
{
throwed = true;
}
else
{
throw;
}
}
if (!throwed)
{
throw new AssertFailedException("Expected exception was not thrown.");
}
}
/// <summary>
/// Checks whether specified code throws exception.
/// </summary>
public static void Throws(
TestCode action,
Type exceptionType = null)
{
bool throwed = false;
try
{
action();
}
catch (Exception exception)
{
if (exceptionType == null)
{
throwed = true;
}
else if (exception.GetType() == exceptionType)
{
throwed = true;
}
else
{
throw;
}
}
if (!throwed)
throw new AssertFailedException("Expected exception was not thrown.");
}
public void GetTest()
{
if (TestCode.Text == "")
{
MessageBox.Show("Please Enter A Subject Code", "Error", MessageBoxButtons.OK, MessageBoxIcon.Information);
TestCode.Focus();
return;
}
try
{
var test = _testService.GetTestDetails(TestCode.Text);
if (test != null)
{
_stateService.SetTestId(test.Id);
this.Hide();
var questionPage = Program.CreateServiceProvider().GetRequiredService <QuestionPage>();
questionPage.ShowDialog();
}
else
{
MessageBox.Show("Wrong Passcode", "information!", MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
}
catch (SqlException exception)
{
MessageBox.Show(exception.Message, "information!", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
public List <int> GetLevelListFromCode()
{
string letters = "abcdefghijklmn";
int pos1 = 0;
var levels = new List <int>();
foreach (char ch in letters)
{
if (ch == 'a')
{
continue;
}
int pos2 = TestCode.IndexOf(ch);
if (pos2 > 0)
{
levels.Add(int.Parse(TestCode.Substring(pos1 + 1, pos2 - pos1 - 1)));
pos1 = pos2;
}
else
{
levels.Add(int.Parse(TestCode.Substring(pos1 + 1)));
break;
}
}
return(levels);
}
public async Task VerifyRefactoringAsync(
string source,
string sourceData,
string expectedData,
IEnumerable <string> additionalFiles = null,
string equivalenceKey = null,
TestOptions options = null,
CancellationToken cancellationToken = default)
{
var code = TestCode.Parse(source, sourceData, expectedData);
Debug.Assert(code.Spans.Length > 0);
var expected = ExpectedTestState.Parse(code.ExpectedValue);
var data = new RefactoringTestData(
code.Value,
code.Spans.OrderByDescending(f => f.Start).ToImmutableArray(),
AdditionalFile.CreateRange(additionalFiles),
equivalenceKey: equivalenceKey);
await VerifyRefactoringAsync(
data,
expected,
options,
cancellationToken : cancellationToken);
}
//-----------------------< Test Stub >--------------------------------
#if (Test_TestCode2)
static void Main(String[] args)
{
int[] num = { 1, 2, 3, 4 };
int sum = TestCode.addNumbers(num);
Console.Write("\n Sum of Numbers" + sum);
}
public void AnalyzeRegionControlFlow()
{
TestCode testCode = new TestCode(@"
class C {
public void F()
{
goto L1; // 1
/*start*/
L1: ;
if (false) return;
/*end*/
goto L1; // 2
}
}");
StatementSyntax firstStatement, lastStatement;
testCode.GetStatementsBetweenMarkers(out firstStatement, out lastStatement);
ControlFlowAnalysis regionControlFlowAnalysis =
testCode.SemanticModel.AnalyzeControlFlow(firstStatement, lastStatement);
Assert.AreEqual(1, regionControlFlowAnalysis.EntryPoints.Count());
Assert.AreEqual(1, regionControlFlowAnalysis.ExitPoints.Count());
Assert.IsTrue(regionControlFlowAnalysis.EndPointIsReachable);
BlockSyntax methodBody = testCode.SyntaxTree
.GetRoot()
.DescendantNodes()
.OfType<MethodDeclarationSyntax>()
.First()
.Body;
regionControlFlowAnalysis = testCode.SemanticModel.AnalyzeControlFlow(methodBody, methodBody);
Assert.IsFalse(regionControlFlowAnalysis.EndPointIsReachable);
}
void Hiding()
{
mon = transform.GetComponent <MonsterStatus>();
td = GetComponent <TestCode>();
td.spd = 10f;
// Debug.Log("hiding");
float distance = Vector3.Distance(td.objEndCube.transform.position, transform.position);// target과 나의 distance 를 잡아준다 .
if (distance > mon.monsterrad + 3f)
{
transform.LookAt(td.objEndCube.transform.position);
SetState(State.Hiding);
td.enabled = true;
td.objEndCube = HPoints[hidingpointindex];
td.objStartCube = monster;
// StopAllCoroutines();
}
else
{
td.enabled = false;
Debug.Log("transfer");
StartCoroutine("TransfertoSleeping", 0.5f);
}
}
public void AnalyzeRegionControlFlow()
{
TestCode testCode = new TestCode(@"
class C {
public void F()
{
goto L1; // 1
/*start*/
L1: ;
if (false) return;
/*end*/
goto L1; // 2
}
}");
StatementSyntax firstStatement, lastStatement;
testCode.GetStatementsBetweenMarkers(out firstStatement, out lastStatement);
ControlFlowAnalysis regionControlFlowAnalysis =
testCode.SemanticModel.AnalyzeControlFlow(firstStatement, lastStatement);
Assert.AreEqual(1, regionControlFlowAnalysis.EntryPoints.Count());
Assert.AreEqual(1, regionControlFlowAnalysis.ExitPoints.Count());
Assert.IsTrue(regionControlFlowAnalysis.EndPointIsReachable);
BlockSyntax methodBody = testCode.SyntaxTree
.GetRoot()
.DescendantNodes()
.OfType <MethodDeclarationSyntax>()
.First()
.Body;
regionControlFlowAnalysis = testCode.SemanticModel.AnalyzeControlFlow(methodBody, methodBody);
Assert.IsFalse(regionControlFlowAnalysis.EndPointIsReachable);
}
public void SymbolDisplayFormatTest()
{
TestCode testCode = new TestCode(@"
class C1<T> { }
class C2 {
public static TSource M<TSource>(this C1<TSource> source, // comment here
int index) {} }");
SymbolDisplayFormat format = new SymbolDisplayFormat(
extensionMethodStyle: SymbolDisplayExtensionMethodStyle.StaticMethod,
genericsOptions:
SymbolDisplayGenericsOptions.IncludeTypeParameters |
SymbolDisplayGenericsOptions.IncludeVariance,
memberOptions:
SymbolDisplayMemberOptions.IncludeParameters |
SymbolDisplayMemberOptions.IncludeModifiers |
SymbolDisplayMemberOptions.IncludeAccessibility |
SymbolDisplayMemberOptions.IncludeType |
SymbolDisplayMemberOptions.IncludeContainingType,
parameterOptions:
SymbolDisplayParameterOptions.IncludeExtensionThis |
SymbolDisplayParameterOptions.IncludeType |
SymbolDisplayParameterOptions.IncludeName |
SymbolDisplayParameterOptions.IncludeDefaultValue,
miscellaneousOptions: SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
var symbol = testCode.Compilation
.SourceModule
.GlobalNamespace
.GetTypeMembers("C2")[0]
.GetMembers("M")[0];
Assert.AreEqual("public static TSource C2.M<TSource>(this C1<TSource> source, int index)", symbol.ToDisplayString(format));
}
public static void Throws(TestCode code, Type expected_exception, Type expected_inner_exception, string message)
{
bool failed = false;
try {
code();
failed = true;
}
catch (Exception ex) {
if (!(ex.GetType() == expected_exception))
{
throw new AssertionException(string.Format("Expected '{0}', got '{1}'. {2}", expected_exception.FullName, ex.GetType().FullName, message));
}
//System.Diagnostics.Debug.WriteLine (ex.ToString ());
if (expected_inner_exception != null)
{
// we only check if the inner exception was supplied
if (ex.InnerException.GetType() != expected_inner_exception)
{
throw new AssertionException(string.Format("Expected InnerException '{0}', got '{1}'. {2}", expected_inner_exception.FullName, ex.InnerException.GetType().FullName, message));
}
}
}
if (failed)
{
throw new AssertionException(string.Format("Expected '{0}', but got no exception. {1}", expected_exception.FullName, message));
}
}
private void Update()
{
if (this.gameObject.activeSelf == true)
{
test = FindObjectOfType <TestCode>();
if (Input.GetKeyDown(KeyCode.Return))
{
theDM.prom = false;
theDM.StopAllCoroutines();
theDM.ExitDialogue();
disappearInput();
if (test.answer == text.text)
{
theDM.ShowDialogue(test.answerD);
if (test.additem == true)
{
test.ResultItem();
}
test.Yes = true;
text.text = "";
test.SetBool();
}
else
{
theDM.ShowDialogue(test.noanswerD);
}
}
}
}
//----< test method is where all the testing gets done >---------
public bool test()
{
logs.Append("entering into TestDriver1-----> test() method");
TestCode.annunciator("first being tested");
logs.Append("\n Execution of Test Code from test Driver");
logs.Append("\n Result of test case" + true);
return(true);
}
public static void DoesNotThrow(TestCode code, string message, params object [] parameters)
{
try {
code();
} catch (Exception ex) {
Assert.Fail("Expected no exception but got: {0}. {1}", ex.GetType().Name, string.Format(message, parameters));
}
}
private static async Task <MirrorSharpTestDriver> NewTestDriverAsync(TestCode code, string optimize = Optimize.Release)
{
var driver = TestEnvironment.NewDriver();
await driver.SendSetOptionsAsync(code.SourceLanguageName, code.TargetName, optimize);
driver.SetText(code.Original);
return(driver);
}
//[InlineData("Output.Inspect.Heap.Null.cs2output"/*, true*/)]
public async Task InspectHeap_ProducesExpectedOutput(string resourceName /*, bool allowExceptions = false*/)
{
var code = TestCode.FromResource(resourceName);
var output = await ContainerTestDriver.CompileAndExecuteAsync(code.Original);
code.AssertIsExpected(RemoveFlowJson(output), _testOutputHelper);
}
public async Task InspectMemoryGraph_ProducesExpectedOutput(string resourceName)
{
var code = TestCode.FromResource(resourceName);
var output = await ContainerTestDriver.CompileAndExecuteAsync(code.Original);
code.AssertIsExpected(RemoveFlowJson(output), _testOutputHelper);
}
public static void Main()
{
TestCode.Output();
for (; ;)
{
Thread.Sleep(10000);
}
}
public void TestServicePointManager(string code, bool expectedResult)
{
var testCode = new TestCode(DefaultUsing + code, NetReference, NetSecurityReference, CertReference);
var syntax = GetServicePointManagerSyntax(testCode);
var result = _analyzer.IsVulnerable(testCode.SemanticModel, syntax);
Assert.AreEqual(result, expectedResult);
}
public async Task SlowUpdate_IncludesInspectHeapInOutput(string resourceName, bool allowExceptions = false)
{
var code = TestCode.FromResource("Execution." + resourceName);
var driver = await NewTestDriverAsync(code.Original);
var result = await driver.SendSlowUpdateAsync <ExecutionResultData>();
AssertIsSuccess(result, allowRuntimeException: allowExceptions);
code.AssertIsExpected(result.ExtensionResult?.GetOutputAsString(), _testOutputHelper);
}
public async Task SlowUpdate_ReturnsExpectedResult_ForAst(string resourceName) {
var data = TestCode.FromResource(resourceName);
var driver = await NewTestDriverAsync(data);
var result = await driver.SendSlowUpdateAsync<JArray>();
var json = result.ExtensionResult?.ToString();
data.AssertIsExpected(json, _output);
}
public void TestResponseRedirect(string code, bool expectedResult)
{
var testCode = new TestCode(DefaultUsing + code, PageReference);
var syntax = GetRedirectSyntax(testCode);
var result = _analyzer.IsVulnerable(testCode.SemanticModel, syntax);
Assert.AreEqual(result, expectedResult);
}
public void TestFileStreamMapPath(string code, bool expectedResult)
{
var testCode = new TestCode(DefaultUsing + "using System.Web;" + code, IOReference, WebReference);
var syntax = GetFileStreamSyntax(testCode);
var result = _analyzer.IsVulnerable(testCode.SemanticModel, syntax);
Assert.AreEqual(result, expectedResult);
}
public void TestCanSuppress(string code, bool expectedResult)
{
var testCode = new TestCode(DefaultUsing + code);
var rightSyntax = GetRightExpressionSyntax(testCode.SyntaxTree);
var result = _analyzer.CanSuppress(testCode.SemanticModel, rightSyntax);
Assert.AreEqual(result, expectedResult);
}
public void TestCanSuppressSafeExpression(string code, bool expectedResult)
{
var testCode = new TestCode(DefaultUsing + "using Microsoft.Security.Application;" + code, AntiXssEncoder);
var rightSyntax = GetRightExpressionSyntax(testCode.SyntaxTree);
var result = _analyzer.CanSuppress(testCode.SemanticModel, rightSyntax);
Assert.AreEqual(result, expectedResult);
}
public void TestCtor(string code, bool expectedResult)
{
var testCode = new TestCode(DefaultUsing + code, DirectoryServicesReferences, AntiXssEncoder);
var syntax = GetSyntax(testCode);
var result = _analyzer.IsVulnerable(testCode.SemanticModel, syntax);
Assert.AreEqual(expectedResult, result);
}
public async Task SlowUpdate_IncludesInspectMemoryGraphInOutput(string resourceName)
{
var code = TestCode.FromResource("Execution." + resourceName);
var driver = await NewTestDriverAsync(code.Original);
var result = await SendSlowUpdateWithRetryOnMovedObjectsAsync(driver);
AssertIsSuccess(result);
code.AssertIsExpected(result.ExtensionResult?.GetOutputAsString(), _testOutputHelper);
}
public void TestFileOpenText(string code, bool expectedResult)
{
var testCode = new TestCode(DefaultUsing + code, IOReference);
var syntax = GetFileSyntax(testCode, "OpenText");
var result = _analyzer.IsVulnerable(testCode.SemanticModel, syntax);
Assert.AreEqual(result, expectedResult);
}
//TODO: assigned via local var thru ctor, cmdText or obj init
//TODO: method supplies cmdTxt to ctor, cmText or obj init
public void TestExecuteReader(string code, bool expectedResult)
{
var testCode = new TestCode(DefaultUsing + code, SqlDataReference, LinqReference);
var syntax = GetSyntax(testCode, "ExecuteReader");
var result = _analyzer.IsVulnerable(testCode.SemanticModel, syntax);
Assert.AreEqual(result, expectedResult);
}
public void BindNameToSymbol()
{
TestCode testCode = new TestCode("using System;");
CompilationUnitSyntax compilationUnit = testCode.SyntaxTree.GetRoot() as CompilationUnitSyntax;
NameSyntax node = compilationUnit.Usings[0].Name;
SymbolInfo semanticInfo = testCode.SemanticModel.GetSymbolInfo(node);
INamespaceSymbol namespaceSymbol = semanticInfo.Symbol as INamespaceSymbol;
Assert.Contains(namespaceSymbol.GetNamespaceMembers(), symbol => symbol.Name == "Collections");
}
public void TestExecuteCommand(string code, bool expectedResult)
{
var testCode = new TestCode(DefaultUsing + MockDbContext + code, DataReference, LinqReference,
DataLinqReference);
var syntax = GetExecuteQuerySyntax(testCode, "ExecuteCommand");
var result = _analyzer.IsVulnerable(testCode.SemanticModel, syntax);
Assert.AreEqual(expectedResult, result);
}
public void BindNameToSymbol()
{
TestCode testCode = new TestCode("using System;");
CompilationUnitSyntax compilationUnit = testCode.SyntaxTree.GetRoot() as CompilationUnitSyntax;
NameSyntax node = compilationUnit.Usings[0].Name;
var semanticInfo = testCode.SemanticModel.GetSymbolInfo(node);
var namespaceSymbol = semanticInfo.Symbol as INamespaceSymbol;
Assert.IsTrue(namespaceSymbol.GetNamespaceMembers().Any(
symbol => symbol.Name == "Collections"));
}
public void GetDeclaredSymbol()
{
TestCode testCode = new TestCode("namespace Acme { internal class C$lass1 { } }");
var symbol = testCode.SemanticModel.GetDeclaredSymbol((TypeDeclarationSyntax)testCode.SyntaxNode);
Assert.AreEqual(true, symbol.CanBeReferencedByName);
Assert.AreEqual("Acme", symbol.ContainingNamespace.Name);
Assert.AreEqual(Accessibility.Internal, symbol.DeclaredAccessibility);
Assert.AreEqual(SymbolKind.NamedType, symbol.Kind);
Assert.AreEqual("Class1", symbol.Name);
Assert.AreEqual("Acme.Class1", symbol.ToDisplayString());
Assert.AreEqual("Acme.Class1", symbol.ToString());
}
/// <summary>
/// Checks whether specified code throws exception.
/// </summary>
public static void Throws(TestCode action)
{
bool throwed = false;
try
{
action();
}
catch
{
throwed = true;
}
Assert.IsTrue(throwed);
}
public void GetSymbolXmlDocComments()
{
TestCode testCode = new TestCode(@"
/// <summary>
/// This is a test class!
/// </summary>
class C$lass1 { }");
var symbol = testCode.SemanticModel.GetDeclaredSymbol((TypeDeclarationSyntax)testCode.SyntaxNode);
string actualXml = symbol.GetDocumentationCommentXml();
string expectedXml =
@"<member name=""T:Class1"">
<summary>
This is a test class!
</summary>
</member>
";
Assert.AreEqual(expectedXml, actualXml);
}
public void GetExpressionType()
{
TestCode testCode = new TestCode(@"class Program
{
public static void Method()
{
var local = new Program().ToString() + string.Empty;
}
}");
TypeSyntax varNode = testCode.SyntaxTree.GetRoot()
.DescendantNodes()
.OfType<LocalDeclarationStatementSyntax>()
.First()
.Declaration
.Type;
var semanticInfo = testCode.SemanticModel.GetTypeInfo(varNode);
Assert.AreEqual("String", semanticInfo.Type.Name);
}
public void AnalyzeRegionDataFlow()
{
TestCode testCode = new TestCode(@"
class C {
public void F(int x)
{
int a;
/*start*/
int b;
int x, y = 1;
{ var z = ""a""; }
/*end*/
int c;
}
}");
StatementSyntax firstStatement, lastStatement;
testCode.GetStatementsBetweenMarkers(out firstStatement, out lastStatement);
DataFlowAnalysis regionDataFlowAnalysis = testCode.SemanticModel.AnalyzeDataFlow(firstStatement, lastStatement);
Assert.AreEqual("b,x,y,z", string.Join(",", regionDataFlowAnalysis
.VariablesDeclared
.Select(symbol => symbol.Name)));
}
public void GetSymbolXmlDocComments()
{
TestCode testCode = new TestCode(@"
/// <summary>
/// This is a test class!
/// </summary>
class C$lass1 { }");
Symbol symbol = testCode.SemanticModel.GetDeclaredSymbol((TypeDeclarationSyntax)testCode.SyntaxNode);
DocumentationComment docComment = symbol.GetDocumentationComment();
Assert.AreEqual("This is a test class!", docComment.SummaryTextOpt);
}
public void SymbolDisplayFormatTest()
{
TestCode testCode = new TestCode(@"
class C1<T> { }
class C2 {
public static TSource M<TSource>(this C1<TSource> source, // comment here
int index) {} }");
SymbolDisplayFormat format = new SymbolDisplayFormat(
extensionMethodStyle: SymbolDisplayExtensionMethodStyle.StaticMethod,
genericsOptions:
SymbolDisplayGenericsOptions.IncludeTypeParameters |
SymbolDisplayGenericsOptions.IncludeVariance,
memberOptions:
SymbolDisplayMemberOptions.IncludeParameters |
SymbolDisplayMemberOptions.IncludeModifiers |
SymbolDisplayMemberOptions.IncludeAccessibility |
SymbolDisplayMemberOptions.IncludeType |
SymbolDisplayMemberOptions.IncludeContainingType,
parameterOptions:
SymbolDisplayParameterOptions.IncludeExtensionThis |
SymbolDisplayParameterOptions.IncludeType |
SymbolDisplayParameterOptions.IncludeName |
SymbolDisplayParameterOptions.IncludeDefaultValue,
miscellaneousOptions: SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
var symbol = testCode.Compilation
.SourceModule
.GlobalNamespace
.GetTypeMembers("C2")[0]
.GetMembers("M")[0];
Assert.AreEqual("public static TSource C2.M<TSource>(this C1<TSource> source, int index)", symbol.ToDisplayString(format));
}
public void FailedOverloadResolution()
{
TestCode testCode = new TestCode(@"
class Program
{
static void Main(string[] args)
{
int i = 8;
int j = i + q;
X$.f(""hello"");
}
}
class X
{
public static void f() { }
public static void f(int i) { }
}
");
var typeInfo = testCode.SemanticModel.GetTypeInfo((ExpressionSyntax)testCode.SyntaxNode);
var semanticInfo = testCode.SemanticModel.GetSymbolInfo((ExpressionSyntax)testCode.SyntaxNode);
Assert.IsNull(typeInfo.Type);
Assert.IsNull(typeInfo.ConvertedType);
Assert.IsNull(semanticInfo.Symbol);
Assert.AreEqual(CandidateReason.OverloadResolutionFailure, semanticInfo.CandidateReason);
Assert.AreEqual(2, semanticInfo.CandidateSymbols.Length);
var sortedCandidates = semanticInfo.CandidateSymbols.AsEnumerable().OrderBy(s => s.ToDisplayString()).ToArray();
Assert.AreEqual("X.f()", sortedCandidates[0].ToDisplayString());
Assert.AreEqual(SymbolKind.Method, sortedCandidates[0].Kind);
Assert.AreEqual("X.f(int)", sortedCandidates[1].ToDisplayString());
Assert.AreEqual(SymbolKind.Method, sortedCandidates[1].Kind);
var memberGroup = testCode.SemanticModel.GetMemberGroup((ExpressionSyntax)testCode.SyntaxNode);
Assert.AreEqual(2, memberGroup.Length);
var sortedMemberGroup = memberGroup.AsEnumerable().OrderBy(s => s.ToDisplayString()).ToArray();
Assert.AreEqual("X.f()", sortedMemberGroup[0].ToDisplayString());
Assert.AreEqual("X.f(int)", sortedMemberGroup[1].ToDisplayString());
}
