[Fork] XUnitTest | C# Online Compiler

[Fork] XUnitTest by RikdeRooij

using System;
using System.Reflection;
using System.Security;
using System.Security.Cryptography;
using System.Collections;
using System.Collections.Generic;
using BenchmarkDotNet;
using BenchmarkDotNet.Running;
using BenchmarkDotNet.Helpers;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Jobs;
using BenchmarkDotNet.Toolchains;
using BenchmarkDotNet.Toolchains.InProcess;
using BenchmarkDotNet.Toolchains.InProcess.Emit;
using BenchmarkDotNet.Toolchains.Parameters;
using BenchmarkDotNet.Toolchains.Results;
using BenchmarkDotNet.Loggers;
using BenchmarkDotNet.Reports;
using Perfolizer.Horology;
using Xunit;
using TimeInterval_t = Perfolizer.Horology.TimeInterval;

[assembly: SecurityTransparent()]
[assembly: AllowPartiallyTrustedCallers]
//[assembly: SecurityRules(SecurityRuleSet.Level1)]
[assembly: System.Diagnostics.Debuggable(isJITTrackingEnabled: false, isJITOptimizerDisabled: false)]

public class Program
{
	public static void Main()
	{
		Console.WriteLine("Entry");
		
		Benchmark.Run();
		
	}

		/*shapes = new Shape[3]
		{
			new Rectangle(3.0f, 4.0f),
			new Triangle(5.0f, 2.0f),
			new Circle(3.3f)
		};
		
		shapeProps = new ShapeProperties[]
		{
			new ShapeProperties(ShapeTypes.Rectangle, 3.0f, 4.0f),
			new ShapeProperties(ShapeTypes.Triangle, 5.0f, 2.0f),
			new ShapeProperties(ShapeTypes.Circle, 3.3f)
		};*/
	/*
	[Theory]
	[InlineData("a","a")]
	public static void Test0(int n)
	{
		// assert
		Assert.Equal(expected, output);
	}
	
	[Theory]
	[InlineData("a","a")]
	public static void Test1(int n)
	{
		// assert
		Assert.Equal(expected, output);
	}
	*/
}

// --------------------------------

//[ReturnValueValidator]
//[MemoryDiagnoser]
public class Benchmark
{
    [Params(0, 1, 2)]
    public int N;
	
	private readonly Shape[] shapes = new Shape[3]
		{
			new Rectangle(3.0f, 4.0f),
			new Triangle(5.0f, 2.0f),
			new Circle(3.3f)
		};
	private readonly ShapeProperties[] shapeProps = new ShapeProperties[]
		{
			new ShapeProperties(ShapeTypes.Rectangle, 3.0f, 4.0f),
			new ShapeProperties(ShapeTypes.Triangle, 5.0f, 2.0f),
			new ShapeProperties(ShapeTypes.Circle, 3.3f)
		};
	
    [GlobalSetup]
    public void Setup()
    {
        //Random rnd = new Random();
    }
	
	// ----
	
	[Benchmark]
	public float Test0()
	{
		return (shapes[N]).area();
	}
	
	[Benchmark]
	public float Test1()
	{
		 return (shapeProps[N]).GetArea();
	}
	
	public static BenchmarkDotNet.Reports.Summary Run()
	{
		//BenchmarkRunner.Run<Benchmark>(DefaultConfig.Instance
		//	.AddJob(Job.Default
		//		.WithToolchain(new InProcessEmitToolchain(
		//			timeout: timeout,
		//			logOutput: false))
		//		.WithIterationTime(TimeInterval.FromMilliseconds(20)))
		//	.AddLogger(new ConsoleLogger(unicodeSupport: true, ConsoleLogger.CreateGrayScheme()))
		//	.WithOptions(ConfigOptions.DisableLogFile));
		
		var maxtime = System.TimeSpan.FromSeconds(30);
		var iterationtime = new TimeInterval_t(20, Perfolizer.Horology.TimeUnit.Millisecond);
		
		var toolChain = new InProcessEmitToolchain(logOutput: false, timeout: maxtime);
		var job = Job.Default.WithToolchain(toolChain).WithIterationTime(iterationtime);
		
		var config = DefaultConfig.Instance.AddJob(job)
					.AddLogger(new ConsoleLogger(true, ConsoleLogger.CreateGrayScheme()))
					.WithOptions(ConfigOptions.DisableLogFile);
		
		/*BenchmarkRunner.Run<Benchmark>(config);*/
		
		// BenchmarkDotNet.Running.BenchmarkRunner
		// BenchmarkDotNet.Running.BenchmarkRunnerClean
		var typeBenchmarkRunnerType = typeof(BenchmarkDotNet.Running.BenchmarkRunner);
		Console.WriteLine(typeBenchmarkRunnerType);
		//  private static Summary RunWithDirtyAssemblyResolveHelper(Type type, IConfig? config, string[]? args)
		var call = typeBenchmarkRunnerType.GetMethod("RunWithDirtyAssemblyResolveHelper", BindingFlags.Static | BindingFlags.NonPublic,
										  null, new Type[] { typeof(Type), typeof(IConfig), typeof( string[]) }, null);
		Console.WriteLine(call);
		//using (MyDirtyAssemblyResolveHelper.Create())
		{
			//return RunWithExceptionHandling(() => RunWithDirtyAssemblyResolveHelper(typeof(T), config, null));
			return RunWithExceptionHandling(() => (BenchmarkDotNet.Reports.Summary)call.Invoke(null, new object [] { typeof(Benchmark), config, null }));
		}
	}
	
        private static Summary RunWithExceptionHandling(Func<Summary> run)
        {
            try
            {
                return run();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                return null;// Summary.ValidationFailed(e.Message, string.Empty, string.Empty);
            }
        }
}

internal class MyDirtyAssemblyResolveHelper : IDisposable
{
    internal static IDisposable Create() { return new MyDirtyAssemblyResolveHelper(); }
    private MyDirtyAssemblyResolveHelper() { AppDomain.CurrentDomain.AssemblyResolve += HelpTheFrameworkToResolveTheAssembly; }
    public void Dispose() { AppDomain.CurrentDomain.AssemblyResolve -= HelpTheFrameworkToResolveTheAssembly; }
    private Assembly HelpTheFrameworkToResolveTheAssembly(object sender, ResolveEventArgs args)
    {
        var fullName = new AssemblyName(args.Name);
        string simpleName = fullName.Name;
        string guessedPath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "{simpleName}.dll");
        if (!System.IO.File.Exists(guessedPath))
            return null; // we can't help, and we also don't call Assembly.Load which if fails comes back here, creates endless loop and causes StackOverflow
        // we warn the user about that, in case some Super User want to be aware of that
        Console.WriteLine("// Wrong assembly binding redirects for {simpleName}, loading it from disk anyway.");
        return Assembly.LoadFrom(guessedPath);
    }
}

// --------------------------------

public enum ShapeTypes
{
	Rectangle,
	Triangle,
	Circle
}

public struct ShapeProperties
{
	public ShapeTypes type;
	public float l;
	public float h;
	public ShapeProperties(ShapeTypes type, float l, float h = 0)
	{
		this.type = type;
		this.l = l;
		this.h = h;
	}
	public float GetArea()
	{
		switch(type)
		{
			case ShapeTypes.Rectangle: return l * h;
			case ShapeTypes.Triangle: return l * h / 2.0f;
			case ShapeTypes.Circle: return l * l  * (float)Math.PI;
			default:
				throw new InvalidOperationException(string.Format("Unkown area for type: {0}", type));
		}
	}
}


// --------------------------------
// http://www.excoded.com/learn/csharp/cs_polymorphism.php

public abstract class Shape
{
    public abstract float area();
}

public class Rectangle : Shape
{
    private float length;
    private float width;

    public Rectangle(float length, float width)
    {
        this.length = length;
        this.width = width;
    }

    public override float area()
    {
        return (length * width);
    }
}

public class Triangle : Shape
{
    private float baseline;
    private float height;

    public Triangle(float baseline, float height)
    {
        this.baseline = baseline;
        this.height = height;
    }

    public override float area()
    {
        return (baseline * height / 2.0f);
    }
}

public class Circle : Shape
{
    private float radius;

    public Circle(float radius)
    {
        this.radius = radius;
    }

    public override float area()
    {
       return (radius * radius * (float)Math.PI);
    }
}

​x
 
using System;
using System.Reflection;
using System.Security;
using System.Security.Cryptography;
using System.Collections;
using System.Collections.Generic;
using BenchmarkDotNet;
using BenchmarkDotNet.Running;
using BenchmarkDotNet.Helpers;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Jobs;
using BenchmarkDotNet.Toolchains;
using BenchmarkDotNet.Toolchains.InProcess;
using BenchmarkDotNet.Toolchains.InProcess.Emit;
using BenchmarkDotNet.Toolchains.Parameters;
using BenchmarkDotNet.Toolchains.Results;
using BenchmarkDotNet.Loggers;
using BenchmarkDotNet.Reports;
using Perfolizer.Horology;
using Xunit;
using TimeInterval_t = Perfolizer.Horology.TimeInterval;
​
[assembly: SecurityTransparent()]
[assembly: AllowPartiallyTrustedCallers]
//[assembly: SecurityRules(SecurityRuleSet.Level1)]
[assembly: System.Diagnostics.Debuggable(isJITTrackingEnabled: false, isJITOptimizerDisabled: false)]
​
public class Program
{
    public static void Main()
    {
        Console.WriteLine("Entry");
        
        Benchmark.Run();
        
    }
​
        /*shapes = new Shape[3]
        {
            new Rectangle(3.0f, 4.0f),
            new Triangle(5.0f, 2.0f),
            new Circle(3.3f)
        };
        
        shapeProps = new ShapeProperties[]
        {
            new ShapeProperties(ShapeTypes.Rectangle, 3.0f, 4.0f),
            new ShapeProperties(ShapeTypes.Triangle, 5.0f, 2.0f),
            new ShapeProperties(ShapeTypes.Circle, 3.3f)
        };*/
    /*
    [Theory]
    [InlineData("a","a")]
    public static void Test0(int n)
    {
        // assert
        Assert.Equal(expected, output);
    }
    
    [Theory]
    [InlineData("a","a")]
    public static void Test1(int n)
    {
        // assert
        Assert.Equal(expected, output);
    }
    */
}
​
// --------------------------------
​
//[ReturnValueValidator]
//[MemoryDiagnoser]
public class Benchmark
{
    [Params(0, 1, 2)]
    public int N;
    
    private readonly Shape[] shapes = new Shape[3]
        {
            new Rectangle(3.0f, 4.0f),
            new Triangle(5.0f, 2.0f),
            new Circle(3.3f)
        };
    private readonly ShapeProperties[] shapeProps = new ShapeProperties[]
        {
            new ShapeProperties(ShapeTypes.Rectangle, 3.0f, 4.0f),
            new ShapeProperties(ShapeTypes.Triangle, 5.0f, 2.0f),
            new ShapeProperties(ShapeTypes.Circle, 3.3f)
        };
    
    [GlobalSetup]
    public void Setup()
    {
        //Random rnd = new Random();
    }
    
    // ----
    
    [Benchmark]
    public float Test0()
    {
        return (shapes[N]).area();
    }
    
    [Benchmark]
    public float Test1()
    {
         return (shapeProps[N]).GetArea();
    }
    
    public static BenchmarkDotNet.Reports.Summary Run()
    {
        //BenchmarkRunner.Run<Benchmark>(DefaultConfig.Instance
        //  .AddJob(Job.Default
        //      .WithToolchain(new InProcessEmitToolchain(
        //          timeout: timeout,
        //          logOutput: false))
        //      .WithIterationTime(TimeInterval.FromMilliseconds(20)))
        //  .AddLogger(new ConsoleLogger(unicodeSupport: true, ConsoleLogger.CreateGrayScheme()))
        //  .WithOptions(ConfigOptions.DisableLogFile));
        
        var maxtime = System.TimeSpan.FromSeconds(30);
        var iterationtime = new TimeInterval_t(20, Perfolizer.Horology.TimeUnit.Millisecond);
        
        var toolChain = new InProcessEmitToolchain(logOutput: false, timeout: maxtime);
        var job = Job.Default.WithToolchain(toolChain).WithIterationTime(iterationtime);
        
        var config = DefaultConfig.Instance.AddJob(job)
                    .AddLogger(new ConsoleLogger(true, ConsoleLogger.CreateGrayScheme()))
                    .WithOptions(ConfigOptions.DisableLogFile);
        
        /*BenchmarkRunner.Run<Benchmark>(config);*/
        
        // BenchmarkDotNet.Running.BenchmarkRunner
        // BenchmarkDotNet.Running.BenchmarkRunnerClean
        var typeBenchmarkRunnerType = typeof(BenchmarkDotNet.Running.BenchmarkRunner);
        Console.WriteLine(typeBenchmarkRunnerType);
        //  private static Summary RunWithDirtyAssemblyResolveHelper(Type type, IConfig? config, string[]? args)
        var call = typeBenchmarkRunnerType.GetMethod("RunWithDirtyAssemblyResolveHelper", BindingFlags.Static | BindingFlags.NonPublic,
                                          null, new Type[] { typeof(Type), typeof(IConfig), typeof( string[]) }, null);
        Console.WriteLine(call);
        //using (MyDirtyAssemblyResolveHelper.Create())
        {
            //return RunWithExceptionHandling(() => RunWithDirtyAssemblyResolveHelper(typeof(T), config, null));
            return RunWithExceptionHandling(() => (BenchmarkDotNet.Reports.Summary)call.Invoke(null, new object [] { typeof(Benchmark), config, null }));
        }
    }
    
        private static Summary RunWithExceptionHandling(Func<Summary> run)
        {
            try
            {
                return run();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                return null;// Summary.ValidationFailed(e.Message, string.Empty, string.Empty);
            }
        }
}
​
internal class MyDirtyAssemblyResolveHelper : IDisposable
{
    internal static IDisposable Create() { return new MyDirtyAssemblyResolveHelper(); }
    private MyDirtyAssemblyResolveHelper() { AppDomain.CurrentDomain.AssemblyResolve += HelpTheFrameworkToResolveTheAssembly; }
    public void Dispose() { AppDomain.CurrentDomain.AssemblyResolve -= HelpTheFrameworkToResolveTheAssembly; }
    private Assembly HelpTheFrameworkToResolveTheAssembly(object sender, ResolveEventArgs args)
    {
        var fullName = new AssemblyName(args.Name);
        string simpleName = fullName.Name;
        string guessedPath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "{simpleName}.dll");
        if (!System.IO.File.Exists(guessedPath))
            return null; // we can't help, and we also don't call Assembly.Load which if fails comes back here, creates endless loop and causes StackOverflow
        // we warn the user about that, in case some Super User want to be aware of that
        Console.WriteLine("// Wrong assembly binding redirects for {simpleName}, loading it from disk anyway.");
        return Assembly.LoadFrom(guessedPath);
    }
}
​
// --------------------------------
​
public enum ShapeTypes
{
    Rectangle,
    Triangle,
    Circle
}
​
public struct ShapeProperties
{
    public ShapeTypes type;
    public float l;
    public float h;
    public ShapeProperties(ShapeTypes type, float l, float h = 0)
    {
        this.type = type;
        this.l = l;
        this.h = h;
    }
    public float GetArea()
    {
        switch(type)
        {
            case ShapeTypes.Rectangle: return l * h;
            case ShapeTypes.Triangle: return l * h / 2.0f;
            case ShapeTypes.Circle: return l * l  * (float)Math.PI;
            default:
                throw new InvalidOperationException(string.Format("Unkown area for type: {0}", type));
        }
    }
}
​
​
// --------------------------------
// http://www.excoded.com/learn/csharp/cs_polymorphism.php
​
public abstract class Shape
{
    public abstract float area();
}
​
public class Rectangle : Shape
{
    private float length;
    private float width;
​
    public Rectangle(float length, float width)
    {
        this.length = length;
        this.width = width;
    }
​
    public override float area()
    {
        return (length * width);
    }
}
​
public class Triangle : Shape
{
    private float baseline;
    private float height;
​
    public Triangle(float baseline, float height)
    {
        this.baseline = baseline;
        this.height = height;
    }
​
    public override float area()
    {
        return (baseline * height / 2.0f);
    }
}
​
public class Circle : Shape
{
    private float radius;
​
    public Circle(float radius)
    {
        this.radius = radius;
    }
​
    public override float area()
    {
       return (radius * radius * (float)Math.PI);
    }
}
​

Entry
BenchmarkDotNet.Running.BenchmarkRunner
BenchmarkDotNet.Reports.Summary RunWithDirtyAssemblyResolveHelper(System.Type, BenchmarkDotNet.Configs.IConfig, System.String[])
System.Reflection.TargetInvocationException: Exception has been thrown by the target of an invocation. ---> System.MethodAccessException: Attempt by security transparent method 'BenchmarkDotNet.Configs.ImmutableConfigBuilder.Create(BenchmarkDotNet.Configs.IConfig)' to access security critical method 'System.Collections.Immutable.ImmutableArray.ToImmutableArray<BenchmarkDotNet.Columns.IColumnProvider>(System.Collections.Generic.IEnumerable`1<BenchmarkDotNet.Columns.IColumnProvider>)' failed.

Assembly 'BenchmarkDotNet, Version=0.13.5.0, Culture=neutral, PublicKeyToken=aa0ca2f9092cefc4' is partially trusted, which causes the CLR to make it entirely security transparent regardless of any transparency annotations in the assembly itself.  In order to access security critical code, this assembly must be fully trusted.
   at BenchmarkDotNet.Configs.ImmutableConfigBuilder.Create(IConfig source)
   at BenchmarkDotNet.Running.BenchmarkConverter.MethodsToBenchmarksWithFullConfig(Type type, MethodInfo[] benchmarkMethods, IConfig config)
   at BenchmarkDotNet.Running.BenchmarkRunner.RunWithDirtyAssemblyResolveHelper(Type type, IConfig config, String[] args)
   --- End of inner exception stack trace ---
   at System.RuntimeMethodHandle.InvokeMethod(Object target, Object[] arguments, Signature sig, Boolean constructor)
   at System.Reflection.RuntimeMethodInfo.UnsafeInvokeInternal(Object obj, Object[] parameters, Object[] arguments)
   at System.Reflection.RuntimeMethodInfo.Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
   at Benchmark.<>c__DisplayClass2.<Run>b__0() in c:\Windows\Temp\cmfpxyd5.0.cs:line 147
   at Benchmark.RunWithExceptionHandling(Func`1 run) in c:\Windows\Temp\cmfpxyd5.0.cs:line 155

Cached Result
Last Run:	7:42:56 pm
Compile:	0.724s
Execute:	0.396s
Memory:	3.55Mb
CPU:	0.359s

View IL Code