ITestReporterWrapper reporter = new NoTestReporting();
StringBuilder builder = new();
builder.AppendLine(string.Join("\n", aliasMap.Values.Where(alias => alias != "global").Select(alias => $"extern alias {alias};")));
+ builder.AppendLine("namespace __GeneratedMainWrapper;");
+ builder.AppendLine("class __GeneratedMainWrapper {");
+ builder.AppendLine("public static int Main() {");
builder.AppendLine("try {");
builder.AppendLine(string.Join("\n", testInfos.Select(m => m.GenerateTestExecution(reporter))));
builder.AppendLine("} catch(System.Exception ex) { System.Console.WriteLine(ex.ToString()); return 101; }");
builder.AppendLine("return 100;");
+ builder.AppendLine("}");
+ builder.AppendLine("}");
return builder.ToString();
}
partial class Program
{
[Fact]
- static void Via_GetFunctionPointer()
+ internal static void Via_GetFunctionPointer()
{
Console.WriteLine($"Running {nameof(Via_GetFunctionPointer)}...");
}
[Fact]
- static void Via_GetFunctionPointer_Generics()
+ internal static void Via_GetFunctionPointer_Generics()
{
Console.WriteLine($"Running {nameof(Via_GetFunctionPointer_Generics)}...");
}
[Fact]
- static void Via_Ldftn()
+ internal static void Via_Ldftn()
{
Console.WriteLine($"Running {nameof(Via_Ldftn)}...");
}
[Fact]
- static void Via_Ldftn_Generics()
+ internal static void Via_Ldftn_Generics()
{
Console.WriteLine($"Running {nameof(Via_Ldftn_Generics)}...");
}
[Fact]
- static void Via_Ldftn_Generics_Virtual()
+ internal static void Via_Ldftn_Generics_Virtual()
{
Console.WriteLine($"Running {nameof(Via_Ldftn_Generics_Virtual)}...");
}
[Fact]
- static void Via_Ldftn_Generics_EarlyLoad()
+ internal static void Via_Ldftn_Generics_EarlyLoad()
{
Console.WriteLine($"Running {nameof(Via_Ldftn_Generics_EarlyLoad)}...");
}
[Fact]
- static void Via_Ldftn_Generics_Virtual_EarlyLoad()
+ internal static void Via_Ldftn_Generics_Virtual_EarlyLoad()
{
Console.WriteLine($"Running {nameof(Via_Ldftn_Generics_Virtual_EarlyLoad)}...");
}
[Fact]
- static void Via_Ldvirtftn()
+ internal static void Via_Ldvirtftn()
{
Console.WriteLine($"Running {nameof(Via_Ldvirtftn)}...");
}
[Fact]
- static void Via_Ldvirtftn_Generics()
+ internal static void Via_Ldvirtftn_Generics()
{
Console.WriteLine($"Running {nameof(Via_Ldvirtftn_Generics)}...");
}
[Fact]
- static void Via_Ldvirtftn_Generics_EarlyLoad()
+ internal static void Via_Ldvirtftn_Generics_EarlyLoad()
{
Console.WriteLine($"Running {nameof(Via_Ldvirtftn_Generics_EarlyLoad)}...");
using System;
using System.Runtime.CompilerServices;
using System.Threading;
+using Xunit;
public class DeadThreads
{
t.Start();
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GCTriggerSanityTest();
return 100;
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for CLRTestEnvironmentVariable -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
</PropertyGroup>
<ItemGroup>
<Compile Include="$(MSBuildProjectName).cs" />
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+ <PropertyGroup>
+ <BuildAsStandalone Condition="'$(BuildAsStandalone)' == ''">false</BuildAsStandalone>
+
+ <AssemblyName Condition="'$(BuildAsStandalone)' != 'true'">$(MSBuildProjectName.Replace('_il_d', '').Replace('_il_r', ''))</AssemblyName>
+ </PropertyGroup>
+
+ <Import Project="..\..\Directory.Build.props" />
+</Project>
\ No newline at end of file
using System.Text;
// using System.Configuration;
using System.Runtime.InteropServices;
+using Xunit;
namespace StackCommitTest
{
- class DefaultStackCommit
+ public class DefaultStackCommit
{
- static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
int result = 1;
bool commitEnabled = false;
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for CLRTestTargetUnsupported -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
<!-- Test unsupported outside of windows -->
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public class mytest {
- public static int Main() {
+ [Fact]
+ public static int TestEntryPoint() {
int rValue = 100;
AutoResetEvent are = null;
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public class mytest {
- public static int Main() {
+ [Fact]
+ public static int TestEntryPoint() {
int rValue = 100;
ManualResetEvent mre = null;
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public class mytest {
- public static int Main() {
+ [Fact]
+ public static int TestEntryPoint() {
int rValue = 100;
Mutex mut = null;
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public class mytest {
- public static int Main() {
+ [Fact]
+ public static int TestEntryPoint() {
int rValue = 100;
RegisteredWaitHandle rwh = null;
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
using System.Threading;
// using System.Runtime.Remoting;
using System.Runtime.Serialization;
+using Xunit;
public class mytest {
- public static int Main() {
+ [Fact]
+ public static int TestEntryPoint() {
int rValue = 100;
SynchronizationLockException sle = null;
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
using System;
using System.Threading;
using System.Runtime.Serialization;
+using Xunit;
public class mytest {
- public static int Main() {
+ [Fact]
+ public static int TestEntryPoint() {
int rValue = 100;
ThreadStateException ta = null;
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public class mytest {
- public static int Main() {
+ [Fact]
+ public static int TestEntryPoint() {
int rValue = 100;
Timer time = null;
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public class mytest {
- public static int Main() {
+ [Fact]
+ public static int TestEntryPoint() {
int rValue = 100;
WaitHandle wh = null;
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
using System.Diagnostics;
using System.Reflection;
using System.Threading;
+using Xunit;
namespace Threading.Tests
{
private static ManualResetEvent s_resetEvent = new ManualResetEvent(false);
private static ulong[] s_threadIds = new ulong[NumThreads];
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
// The property to be tested is internal.
Type runtimeThreadType = typeof(object).Assembly.GetType("System.Threading.Thread");
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
<ItemGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
namespace DelegateTest
{
}
}
- class BeginInvokeEndInvokeTest
+ public class BeginInvokeEndInvokeTest
{
public delegate string AsyncMethodCaller(int input);
- static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
IAsyncResult result = null;
AsyncMethodCaller caller = new AsyncMethodCaller(DelegateCommon.TestMethod);
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
public class RefX1<T> {}
}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.EnterExitTest();
Gen<double>.EnterExitTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<double>.EnterExitTest<int>();
Gen<string>.EnterExitTest<int>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.EnterExitTest();
Gen<double>.EnterExitTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<double>.EnterExitTest<int>();
Gen<string>.EnterExitTest<int>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.EnterExitTest();
Gen<double>.EnterExitTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<double>.EnterExitTest<int>();
Gen<string>.EnterExitTest<int>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.EnterExitTest();
Gen<double>.EnterExitTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<double>.EnterExitTest<int>();
Gen<string>.EnterExitTest<int>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
public class RefX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.EnterExitTest();
Gen<double>.EnterExitTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.EnterExitTest();
Gen<double>.EnterExitTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.EnterExitTest();
Gen<double>.EnterExitTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<double>.EnterExitTest<int>();
Gen<string>.EnterExitTest<int>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.EnterExitTest();
Gen<double>.EnterExitTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<double>.EnterExitTest<int>();
Gen<string>.EnterExitTest<int>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.TryEnterTest();
Gen<double>.TryEnterTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
public class RefX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.TryEnterTest<int>(true);
Gen<double>.TryEnterTest<int>(false);
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.TryEnterTest();
/*Gen<double>.TryEnterTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.TryEnterTest();
Gen<double>.TryEnterTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public struct ValX1<T> {}
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.TryEnterTest<int>(true);
Gen<double>.TryEnterTest<int>(false);
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest<int>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest<int>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest<int>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
using System;
using System.Threading;
using System.Diagnostics;
+using Xunit;
//namespace TimerCallbackTests ////////////// added this namesp
public static bool result = true;
public static int timeToRun = 5000;
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest<int>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest<int>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest<int>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.DelegateTest();
Gen<double>.DelegateTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.DelegateTest();
Gen<double>.DelegateTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.DelegateTest<object>();
Gen.DelegateTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.DelegateTest<object>();
Gen.DelegateTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.DelegateTest<object>();
Gen<double>.DelegateTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.DelegateTest<object>();
Gen<double>.DelegateTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.DelegateTest();
Gen<double>.DelegateTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.DelegateTest<object>();
Gen.DelegateTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.DelegateTest<object>();
Gen<double>.DelegateTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.DelegateTest();
Gen<double>.DelegateTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.DelegateTest();
Gen<double>.DelegateTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.DelegateTest();
Gen<double>.DelegateTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.DelegateTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.DelegateTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.DelegateTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.DelegateTest<object>();
Gen.DelegateTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.DelegateTest<object>();
Gen.DelegateTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.DelegateTest<object>();
Gen.DelegateTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.DelegateTest<object>();
Gen<double>.DelegateTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.DelegateTest<object>();
Gen<double>.DelegateTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.DelegateTest<object>();
Gen<double>.DelegateTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.DelegateTest<int>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.DelegateTest<int>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.DelegateTest<int>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.DelegateTest();
Gen<double>.DelegateTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.DelegateTest();
Gen<double>.DelegateTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.DelegateTest<object>();
Gen<double>.DelegateTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.DelegateTest<object>();
Gen<double>.DelegateTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.DelegateTest<object>();
Gen.DelegateTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.DelegateTest<object>();
Gen.DelegateTest<string>();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest<int>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest<int>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
interface IGen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
GenInt.ThreadPoolTest<int>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest();
Gen<double>.ThreadPoolTest();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen<T>
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen<int>.ThreadPoolTest<object>();
Gen<double>.ThreadPoolTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
class Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
struct Gen
{
}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Gen.ThreadPoolTest<object>();
Gen.ThreadPoolTest<string>();
using System;
using System.Threading;
+using Xunit;
public class Test_13662_a {
- public static int Main(){
+ [Fact]
+ public static int TestEntryPoint(){
int rValue = 100;
Timer[] tArray = new Timer[1000];
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for UnloadabilityIncompatible -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<!-- Under heavy load, some of the TimerCallback functions don't complete before the test exits, preventing unload -->
<UnloadabilityIncompatible>true</UnloadabilityIncompatible>
<CLRTestPriority>1</CLRTestPriority>
using System;
using System.Threading;
+using Xunit;
public class Test_13662_b {
- public static int Main(){
+ [Fact]
+ public static int TestEntryPoint(){
int rValue = 100;
Timer[] tArray = new Timer[1000];
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for UnloadabilityIncompatible -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<!-- Under heavy load, some of the TimerCallback functions don't complete before the test exits, preventing unload -->
<UnloadabilityIncompatible>true</UnloadabilityIncompatible>
<CLRTestPriority>1</CLRTestPriority>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for UnloadabilityIncompatible -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<!-- Under heavy load, some of the TimerCallback functions don't complete before the test exits, preventing unload -->
<UnloadabilityIncompatible>true</UnloadabilityIncompatible>
<CLRTestPriority>1</CLRTestPriority>
using System;
using System.Threading;
+using Xunit;
public class Test_simple {
- public static int Main(){
+ [Fact]
+ public static int TestEntryPoint(){
int rValue = 100;
Timer[] tArray = new Timer[100];
using System.Runtime.InteropServices;
using System.Reflection;
using System.Threading;
+using Xunit;
/*
* Issue description:
public class Test_foreground_shutdown
{
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
new Thread(() =>
{
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for Environment.Exit -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<ItemGroup>
using System;
using System.Threading;
+using Xunit;
-class ObjMonHelper {
+public class ObjMonHelper {
const string FailMsg = @"Monitor.Enter appears to have mistaken a hash code in an object header for
a valid lock owned by the current thread.";
- public static int Main() {
+ [Fact]
+ public static int TestEntryPoint() {
var ok = true;
var arr = new object[1024*1024];
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for GCStressIncompatible, CLRTestEnvironmentVariable -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<CLRTestPriority>1</CLRTestPriority>
<GCStressIncompatible>true</GCStressIncompatible>
</PropertyGroup>
using System;
using System.Threading;
+using Xunit;
public class Test_30032 {
- public static int Main(){
+ [Fact]
+ public static int TestEntryPoint(){
int rValue = 100;
Timer[] tArray = new Timer[100];
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<ItemGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
-
-class Test
+using System.Runtime.CompilerServices;
+using Xunit;
+public class Test
{
bool _aRun = false;
public void A()
static bool s_takeLock = false;
static bool s_contention = false;
- public static int Main(string[] args)
+ [Fact]
+ public static int TestEntryPoint() => Run(new string[0]);
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public static int Run(string[] args)
{
ReadArgs(args);
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for GCStressIncompatible -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
<GCStressIncompatible>true</GCStressIncompatible>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Threading;
+using Xunit;
public class Beta
{
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
int rValue = 100;
Console.WriteLine("Setup an Infinite Wait with negative value other than -1");
using System;
using System.Threading;
+using Xunit;
public class TimerTest
{
public static void Target(Object foo){}
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
int retVal = 0;
Timer timer = new Timer(new TimerCallback(Target),new Object(), 1000,1000);
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<ItemGroup>
using System;
using System.Threading;
+using Xunit;
-class Test
+public class Test
{
static bool _fTestFailed = false;
static bool _fTestDone = false;
static ManualResetEvent _mre;
static AutoResetEvent _are = new AutoResetEvent(false);
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Thread th = new Thread(new ThreadStart(Thread2));
th.Start();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for UnloadabilityIncompatible -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<!-- This test leaves random number of WaitOrTimerCallbacks registered at the exit, which prevents unloading -->
<UnloadabilityIncompatible>true</UnloadabilityIncompatible>
<CLRTestPriority>1</CLRTestPriority>
using System;
using System.Threading;
+using Xunit;
-class Test
+public class Test
{
static bool _fTestFailed = false;
static bool _fTestDone = false;
static ManualResetEvent _mre;
static AutoResetEvent _are = new AutoResetEvent(false);
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Thread th = new Thread(new ThreadStart(Thread2));
th.Start();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for GCStressIncompatible -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<CLRTestPriority>1</CLRTestPriority>
<!-- This test isn't technically incompatible with GCStress, but it ends up running very slowly
in some configurations, e.g. GCStress=3 on Linux/arm32 measured at 20 minutes.
using System;
using System.Threading;
using System.Threading.Tasks;
+using Xunit;
/*
* Issue description:
cancel the associated Task.
*/
-class Test
+public class Test
{
- static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
SemaphoreSlim s = new SemaphoreSlim(initialCount: 1);
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<ItemGroup>
using System;
using System.Threading;
+using Xunit;
public class Stop {
- public static int Main() {
+ [Fact]
+ public static int TestEntryPoint() {
Stop tm = new Stop();
try
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for CLRTestTargetUnsupported -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<CLRTestPriority>1</CLRTestPriority>
<!-- Test unsupported outside of windows -->
<CLRTestTargetUnsupported Condition="'$(TargetsWindows)' != 'true'">true</CLRTestTargetUnsupported>
--- /dev/null
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <IsMergedTestRunnerAssembly>true</IsMergedTestRunnerAssembly>
+ </PropertyGroup>
+ <ItemGroup>
+ <MergedWrapperProjectReference Include="commitstackonlyasneeded/**/*.??proj" />
+ <MergedWrapperProjectReference Include="coverage/**/*.??proj" />
+ <MergedWrapperProjectReference Include="DeadThreads/**/*.??proj" />
+ <MergedWrapperProjectReference Include="delegate/**/*.??proj" />
+ <MergedWrapperProjectReference Include="generics/threadstart/*.??proj" />
+ <MergedWrapperProjectReference Include="generics/syncdelegate/*.??proj" />
+ <MergedWrapperProjectReference Include="regressions/**/*.??proj" />
+ <MergedWrapperProjectReference Update="**" Aliases="$([System.String]::Concat("_",$([System.String]::Copy("%(Filename)").Replace("-","_"))))" />
+ <ProjectReference Include="@(MergedWrapperProjectReference)" />
+ </ItemGroup>
+</Project>
\ No newline at end of file
--- /dev/null
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <IsMergedTestRunnerAssembly>true</IsMergedTestRunnerAssembly>
+ </PropertyGroup>
+ <ItemGroup>
+ <MergedWrapperProjectReference Include="*/**/*.??proj" />
+ <MergedWrapperProjectReference Remove="commitstackonlyasneeded/**/*.??proj" />
+ <MergedWrapperProjectReference Remove="coverage/**/*.??proj" />
+ <MergedWrapperProjectReference Remove="DeadThreads/**/*.??proj" />
+ <MergedWrapperProjectReference Remove="delegate/**/*.??proj" />
+ <MergedWrapperProjectReference Remove="generics/syncdelegate/*.??proj" />
+ <MergedWrapperProjectReference Remove="generics/threadstart/*.??proj" />
+ <MergedWrapperProjectReference Remove="regressions/**/*.??proj" />
+ <MergedWrapperProjectReference Update="**" Aliases="$([System.String]::Concat("_",$([System.String]::Copy("%(Filename)").Replace("-","_"))))" />
+ <ProjectReference Include="@(MergedWrapperProjectReference)" />
+ </ItemGroup>
+</Project>
\ No newline at end of file
using System.IO;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
+using Xunit;
/// <summary>
/// Verifies passing an invalid handle (not overlapped) to BindHandle works as expected
/// </summary>
-class BindHandle1
+public class BindHandle1
{
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
return (new BindHandle1().RunTest());
}
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for CLRTestTargetUnsupported -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<CLRTestPriority>1</CLRTestPriority>
<!-- Test unsupported outside of windows -->
<CLRTestTargetUnsupported Condition="'$(TargetsWindows)' != 'true'">true</CLRTestTargetUnsupported>
using System;
using System.Threading;
using Microsoft.Win32.SafeHandles;
+using Xunit;
-class BindHandleInvalid
+public class BindHandleInvalid
{
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
return (new BindHandleInvalid().RunTest());
}
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for CLRTestTargetUnsupported -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<CLRTestPriority>1</CLRTestPriority>
<!-- Test unsupported outside of windows -->
<CLRTestTargetUnsupported Condition="'$(TargetsWindows)' != 'true'">true</CLRTestTargetUnsupported>
using System.IO;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
+using Xunit;
/// <summary>
/// Verifies passing an invalid handle (not overlapped) to BindHandle works as expected
/// </summary>
-class BindHandleInvalid3
+public class BindHandleInvalid3
{
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
return (new BindHandleInvalid3().RunTest());
}
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for CLRTestTargetUnsupported -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<CLRTestPriority>1</CLRTestPriority>
<!-- Test unsupported outside of windows -->
<CLRTestTargetUnsupported Condition="'$(TargetsWindows)' != 'true'">true</CLRTestTargetUnsupported>
using System.IO;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
+using Xunit;
/// <summary>
/// Verifies passing an invalid handle (not overlapped) to BindHandle works as expected
/// </summary>
-class BindHandleInvalid3
+public class BindHandleInvalid3
{
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
return (new BindHandleInvalid3().RunTest());
}
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for CLRTestTargetUnsupported -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<CLRTestPriority>1</CLRTestPriority>
<!-- Test unsupported outside of windows -->
<CLRTestTargetUnsupported Condition="'$(TargetsWindows)' != 'true'">true</CLRTestTargetUnsupported>
using System.IO;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
+using Xunit;
/// <summary>
/// Verifies passing an invalid handle (not overlapped) to BindHandle works as expected
/// </summary>
-class BindHandleInvalid3
+public class BindHandleInvalid3
{
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
return (new BindHandleInvalid3().RunTest());
}
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for CLRTestTargetUnsupported -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<CLRTestPriority>1</CLRTestPriority>
<!-- Test unsupported outside of windows -->
<CLRTestTargetUnsupported Condition="'$(TargetsWindows)' != 'true'">true</CLRTestTargetUnsupported>
using System.IO;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
+using Xunit;
/// <summary>
/// Verifies passing an invalid handle (not overlapped) to BindHandle works as expected
/// </summary>
-class BindHandle1
+public class BindHandle1
{
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
return (new BindHandle1().RunTest());
}
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for CLRTestTargetUnsupported -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<CLRTestPriority>1</CLRTestPriority>
<!-- Test unsupported outside of windows -->
<CLRTestTargetUnsupported Condition="'$(TargetsWindows)' != 'true'">true</CLRTestTargetUnsupported>
using System;
using System.Threading;
+using Xunit;
-class BindHandleNull
+public class BindHandleNull
{
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
return (new BindHandleNull().RunTest());
}
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
+ <!-- Needed for CLRTestTargetUnsupported -->
+ <RequiresProcessIsolation>true</RequiresProcessIsolation>
<CLRTestPriority>1</CLRTestPriority>
<!-- Test unsupported outside of windows -->
<CLRTestTargetUnsupported Condition="'$(TargetsWindows)' != 'true'">true</CLRTestTargetUnsupported>
using System.Text;
using System.Threading.Tasks;
using System.Threading;
+using Xunit;
/************************
* Regression test for bug Bug 749068:WatsonCrash: coreclr.dll!Thread::DoAppropriateWaitWorker -- APPLICATION_HANG_BlockedOn_EventHandle c0000194
}
}
- class Program
+ public class Program
{
- static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Callback obj = new Callback();
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<ItemGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
using System;
using System.Threading;
+using Xunit;
public class Value0
{
private int retVal = 0;
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Test_threadstatic01 staticsTest = new Test_threadstatic01();
staticsTest.RunTest();
using System;
using System.Threading;
+using Xunit;
public class MyData
{
private int retVal = 0;
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Test_threadstatic02 staticsTest = new Test_threadstatic02();
staticsTest.RunTest();
using System;
using System.Threading;
+using Xunit;
public class MyData
{
private int retVal = 0;
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Test_threadstatic03 staticsTest = new Test_threadstatic03();
staticsTest.RunTest();
using System;
using System.Threading;
+using Xunit;
public class MyData
{
private int retVal = 0;
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Test_threadstatic05 staticsTest = new Test_threadstatic05();
staticsTest.RunTest();
using System;
using System.Threading;
+using Xunit;
public class MyData
{
private int retVal = 0;
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Test_threadstatic06 staticsTest = new Test_threadstatic06();
staticsTest.RunTest();
using System;
using System.IO;
using System.Threading;
+using Xunit;
// Test Description:
// Just basic heavy reading and writing from ThreadStatic members in normal threads and threadpools threads as well.
[ThreadStatic]
static String SSS = "Olden Polynice";
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
Console.WriteLine("Hello NBA Fans!!");
Console.WriteLine("ThreadStatic test 2: Various reading and writing of Threadstatic variables.");
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<ItemGroup>
using System;
using System.IO;
using System.Threading;
+using Xunit;
public struct Struct
{
[ThreadStatic]
private static Struct TSStruct;
- public static int Main()
+ [Fact]
+ public static int TestEntryPoint()
{
if(TSStruct.a != 0 || TSStruct.b != 0)
return 101;
<Project Sdk="Microsoft.NET.Sdk">
- <PropertyGroup>
- <OutputType>Exe</OutputType>
- </PropertyGroup>
<ItemGroup>
<Compile Include="threadstatic08.cs" />
</ItemGroup>
projects / platform / upstream / dotnet / runtime.git / commitdiff