Skip to content

Set MSTest.Sdk-wide defaults: UseMSTestSdk, method-level parallelization, Recommended analyzers #54766

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
Evangelink merged 2 commits into from
Jun 16, 2026
+46 −28
Merged

Set MSTest.Sdk-wide defaults: UseMSTestSdk, method-level parallelization, Recommended analyzers #54766

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
ecef043
Set MSTest.Sdk-wide defaults: UseMSTestSdk, method-level parallelizat…
Evangelink Jun 15, 2026
6b993f0
Fix MSTEST0037 in ArrayBufferWriterTests after enabling MSTestAnalysi…
Evangelink Jun 15, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
7 changes: 7 additions & 0 deletions Directory.Build.props
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -87,6 +87,13 @@
<ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
<CentralPackageTransitivePinningEnabled>true</CentralPackageTransitivePinningEnabled>

<!-- Tell Arcade we are using MSTest.Sdk for MSTest test projects. This prevents
Arcade from implicitly adding Microsoft.TestPlatform / MSTest.TestFramework /
MSTest.TestAdapter / Microsoft.NET.Test.Sdk package references (MSTest.Sdk
brings them transitively with versions controlled by the SDK), so the MSTest
package versions don't need to be specified in Directory.Packages.props. -->
<UseMSTestSdk>true</UseMSTestSdk>

<!-- https://github.com/dotnet/source-build/issues/4115. -->
<PublishWindowsPdb>false</PublishWindowsPdb>

Expand Down
11 changes: 11 additions & 0 deletions test/Directory.Build.props
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -25,4 +25,15 @@
<IncludeSymbols>false</IncludeSymbols>
</PropertyGroup>

<!-- MSTest.Sdk defaults. Applied to projects that opt in via <Project Sdk="MSTest.Sdk">,
which sets UsingMSTestSdk=true in its Sdk.props before this file is evaluated. -->
<PropertyGroup Condition="'$(UsingMSTestSdk)' == 'true'">
<!-- Run tests in parallel at the method level by default. MSTest.TestAdapter
emits the corresponding [assembly: Parallelize(Scope = MethodLevel)] attribute. -->
<MSTestParallelizeScope>MethodLevel</MSTestParallelizeScope>

<!-- Promote info-severity MSTest analyzer rules to warnings and critical rules to errors. -->
<MSTestAnalysisMode>Recommended</MSTestAnalysisMode>
</PropertyGroup>

</Project>
56 changes: 28 additions & 28 deletions test/Microsoft.DotNet.HotReload.Client.Tests/ArrayBufferWriterTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -44,8 +44,8 @@ public void ArrayBufferWriter_Ctor()

{
var output = new ArrayBufferWriter<T>(200);
Assert.IsTrue(output.FreeCapacity >= 200);
Assert.IsTrue(output.Capacity >= 200);
Assert.IsGreaterThanOrEqualTo(200, output.FreeCapacity);
Assert.IsGreaterThanOrEqualTo(200, output.Capacity);
Assert.AreEqual(0, output.WrittenCount);
Assert.IsTrue(ReadOnlySpan<T>.Empty.SequenceEqual(output.WrittenSpan));
Assert.IsTrue(ReadOnlyMemory<T>.Empty.Span.SequenceEqual(output.WrittenMemory.Span));
Expand Down Expand Up @@ -76,8 +76,8 @@ public void Clear()
var output = new ArrayBufferWriter<T>(256);
int previousAvailable = output.FreeCapacity;
WriteData(output, 2);
Assert.IsTrue(output.FreeCapacity < previousAvailable);
Assert.IsTrue(output.WrittenCount > 0);
Assert.IsLessThan(previousAvailable, output.FreeCapacity);
Assert.IsGreaterThan(0, output.WrittenCount);
Assert.IsFalse(ReadOnlySpan<T>.Empty.SequenceEqual(output.WrittenSpan));
Assert.IsFalse(ReadOnlyMemory<T>.Empty.Span.SequenceEqual(output.WrittenMemory.Span));
Assert.IsTrue(output.WrittenSpan.SequenceEqual(output.WrittenMemory.Span));
Expand All @@ -104,8 +104,8 @@ public void ResetWrittenCount()
var output = new ArrayBufferWriter<T>(256);
int previousAvailable = output.FreeCapacity;
WriteData(output, 2);
Assert.IsTrue(output.FreeCapacity < previousAvailable);
Assert.IsTrue(output.WrittenCount > 0);
Assert.IsLessThan(previousAvailable, output.FreeCapacity);
Assert.IsGreaterThan(0, output.WrittenCount);
Assert.IsFalse(ReadOnlySpan<T>.Empty.SequenceEqual(output.WrittenSpan));
Assert.IsFalse(ReadOnlyMemory<T>.Empty.Span.SequenceEqual(output.WrittenMemory.Span));
Assert.IsTrue(output.WrittenSpan.SequenceEqual(output.WrittenMemory.Span));
Expand Down Expand Up @@ -145,7 +145,7 @@ public void Advance()
Assert.AreEqual(0, output.FreeCapacity);
int previousCapacity = output.Capacity;
Span<T> _ = output.GetSpan();
Assert.IsTrue(output.Capacity > previousCapacity);
Assert.IsGreaterThan(previousCapacity, output.Capacity);
}

{
Expand Down Expand Up @@ -257,7 +257,7 @@ public void GetMemory_DefaultCtor()
Assert.AreEqual(256, memory.Length);

var segment = output.GetArraySegment();
Assert.AreEqual(memory.Length, segment.Count);
Assert.HasCount(memory.Length, segment);
}

[TestMethod]
Expand All @@ -269,7 +269,7 @@ public void GetMemory_DefaultCtor_WithSizeHint(int sizeHint)
Assert.AreEqual(sizeHint <= 256 ? 256 : sizeHint, memory.Length);

var segment = output.GetArraySegment(sizeHint);
Assert.AreEqual(memory.Length, segment.Count);
Assert.HasCount(memory.Length, segment);
}

[TestMethod]
Expand All @@ -288,7 +288,7 @@ public void GetMemory_InitSizeCtor()
Assert.AreEqual(100, memory.Length);

var segment = output.GetArraySegment();
Assert.AreEqual(memory.Length, segment.Count);
Assert.HasCount(memory.Length, segment);
}

[TestMethod]
Expand All @@ -301,7 +301,7 @@ public void GetMemory_InitSizeCtor_WithSizeHint(int sizeHint)
Assert.AreEqual(sizeHint <= 256 ? 256 : sizeHint + 256, memory.Length);

var segment = output.GetArraySegment();
Assert.AreEqual(memory.Length, segment.Count);
Assert.HasCount(memory.Length, segment);
}

{
Expand All @@ -310,7 +310,7 @@ public void GetMemory_InitSizeCtor_WithSizeHint(int sizeHint)
Assert.AreEqual(sizeHint <= 1000 ? 1000 : sizeHint + 1000, memory.Length);

var segment = output.GetArraySegment();
Assert.AreEqual(memory.Length, segment.Count);
Assert.HasCount(memory.Length, segment);
}
}

Expand Down Expand Up @@ -346,9 +346,9 @@ public void GetMemoryAndSpan()
var memory = output.GetMemory();
var segment = output.GetArraySegment();
Span<T> memorySpan = memory.Span;
Assert.IsTrue(span.Length > 0);
Assert.IsGreaterThan(0, span.Length);
Assert.AreEqual(span.Length, memorySpan.Length);
Assert.AreEqual(span.Length, segment.Count);
Assert.HasCount(span.Length, segment);

for (int i = 0; i < span.Length; i++)
{
Expand All @@ -366,20 +366,20 @@ public void GetMemoryAndSpan()
Assert.IsTrue(writtenSoFarMemory.Span.SequenceEqual(writtenSoFar));
int previousAvailable = output.FreeCapacity;
var span = output.GetSpan(500);
Assert.IsTrue(span.Length >= 500);
Assert.IsTrue(output.FreeCapacity >= 500);
Assert.IsTrue(output.FreeCapacity > previousAvailable);
Assert.IsGreaterThanOrEqualTo(500, span.Length);
Assert.IsGreaterThanOrEqualTo(500, output.FreeCapacity);
Assert.IsGreaterThan(previousAvailable, output.FreeCapacity);

Assert.AreEqual(writtenSoFar.Length, output.WrittenCount);
Assert.IsFalse(writtenSoFar.SequenceEqual(span.Slice(0, output.WrittenCount)));

var memory = output.GetMemory();
var segment = output.GetArraySegment();
Span<T> memorySpan = memory.Span;
Assert.IsTrue(span.Length >= 500);
Assert.IsTrue(memorySpan.Length >= 500);
Assert.IsGreaterThanOrEqualTo(500, span.Length);
Assert.IsGreaterThanOrEqualTo(500, memorySpan.Length);
Assert.AreEqual(span.Length, memorySpan.Length);
Assert.AreEqual(span.Length, segment.Count);
Assert.HasCount(span.Length, segment);
for (int i = 0; i < span.Length; i++)
{
Assert.AreEqual(default, span[i]);
Expand All @@ -390,7 +390,7 @@ public void GetMemoryAndSpan()
memory = output.GetMemory(500);
segment = output.GetArraySegment(500);
memorySpan = memory.Span;
Assert.IsTrue(memorySpan.Length >= 500);
Assert.IsGreaterThanOrEqualTo(500, memorySpan.Length);
Assert.AreEqual(span.Length, memorySpan.Length);
for (int i = 0; i < memorySpan.Length; i++)
{
Expand All @@ -411,7 +411,7 @@ public void GetSpanShouldAtleastDoubleWhenGrowing()
Assert.AreEqual(previousAvailable, output.FreeCapacity);

_ = output.GetSpan(previousAvailable + 1);
Assert.IsTrue(output.FreeCapacity >= previousAvailable * 2);
Assert.IsGreaterThanOrEqualTo(previousAvailable * 2, output.FreeCapacity);
}

[TestMethod]
Expand Down Expand Up @@ -485,7 +485,7 @@ public class ArrayBufferWriterTests_Byte : ArrayBufferWriterTests<byte>
protected override void WriteData(IBufferWriter<byte> bufferWriter, int numBytes)
{
Span<byte> outputSpan = bufferWriter.GetSpan(numBytes);
Assert.IsTrue(outputSpan.Length >= numBytes);
Assert.IsGreaterThanOrEqualTo(numBytes, outputSpan.Length);
var random = new Random(42);

var data = new byte[numBytes];
Expand Down Expand Up @@ -514,7 +514,7 @@ public void WriteAndCopyToStream(bool clearContent)

Assert.IsTrue(transientSpan.SequenceEqual(transientMemory.Span));

Assert.IsTrue(transientSpan[0] != 0);
Assert.AreNotEqual((byte)0, transientSpan[0]);
byte expectedFirstByte = transientSpan[0];

memStream.Write(transientSpan.ToArray(), 0, transientSpan.Length);
Expand All @@ -539,7 +539,7 @@ public void WriteAndCopyToStream(bool clearContent)
Assert.IsTrue(ReadOnlySpan<byte>.Empty.SequenceEqual(output.WrittenMemory.Span));
Assert.IsTrue(output.WrittenSpan.SequenceEqual(output.WrittenMemory.Span));

Assert.AreEqual(outputSpan.Length, streamOutput.Length);
Assert.HasCount(outputSpan.Length, streamOutput);
Assert.IsTrue(outputSpan.SequenceEqual(streamOutput));
}

Expand All @@ -559,7 +559,7 @@ public async Task WriteAndCopyToStreamAsync(bool clearContent)

ReadOnlyMemory<byte> transient = output.WrittenMemory;

Assert.IsTrue(transient.Span[0] != 0);
Assert.AreNotEqual((byte)0, transient.Span[0]);
byte expectedFirstByte = transient.Span[0];

await memStream.WriteAsync(transient.ToArray(), 0, transient.Length, TestContext.CancellationToken);
Expand All @@ -574,15 +574,15 @@ public async Task WriteAndCopyToStreamAsync(bool clearContent)
output.ResetWrittenCount();
}

Assert.IsTrue(transient.Span[0] == expectedFirstByte);
Assert.AreEqual(expectedFirstByte, transient.Span[0]);

Assert.AreEqual(0, output.WrittenCount);
byte[] streamOutput = memStream.ToArray();

Assert.IsTrue(ReadOnlyMemory<byte>.Empty.Span.SequenceEqual(output.WrittenMemory.Span));
Assert.IsTrue(ReadOnlySpan<byte>.Empty.SequenceEqual(output.WrittenMemory.Span));

Assert.AreEqual(outputMemory.Length, streamOutput.Length);
Assert.HasCount(outputMemory.Length, streamOutput);
Assert.IsTrue(outputMemory.Span.SequenceEqual(streamOutput));
}
}
Loading