// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
using AwesomeAssertions;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.SourceGeneration.Generators;
namespace Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.SourceGeneration.UnitTests;
///
/// Behavior tests for .
/// These pin the current PoC output so the upcoming follow-up PRs (#1837) can extend it safely.
///
[TestClass]
public sealed class MSTestReflectionMetadataGeneratorTests
{
[TestMethod]
public void CollectInheritedPropertyAttributes_PreservesOrderMultipleAndNearestSingleApplications()
{
CSharpCompilation compilation = CreateCompilation(
"""
using System;
[AttributeUsage(AttributeTargets.All, AllowMultiple = true)]
public sealed class MultiAttribute(string value) : Attribute { }
[AttributeUsage(AttributeTargets.All)]
public sealed class SingleAttribute(string value) : Attribute { }
[AttributeUsage(AttributeTargets.All, Inherited = false)]
public class LocalAttribute : Attribute { }
public sealed class DerivedLocalAttribute : LocalAttribute { }
public class Grand
{
[Multi("grand"), Single("grand"), DerivedLocal]
public virtual int Value { get; set; }
}
public class Middle : Grand
{
[Multi("middle"), Single("middle")]
public override int Value { get; set; }
}
public sealed class Leaf : Middle
{
[Multi("leaf")]
public override int Value { get; set; }
}
""");
compilation.GetDiagnostics().Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).Should().BeEmpty();
IPropertySymbol property = compilation.GetTypeByMetadataName("Leaf")!.GetMembers("Value").OfType().Single();
System.Collections.Immutable.ImmutableArray attributes = AttributeMaterializationHelper.CollectInheritedAttributes(property);
attributes.Select(attribute => (attribute.AttributeClass!.Name, (string)attribute.ConstructorArguments[0].Value!))
.Should().Equal(("MultiAttribute", "leaf"), ("MultiAttribute", "middle"), ("SingleAttribute", "middle"), ("MultiAttribute", "grand"));
}
[TestMethod]
public void CollectInheritedPropertyAttributes_NoOverrideKeepsOwnNonInheritedAttributeAndEmptyIsEmpty()
{
CSharpCompilation compilation = CreateCompilation(
"""
using System;
[AttributeUsage(AttributeTargets.All, Inherited = false)]
public sealed class LocalAttribute : Attribute { }
public sealed class Sample
{
[Local]
public int Own { get; set; }
public int Empty { get; set; }
}
""");
compilation.GetDiagnostics().Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).Should().BeEmpty();
INamedTypeSymbol type = compilation.GetTypeByMetadataName("Sample")!;
IPropertySymbol own = type.GetMembers("Own").OfType().Single();
IPropertySymbol empty = type.GetMembers("Empty").OfType().Single();
AttributeMaterializationHelper.CollectInheritedAttributes(own).Select(attribute => attribute.AttributeClass!.Name)
.Should().Equal("LocalAttribute");
AttributeMaterializationHelper.CollectInheritedAttributes(empty).Should().BeEmpty();
}
///
/// Minimal MSTest attribute stubs so the generator can locate [TestClass] /
/// [TestMethod] in test fixtures without dragging the real TestFramework
/// assemblies into the Roslyn compilation.
///
private const string MinimalMSTestStub = """
namespace Microsoft.VisualStudio.TestTools.UnitTesting
{
[System.AttributeUsage(System.AttributeTargets.Class)]
public class TestClassAttribute : System.Attribute { }
[System.AttributeUsage(System.AttributeTargets.Method, Inherited = false)]
public class TestMethodAttribute : System.Attribute
{
public TestMethodAttribute() { }
public TestMethodAttribute(string displayName) { DisplayName = displayName; }
public string? DisplayName { get; set; }
}
[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
public class TestCategoryAttribute : System.Attribute
{
public TestCategoryAttribute(string category) { Category = category; }
public string Category { get; }
}
[System.AttributeUsage(System.AttributeTargets.Property)]
public class TestContextAttribute : System.Attribute { }
[System.AttributeUsage(System.AttributeTargets.Method)]
public class TestInitializeAttribute : System.Attribute { }
[System.AttributeUsage(System.AttributeTargets.Method)]
public class TestCleanupAttribute : System.Attribute { }
[System.AttributeUsage(System.AttributeTargets.Assembly, AllowMultiple = true)]
public class ParallelizeAttribute : System.Attribute
{
public int Workers { get; set; }
public string? Scope { get; set; }
}
[System.AttributeUsage(System.AttributeTargets.Method, AllowMultiple = true, Inherited = false)]
public class DataRowAttribute : System.Attribute
{
public DataRowAttribute() : this(System.Array.Empty()) { }
public DataRowAttribute(object? data) { Data = new object?[] { data }; }
public DataRowAttribute(string?[]? stringArrayData) : this(new object?[] { stringArrayData }) { }
public DataRowAttribute(params object?[]? data) { Data = data ?? new object?[] { null }; }
public object?[] Data { get; }
}
public enum DynamicDataSourceType { Property = 0, Method = 1, AutoDetect = 2, Field = 3 }
[System.AttributeUsage(System.AttributeTargets.Method, AllowMultiple = true, Inherited = false)]
public class DynamicDataAttribute : System.Attribute
{
public DynamicDataAttribute(string sourceName) { }
public DynamicDataAttribute(string sourceName, DynamicDataSourceType sourceType) { }
public DynamicDataAttribute(string sourceName, System.Type declaringType) { }
public DynamicDataAttribute(string sourceName, System.Type declaringType, DynamicDataSourceType sourceType) { }
public DynamicDataAttribute(string sourceName, params object?[] arguments) { }
public DynamicDataAttribute(string sourceName, System.Type declaringType, params object?[] arguments) { }
public string? DynamicDataDisplayName { get; set; }
public System.Type? DynamicDataDisplayNameDeclaringType { get; set; }
}
public static class DynamicDataSourceResolver
{
public static void RegisterDataProvider(System.Type declaringType, string sourceName, DynamicDataSourceType sourceType, System.Func dataProvider) { }
public static void RegisterDisplayNameProvider(System.Type declaringType, string methodName, System.Func displayNameProvider) { }
}
}
""";
///
/// Minimal stub of the adapter's runtime hook so the emitted [ModuleInitializer] wiring
/// (shared from MSTest.SourceGeneration) compiles in the Roslyn test compilation without
/// referencing MSTestAdapter.PlatformServices.
///
private const string RuntimeHookStub = """
namespace Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.SourceGeneration
{
public readonly struct ConstructorInvokerInfo
{
public ConstructorInvokerInfo(System.Type[] parameterTypes, System.Func invoker) { ParameterTypes = parameterTypes; Invoker = invoker; }
public System.Type[] ParameterTypes { get; }
public System.Func Invoker { get; }
}
public static class ReflectionMetadataHook
{
public static System.Collections.Generic.IReadOnlyDictionary? RegisteredTestMethods { get; private set; }
public static void Register(System.Reflection.Assembly assembly, System.Type[] types, System.Collections.Generic.IReadOnlyDictionary testMethods) { }
public static void Register(System.Reflection.Assembly assembly, System.Type[] types, System.Collections.Generic.IReadOnlyDictionary testMethods, System.Collections.Generic.IReadOnlyDictionary typeAttributes, object[] assemblyAttributes) { }
public static void Register(System.Reflection.Assembly assembly, System.Type[] types, System.Collections.Generic.IReadOnlyDictionary testMethods, System.Collections.Generic.IReadOnlyDictionary typeAttributes, object[] assemblyAttributes, System.Collections.Generic.IReadOnlyDictionary> methodInvokers, System.Collections.Generic.IReadOnlyDictionary constructorInvokers, System.Collections.Generic.IReadOnlyDictionary> propertySetters) { }
public static void Register(System.Reflection.Assembly assembly, System.Type[] types, System.Collections.Generic.IReadOnlyDictionary testMethods, System.Collections.Generic.IReadOnlyDictionary typeAttributes, object[] assemblyAttributes, System.Collections.Generic.IReadOnlyDictionary methodAttributes, System.Collections.Generic.IReadOnlyDictionary> methodInvokers, System.Collections.Generic.IReadOnlyDictionary constructorInvokers, System.Collections.Generic.IReadOnlyDictionary> propertySetters) { }
public static void Register(System.Reflection.Assembly assembly, System.Type[] types, System.Collections.Generic.IReadOnlyDictionary testMethods, System.Collections.Generic.IReadOnlyDictionary typeAttributes, object[] assemblyAttributes, System.Collections.Generic.IReadOnlyDictionary methodAttributes, System.Collections.Generic.IReadOnlyDictionary> methodInvokers, System.Collections.Generic.IReadOnlyDictionary constructorInvokers, System.Collections.Generic.IReadOnlyDictionary> propertySetters, System.Collections.Generic.IReadOnlyDictionary descriptorTestMethods, System.Type[] descriptorCompleteTypes) { RegisteredTestMethods = testMethods; }
}
}
""";
[TestMethod]
public void Generator_EmitsSupportTypes_OnAnyCompilation()
{
const string userCode = """
// Intentionally empty — no [TestClass] in the consumer.
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
// Support types are emitted via RegisterPostInitializationOutput → always present.
string support = result.GeneratedSources
.Single(s => s.HintName == "MSTestReflectionMetadata.SupportTypes.g.cs")
.SourceText.ToString();
support.Should().Contain("namespace MSTest.SourceGenerated");
support.Should().Contain("internal sealed class TestClassReflectionInfo");
support.Should().Contain("internal sealed class TestMethodReflectionInfo");
support.Should().Contain("internal sealed class TestPropertyReflectionInfo");
support.Should().Contain("internal sealed class TestConstructorReflectionInfo");
}
[TestMethod]
public void Generator_EmitsRegistry_WithDiscoveredTestClass()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public class MyTests
{
[TestMethod]
public void Test1() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
registry.Should().Contain("internal static class MSTestReflectionMetadata");
registry.Should().Contain("public const string AssemblyName = \"TestSample\";");
registry.Should().Contain("Type = typeof(global::Sample.MyTests)");
registry.Should().Contain("Name = \"Test1\"");
registry.Should().Contain("Invoke = static (instance, args) => { ((global::Sample.MyTests)instance!).Test1(); return Task.CompletedTask; },");
registry.Should().Contain("SupportsGeneratedDescriptors = true");
registry.Should().Contain("AreGeneratedDescriptorsComplete = true");
registry.Should().Contain("IsDescriptorSupported = true");
}
[TestMethod]
public void Generator_DeclaresDescriptorSupportOnlyForBoundedSynchronousSubset()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public class MyTests
{
[TestMethod]
[DataRow(1)]
public void Supported(int value) { }
[TestMethod]
[TestCategory("fallback")]
public void AttributeFallback() { }
[TestMethod]
public async System.Threading.Tasks.Task AsyncFallback()
{
await System.Threading.Tasks.Task.Yield();
}
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
string registration = result.GeneratedSources
.Single(source => source.HintName == "MSTestReflectionMetadata.Registration.g.cs")
.SourceText.ToString();
registry.Should().Contain("AreGeneratedDescriptorsComplete = false");
int supportedIndex = registry.IndexOf("Name = \"Supported\"", System.StringComparison.Ordinal);
int attributeFallbackIndex = registry.IndexOf("Name = \"AttributeFallback\"", System.StringComparison.Ordinal);
int asyncFallbackIndex = registry.IndexOf("Name = \"AsyncFallback\"", System.StringComparison.Ordinal);
supportedIndex.Should().BeGreaterThan(-1);
attributeFallbackIndex.Should().BeGreaterThan(supportedIndex);
asyncFallbackIndex.Should().BeGreaterThan(attributeFallbackIndex);
registry.Substring(supportedIndex, attributeFallbackIndex - supportedIndex)
.Should().Contain("IsDescriptorSupported = true");
registry.Substring(attributeFallbackIndex, asyncFallbackIndex - attributeFallbackIndex)
.Should().Contain("IsDescriptorSupported = false");
registry[asyncFallbackIndex..].Should().Contain("IsDescriptorSupported = false");
registration.Should().Contain("descriptorTestMethods[type] = descriptorMethodRoots.ToArray();");
registration.Should().Contain("areDescriptorMethodsResolved = false;");
registration.Should().Contain("testClass.AreGeneratedDescriptorsComplete && areDescriptorMethodsResolved");
registration.Should().Contain("descriptorCompleteTypes.Add(type);");
registration.Should().Contain("descriptorTestMethods, descriptorCompleteTypes.ToArray()");
}
[TestMethod]
public void Generator_InaccessibleTestMethodRetainsLegacyDiscoveryFallback()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public class MyTests
{
[TestMethod]
public void Supported() { }
[TestMethod]
private void InaccessibleFallback() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
registry.Should().Contain("Name = \"Supported\"");
registry.Should().Contain("IsDescriptorSupported = true");
registry.Should().Contain("AreGeneratedDescriptorsComplete = false");
registry.Should().NotContain("Name = \"InaccessibleFallback\"");
}
[TestMethod]
public void Generator_UnsupportedExecutionShapesRetainLegacyDiscoveryFallback()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public class MyTests
{
[TestMethod]
public static void StaticTest() { }
[TestMethod]
public System.Threading.Tasks.Task SynchronousTaskTest()
=> System.Threading.Tasks.Task.CompletedTask;
[TestMethod]
public System.Threading.Tasks.ValueTask SynchronousValueTaskTest()
=> default;
[TestMethod]
public async void AsyncVoidTest()
{
await System.Threading.Tasks.Task.Yield();
}
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
registry.Should().Contain("AreGeneratedDescriptorsComplete = false");
foreach (string methodName in new[] { "StaticTest", "SynchronousTaskTest", "SynchronousValueTaskTest", "AsyncVoidTest" })
{
int methodIndex = registry.IndexOf($"Name = \"{methodName}\"", System.StringComparison.Ordinal);
methodIndex.Should().BeGreaterThan(-1);
int nextMethodIndex = registry.IndexOf("Name = \"", methodIndex + 1, System.StringComparison.Ordinal);
string methodEntry = nextMethodIndex < 0
? registry[methodIndex..]
: registry.Substring(methodIndex, nextMethodIndex - methodIndex);
methodEntry.Should().Contain("IsDescriptorSupported = false");
}
}
[TestMethod]
public void Generator_PartialTestClassRetainsLegacyDiscoveryFallback()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public partial class PartialTests
{
[TestMethod]
public void Test1() { }
}
public partial class PartialTests
{
[TestMethod]
public void Test2() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
int test1Index = registry.IndexOf("Name = \"Test1\"", System.StringComparison.Ordinal);
int test2Index = registry.IndexOf("Name = \"Test2\"", System.StringComparison.Ordinal);
int propertiesIndex = registry.IndexOf("Properties = ", test2Index, System.StringComparison.Ordinal);
test1Index.Should().BeGreaterThan(-1);
test2Index.Should().BeGreaterThan(test1Index);
propertiesIndex.Should().BeGreaterThan(test2Index);
registry.Should().Contain("Type = typeof(global::Sample.PartialTests)");
registry.Substring(test1Index, test2Index - test1Index)
.Should().Contain("IsDescriptorSupported = true");
registry.Substring(test2Index, propertiesIndex - test2Index)
.Should().Contain("IsDescriptorSupported = true");
registry.Should().Contain("AreGeneratedDescriptorsComplete = false");
}
[TestMethod]
public void Generator_InheritedCustomTestMethodOverrideRetainsLegacyDiscoveryFallback()
{
const string userCode = """
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[AttributeUsage(AttributeTargets.Method, Inherited = true)]
public sealed class InheritedTestMethodAttribute : TestMethodAttribute
{
}
public class BaseTests
{
[InheritedTestMethod]
public virtual void Run() { }
}
[TestClass]
public class DerivedTests : BaseTests
{
public override void Run() { }
[TestMethod]
public void Supported() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
int runIndex = registry.IndexOf("Name = \"Run\"", System.StringComparison.Ordinal);
int supportedIndex = registry.IndexOf("Name = \"Supported\"", runIndex, System.StringComparison.Ordinal);
runIndex.Should().BeGreaterThan(-1);
supportedIndex.Should().BeGreaterThan(runIndex);
string runEntry = registry.Substring(runIndex, supportedIndex - runIndex);
runEntry.Should().Contain("IsTestMethod = true");
runEntry.Should().Contain("IsDescriptorSupported = false");
registry.Should().Contain("AreGeneratedDescriptorsComplete = false");
}
[TestMethod]
public void Generator_TestMethodAccessorRetainsLegacyDiscoveryFallback()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public class AccessorTests
{
public int Value
{
get => 0;
[TestMethod]
[DataRow(1)]
set { }
}
[TestMethod]
public void Supported() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
registry.Should().Contain("Name = \"Supported\"");
registry.Should().Contain("IsDescriptorSupported = true");
registry.Should().Contain("AreGeneratedDescriptorsComplete = false");
registry.Should().NotContain("Name = \"set_Value\"");
}
[TestMethod]
public void Generator_EmitsEmptyRegistry_WhenNoTestClasses()
{
const string userCode = """
namespace Sample
{
// No [TestClass] anywhere.
public class NotATest { public void Foo() { } }
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
registry.Should().Contain("public static IReadOnlyList TestClasses { get; } = new TestClassReflectionInfo[]");
// No concrete TestClassReflectionInfo instance is emitted (note the open paren).
registry.Should().NotContain("new TestClassReflectionInfo(");
}
[TestMethod]
public void Generator_SkipsStaticTestClass()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public static class StaticTests
{
[TestMethod]
public static void Test1() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().ContainSingle(d => d.Id == "AOTSG0001");
string registry = GetRegistry(result);
// Static classes are excluded from the registry (cannot be instantiated) and reported via AOTSG0001.
registry.Should().NotContain("StaticTests");
}
[TestMethod]
public void Generator_SkipsAbstractTestClass()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public abstract class AbstractTests
{
[TestMethod]
public void Test1() { }
}
[TestClass]
public class ConcreteTests
{
[TestMethod]
public void Test2() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
// Abstract classes are filtered in BuildModel — they cannot be instantiated.
registry.Should().NotContain("AbstractTests");
registry.Should().Contain("typeof(global::Sample.ConcreteTests)");
}
[TestMethod]
public void Generator_SkipsGenericTestClass()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public class GenericTests
{
[TestMethod]
public void Test1() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().ContainSingle(d => d.Id == "AOTSG0002");
string registry = GetRegistry(result);
// Open-generic test classes are out of scope for this PoC and reported via AOTSG0002.
registry.Should().NotContain("GenericTests");
}
[TestMethod]
public void Generator_EmitsConstructorInvoker()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public class CtorTests
{
public CtorTests() { }
[TestMethod]
public void Test1() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
registry.Should().Contain("Constructors = new TestConstructorReflectionInfo[]");
registry.Should().Contain("Invoke = static args => new global::Sample.CtorTests(),");
}
[TestMethod]
public void Generator_RegistersOnlySupportedConstructorShapes()
{
// MSTest only instantiates a test class via a parameterless or single-TestContext ctor. An
// additional ctor(object) (or any other shape) must NOT be registered: it is never selected by
// the adapter, and registering it could let the runtime's argument-type matching pick it over
// the intended ctor.
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Microsoft.VisualStudio.TestTools.UnitTesting
{
public class TestContext { }
}
namespace Sample
{
[TestClass]
public class CtorTests
{
public CtorTests() { }
public CtorTests(TestContext context) { }
public CtorTests(object anything) { }
[TestMethod]
public void Test1() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
// Parameterless and single-TestContext ctors are registered.
registry.Should().Contain("Invoke = static args => new global::Sample.CtorTests(),");
registry.Should().Contain("Invoke = static args => new global::Sample.CtorTests((global::Microsoft.VisualStudio.TestTools.UnitTesting.TestContext)args![0]!),");
// The unsupported ctor(object) is not registered.
registry.Should().NotContain("new global::Sample.CtorTests((object)args![0]!)");
}
[TestMethod]
public void Generator_EmitsParameterTypes_ForMethodWithParameters()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public class ParamTests
{
[TestMethod]
public void Test1(int x, string y) { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
registry.Should().Contain("ParameterTypes = new Type[] { typeof(int), typeof(string) }");
registry.Should().NotContain("ParameterNames");
}
[TestMethod]
public void Generator_FlagsAsyncReturnTypes()
{
const string userCode = """
using System.Threading.Tasks;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public class AsyncTests
{
[TestMethod]
public Task Test1() => Task.CompletedTask;
[TestMethod]
public ValueTask Test2() => default;
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
registry.Should().Contain("Name = \"Test1\"");
registry.Should().Contain("ReturnsTask = true");
registry.Should().Contain("Name = \"Test2\"");
registry.Should().Contain("ReturnsValueTask = true");
}
[TestMethod]
public void Generator_OmitsInaccessibleAttribute_AndStillCompiles()
{
// [Mark] resolves to Outer.MarkAttribute, which is private to Outer. It is validly applied to
// Inner (nested in Outer, so it can see Outer's private members), but the generated registry —
// a top-level type in a different namespace — cannot reference it. Emitting
// `new global::Sample.Outer.MarkAttribute()` would fail with CS0122, so the safener must omit
// it while still materializing the accessible [TestCategory] on the same class.
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class Outer
{
private sealed class MarkAttribute : System.Attribute { }
[TestClass]
[Mark]
[TestCategory("Smoke")]
public class Inner
{
[TestMethod]
public void Test1() { }
}
}
}
""";
Compilation outputCompilation = RunGeneratorAndGetCompilation(MinimalMSTestStub, userCode);
// The emitted registry must compile — no CS0122 from referencing the private attribute.
outputCompilation.GetDiagnostics()
.Where(d => d.Severity == DiagnosticSeverity.Error)
.Should().BeEmpty("the safener must omit attributes the generated code cannot reference");
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
string registry = GetRegistry(result);
// Accessible attribute is still materialized; the inaccessible one is omitted.
registry.Should().Contain("global::Microsoft.VisualStudio.TestTools.UnitTesting.TestCategoryAttribute");
registry.Should().NotContain("MarkAttribute");
}
[TestMethod]
public void Generator_CapturesClassLevelAttributes()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
[TestCategory("Smoke")]
public class TaggedTests
{
[TestMethod]
public void Test1() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
registry.Should().Contain("global::Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute");
registry.Should().Contain("global::Microsoft.VisualStudio.TestTools.UnitTesting.TestCategoryAttribute");
registry.Should().Contain("\"Smoke\"");
}
[TestMethod]
public void Generator_EmitsPropertyGetterAndSetter()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class TestContext { }
[TestClass]
public class PropTests
{
[TestContext]
public TestContext? Context { get; set; }
[TestMethod]
public void Test1() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
registry.Should().Contain("Name = \"Context\"");
registry.Should().Contain("HasPublicSetter = true");
registry.Should().Contain("Get = static instance => instance is null ? null : (object?)((global::Sample.PropTests)instance).Context,");
registry.Should().Contain("Set = static (instance, value) => ((global::Sample.PropTests)instance!).Context = (global::Sample.TestContext)value!,");
}
[TestMethod]
public void Generator_NonPublicSetter_IsNotPubliclySettable_AndNotRegistered()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class TestContext { }
[TestClass]
public class PropTests
{
[TestContext]
public TestContext? Context { get; private set; }
[TestMethod]
public void Test1() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
// A non-public setter is not callable from the generated code, so the registry emits a
// throwing setter (never a direct assignment) and reports HasPublicSetter = false.
registry.Should().Contain("HasPublicSetter = false");
registry.Should().Contain("Property 'Context' has no public setter.");
registry.Should().NotContain(".Context = (global::Sample.TestContext)value!");
// The module initializer gates setter registration on HasPublicSetter, so this property's
// (throwing) setter is never published; the adapter falls back to PropertyInfo.SetValue.
string registration = result.GeneratedSources
.Single(s => s.HintName == "MSTestReflectionMetadata.Registration.g.cs")
.SourceText.ToString();
registration.Should().Contain("if (property.HasPublicSetter)");
}
[TestMethod]
public void Generator_InitOnlySetter_IsNotPubliclySettable_AndDoesNotEmitAssignment()
{
// An init-only setter has public accessibility but cannot be assigned outside an object
// initializer; emitting `instance.Prop = value` would not compile (CS8852). The generator
// must treat it as non-settable.
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class TestContext { }
[TestClass]
public class PropTests
{
[TestContext]
public TestContext? Context { get; init; }
[TestMethod]
public void Test1() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
registry.Should().Contain("HasPublicSetter = false");
registry.Should().Contain("Property 'Context' has no public setter.");
registry.Should().NotContain(".Context = (global::Sample.TestContext)value!");
}
[TestMethod]
public void Generator_EmitsStaticPropertyAccess_WithoutInstanceCast()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public class StaticProps
{
public static int Value { get; set; }
[TestMethod]
public void Test1() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
registry.Should().Contain("Name = \"Value\"");
// A static member must be accessed through the type, never through an instance cast,
// otherwise the generated code fails to compile with CS0176.
registry.Should().Contain("Get = static instance => (object?)global::Sample.StaticProps.Value,");
registry.Should().Contain("Set = static (instance, value) => global::Sample.StaticProps.Value = (int)value!,");
registry.Should().NotContain("((global::Sample.StaticProps)instance).Value");
}
[TestMethod]
public void Generator_SkipsIndexerProperty()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public class WithIndexer
{
public int this[int index] => index;
[TestMethod]
public void Test1() { }
}
}
""";
Compilation outputCompilation = RunGeneratorAndGetCompilation(MinimalMSTestStub, userCode);
string registry = outputCompilation
.SyntaxTrees
.Single(t => t.FilePath.EndsWith("MSTestReflectionMetadata.Registry.g.cs", System.StringComparison.Ordinal))
.ToString();
// Indexers cannot be represented by the name-based Get/Set delegate shape, so they are
// dropped entirely instead of emitting non-compiling `((T)instance).this[]` code.
registry.Should().NotContain("this[");
registry.Should().NotContain("Name = \"Item\"");
IEnumerable errors = outputCompilation
.GetDiagnostics()
.Where(d => d.Severity == DiagnosticSeverity.Error);
errors.Should().BeEmpty("indexers must be skipped so the emitted registry still compiles");
}
[TestMethod]
public void Generator_EmitsThrowingGetter_ForSetOnlyProperty()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public class WriteOnly
{
private int _value;
public int Value { set { _value = value; } }
[TestMethod]
public void Test1() { }
}
}
""";
Compilation outputCompilation = RunGeneratorAndGetCompilation(MinimalMSTestStub, userCode);
string registry = outputCompilation
.SyntaxTrees
.Single(t => t.FilePath.EndsWith("MSTestReflectionMetadata.Registry.g.cs", System.StringComparison.Ordinal))
.ToString();
registry.Should().Contain("Name = \"Value\"");
// A set-only property has no readable getter; emitting `instance.Value` would not compile,
// so the Get delegate throws instead.
registry.Should().Contain("Get = static instance => throw new InvalidOperationException(\"Property 'Value' has no accessible getter.\"),");
registry.Should().Contain("((global::Sample.WriteOnly)instance!).Value = (int)value!");
IEnumerable errors = outputCompilation
.GetDiagnostics()
.Where(d => d.Severity == DiagnosticSeverity.Error);
errors.Should().BeEmpty("a set-only property must still produce a compiling registry");
}
[TestMethod]
public void Generator_EmittedSource_CompilesCleanly()
{
const string userCode = """
using System.Threading.Tasks;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class TestContext { }
[TestClass]
[TestCategory("Smoke")]
public class FullShape
{
[TestContext]
public TestContext? Context { get; set; }
public FullShape() { }
[TestMethod("alias")]
public void Sync(int x) { }
[TestMethod]
public Task Asynchronous() => Task.CompletedTask;
}
}
""";
Compilation outputCompilation = RunGeneratorAndGetCompilation(MinimalMSTestStub, userCode);
IEnumerable diagnostics = outputCompilation
.GetDiagnostics()
.Where(d => d.Severity == DiagnosticSeverity.Error);
diagnostics.Should().BeEmpty(
"the generated source MUST compile cleanly when consumed in the same compilation as the user code");
}
[TestMethod]
public void Generator_SkipsProtectedMembers()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class TestContext { }
[TestClass]
public class ProtectedShapes
{
[TestContext]
protected TestContext? Context { get; set; }
[TestMethod]
protected void ProtectedTest() { }
[TestMethod]
private protected void PrivateProtectedTest() { }
[TestMethod]
protected internal void ProtectedInternalTest() { }
}
}
""";
Compilation outputCompilation = RunGeneratorAndGetCompilation(MinimalMSTestStub, userCode);
string registry = outputCompilation
.SyntaxTrees
.Single(t => t.FilePath.EndsWith("MSTestReflectionMetadata.Registry.g.cs", System.StringComparison.Ordinal))
.ToString();
registry.Should().NotContain("ProtectedTest");
registry.Should().NotContain("PrivateProtectedTest");
registry.Should().NotContain("Context");
registry.Should().Contain("ProtectedInternalTest");
IEnumerable errors = outputCompilation
.GetDiagnostics()
.Where(d => d.Severity == DiagnosticSeverity.Error);
errors.Should().BeEmpty("the registry can only call members accessible from a non-derived type in the same assembly");
}
[TestMethod]
public void Generator_StripsNullableAnnotation_FromTypeofExpressions()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class TestContext { }
[TestClass]
public class NullableShapes
{
[TestContext]
public TestContext? Context { get; set; }
[TestMethod]
public void TakesNullableRef(string? value) { }
[TestMethod]
public void TakesNullableValueType(int? n) { }
}
}
""";
Compilation outputCompilation = RunGeneratorAndGetCompilation(MinimalMSTestStub, userCode);
string registry = outputCompilation
.SyntaxTrees
.Single(t => t.FilePath.EndsWith("MSTestReflectionMetadata.Registry.g.cs", System.StringComparison.Ordinal))
.ToString();
// typeof(...) MUST NOT carry nullable reference type annotation (CS8639).
registry.Should().NotContain("typeof(global::Sample.TestContext?)");
registry.Should().NotContain("typeof(string?)");
// Reference types in typeof drop the annotation entirely.
registry.Should().Contain("typeof(global::Sample.TestContext)");
registry.Should().Contain("typeof(string)");
// Nullable value types are still distinct from their underlying type and must be preserved as Nullable.
registry.Should().Contain("typeof(int?)");
// The whole compilation must be free of CS errors.
IEnumerable errors = outputCompilation
.GetDiagnostics()
.Where(d => d.Severity == DiagnosticSeverity.Error);
errors.Should().BeEmpty("typeof(T?) on a reference type is invalid C# (CS8639)");
}
[TestMethod]
public void Generator_IsIncremental_ProducesStableOutputAndCachesSteps_WhenInputUnchanged()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public class IncTests
{
[TestMethod]
public void Test1() { }
}
}
""";
CSharpCompilation compilation = CreateCompilation(MinimalMSTestStub, userCode);
GeneratorDriver driver = CSharpGeneratorDriver.Create(
generators: new ISourceGenerator[] { new MSTestReflectionMetadataGenerator().AsSourceGenerator() },
additionalTexts: null,
parseOptions: (CSharpParseOptions)compilation.SyntaxTrees.First().Options,
optionsProvider: ReflectionFreeOptionsProvider.Instance,
driverOptions: new GeneratorDriverOptions(IncrementalGeneratorOutputKind.None, trackIncrementalGeneratorSteps: true));
GeneratorDriver firstDriver = driver.RunGenerators(compilation);
GeneratorDriverRunResult firstResult = firstDriver.GetRunResult();
GeneratorDriver secondDriver = firstDriver.RunGenerators(compilation);
GeneratorDriverRunResult secondResult = secondDriver.GetRunResult();
firstResult.Diagnostics.Should().BeEmpty();
secondResult.Diagnostics.Should().BeEmpty();
firstResult.Results.Should().ContainSingle();
secondResult.Results.Should().ContainSingle();
// Two passes against the same compilation MUST produce identical sources (deterministic output).
secondResult.Results[0].GeneratedSources
.Select(s => (s.HintName, Text: s.SourceText.ToString()))
.Should()
.BeEquivalentTo(firstResult.Results[0].GeneratedSources
.Select(s => (s.HintName, Text: s.SourceText.ToString())));
// The implementation-source-output pipeline MUST report cached steps on the second run
// (proves the generator's incremental graph actually short-circuits when inputs are unchanged).
secondResult.Results[0].TrackedOutputSteps
.Should()
.NotBeEmpty("the generator registers RegisterImplementationSourceOutput which produces a tracked output step");
secondResult.Results[0].TrackedOutputSteps
.SelectMany(static kv => kv.Value)
.SelectMany(static step => step.Outputs)
.Should()
.OnlyContain(
static o => o.Reason == IncrementalStepRunReason.Cached || o.Reason == IncrementalStepRunReason.Unchanged,
"output steps for unchanged inputs MUST be Cached or Unchanged on subsequent runs");
}
[TestMethod]
public void Generator_IsIncremental_SupportTypesAreCached_WhenInputUnchanged()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public class IncTests
{
[TestMethod]
public void Test1() { }
}
}
""";
CSharpCompilation compilation = CreateCompilation(MinimalMSTestStub, userCode);
GeneratorDriver driver = CreateDriver(compilation);
// Track step output cache reasons.
driver = driver.RunGenerators(compilation);
driver = driver.RunGenerators(compilation);
GeneratorDriverRunResult result = driver.GetRunResult();
result.Diagnostics.Should().BeEmpty();
result.Results.Should().ContainSingle();
// Two passes against the same compilation must produce identical sources:
// support types + registry + module-initializer registration.
result.Results[0].GeneratedSources.Should().HaveCount(3);
}
[TestMethod]
public void Generator_IncludesMethodsFromBaseType()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class BaseTests
{
[TestInitialize]
public void Setup() { }
[TestMethod]
public void InheritedTest() { }
}
[TestClass]
public class DerivedTests : BaseTests
{
[TestMethod]
public void DerivedTest() { }
}
}
""";
string registry = GetRegistry(RunGenerator(MinimalMSTestStub, userCode));
registry.Should().Contain("Name = \"InheritedTest\"");
registry.Should().Contain("Name = \"Setup\"");
registry.Should().Contain("Name = \"DerivedTest\"");
// The TestInitialize attribute applied on the base method must propagate too.
registry.Should().Contain("global::Microsoft.VisualStudio.TestTools.UnitTesting.TestInitializeAttribute");
}
[TestMethod]
public void Generator_ExcludesProtectedAndPrivateProtectedMembersFromBaseType()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class TestContext { }
public class BaseTests
{
[TestMethod]
protected void ProtectedTest() { }
[TestMethod]
private protected void PrivateProtectedTest() { }
[TestMethod]
protected internal void ProtectedInternalTest() { }
[TestContext]
protected TestContext ProtectedContext { get; set; } = new();
[TestContext]
private protected TestContext PrivateProtectedContext { get; set; } = new();
[TestContext]
protected internal TestContext ProtectedInternalContext { get; set; } = new();
}
[TestClass]
public class DerivedTests : BaseTests
{
[TestMethod]
public void Test() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
registry.Should().NotContain("Name = \"ProtectedTest\"");
registry.Should().NotContain("Name = \"PrivateProtectedTest\"");
registry.Should().NotContain("Name = \"ProtectedContext\"");
registry.Should().NotContain("Name = \"PrivateProtectedContext\"");
registry.Should().Contain("Name = \"ProtectedInternalTest\"");
registry.Should().Contain("Name = \"ProtectedInternalContext\"");
}
[TestMethod]
public void Generator_ExcludesInaccessibleMembersFromBaseTypeInAnotherAssembly()
{
const string baseCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class GrandparentTests
{
[TestMethod]
public void HiddenTest() { }
[TestMethod]
public void PropertyHidesMethod() { }
[TestMethod]
public void StaticHidesInstance() { }
[TestMethod]
public void InaccessibleOverloadHidesMethodGroup(int value) { }
[TestContext]
public int HiddenContext { get; set; }
public int MethodHidesProperty { [TestMethod] get; set; }
}
public class BaseTests : GrandparentTests
{
[TestMethod]
public void PublicInheritedTest() { }
[TestMethod]
protected internal void InheritedTest() { }
[TestMethod]
internal void InternalTest() { }
protected internal new void HiddenTest() { }
protected internal int PropertyHidesMethod { get; set; }
protected internal static new void StaticHidesInstance() { }
protected internal void InaccessibleOverloadHidesMethodGroup(string value) { }
[TestContext]
public int PublicContext { get; set; }
[TestContext]
protected internal int InaccessibleContext { get; set; }
[TestContext]
internal int InternalContext { get; set; }
protected internal new int HiddenContext { get; set; }
protected internal void MethodHidesProperty() { }
public int ContextWithInaccessibleGetter { protected internal get; set; }
public int ContextWithInternalGetter { internal get; set; }
}
""";
CSharpCompilation baseCompilation = CreateCompilation(MinimalMSTestStub, baseCode)
.WithAssemblyName("BaseAssembly");
using var stream = new MemoryStream();
baseCompilation.Emit(stream).Success.Should().BeTrue();
MetadataReference baseReference = MetadataReference.CreateFromImage(stream.ToArray());
const string consumerCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
[TestClass]
public class DerivedTests : BaseTests { }
""";
CSharpCompilation consumerCompilation = CreateCompilation(consumerCode);
consumerCompilation = consumerCompilation
.WithOptions(consumerCompilation.Options.WithMetadataImportOptions(MetadataImportOptions.All))
.AddReferences(baseReference);
GeneratorDriver driver = CreateDriver(consumerCompilation);
driver.RunGeneratorsAndUpdateCompilation(consumerCompilation, out Compilation outputCompilation, out _);
string registry = outputCompilation.SyntaxTrees
.Single(t => t.FilePath.EndsWith("MSTestReflectionMetadata.Registry.g.cs", StringComparison.Ordinal))
.ToString();
registry.Should().NotContain("Name = \"InheritedTest\"");
registry.Should().NotContain("Name = \"InternalTest\"");
registry.Should().Contain("Name = \"PublicInheritedTest\"");
registry.Should().NotContain("Name = \"InaccessibleContext\"");
registry.Should().NotContain("Name = \"InternalContext\"");
registry.Should().Contain("Name = \"PublicContext\"");
registry.Should().NotContain("Name = \"HiddenTest\"");
registry.Should().NotContain("Name = \"HiddenContext\"");
registry.Should().NotContain("Name = \"PropertyHidesMethod\"");
registry.Should().NotContain("Name = \"StaticHidesInstance\"");
registry.Should().NotContain("Name = \"InaccessibleOverloadHidesMethodGroup\"");
registry.Should().NotContain("Name = \"MethodHidesProperty\"");
registry.Should().Contain("Property 'ContextWithInaccessibleGetter' has no accessible getter.");
registry.Should().Contain("Property 'ContextWithInternalGetter' has no accessible getter.");
outputCompilation.GetDiagnostics()
.Where(d => d.Severity == DiagnosticSeverity.Error)
.Should().BeEmpty();
}
[TestMethod]
public void Generator_PropertyHidingTestMethod_MarksDescriptorsIncomplete()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class BaseTests
{
[TestMethod]
public void Hidden() { }
}
[TestClass]
public class DerivedTests : BaseTests
{
public new int Hidden { get; set; }
}
""";
string registry = GetRegistry(RunGenerator(MinimalMSTestStub, userCode));
registry.Should().Contain("AreGeneratedDescriptorsComplete = false");
registry.Should().NotContain("((global::DerivedTests)instance!).Hidden();");
}
[TestMethod]
public void Generator_NonMethodMembersHideBaseMethods()
{
const string userCode = """
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class BaseTests
{
[TestMethod]
public void FieldHidden() { }
[TestMethod]
public void EventHidden() { }
[TestMethod]
public void TypeHidden() { }
}
[TestClass]
public class DerivedTests : BaseTests
{
public int FieldHidden;
public event Action? EventHidden;
public class TypeHidden { }
}
""";
Compilation outputCompilation = RunGeneratorAndGetCompilation(MinimalMSTestStub, userCode);
string registry = outputCompilation.SyntaxTrees
.Single(t => t.FilePath.EndsWith("MSTestReflectionMetadata.Registry.g.cs", StringComparison.Ordinal))
.ToString();
registry.Should().Contain("AreGeneratedDescriptorsComplete = false");
registry.Should().NotContain("((global::DerivedTests)instance!).FieldHidden();");
registry.Should().NotContain("((global::DerivedTests)instance!).EventHidden();");
registry.Should().NotContain("((global::DerivedTests)instance!).TypeHidden();");
outputCompilation.GetDiagnostics()
.Where(d => d.Severity == DiagnosticSeverity.Error)
.Should().BeEmpty();
}
[TestMethod]
public void Generator_MethodHidingTestAttributedPropertyAccessor_MarksDescriptorsIncomplete()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class BaseTests
{
public int Hidden { [TestMethod] get; set; }
}
[TestClass]
public class DerivedTests : BaseTests
{
public new void Hidden() { }
}
""";
string registry = GetRegistry(RunGenerator(MinimalMSTestStub, userCode));
registry.Should().Contain("AreGeneratedDescriptorsComplete = false");
registry.Should().NotContain("PropertyType = typeof(int)");
}
[TestMethod]
public void Generator_HiddenUnsupportedInheritedMethods_ReportDiagnostics()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class BaseTests
{
[TestMethod]
public void GenericHidden() { }
[TestMethod]
public void ByRefHidden(ref int value) { }
}
[TestClass]
public class DerivedTests : BaseTests
{
public int GenericHidden { get; set; }
public int ByRefHidden { get; set; }
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().ContainSingle(d => d.Id == "AOTSG0004");
result.Diagnostics.Should().ContainSingle(d => d.Id == "AOTSG0005");
}
[TestMethod]
public void Generator_IncludesMethodsFromMultiLevelInheritance()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class GrandparentTests
{
[TestMethod]
public void GrandparentTest() { }
}
public class ParentTests : GrandparentTests
{
[TestMethod]
public void ParentTest() { }
}
[TestClass]
public class LeafTests : ParentTests
{
[TestMethod]
public void LeafTest() { }
}
}
""";
string registry = GetRegistry(RunGenerator(MinimalMSTestStub, userCode));
registry.Should().Contain("Name = \"GrandparentTest\"");
registry.Should().Contain("Name = \"ParentTest\"");
registry.Should().Contain("Name = \"LeafTest\"");
}
[TestMethod]
public void Generator_OverriddenVirtualMethod_KeepsOnlyDerivedImplementation()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class BaseTests
{
[TestMethod]
public virtual void Run() { }
}
[TestClass]
public class DerivedTests : BaseTests
{
public override void Run() { }
}
}
""";
string registry = GetRegistry(RunGenerator(MinimalMSTestStub, userCode));
// Only one entry for Run should be emitted, and the invoker must dispatch on the derived type.
int runEntries = registry.Split(["Name = \"Run\""], System.StringSplitOptions.None).Length - 1;
runEntries.Should().Be(1, "the derived override must replace the base entry (not duplicate it)");
registry.Should().Contain("((global::Sample.DerivedTests)instance!).Run();");
registry.Should().NotContain("((global::Sample.BaseTests)instance!).Run();");
registry.Should().Contain("AreGeneratedDescriptorsComplete = true");
// TestMethodAttribute is not inherited, so the override should not pick up the base attribute.
registry.Should().NotContain("global::Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute");
}
[TestMethod]
public void Generator_OverriddenVirtualMethod_HonorsInheritedAttributeUsage()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class BaseTests
{
[TestMethod]
[TestCategory("Base")]
[DataRow(1)]
public virtual void Run(int value) { }
}
[TestClass]
public class DerivedTests : BaseTests
{
[TestMethod]
[TestCategory("Derived")]
public override void Run(int value) { }
}
}
""";
string registry = GetRegistry(RunGenerator(MinimalMSTestStub, userCode));
registry.Should().Contain("\"Base\"");
registry.Should().Contain("\"Derived\"");
registry.Should().NotContain("DataRows");
registry.Should().NotContain("new object?[] { 1 }");
}
[TestMethod]
public void Generator_NewKeywordHiddenMethod_DedupsBySignature()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class BaseTests
{
[TestMethod]
public void Hidden() { }
}
[TestClass]
public class DerivedTests : BaseTests
{
[TestMethod]
public new void Hidden() { }
}
}
""";
string registry = GetRegistry(RunGenerator(MinimalMSTestStub, userCode));
int hiddenEntries = registry.Split(["Name = \"Hidden\""], System.StringSplitOptions.None).Length - 1;
hiddenEntries.Should().Be(1, "members with the same name and signature must be de-duplicated; derived wins");
registry.Should().Contain("((global::Sample.DerivedTests)instance!).Hidden();");
registry.Should().Contain("AreGeneratedDescriptorsComplete = true");
}
[TestMethod]
public void Generator_PrivateSameSignatureMethod_DoesNotReplaceInheritedTest()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class BaseTests
{
[TestMethod]
public void Hidden() { }
}
[TestClass]
public class DerivedTests : BaseTests
{
private new void Hidden() { }
}
""";
string registry = GetRegistry(RunGenerator(MinimalMSTestStub, userCode));
registry.Should().Contain("AreGeneratedDescriptorsComplete = false");
registry.Should().NotContain("((global::DerivedTests)instance!).Hidden();");
}
[TestMethod]
public void Generator_PublicNonTestSameSignatureMethod_DoesNotReplaceInheritedTest()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class BaseTests
{
[TestMethod]
public void Hidden() { }
}
[TestClass]
public class DerivedTests : BaseTests
{
public new void Hidden() { }
}
""";
string registry = GetRegistry(RunGenerator(MinimalMSTestStub, userCode));
registry.Should().Contain("AreGeneratedDescriptorsComplete = false");
registry.Should().Contain("((global::DerivedTests)instance!).Hidden();");
}
[TestMethod]
public void Generator_InstanceTestMethod_ReplacesStaticAncestor()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class BaseTests
{
[TestMethod]
public static void Hidden() { }
}
[TestClass]
public class DerivedTests : BaseTests
{
[TestMethod]
public new void Hidden() { }
}
""";
string registry = GetRegistry(RunGenerator(MinimalMSTestStub, userCode));
registry.Should().Contain("AreGeneratedDescriptorsComplete = true");
registry.Should().Contain("((global::DerivedTests)instance!).Hidden();");
}
[TestMethod]
public void Generator_DynamicTestMethod_ReplacesObjectAncestor()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class BaseTests
{
[TestMethod]
public void Hidden(object value) { }
}
[TestClass]
public class DerivedTests : BaseTests
{
[TestMethod]
public new void Hidden(dynamic value) { }
}
""";
string registry = GetRegistry(RunGenerator(MinimalMSTestStub, userCode));
registry.Should().Contain("AreGeneratedDescriptorsComplete = true");
registry.Should().Contain("((global::DerivedTests)instance!).Hidden((dynamic)args![0]!);");
}
[TestMethod]
public void RuntimeSignature_DynamicAndObjectReturnTypes_AreEquivalent()
{
const string userCode = """
public class DynamicReturn
{
public dynamic Method() => new object();
}
public class ObjectReturn
{
public object Method() => new object();
}
""";
CSharpCompilation compilation = CreateCompilation(userCode);
var dynamicMethod = (IMethodSymbol)compilation.GetTypeByMetadataName("DynamicReturn")!.GetMembers("Method").Single();
var objectMethod = (IMethodSymbol)compilation.GetTypeByMetadataName("ObjectReturn")!.GetMembers("Method").Single();
TestMemberValidationHelper.HaveSameRuntimeDiscoverySignature(dynamicMethod, objectMethod).Should().BeTrue();
}
[TestMethod]
public void RuntimeSignature_DifferentReturnTypes_AreNotEquivalent()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class BaseTests
{
[TestMethod]
public void Hidden() { }
}
[TestClass]
public class DerivedTests : BaseTests
{
[TestMethod]
public new int Hidden() => 1;
}
""";
CSharpCompilation compilation = CreateCompilation(userCode);
var baseMethod = (IMethodSymbol)compilation.GetTypeByMetadataName("BaseTests")!.GetMembers("Hidden").Single();
var derivedMethod = (IMethodSymbol)compilation.GetTypeByMetadataName("DerivedTests")!.GetMembers("Hidden").Single();
TestMemberValidationHelper.HaveSameRuntimeDiscoverySignature(derivedMethod, baseMethod).Should().BeFalse();
GetRegistry(RunGenerator(MinimalMSTestStub, userCode))
.Should().Contain("AreGeneratedDescriptorsComplete = false");
}
[TestMethod]
public void RuntimeSignature_DifferentlyNamedMethodTypeParameters_AreNotEquivalent()
{
const string userCode = """
public class First
{
public void Method(T value) { }
}
public class Second
{
public void Method(U value) { }
}
""";
CSharpCompilation compilation = CreateCompilation(userCode);
var firstMethod = (IMethodSymbol)compilation.GetTypeByMetadataName("First")!.GetMembers("Method").Single();
var secondMethod = (IMethodSymbol)compilation.GetTypeByMetadataName("Second")!.GetMembers("Method").Single();
TestMemberValidationHelper.HaveSameRuntimeDiscoverySignature(firstMethod, secondMethod).Should().BeFalse();
}
[TestMethod]
public void Generator_NestedGenericContainingTypeSubstitutions_HaveDistinctRuntimeSignatures()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class Outer
{
public class Middle
{
public class Inner { }
}
}
public class BaseTests
{
[TestMethod]
public void Hidden(Outer.Middle.Inner value) { }
}
[TestClass]
public class DerivedTests : BaseTests
{
[TestMethod]
public new void Hidden(Outer.Middle.Inner value) { }
}
""";
string registry = GetRegistry(RunGenerator(MinimalMSTestStub, userCode));
registry.Should().Contain("AreGeneratedDescriptorsComplete = false");
registry.Should().Contain("typeof(global::Outer.Middle.Inner)");
registry.Should().NotContain("typeof(global::Outer.Middle.Inner)");
}
[TestMethod]
public void Generator_DerivedMethodGroup_HidesBaseOverloads()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class BaseTests
{
[TestMethod]
public void Op(int x) { }
}
[TestClass]
public class DerivedTests : BaseTests
{
[TestMethod]
public void Op(string x) { }
}
}
""";
Compilation outputCompilation = RunGeneratorAndGetCompilation(MinimalMSTestStub, userCode);
string registry = outputCompilation.SyntaxTrees
.Single(t => t.FilePath.EndsWith("MSTestReflectionMetadata.Registry.g.cs", StringComparison.Ordinal))
.ToString();
int opEntries = registry.Split(["Name = \"Op\""], System.StringSplitOptions.None).Length - 1;
opEntries.Should().Be(1);
registry.Should().Contain("AreGeneratedDescriptorsComplete = false");
registry.Should().Contain("typeof(string)");
outputCompilation.GetDiagnostics()
.Where(d => d.Severity == DiagnosticSeverity.Error)
.Should().BeEmpty();
}
[TestMethod]
public void Generator_DerivedIndexer_DoesNotHideBaseItemMethod()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class BaseTests
{
[TestMethod]
public void Item() { }
}
[TestClass]
public class DerivedTests : BaseTests
{
public int this[int index] => index;
}
""";
Compilation outputCompilation = RunGeneratorAndGetCompilation(MinimalMSTestStub, userCode);
string registry = outputCompilation.SyntaxTrees
.Single(t => t.FilePath.EndsWith("MSTestReflectionMetadata.Registry.g.cs", StringComparison.Ordinal))
.ToString();
registry.Should().Contain("AreGeneratedDescriptorsComplete = true");
registry.Should().Contain("((global::DerivedTests)instance!).Item();");
outputCompilation.GetDiagnostics()
.Where(d => d.Severity == DiagnosticSeverity.Error)
.Should().BeEmpty();
}
[TestMethod]
public void Generator_DerivedPropertyAccessor_DoesNotHideBaseAccessorNamedMethod()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class BaseTests
{
[TestMethod]
public void get_Value() { }
}
[TestClass]
public class DerivedTests : BaseTests
{
public int Value => 1;
}
""";
Compilation outputCompilation = RunGeneratorAndGetCompilation(MinimalMSTestStub, userCode);
string registry = outputCompilation.SyntaxTrees
.Single(t => t.FilePath.EndsWith("MSTestReflectionMetadata.Registry.g.cs", StringComparison.Ordinal))
.ToString();
registry.Should().Contain("AreGeneratedDescriptorsComplete = true");
registry.Should().Contain("((global::DerivedTests)instance!).get_Value();");
outputCompilation.GetDiagnostics()
.Where(d => d.Severity == DiagnosticSeverity.Error)
.Should().BeEmpty();
using var assemblyStream = new MemoryStream();
outputCompilation.Emit(assemblyStream).Success.Should().BeTrue();
var assembly = System.Reflection.Assembly.Load(assemblyStream.ToArray());
Type hookType = assembly.GetType("Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.SourceGeneration.ReflectionMetadataHook")!;
var registeredTestMethods = (IReadOnlyDictionary)hookType
.GetProperty("RegisteredTestMethods")!
.GetValue(null)!;
System.Reflection.MethodInfo registeredMethod = registeredTestMethods.Values.SelectMany(static methods => methods).Single();
registeredMethod.DeclaringType!.Name.Should().Be("BaseTests");
registeredMethod.ReturnType.Should().Be(typeof(void));
}
[TestMethod]
public void Generator_IncludesPropertiesFromBaseType()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class TestContext { }
public class BaseTests
{
[TestContext]
public virtual TestContext Context { get; set; } = new();
}
[TestClass]
public class DerivedTests : BaseTests
{
[TestMethod]
public void Test() { }
}
}
""";
string registry = GetRegistry(RunGenerator(MinimalMSTestStub, userCode));
registry.Should().Contain("Name = \"Context\"");
registry.Should().Contain("global::Microsoft.VisualStudio.TestTools.UnitTesting.TestContextAttribute");
}
[TestMethod]
public void Generator_ExcludesProtectedBaseMembers()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public abstract class BaseTests
{
[TestInitialize]
protected void ProtectedSetup() { }
[TestCleanup]
private protected void PrivateProtectedCleanup() { }
[TestMethod]
protected void ProtectedTest() { }
}
[TestClass]
public class DerivedTests : BaseTests
{
[TestMethod]
public void PublicTest() { }
}
}
""";
Compilation outputCompilation = RunGeneratorAndGetCompilation(MinimalMSTestStub, userCode);
string registry = outputCompilation
.SyntaxTrees
.Single(t => t.FilePath.EndsWith("MSTestReflectionMetadata.Registry.g.cs", System.StringComparison.Ordinal))
.ToString();
registry.Should().Contain("PublicTest");
registry.Should().NotContain("ProtectedSetup");
registry.Should().NotContain("PrivateProtectedCleanup");
registry.Should().NotContain("ProtectedTest");
IEnumerable errors = outputCompilation
.GetDiagnostics()
.Where(d => d.Severity == DiagnosticSeverity.Error);
errors.Should().BeEmpty("generated invokers are emitted from a non-derived type and cannot call protected base members");
}
[TestMethod]
public void Generator_DoesNotInheritConstructors()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class BaseTests
{
public BaseTests(int x) { }
}
[TestClass]
public class DerivedTests : BaseTests
{
public DerivedTests() : base(1) { }
[TestMethod]
public void Test() { }
}
}
""";
string registry = GetRegistry(RunGenerator(MinimalMSTestStub, userCode));
// Only the derived ctor (parameterless) should be emitted — base ctor is never inherited.
registry.Should().Contain("Invoke = static args => new global::Sample.DerivedTests(),");
registry.Should().NotContain("Invoke = static args => new global::Sample.BaseTests(");
// No int parameter from the base constructor leaks into the constructor list.
registry.Should().NotContain("ParameterTypes = new Type[] { typeof(int) },");
}
[TestMethod]
public void Generator_AbstractBaseWithConcreteDerived_FoldsBaseMembers()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
public class TestContext { }
public abstract class AbstractBase
{
[TestInitialize]
public void Setup() { }
[TestContext]
public TestContext Ctx { get; set; } = new();
}
[TestClass]
public class Concrete : AbstractBase
{
[TestMethod]
public void Test() { }
}
}
""";
string registry = GetRegistry(RunGenerator(MinimalMSTestStub, userCode));
registry.Should().Contain("Name = \"Setup\"");
registry.Should().Contain("Name = \"Ctx\"");
registry.Should().Contain("Name = \"Test\"");
// The base class was abstract but the concrete derived type is the one emitted.
registry.Should().Contain("Type = typeof(global::Sample.Concrete)");
}
[TestMethod]
public void Generator_DoesNotWalkPastSystemObject()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public class SimpleTests
{
[TestMethod]
public void Test() { }
}
}
""";
string registry = GetRegistry(RunGenerator(MinimalMSTestStub, userCode));
// Members of System.Object (ToString, Equals, GetHashCode, GetType) must NOT be emitted.
registry.Should().NotContain("Name = \"ToString\"");
registry.Should().NotContain("Name = \"Equals\"");
registry.Should().NotContain("Name = \"GetHashCode\"");
registry.Should().NotContain("Name = \"GetType\"");
}
[TestMethod]
public void Generator_MaterializesSchedulingAttributes_OnMethodAndClass()
{
// '[DependsOn]' and '[ResourceLock]' are not part of the generator's small set of specially
// understood attributes; they ride the generic attribute-materialization path, which is what
// makes them work under Native AOT. This pins that so the generic path is not narrowed to an
// allow-list by accident.
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Microsoft.VisualStudio.TestTools.UnitTesting
{
[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Method, AllowMultiple = true, Inherited = false)]
public sealed class DependsOnAttribute : System.Attribute
{
public DependsOnAttribute(string testMethodName) { }
public DependsOnAttribute(System.Type testClass) { }
public bool ProceedOnFailure { get; set; }
}
[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Method, AllowMultiple = true, Inherited = false)]
public sealed class ResourceLockAttribute : System.Attribute
{
public ResourceLockAttribute(string resource) { }
}
}
namespace Sample
{
[TestClass]
[DependsOn(typeof(Tests))]
public class Tests
{
[TestMethod]
public void CreateCart() { }
[TestMethod]
[DependsOn(nameof(CreateCart), ProceedOnFailure = true)]
[ResourceLock("database")]
public void AddItem() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
registry.Should().Contain("new global::Microsoft.VisualStudio.TestTools.UnitTesting.DependsOnAttribute(\"CreateCart\")");
registry.Should().Contain("ProceedOnFailure = true");
registry.Should().Contain("new global::Microsoft.VisualStudio.TestTools.UnitTesting.DependsOnAttribute(typeof(global::Sample.Tests))");
registry.Should().Contain("new global::Microsoft.VisualStudio.TestTools.UnitTesting.ResourceLockAttribute(\"database\")");
}
[TestMethod]
public void Generator_CapturesAssemblyLevelAttribute()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
[assembly: Parallelize(Workers = 4, Scope = "Method")]
namespace Sample
{
[TestClass]
public class Tests
{
[TestMethod]
public void Test() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
registry.Should().Contain("#pragma warning disable MSTESTEXP");
registry.Should().Contain("public static object[] AssemblyAttributes { get; } = new object[]");
registry.Should().Contain("(Attribute)new global::Microsoft.VisualStudio.TestTools.UnitTesting.ParallelizeAttribute()");
registry.Should().Contain("Workers = 4");
registry.Should().Contain("Scope = \"Method\"");
}
[TestMethod]
public void Generator_AssemblyAttributes_IsEmptyArray_WhenNoneApplied()
{
const string userCode = """
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Sample
{
[TestClass]
public class Tests
{
[TestMethod]
public void Test() { }
}
}
""";
GeneratorRunResult result = RunGenerator(MinimalMSTestStub, userCode);
result.Diagnostics.Should().BeEmpty();
string registry = GetRegistry(result);
registry.Should().Contain("public static object[] AssemblyAttributes { get; } = Array.Empty