Skip to content

R
roslyn

lwm1986 / roslyn
与 Fork 源项目一致

从无法访问的项目Fork

通知 1
Star 0
Fork 0
R
roslyn

体验新版 GitCode，发现更多精彩内容 >>

提交 41432017 编写于 作者: T Tomas Matousek
浏览文件
操作

Add tests

上级 a70075f5
隐藏空白更改
内联 并排
Showing with 897 addition and 33 deletion
src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
浏览文件 @ 41432017
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections.Immutable;
using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
using Microsoft.CodeAnalysis.Emit;
......@@ -2114,6 +2115,394 @@ static int TestMain()
Assert.True(false);
}
[Fact]
public void ExcludeFromCodeCoverageAttribute_Method()
{
string source = @"
using System;
using System.Diagnostics.CodeAnalysis;
class C
{
[ExcludeFromCodeCoverage]
void M1() { Console.WriteLine(1); }
void M2() { Console.WriteLine(1); }
}
";
var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
AssertNotInstrumented(verifier, "C.M1");
AssertInstrumented(verifier, "C.M2");
}
[Fact]
public void ExcludeFromCodeCoverageAttribute_Ctor()
{
string source = @"
using System;
using System.Diagnostics.CodeAnalysis;
class C
{
int a = 1;
[ExcludeFromCodeCoverage]
public C() { Console.WriteLine(3); }
}
";
var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
AssertNotInstrumented(verifier, "C..ctor");
}
[Fact]
public void ExcludeFromCodeCoverageAttribute_Cctor()
{
string source = @"
using System;
using System.Diagnostics.CodeAnalysis;
class C
{
static int a = 1;
[ExcludeFromCodeCoverage]
static C() { Console.WriteLine(3); }
}
";
var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
AssertNotInstrumented(verifier, "C..cctor");
}
[Fact]
public void ExcludeFromCodeCoverageAttribute_LocalFunctionsAndLambdas_InMethod()
{
string source = @"
using System;
using System.Diagnostics.CodeAnalysis;
class C
{
[ExcludeFromCodeCoverage]
static void M1() { L1(); void L1() { new Action(() => { Console.WriteLine(1); }).Invoke(); } }
static void M2() { L2(); void L2() { new Action(() => { Console.WriteLine(2); }).Invoke(); } }
}
";
var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
AssertNotInstrumented(verifier, "C.M1");
AssertNotInstrumented(verifier, "C.<M1>g__L10_0");
AssertNotInstrumented(verifier, "C.<>c.<M1>b__0_1");
AssertInstrumented(verifier, "C.M2");
AssertInstrumented(verifier, "C.<>c__DisplayClass1_0.<M2>g__L20"); // M2:L2
AssertInstrumented(verifier, "C.<>c__DisplayClass1_0.<M2>b__1"); // M2:L2 lambda
}
[Fact]
public void ExcludeFromCodeCoverageAttribute_LocalFunctionsAndLambdas_InInitializers()
{
string source = @"
using System;
using System.Diagnostics.CodeAnalysis;
class C
{
Action IF = new Action(() => { Console.WriteLine(1); });
Action IP { get; } = new Action(() => { Console.WriteLine(2); });
static Action SF = new Action(() => { Console.WriteLine(3); });
static Action SP { get; } = new Action(() => { Console.WriteLine(4); });
[ExcludeFromCodeCoverage]
C() {}
static C() {}
}
";
var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
AssertNotInstrumented(verifier, "C..ctor");
AssertNotInstrumented(verifier, "C.<>c.<.ctor>b__8_0");
AssertNotInstrumented(verifier, "C.<>c.<.ctor>b__8_1");
AssertInstrumented(verifier, "C..cctor");
AssertInstrumented(verifier, "C.<>c__DisplayClass9_0.<.cctor>b__0");
AssertInstrumented(verifier, "C.<>c__DisplayClass9_0.<.cctor>b__1");
}
[Fact]
public void ExcludeFromCodeCoverageAttribute_LocalFunctionsAndLambdas_InAccessors()
{
string source = @"
using System;
using System.Diagnostics.CodeAnalysis;
class C
{
[ExcludeFromCodeCoverage]
int P1
{
get { L1(); void L1() { Console.WriteLine(1); } return 1; }
set { L2(); void L2() { Console.WriteLine(2); } }
}
int P2
{
get { L3(); void L3() { Console.WriteLine(3); } return 3; }
set { L4(); void L4() { Console.WriteLine(4); } }
}
}
";
var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
AssertNotInstrumented(verifier, "C.P1.get");
AssertNotInstrumented(verifier, "C.P1.set");
AssertNotInstrumented(verifier, "C.<get_P1>g__L11_0");
AssertNotInstrumented(verifier, "C.<set_P1>g__L22_0");
AssertInstrumented(verifier, "C.P2.get");
AssertInstrumented(verifier, "C.P2.set");
AssertInstrumented(verifier, "C.<get_P2>g__L34_0");
AssertInstrumented(verifier, "C.<set_P2>g__L45_0");
}
[Fact]
public void ExcludeFromCodeCoverageAttribute_Type()
{
string source = @"
using System;
using System.Diagnostics.CodeAnalysis;
[ExcludeFromCodeCoverage]
class C
{
int x = 1;
static C() { }
void M1() { Console.WriteLine(1); }
int P { get => 1; set { } }
event Action E { add { } remove { } }
}
class D
{
int x = 1;
static D() { }
void M1() { Console.WriteLine(1); }
int P { get => 1; set { } }
event Action E { add { } remove { } }
}
";
var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
AssertNotInstrumented(verifier, "C..ctor");
AssertNotInstrumented(verifier, "C..cctor");
AssertNotInstrumented(verifier, "C.M1");
AssertNotInstrumented(verifier, "C.P.get");
AssertNotInstrumented(verifier, "C.P.set");
AssertNotInstrumented(verifier, "C.E.add");
AssertNotInstrumented(verifier, "C.E.remove");
AssertInstrumented(verifier, "D..ctor");
AssertInstrumented(verifier, "D..cctor");
AssertInstrumented(verifier, "D.M1");
AssertInstrumented(verifier, "D.P.get");
AssertInstrumented(verifier, "D.P.set");
AssertInstrumented(verifier, "D.E.add");
AssertInstrumented(verifier, "D.E.remove");
}
[Fact]
public void ExcludeFromCodeCoverageAttribute_NestedType()
{
string source = @"
using System;
using System.Diagnostics.CodeAnalysis;
class A
{
class B1
{
[ExcludeFromCodeCoverage]
class C
{
void M1() { Console.WriteLine(1); }
}
void M2() { Console.WriteLine(2); }
}
[ExcludeFromCodeCoverage]
partial class B2
{
partial class C1
{
void M3() { Console.WriteLine(3); }
}
class C2
{
void M4() { Console.WriteLine(4); }
}
void M5() { Console.WriteLine(5); }
}
partial class B2
{
[ExcludeFromCodeCoverage]
partial class C1
{
void M6() { Console.WriteLine(6); }
}
void M7() { Console.WriteLine(7); }
}
void M8() { Console.WriteLine(8); }
}
";
var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
AssertNotInstrumented(verifier, "A.B1.C.M1");
AssertInstrumented(verifier, "A.B1.M2");
AssertNotInstrumented(verifier, "A.B2.C1.M3");
AssertNotInstrumented(verifier, "A.B2.C2.M4");
AssertNotInstrumented(verifier, "A.B2.C1.M6");
AssertNotInstrumented(verifier, "A.B2.M7");
AssertInstrumented(verifier, "A.M8");
}
[Fact]
public void ExcludeFromCodeCoverageAttribute_Accessors()
{
string source = @"
using System;
using System.Diagnostics.CodeAnalysis;
class C
{
[ExcludeFromCodeCoverage]
int P1 { get => 1; set {} }
[ExcludeFromCodeCoverage]
event Action E1 { add { } remove { } }
int P2 { get => 1; set {} }
event Action E2 { add { } remove { } }
}
";
var verifier = CompileAndVerify(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
AssertNotInstrumented(verifier, "C.P1.get");
AssertNotInstrumented(verifier, "C.P1.set");
AssertNotInstrumented(verifier, "C.E1.add");
AssertNotInstrumented(verifier, "C.E1.remove");
AssertInstrumented(verifier, "C.P2.get");
AssertInstrumented(verifier, "C.P2.set");
AssertInstrumented(verifier, "C.E2.add");
AssertInstrumented(verifier, "C.E2.remove");
}
[Fact]
public void ExcludeFromCodeCoverageAttribute_CustomDefinition_Good()
{
string source = @"
using System;
using System.Diagnostics.CodeAnalysis;
namespace System.Diagnostics.CodeAnalysis
{
[AttributeUsage(AttributeTargets.Class)]
public sealed class ExcludeFromCodeCoverageAttribute : Attribute
{
public ExcludeFromCodeCoverageAttribute() {}
}
}
[ExcludeFromCodeCoverage]
class C
{
void M() {}
}
class D
{
void M() {}
}
";
var c = CreateCompilationWithMscorlib(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
c.VerifyDiagnostics();
var verifier = CompileAndVerify(c, emitOptions: EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
c.VerifyEmitDiagnostics();
AssertNotInstrumented(verifier, "C.M");
AssertInstrumented(verifier, "D.M");
}
[Fact]
public void ExcludeFromCodeCoverageAttribute_CustomDefinition_Bad()
{
string source = @"
using System;
using System.Diagnostics.CodeAnalysis;
namespace System.Diagnostics.CodeAnalysis
{
[AttributeUsage(AttributeTargets.Class)]
public sealed class ExcludeFromCodeCoverageAttribute : Attribute
{
public ExcludeFromCodeCoverageAttribute(int x) {}
}
}
[ExcludeFromCodeCoverage(1)]
class C
{
void M() {}
}
class D
{
void M() {}
}
";
var c = CreateCompilationWithMscorlib(source + InstrumentationHelperSource, options: TestOptions.ReleaseDll);
c.VerifyDiagnostics();
var verifier = CompileAndVerify(c, emitOptions: EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
c.VerifyEmitDiagnostics();
AssertInstrumented(verifier, "C.M");
AssertInstrumented(verifier, "D.M");
}
private static void AssertNotInstrumented(CompilationVerifier verifier, string qualifiedMethodName)
=> AssertInstrumented(verifier, qualifiedMethodName, expected: false);
private static void AssertInstrumented(CompilationVerifier verifier, string qualifiedMethodName, bool expected = true)
{
string il = verifier.VisualizeIL(qualifiedMethodName);
// Tests using this helper are constructed such that instrumented methods contain a call to CreatePayload,
// lambdas a reference to payload bool array.
bool instrumented = il.Contains("CreatePayload") || il.Contains("bool[]");
Assert.True(expected == instrumented, $"Method '{qualifiedMethodName}' should {(expected ? "be" : "not be")} instrumented. Actual IL:{Environment.NewLine}{il}");
}
private CompilationVerifier CompileAndVerify(string source, string expectedOutput = null, CompilationOptions options = null)
{
return base.CompileAndVerify(source, expectedOutput: expectedOutput, additionalRefs: s_refs, options: (options ?? TestOptions.ReleaseExe).WithDeterministic(true), emitOptions: EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
......
src/Compilers/VisualBasic/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.vb
浏览文件 @ 41432017
' Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
Imports System
Imports System.Collections.Immutable
Imports System.Linq
Imports System.Reflection.PortableExecutable
Imports System.Xml.Linq
Imports Microsoft.CodeAnalysis.Emit
Imports Microsoft.CodeAnalysis.Test.Utilities
Imports Microsoft.CodeAnalysis.VisualBasic
Imports Microsoft.CodeAnalysis.VisualBasic.UnitTests
Imports Roslyn.Test.Utilities
Imports Xunit
Namespace Microsoft.CodeAnalysis.VisualBasic.DynamicAnalysis.UnitTests
Public Class DynamicInstrumentationTests
Inherits BasicTestBase
ReadOnly InstrumentationHelperSource As XElement = <file name="c.vb">
<![CDATA[
Const InstrumentationHelperSourceStr As String = "
Namespace Microsoft.CodeAnalysis.Runtime
Public Class Instrumentation
......@@ -44,15 +37,15 @@ Namespace Microsoft.CodeAnalysis.Runtime
End Function
Public Shared Sub FlushPayload()
System.Console.WriteLine("Flushing")
System.Console.WriteLine(""Flushing"")
If _payloads Is Nothing Then
Return
End If
For i As Integer = 0 To _payloads.Length - 1
Dim payload As Boolean() = _payloads(i)
if payload IsNot Nothing
System.Console.WriteLine("Method " & i.ToString())
System.Console.WriteLine("File " & _fileIndices(i).ToString())
System.Console.WriteLine(""Method "" & i.ToString())
System.Console.WriteLine(""File "" & _fileIndices(i).ToString())
For j As Integer = 0 To payload.Length - 1
System.Console.WriteLine(payload(j))
payload(j) = False
......@@ -62,9 +55,11 @@ Namespace Microsoft.CodeAnalysis.Runtime
End Sub
End Class
End Namespace
]]>
</file>
"
ReadOnly InstrumentationHelperSource As XElement = <file name="c.vb">
<%= InstrumentationHelperSourceStr %>
</file>
<Fact>
Public Sub SimpleCoverage()
Dim testSource As XElement = <file name="c.vb">
......@@ -1645,14 +1640,502 @@ End Class
Assert.True(False)
End Sub
<Fact>
Public Sub ExcludeFromCodeCoverageAttribute_Method()
Dim source = "
Imports System
Imports System.Diagnostics.CodeAnalysis
Class C
<ExcludeFromCodeCoverage>
Sub M1()
Console.WriteLine(1)
End Sub
Sub M2()
Console.WriteLine(1)
End Sub
End Class
"
Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
AssertNotInstrumented(verifier, "C.M1")
AssertInstrumented(verifier, "C.M2")
End Sub
<Fact>
Public Sub ExcludeFromCodeCoverageAttribute_Ctor()
Dim source = "
Imports System
Imports System.Diagnostics.CodeAnalysis
Class C
Dim a As Integer = 1
<ExcludeFromCodeCoverage>
Public Sub New()
Console.WriteLine(3)
End Sub
End Class
"
Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
AssertNotInstrumented(verifier, "C..ctor")
End Sub
<Fact>
Public Sub ExcludeFromCodeCoverageAttribute_Cctor()
Dim source = "
Imports System
Imports System.Diagnostics.CodeAnalysis
Class C
Shared a As Integer = 1
<ExcludeFromCodeCoverage>
Shared Sub New()
Console.WriteLine(3)
End Sub
End Class
"
Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
AssertNotInstrumented(verifier, "C..cctor")
End Sub
<Fact>
Public Sub ExcludeFromCodeCoverageAttribute_Lambdas_InMethod()
Dim source = "
Imports System
Imports System.Diagnostics.CodeAnalysis
Class C
<ExcludeFromCodeCoverage>
Shared Sub M1()
Dim s = New Action(Sub() Console.WriteLine(1))
s.Invoke()
End Sub
Shared Sub M2()
Dim s = New Action(Sub() Console.WriteLine(2))
s.Invoke()
End Sub
End Class
"
Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
AssertNotInstrumented(verifier, "C.M1")
AssertNotInstrumented(verifier, "C._Closure$__._Lambda$__1-0")
AssertInstrumented(verifier, "C.M2")
AssertInstrumented(verifier, "C._Closure$__2-0._Lambda$__0")
End Sub
<Fact>
Public Sub ExcludeFromCodeCoverageAttribute_Lambdas_InInitializers()
Dim source = "
Imports System
Imports System.Diagnostics.CodeAnalysis
Class C
Dim [IF] As Action = Sub() Console.WriteLine(1)
ReadOnly Property IP As Action = Sub() Console.WriteLine(2)
Shared SF As Action = Sub() Console.WriteLine(3)
Shared ReadOnly Property SP As Action = Sub() Console.WriteLine(4)
<ExcludeFromCodeCoverage>
Sub New()
End Sub
Shared Sub New()
End Sub
End Class
"
Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
verifier.VerifyDiagnostics()
AssertNotInstrumented(verifier, "C..ctor")
AssertNotInstrumented(verifier, "C._Closure$__._Lambda$__8-0")
AssertNotInstrumented(verifier, "C._Closure$__._Lambda$__8-1")
AssertInstrumented(verifier, "C..cctor")
AssertInstrumented(verifier, "C._Closure$__9-0._Lambda$__0")
AssertInstrumented(verifier, "C._Closure$__9-0._Lambda$__1")
End Sub
<Fact>
Public Sub ExcludeFromCodeCoverageAttribute_Lambdas_InAccessors()
Dim source = "
Imports System
Imports System.Diagnostics.CodeAnalysis
Class C
<ExcludeFromCodeCoverage>
Property P1 As Integer
Get
Dim s = Sub() Console.WriteLine(1)
s()
Return 1
End Get
Set
Dim s = Sub() Console.WriteLine(2)
s()
End Set
End Property
Property P2 As Integer
Get
Dim s = Sub() Console.WriteLine(3)
s()
Return 3
End Get
Set
Dim s = Sub() Console.WriteLine(4)
s()
End Set
End Property
End Class
"
Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
AssertNotInstrumented(verifier, "C.get_P1")
AssertNotInstrumented(verifier, "C.set_P1")
AssertNotInstrumented(verifier, "C._Closure$__._Lambda$__2-0")
AssertNotInstrumented(verifier, "C._Closure$__._Lambda$__3-0")
AssertInstrumented(verifier, "C.get_P2")
AssertInstrumented(verifier, "C.set_P2")
AssertInstrumented(verifier, "C._Closure$__6-0._Lambda$__0")
AssertInstrumented(verifier, "C._Closure$__5-0._Lambda$__0")
End Sub
<Fact>
Public Sub ExcludeFromCodeCoverageAttribute_Type()
Dim source = "
Imports System
Imports System.Diagnostics.CodeAnalysis
<ExcludeFromCodeCoverage>
Class C
Dim x As Integer = 1
Shared Sub New()
End Sub
Sub M1()
Console.WriteLine(1)
End Sub
Property P As Integer
Get
Return 1
End Get
Set
End Set
End Property
Custom Event E As Action
AddHandler(v As Action)
End AddHandler
RemoveHandler(v As Action)
End RemoveHandler
RaiseEvent()
End RaiseEvent
End Event
End Class
Class D
Dim x As Integer = 1
Shared Sub New()
End Sub
Sub M1()
Console.WriteLine(1)
End Sub
Property P As Integer
Get
Return 1
End Get
Set
End Set
End Property
Custom Event E As Action
AddHandler(v As Action)
End AddHandler
RemoveHandler(v As Action)
End RemoveHandler
RaiseEvent()
End RaiseEvent
End Event
End Class
"
Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
AssertNotInstrumented(verifier, "C..ctor")
AssertNotInstrumented(verifier, "C..cctor")
AssertNotInstrumented(verifier, "C.M1")
AssertNotInstrumented(verifier, "C.get_P")
AssertNotInstrumented(verifier, "C.set_P")
AssertNotInstrumented(verifier, "C.add_E")
AssertNotInstrumented(verifier, "C.remove_E")
AssertNotInstrumented(verifier, "C.raise_E")
AssertInstrumented(verifier, "D..ctor")
AssertInstrumented(verifier, "D..cctor")
AssertInstrumented(verifier, "D.M1")
AssertInstrumented(verifier, "D.get_P")
AssertInstrumented(verifier, "D.set_P")
AssertInstrumented(verifier, "D.add_E")
AssertInstrumented(verifier, "D.remove_E")
AssertInstrumented(verifier, "D.raise_E")
End Sub
<Fact>
Public Sub ExcludeFromCodeCoverageAttribute_NestedType()
Dim source = "
Imports System
Imports System.Diagnostics.CodeAnalysis
Class A
Class B1
<ExcludeFromCodeCoverage>
Class C
Sub M1()
Console.WriteLine(1)
End Sub
End Class
Sub M2()
Console.WriteLine(2)
End Sub
End Class
<ExcludeFromCodeCoverage>
Partial Class B2
Partial Class C1
Sub M3()
Console.WriteLine(3)
End Sub
End Class
Class C2
Sub M4()
Console.WriteLine(4)
End Sub
End Class
Sub M5()
Console.WriteLine(5)
End Sub
End Class
Partial Class B2
<ExcludeFromCodeCoverage>
Partial Class C1
Sub M6()
Console.WriteLine(6)
End Sub
End Class
Sub M7()
Console.WriteLine(7)
End Sub
End Class
Sub M8()
Console.WriteLine(8)
End Sub
End Class
"
Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
AssertNotInstrumented(verifier, "A.B1.C.M1")
AssertInstrumented(verifier, "A.B1.M2")
AssertNotInstrumented(verifier, "A.B2.C1.M3")
AssertNotInstrumented(verifier, "A.B2.C2.M4")
AssertNotInstrumented(verifier, "A.B2.C1.M6")
AssertNotInstrumented(verifier, "A.B2.M7")
AssertInstrumented(verifier, "A.M8")
End Sub
<Fact>
Public Sub ExcludeFromCodeCoverageAttribute_Accessors()
Dim source = "
Imports System
Imports System.Diagnostics.CodeAnalysis
Class C
<ExcludeFromCodeCoverage>
Property P1 As Integer
Get
Return 1
End Get
Set
End Set
End Property
<ExcludeFromCodeCoverage>
Custom Event E1 As Action
AddHandler(v As Action)
End AddHandler
RemoveHandler(v As Action)
End RemoveHandler
RaiseEvent()
End RaiseEvent
End Event
Property P2 As Integer
Get
Return 2
End Get
Set
End Set
End Property
Custom Event E2 As Action
AddHandler(v As Action)
End AddHandler
RemoveHandler(v As Action)
End RemoveHandler
RaiseEvent()
End RaiseEvent
End Event
End Class
"
Dim verifier = CompileAndVerify(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
AssertNotInstrumented(verifier, "C.get_P1")
AssertNotInstrumented(verifier, "C.set_P1")
AssertNotInstrumented(verifier, "C.add_E1")
AssertNotInstrumented(verifier, "C.remove_E1")
AssertNotInstrumented(verifier, "C.raise_E1")
AssertInstrumented(verifier, "C.get_P2")
AssertInstrumented(verifier, "C.set_P2")
AssertInstrumented(verifier, "C.add_E2")
AssertInstrumented(verifier, "C.remove_E2")
AssertInstrumented(verifier, "C.raise_E2")
End Sub
<Fact>
Public Sub ExcludeFromCodeCoverageAttribute_CustomDefinition_Good()
Dim source = "
Imports System.Diagnostics.CodeAnalysis
Namespace System.Diagnostics.CodeAnalysis
<AttributeUsage(AttributeTargets.Class)>
Public Class ExcludeFromCodeCoverageAttribute
Inherits Attribute
Public Sub New()
End Sub
End Class
End Namespace
<ExcludeFromCodeCoverage>
Class C
Sub M()
End Sub
End Class
Class D
Sub M()
End Sub
End Class
"
Dim c = CreateCompilationWithMscorlib(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
c.VerifyDiagnostics()
Dim verifier = CompileAndVerify(c, emitOptions:=EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)))
c.VerifyEmitDiagnostics()
AssertNotInstrumented(verifier, "C.M")
AssertInstrumented(verifier, "D.M")
End Sub
<Fact>
Public Sub ExcludeFromCodeCoverageAttribute_CustomDefinition_Bad()
Dim source = "
Imports System.Diagnostics.CodeAnalysis
Namespace System.Diagnostics.CodeAnalysis
<AttributeUsage(AttributeTargets.Class)>
Public Class ExcludeFromCodeCoverageAttribute
Inherits Attribute
Public Sub New(x As Integer)
End Sub
End Class
End Namespace
<ExcludeFromCodeCoverage(1)>
Class C
Sub M()
End Sub
End Class
Class D
Sub M()
End Sub
End Class
"
Dim c = CreateCompilationWithMscorlib(source & InstrumentationHelperSourceStr, options:=TestOptions.ReleaseDll)
c.VerifyDiagnostics()
Dim verifier = CompileAndVerify(c, emitOptions:=EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)))
c.VerifyEmitDiagnostics()
AssertInstrumented(verifier, "C.M")
AssertInstrumented(verifier, "D.M")
End Sub
Private Shared Sub AssertNotInstrumented(verifier As CompilationVerifier, qualifiedMethodName As String)
AssertInstrumented(verifier, qualifiedMethodName, expected:=False)
End Sub
Private Shared Sub AssertInstrumented(verifier As CompilationVerifier, qualifiedMethodName As String, Optional expected As Boolean = True)
Dim il = verifier.VisualizeIL(qualifiedMethodName)
' Tests using this helper are constructed such that instrumented methods contain a call to CreatePayload,
' lambdas a reference to payload Boolean array.
Dim instrumented = il.Contains("CreatePayload") OrElse il.Contains("As Boolean()")
Assert.True(expected = instrumented, $"Method '{qualifiedMethodName}' should {If(expected, "be", "not be")} instrumented. Actual IL:{Environment.NewLine}{il}")
End Sub
Private Function CreateCompilation(source As XElement) As Compilation
Return CompilationUtils.CreateCompilationWithReferences(source, references:=New MetadataReference() {}, options:=TestOptions.ReleaseExe.WithDeterministic(True))
Return CreateCompilationWithReferences(source, references:=New MetadataReference() {}, options:=TestOptions.ReleaseExe.WithDeterministic(True))
End Function
Private Overloads Function CompileAndVerify(source As XElement, expectedOutput As XCData, Optional options As VisualBasicCompilationOptions = Nothing) As CompilationVerifier
Return MyBase.CompileAndVerify(source, expectedOutput:=expectedOutput, additionalRefs:=s_refs, options:=If(options IsNot Nothing, options, TestOptions.ReleaseExe).WithDeterministic(True), emitOptions:=EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)))
Private Overloads Function CompileAndVerify(source As XElement, Optional expectedOutput As XCData = Nothing, Optional options As VisualBasicCompilationOptions = Nothing) As CompilationVerifier
Return CompileAndVerify(source,
LatestVbReferences,
XCDataToString(expectedOutput),
options:=If(options, TestOptions.ReleaseExe).WithDeterministic(True),
emitOptions:=EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)))
End Function
Private Shared ReadOnly s_refs As MetadataReference() = New MetadataReference() {MscorlibRef_v4_0_30316_17626, SystemRef_v4_0_30319_17929, SystemCoreRef_v4_0_30319_17929}
Private Overloads Function CompileAndVerify(source As String, Optional expectedOutput As String = Nothing, Optional options As VisualBasicCompilationOptions = Nothing) As CompilationVerifier
Return CompileAndVerify(source,
LatestVbReferences,
expectedOutput,
options:=If(options, TestOptions.ReleaseExe).WithDeterministic(True),
emitOptions:=EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)))
End Function
End Class
End Namespace
src/Test/Utilities/Desktop/CommonTestBase.CompilationVerifier.cs
浏览文件 @ 41432017
......@@ -177,19 +177,8 @@ private string Emit(IRuntimeEnvironment testEnvironment, IEnumerable<ResourceDes
int callerLine,
bool escapeQuotes)
{
// TODO: Currently the qualifiedMethodName is a symbol display name while PDB need metadata name.
// So we need to pass the PDB metadata name of the method to sequencePoints (instead of just bool).
var methodData = _testData.GetMethodData(qualifiedMethodName);
// verify IL emitted via CCI, if any:
string actualCciIL = VisualizeIL(methodData, realIL, sequencePoints, useRefEmitter: false);
AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualCciIL, escapeQuotes, callerPath, callerLine);
// verify IL emitted via ReflectionEmitter, if any:
string actualRefEmitIL = VisualizeIL(methodData, realIL, sequencePoints, useRefEmitter: true);
AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualRefEmitIL, escapeQuotes, callerPath, callerLine);
string actualIL = VisualizeIL(qualifiedMethodName, realIL, sequencePoints);
AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL, escapeQuotes, callerPath, callerLine);
return this;
}
......@@ -249,12 +238,15 @@ public ISymUnmanagedReader3 CreateSymReader()
return SymReaderFactory.CreateReader(pdbStream, metadataReaderOpt: null, metadataMemoryOwnerOpt: null);
}
public string VisualizeIL(string qualifiedMethodName, bool realIL = false, string sequencePoints = null, bool useRefEmitter = false)
public string VisualizeIL(string qualifiedMethodName, bool realIL = false, string sequencePoints = null)
{
return VisualizeIL(_testData.GetMethodData(qualifiedMethodName), realIL, sequencePoints, useRefEmitter);
// TODO: Currently the qualifiedMethodName is a symbol display name while PDB need metadata name.
// So we need to pass the PDB metadata name of the method to sequencePoints (instead of just bool).
return VisualizeIL(_testData.GetMethodData(qualifiedMethodName), realIL, sequencePoints);
}
internal string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL, string sequencePoints = null, bool useRefEmitter = false)
internal string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL, string sequencePoints = null)
{
Dictionary<int, string> markers = null;
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或