Code Cleanup: Tests.Benchmarking, Tests.ClusterLauncher

Author: Mpdreamz

src/Tests/Tests.Benchmarking/BenchmarkProgram.cs

@@ -15,10 +15,7 @@ public static int Main(string[] arguments)
 			if (arguments.Count() >= 1 && arguments[0].Equals("non-interactive", StringComparison.OrdinalIgnoreCase))
 			{
 				Console.WriteLine("Running in Non-Interactive mode.");
-				foreach (var benchmarkType in GetBenchmarkTypes())
-				{
-					BenchmarkRunner.Run(benchmarkType);
-				}
+				foreach (var benchmarkType in GetBenchmarkTypes()) BenchmarkRunner.Run(benchmarkType);
 
 				return 0;
 			}

src/Tests/Tests.Benchmarking/BulkDeserializationBenchmarkTests.cs

@@ -8,9 +8,9 @@
 using Newtonsoft.Json;
 using Tests.Benchmarking.Framework;
 using Tests.Core.Client;
-
 #if !DOTNETCORE
 using System.Buffers;
+
 #endif
 
 namespace Tests.Benchmarking
@@ -19,11 +19,11 @@ namespace Tests.Benchmarking
 	public class BulkDeserializationBenchmarkTests
 	{
 		private static readonly IElasticClient Client = TestClient.DefaultInMemoryClient;
-		private byte[] _tinyResponse;
-		private byte[] _mediumResponse;
-		private byte[] _largeResponse;
 		private byte[] _hugeResponse;
 		private JsonSerializer _jsonSerializer;
+		private byte[] _largeResponse;
+		private byte[] _mediumResponse;
+		private byte[] _tinyResponse;
 
 		[GlobalSetup]
 		public void Setup()
@@ -97,9 +97,7 @@ public BulkResponse Baseline()
 		{
 			using (var reader = new JsonTextReader(new StreamReader(new MemoryStream(_hugeResponse))))
 			{
-				while (reader.Read())
-				{
-				}
+				while (reader.Read()) { }
 
 				return new BulkResponse();
 			}
@@ -124,34 +122,23 @@ public BulkResponse Baseline()
 			}
 		};
 
-		private static object ReturnBulkResponse(int numberOfItems)
+		private static object ReturnBulkResponse(int numberOfItems) => new
 		{
-			return new
-			{
-				took = 276,
-				errors = false,
-				items = Enumerable.Range(0, numberOfItems)
-					.Select(i => BulkItemResponse())
-					.ToArray()
-			};
-		}
+			took = 276,
+			errors = false,
+			items = Enumerable.Range(0, numberOfItems)
+				.Select(i => BulkItemResponse())
+				.ToArray()
+		};
 
 #if !DOTNETCORE
 		public class JsonArrayPool : IArrayPool<char>
 		{
 			public static readonly JsonArrayPool Instance = new JsonArrayPool();
 
-			public char[] Rent(int minimumLength)
-			{
-				// get char array from System.Buffers shared pool
-				return ArrayPool<char>.Shared.Rent(minimumLength);
-			}
+			public char[] Rent(int minimumLength) => ArrayPool<char>.Shared.Rent(minimumLength);
 
-			public void Return(char[] array)
-			{
-				// return char array to System.Buffers shared pool
-				ArrayPool<char>.Shared.Return(array);
-			}
+			public void Return(char[] array) => ArrayPool<char>.Shared.Return(array);
 		}
 #endif
 	}

src/Tests/Tests.Benchmarking/FieldResolverBenchmarkTests.cs

@@ -8,15 +8,15 @@ namespace Tests.Benchmarking
 	[BenchmarkConfig(100)]
 	public class FieldResolverBenchmarkTests
 	{
+		private static readonly Field InferredField = Infer.Field<Project>(p => p.Name);
+		private static readonly Field PropertyField = typeof(Project).GetProperty(nameof(Project.Name));
+		private static readonly Field StringField = "Name";
 		private FieldResolver _expressionResolver;
-		private FieldResolver _propertyResolver;
-		private FieldResolver _stringResolver;
 		private NoncachingFieldResolver _nonCachingExpressionResolver;
 		private NoncachingFieldResolver _nonCachingPropertyResolver;
 		private NoncachingFieldResolver _nonCachingStringResolver;
-		private static readonly Field StringField = "Name";
-		private static readonly Field PropertyField = typeof(Project).GetProperty(nameof(Project.Name));
-		private static readonly Field InferredField = Infer.Field<Project>(p => p.Name);
+		private FieldResolver _propertyResolver;
+		private FieldResolver _stringResolver;
 
 		[GlobalSetup]
 		public void Setup()
@@ -30,39 +30,21 @@ public void Setup()
 		}
 
 		[Benchmark]
-		public string NonCachedFieldUsingExpression()
-		{
-			return _nonCachingExpressionResolver.Resolve(InferredField);
-		}
+		public string NonCachedFieldUsingExpression() => _nonCachingExpressionResolver.Resolve(InferredField);
 
 		[Benchmark]
-		public string CachedFieldUsingExpression()
-		{
-			return _expressionResolver.Resolve(InferredField);
-		}
+		public string CachedFieldUsingExpression() => _expressionResolver.Resolve(InferredField);
 
 		[Benchmark]
-		public string NonCachedFieldUsingPropertyInfo()
-		{
-			return _nonCachingPropertyResolver.Resolve(PropertyField);
-		}
+		public string NonCachedFieldUsingPropertyInfo() => _nonCachingPropertyResolver.Resolve(PropertyField);
 
 		[Benchmark]
-		public string CachedFieldUsingPropertyInfo()
-		{
-			return _propertyResolver.Resolve(PropertyField);
-		}
+		public string CachedFieldUsingPropertyInfo() => _propertyResolver.Resolve(PropertyField);
 
 		[Benchmark(Baseline = true)]
-		public string NonCachedFieldUsingString()
-		{
-			return _nonCachingStringResolver.Resolve(StringField);
-		}
+		public string NonCachedFieldUsingString() => _nonCachingStringResolver.Resolve(StringField);
 
 		[Benchmark]
-		public string CachedFieldUsingString()
-		{
-			return _stringResolver.Resolve(StringField);
-		}
+		public string CachedFieldUsingString() => _stringResolver.Resolve(StringField);
 	}
 }

src/Tests/Tests.Benchmarking/Framework/BenchmarkConfig.cs

@@ -4,14 +4,15 @@
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.Environments;
+using BenchmarkDotNet.Exporters;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Loggers;
 using BenchmarkDotNet.Reports;
 using Newtonsoft.Json;
 
 namespace Tests.Benchmarking.Framework
 {
-	public class CustomJsonExporter : BenchmarkDotNet.Exporters.ExporterBase
+	public class CustomJsonExporter : ExporterBase
 	{
 		protected override string FileExtension => "json";
 
@@ -41,13 +42,13 @@ public override void ExportToLog(Summary summary, ILogger logger)
 			{
 				var data = new Dictionary<string, object>
 				{
-                    { "DisplayInfo", r.BenchmarkCase.DisplayInfo },
+					{ "DisplayInfo", r.BenchmarkCase.DisplayInfo },
 					{ "Namespace", r.BenchmarkCase.Descriptor.Type.Namespace },
 					{ "Type", r.BenchmarkCase.Descriptor.Type.Name },
 					{ "Method", r.BenchmarkCase.Descriptor.WorkloadMethod.Name },
 					{ "MethodTitle", r.BenchmarkCase.Descriptor.WorkloadMethod.Name },
 					{ "Parameters", r.BenchmarkCase.Parameters.PrintInfo },
-                    { "Statistics", r.ResultStatistics },
+					{ "Statistics", r.ResultStatistics },
 					{ "Memory", r.GcStats }
 				};
 
@@ -63,21 +64,23 @@ public override void ExportToLog(Summary summary, ILogger logger)
 			}));
 		}
 	}
+
 	public class BenchmarkConfigAttribute : Attribute, IConfigSource
 	{
-		public IConfig Config { get; }
-
 		public BenchmarkConfigAttribute(int runCount = 1)
 		{
-			var jobs = new[] {
+			var jobs = new[]
+			{
 				Job.Dry.With(Runtime.Core).With(Jit.RyuJit).WithIterationCount(runCount),
 				Job.Dry.With(Runtime.Clr).With(Jit.RyuJit).WithIterationCount(runCount),
 				Job.Dry.With(Runtime.Clr).With(Jit.LegacyJit).WithIterationCount(runCount)
 			};
-			this.Config = DefaultConfig.Instance
+			Config = DefaultConfig.Instance
 				.With(jobs)
 				.With(new CustomJsonExporter())
 				.With(MemoryDiagnoser.Default);
 		}
+
+		public IConfig Config { get; }
 	}
 }

src/Tests/Tests.Benchmarking/NoncachingFieldResolver.cs

@@ -8,7 +8,6 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text;
-using Elasticsearch.Net;
 using Nest;
 
 namespace Tests.Benchmarking
@@ -17,27 +16,28 @@ public class NoncachingFieldResolver
 	{
 		private readonly IConnectionSettingsValues _settings;
 
-		public NoncachingFieldResolver(IConnectionSettingsValues settings) => this._settings = settings;
+		public NoncachingFieldResolver(IConnectionSettingsValues settings) => _settings = settings;
 
 		public string Resolve(Field field)
 		{
-			var name = this.ResolveFieldName(field);
+			var name = ResolveFieldName(field);
 			if (field.Boost.HasValue) name += $"^{field.Boost.Value.ToString(CultureInfo.InvariantCulture)}";
 			return name;
 		}
 
-		internal static bool IsConditionless(Field field) => field == null || (string.IsNullOrEmpty(field.Name) && field.Expression == null && field.Property == null);
+		internal static bool IsConditionless(Field field) =>
+			field == null || string.IsNullOrEmpty(field.Name) && field.Expression == null && field.Property == null;
 
 		internal static bool IsConditionless(PropertyName property) =>
-			property == null || (string.IsNullOrEmpty(property.Name) && property.Expression == null && property.Property == null);
+			property == null || string.IsNullOrEmpty(property.Name) && property.Expression == null && property.Property == null;
 
 		private string ResolveFieldName(Field field)
 		{
 			if (IsConditionless(field)) return null;
 			if (!string.IsNullOrEmpty(field.Name)) return field.Name;
-			if (field.Expression != null && !field.CachableExpression) return this.Resolve(field.Expression, field.Property);
+			if (field.Expression != null && !field.CachableExpression) return Resolve(field.Expression, field.Property);
 
-			var fieldName = this.Resolve(field.Expression, field.Property);
+			var fieldName = Resolve(field.Expression, field.Property);
 			return fieldName;
 		}
 
@@ -46,12 +46,9 @@ public string Resolve(PropertyName property)
 			if (IsConditionless(property)) return null;
 			if (!string.IsNullOrEmpty(property.Name)) return property.Name;
 
-			if (property.Expression != null && !property.CacheableExpression)
-			{
-				return this.Resolve(property.Expression, property.Property);
-			}
+			if (property.Expression != null && !property.CacheableExpression) return Resolve(property.Expression, property.Property);
 
-			var propertyName = this.Resolve(property.Expression, property.Property, true);
+			var propertyName = Resolve(property.Expression, property.Property, true);
 			return propertyName;
 		}
 
@@ -72,16 +69,16 @@ private string Resolve(Expression expression, MemberInfo member, bool toLastToke
 
 		internal class FieldExpressionVisitor : ExpressionVisitor
 		{
-			private readonly Stack<string> _stack = new Stack<string>();
-
 			private readonly IConnectionSettingsValues _settings;
+			private readonly Stack<string> _stack = new Stack<string>();
 
 			public FieldExpressionVisitor(IConnectionSettingsValues settings) => _settings = settings;
 
 			public string Resolve(Expression expression, bool toLastToken = false)
 			{
-				this.Visit(expression);
+				Visit(expression);
 				if (toLastToken) return Enumerable.Last<string>(_stack);
+
 				return Enumerable.Aggregate<string, StringBuilder>(_stack, new StringBuilder(),
 						(sb, name) =>
 							(sb.Length > 0 ? sb.Append(".") : sb).Append(name))
@@ -95,7 +92,7 @@ public string Resolve(MemberInfo info)
 
 				var name = info.Name;
 
-				if (this._settings.PropertyMappings.TryGetValue(info, out var propertyMapping))
+				if (_settings.PropertyMappings.TryGetValue(info, out var propertyMapping))
 					return propertyMapping.Name;
 
 				var att = ElasticsearchPropertyAttributeBase.From(info);
@@ -108,7 +105,8 @@ public string Resolve(MemberInfo info)
 			protected override Expression VisitMember(MemberExpression expression)
 			{
 				if (_stack == null) return base.VisitMember(expression);
-				var name = this.Resolve(expression.Member);
+
+				var name = Resolve(expression.Member);
 				_stack.Push(name);
 				return base.VisitMember(expression);
 			}
@@ -121,7 +119,7 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCall)
 					var callingMember = new ReadOnlyCollection<Expression>(
 						new List<Expression> { { methodCall.Arguments.First() } }
 					);
-					base.Visit(callingMember);
+					Visit(callingMember);
 					return methodCall;
 				}
 				else if (methodCall.Method.Name == "get_Item" && methodCall.Arguments.Any())
@@ -130,23 +128,18 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCall)
 					var isDict =
 						typeof(IDictionary).IsAssignableFrom(t)
 						|| typeof(IDictionary<,>).IsAssignableFrom(t)
-						|| (t.GetTypeInfo().IsGenericType && t.GetGenericTypeDefinition() == typeof(IDictionary<,>));
+						|| t.GetTypeInfo().IsGenericType && t.GetGenericTypeDefinition() == typeof(IDictionary<,>);
+
+					if (!isDict) return base.VisitMethodCall(methodCall);
 
-					if (!isDict)
-					{
-						return base.VisitMethodCall(methodCall);
-					}
 					VisitConstantOrVariable(methodCall, _stack);
-					this.Visit(methodCall.Object);
+					Visit(methodCall.Object);
 					return methodCall;
 				}
 				else if (IsLinqOperator(methodCall.Method))
 				{
-					for (int i = 1; i < methodCall.Arguments.Count; i++)
-					{
-						this.Visit(methodCall.Arguments[i]);
-					}
-					this.Visit(methodCall.Arguments[0]);
+					for (var i = 1; i < methodCall.Arguments.Count; i++) Visit(methodCall.Arguments[i]);
+					Visit(methodCall.Arguments[0]);
 					return methodCall;
 				}
 				return base.VisitMethodCall(methodCall);