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 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()); }