protected static CSharpCompilation CreateCompilation(string source, string compilationName)
    => CSharpCompilation.Create(compilationName,
        syntaxTrees: new[]
        {
            CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview))
        },
        references: new[]
        {
            MetadataReference.CreateFromFile(Assembly.GetCallingAssembly().Location),
            MetadataReference.CreateFromFile(typeof(string).Assembly.Location),
            MetadataReference.CreateFromFile(typeof(LightMock.InvocationInfo).Assembly.Location),
            MetadataReference.CreateFromFile(typeof(IMock<>).Assembly.Location),
            MetadataReference.CreateFromFile(typeof(Xunit.Assert).Assembly.Location),
            MetadataReference.CreateFromFile(Assembly.Load(new AssemblyName("System.Linq.Expressions")).Location),
            MetadataReference.CreateFromFile(Assembly.Load(new AssemblyName("System.Runtime")).Location),
            MetadataReference.CreateFromFile(Assembly.Load(new AssemblyName("netstandard")).Location),
        },
        options: new CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind.DynamicallyLinkedLibrary));

Ссылка на код

protected (ImmutableArray<Diagnostic> diagnostics, bool success, byte[] assembly) DoCompile(string source, string compilationName)
{
    var compilation = CreateCompilation(source, compilationName);
    var driver = CSharpGeneratorDriver.Create(
        ImmutableArray.Create(new LightMockGenerator()),
        Enumerable.Empty<AdditionalText>(),
        (CSharpParseOptions)compilation.SyntaxTrees.First().Options);

    driver.RunGeneratorsAndUpdateCompilation(compilation, out var updatedCompilation, out var diagnostics);
    var ms = new MemoryStream();
    var result = updatedCompilation.Emit(ms);
    foreach (var i in result.Diagnostics)
        testOutputHelper.WriteLine(i.ToString());
    return (diagnostics, result.Success, ms.ToArray());
}

Ссылка на код

public interface ITestScript<T>
    where T : class
{
    IMock<T> Context { get; } // интерфейс для сгенерированного кода
    T MockObject { get; } // интерфейс для сгенерированнго объекта

    int DoRun(); // чтобы тестировать сгенерированные функции,
    // которые сложно пробросить наружу
}

Исходный код

using System;
using Xunit;

namespace LightMock.Generator.Tests.Mock
{
    public class AbstractClassWithBasicMethods : ITestScript<AAbstractClassWithBasicMethods>
    {
    		// этот объект Mock<T> был сгенерирован
        private readonly Mock<AAbstractClassWithBasicMethods> mock;

        public AbstractClassWithBasicMethods()
            => mock = new Mock<AAbstractClassWithBasicMethods>();

        public IMock<AAbstractClassWithBasicMethods> Context => mock;

        public AAbstractClassWithBasicMethods MockObject => mock.Object;

        public int DoRun()
        {
        		// функция Protected() была сгенерирована
            mock.Protected().Arrange(f => f.ProtectedGetSomething()).Returns(1234);
            Assert.Equal(expected: 1234, mock.Object.InvokeProtectedGetSomething());

            mock.Object.InvokeProtectedDoSomething(5678);
            mock.Protected().Assert(f => f.ProtectedDoSomething(5678));

            return 42;
        }
    }
}

Исходный код

sealed class MockAnalyzerConfigOptions : AnalyzerConfigOptions
{
    public static MockAnalyzerConfigOptions Empty { get; }
        = new MockAnalyzerConfigOptions(ImmutableDictionary<string, string>.Empty);

    private readonly ImmutableDictionary<string, string> backing;

    public MockAnalyzerConfigOptions(ImmutableDictionary<string, string> backing)
        => this.backing = backing;

    public override bool TryGetValue(string key, [NotNullWhen(true)] out string? value)
        => backing.TryGetValue(key, out value);
}

sealed class MockAnalyzerConfigOptionsProvider : AnalyzerConfigOptionsProvider
{
    private readonly ImmutableDictionary<object, AnalyzerConfigOptions> otherOptions;

    public MockAnalyzerConfigOptionsProvider(AnalyzerConfigOptions globalOptions)
        : this(globalOptions, ImmutableDictionary<object, AnalyzerConfigOptions>.Empty)
    { }

    public MockAnalyzerConfigOptionsProvider(AnalyzerConfigOptions globalOptions,
        ImmutableDictionary<object, AnalyzerConfigOptions> otherOptions)
    {
        GlobalOptions = globalOptions;
        this.otherOptions = otherOptions;
    }

    public static MockAnalyzerConfigOptionsProvider Empty { get; }
        = new MockAnalyzerConfigOptionsProvider(
            MockAnalyzerConfigOptions.Empty,
            ImmutableDictionary<object, AnalyzerConfigOptions>.Empty);

    public override AnalyzerConfigOptions GlobalOptions { get; }

    public override AnalyzerConfigOptions GetOptions(SyntaxTree tree)
        => GetOptionsPrivate(tree);

    public override AnalyzerConfigOptions GetOptions(AdditionalText textFile)
        => GetOptionsPrivate(textFile);

    AnalyzerConfigOptions GetOptionsPrivate(object o)
        => otherOptions.TryGetValue(o, out var options) ? options : MockAnalyzerConfigOptions.Empty;
}

Исходный код: раз, два.