Do some more cleanup

fredericDelaporte · fredericDelaporte · commit d8b69b73d7ff · 2018-12-05T12:53:07.000+01:00
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis.Tests/RedisCacheFixture.cs b/StackExRedis/NHibernate.Caches.StackExRedis.Tests/RedisCacheFixture.cs
@@ -416,7 +416,7 @@ public void TestNonEqualObjectsWithEqualToStringUseHashCode()
 
 			cache.Put(obj1, value);
 			Assert.That(cache.Get(obj1), Is.EqualTo(value), "Unable to retrieved cached object for key obj1");
-			Assert.That(cache.Get(obj2), Is.Null, "Unexectedly found a cache entry for key obj2 after obj1 put");
+			Assert.That(cache.Get(obj2), Is.Null, "Unexpectedly found a cache entry for key obj2 after obj1 put");
 			cache.Remove(obj1);
 		}
 
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis.Tests/RedisCacheProviderFixture.cs b/StackExRedis/NHibernate.Caches.StackExRedis.Tests/RedisCacheProviderFixture.cs
@@ -57,15 +57,15 @@ public void TestDefaultCacheConfiguration()
 			var retryDelayProvider = Substitute.For<ICacheLockRetryDelayProvider>();
 			var lockValueProvider = Substitute.For<ICacheLockValueProvider>();
 			var regionStrategyFactory = Substitute.For<ICacheRegionStrategyFactory>();
-			var serialzer = Substitute.For<IRedisSerializer>();
+			var serializer = Substitute.For<IRedisSerializer>();
 
 			var defaultConfig = RedisCacheProvider.DefaultCacheConfiguration;
 			defaultConfig.ConnectionMultiplexerProvider = connectionProvider;
 			defaultConfig.DatabaseProvider = databaseProvider;
 			defaultConfig.LockConfiguration.ValueProvider = lockValueProvider;
 			defaultConfig.LockConfiguration.RetryDelayProvider = retryDelayProvider;
 			defaultConfig.RegionStrategyFactory = regionStrategyFactory;
-			defaultConfig.Serializer = serialzer;
+			defaultConfig.Serializer = serializer;
 
 			var provider = (RedisCacheProvider) GetNewProvider();
 			var config = provider.CacheConfiguration;
@@ -75,7 +75,7 @@ public void TestDefaultCacheConfiguration()
 			Assert.That(config.LockConfiguration.RetryDelayProvider, Is.EqualTo(retryDelayProvider));
 			Assert.That(config.LockConfiguration.ValueProvider, Is.EqualTo(lockValueProvider));
 			Assert.That(config.RegionStrategyFactory, Is.EqualTo(regionStrategyFactory));
-			Assert.That(config.Serializer, Is.EqualTo(serialzer));
+			Assert.That(config.Serializer, Is.EqualTo(serializer));
 
 			RedisCacheProvider.DefaultCacheConfiguration = new RedisCacheConfiguration();
 		}
@@ -93,14 +93,14 @@ public void TestUserProvidedObjectsFactory()
 			var retryDelayProvider = Substitute.For<ICacheLockRetryDelayProvider>();
 			var lockValueProvider = Substitute.For<ICacheLockValueProvider>();
 			var regionStrategyFactory = Substitute.For<ICacheRegionStrategyFactory>();
-			var serialzer = Substitute.For<IRedisSerializer>();
+			var serializer = Substitute.For<IRedisSerializer>();
 
 			customObjectsFactory.RegisterSingleton(connectionProvider);
 			customObjectsFactory.RegisterSingleton(databaseProvider);
 			customObjectsFactory.RegisterSingleton(retryDelayProvider);
 			customObjectsFactory.RegisterSingleton(lockValueProvider);
 			customObjectsFactory.RegisterSingleton(regionStrategyFactory);
-			customObjectsFactory.RegisterSingleton(serialzer);
+			customObjectsFactory.RegisterSingleton(serializer);
 
 			field.SetValue(Cfg.Environment.BytecodeProvider, customObjectsFactory);
 
@@ -112,7 +112,7 @@ public void TestUserProvidedObjectsFactory()
 			Assert.That(config.LockConfiguration.RetryDelayProvider, Is.EqualTo(retryDelayProvider));
 			Assert.That(config.LockConfiguration.ValueProvider, Is.EqualTo(lockValueProvider));
 			Assert.That(config.RegionStrategyFactory, Is.EqualTo(regionStrategyFactory));
-			Assert.That(config.Serializer, Is.EqualTo(serialzer));
+			Assert.That(config.Serializer, Is.EqualTo(serializer));
 
 			field.SetValue(Cfg.Environment.BytecodeProvider, new ActivatorObjectsFactory());
 		}
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/AbstractRegionStrategy.cs b/StackExRedis/NHibernate.Caches.StackExRedis/AbstractRegionStrategy.cs
@@ -1,5 +1,4 @@
 ﻿using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using NHibernate.Cache;
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/Async/AbstractRegionStrategy.cs b/StackExRedis/NHibernate.Caches.StackExRedis/Async/AbstractRegionStrategy.cs
@@ -9,7 +9,6 @@
 
 
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using NHibernate.Cache;
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/Async/FastRegionStrategy.cs b/StackExRedis/NHibernate.Caches.StackExRedis/Async/FastRegionStrategy.cs
@@ -10,13 +10,11 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using StackExchange.Redis;
 
 namespace NHibernate.Caches.StackExRedis
 {
+	using System.Threading.Tasks;
 	using System.Threading;
 	public partial class FastRegionStrategy : AbstractRegionStrategy
 	{
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/Async/RedisKeyLocker.cs b/StackExRedis/NHibernate.Caches.StackExRedis/Async/RedisKeyLocker.cs
@@ -9,15 +9,14 @@
 
 
 using System;
-using System.Diagnostics;
 using System.Linq;
-using System.Threading;
 using NHibernate.Cache;
 using StackExchange.Redis;
 
 namespace NHibernate.Caches.StackExRedis
 {
 	using System.Threading.Tasks;
+	using System.Threading;
 	internal partial class RedisKeyLocker
 	{
 
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/BinaryRedisSerializer.cs b/StackExRedis/NHibernate.Caches.StackExRedis/BinaryRedisSerializer.cs
@@ -1,6 +1,5 @@
 ﻿using System.IO;
 using System.Runtime.Serialization.Formatters.Binary;
-using StackExchange.Redis;
 
 namespace NHibernate.Caches.StackExRedis
 {
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/CacheConfig.cs b/StackExRedis/NHibernate.Caches.StackExRedis/CacheConfig.cs
@@ -1,5 +1,3 @@
-using System;
-
 namespace NHibernate.Caches.StackExRedis
 {
 	/// <summary>
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/DefaultConnectionMultiplexerProvider.cs b/StackExRedis/NHibernate.Caches.StackExRedis/DefaultConnectionMultiplexerProvider.cs
@@ -1,9 +1,4 @@
-﻿using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+﻿using System.IO;
 using StackExchange.Redis;
 
 namespace NHibernate.Caches.StackExRedis
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/DefaultDatabaseProvider.cs b/StackExRedis/NHibernate.Caches.StackExRedis/DefaultDatabaseProvider.cs
@@ -1,9 +1,4 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using StackExchange.Redis;
+﻿using StackExchange.Redis;
 
 namespace NHibernate.Caches.StackExRedis
 {
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/DefaultRegionStrategy.cs b/StackExRedis/NHibernate.Caches.StackExRedis/DefaultRegionStrategy.cs
@@ -9,7 +9,7 @@ namespace NHibernate.Caches.StackExRedis
 	/// <summary>
 	/// The default region strategy. This strategy uses a special key that contains the region current version number which is appended
 	/// after the region prefix. Each time a clear operation is performed the version number is increased and an event is send to all
-	/// clients so that they can update thier local versions. Even if the event was not sent to all clients, each operation has a
+	/// clients so that they can update their local versions. Even if the event was not sent to all clients, each operation has a
 	/// version check in order to prevent working with stale data.
 	/// </summary>
 	public partial class DefaultRegionStrategy : AbstractRegionStrategy
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/FastRegionStrategy.cs b/StackExRedis/NHibernate.Caches.StackExRedis/FastRegionStrategy.cs
@@ -1,8 +1,5 @@
 ﻿using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using StackExchange.Redis;
 
 namespace NHibernate.Caches.StackExRedis
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/IConnectionMultiplexerProvider.cs b/StackExRedis/NHibernate.Caches.StackExRedis/IConnectionMultiplexerProvider.cs
@@ -1,9 +1,4 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using StackExchange.Redis;
+﻿using StackExchange.Redis;
 
 namespace NHibernate.Caches.StackExRedis
 {
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/IDatabaseProvider.cs b/StackExRedis/NHibernate.Caches.StackExRedis/IDatabaseProvider.cs
@@ -1,9 +1,4 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using StackExchange.Redis;
+﻿using StackExchange.Redis;
 
 namespace NHibernate.Caches.StackExRedis
 {
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/LuaScriptProvider.cs b/StackExRedis/NHibernate.Caches.StackExRedis/LuaScriptProvider.cs
@@ -1,11 +1,8 @@
-﻿using System;
-using System.Collections.Generic;
+﻿using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Reflection;
 using System.Text;
 using System.Text.RegularExpressions;
-using System.Threading.Tasks;
 
 namespace NHibernate.Caches.StackExRedis
 {
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/RedisCacheLockConfiguration.cs b/StackExRedis/NHibernate.Caches.StackExRedis/RedisCacheLockConfiguration.cs
@@ -40,7 +40,7 @@ public class RedisCacheLockConfiguration
 		public TimeSpan MaxRetryDelay { get; set; } = TimeSpan.FromMilliseconds(400);
 
 		/// <summary>
-		/// The minumum delay before retrying to acquire the lock.
+		/// The minimum delay before retrying to acquire the lock.
 		/// </summary>
 		public TimeSpan MinRetryDelay { get; set; } = TimeSpan.FromMilliseconds(10);
 
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/RedisCacheRegionConfiguration.cs b/StackExRedis/NHibernate.Caches.StackExRedis/RedisCacheRegionConfiguration.cs
@@ -1,8 +1,5 @@
 ﻿using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Text;
-using System.Threading.Tasks;
 
 namespace NHibernate.Caches.StackExRedis
 {
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/RedisEnvironment.cs b/StackExRedis/NHibernate.Caches.StackExRedis/RedisEnvironment.cs
@@ -85,7 +85,7 @@ public static class RedisEnvironment
 		public const string LockMaxRetryDelay = "cache.lock.max_retry_delay";
 
 		/// <summary>
-		/// The minumum delay before retrying to acquire the lock in milliseconds.
+		/// The minimum delay before retrying to acquire the lock in milliseconds.
 		/// </summary>
 		public const string LockMinRetryDelay = "cache.lock.min_retry_delay";
 
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/RedisKeyLocker.cs b/StackExRedis/NHibernate.Caches.StackExRedis/RedisKeyLocker.cs
@@ -1,7 +1,5 @@
 ﻿using System;
-using System.Diagnostics;
 using System.Linq;
-using System.Threading;
 using NHibernate.Cache;
 using StackExchange.Redis;
 
@@ -46,7 +44,7 @@ public RedisKeyLocker(
 					() => lockRetryDelayProvider.GetValue(minRetryDelay, maxRetryDelay)
 				)
 				.ShouldRetry(s => s == null)
-				.OnFaliure((totalAttempts, elapsedMs, getKeysFn) =>
+				.OnFailure((totalAttempts, elapsedMs, getKeysFn) =>
 					throw new CacheException("Unable to acquire cache lock: " +
 					                         $"region='{regionName}', " +
 					                         $"keys='{getKeysFn()}', " +
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/RegionConfig.cs b/StackExRedis/NHibernate.Caches.StackExRedis/RegionConfig.cs
@@ -1,8 +1,4 @@
 ﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace NHibernate.Caches.StackExRedis
 {
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/RetryPolicy.cs b/StackExRedis/NHibernate.Caches.StackExRedis/RetryPolicy.cs
@@ -1,8 +1,5 @@
 ﻿using System;
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -34,7 +31,7 @@ public RetryPolicy<TResult, TContext> ShouldRetry(Predicate<TResult> predicate)
 			return this;
 		}
 
-		public RetryPolicy<TResult, TContext> OnFaliure(Action<int, long, TContext> callback)
+		public RetryPolicy<TResult, TContext> OnFailure(Action<int, long, TContext> callback)
 		{
 			_onFailureCallback = callback;
 			return this;

Original file line number	Diff line number	Diff line change
`@@ -416,7 +416,7 @@ public void TestNonEqualObjectsWithEqualToStringUseHashCode()`
`416`	`416`
`417`	`417`	`cache.Put(obj1, value);`
`418`	`418`	`Assert.That(cache.Get(obj1), Is.EqualTo(value), "Unable to retrieved cached object for key obj1");`
`419`		`- Assert.That(cache.Get(obj2), Is.Null, "Unexectedly found a cache entry for key obj2 after obj1 put");`
	`419`	`+ Assert.That(cache.Get(obj2), Is.Null, "Unexpectedly found a cache entry for key obj2 after obj1 put");`
`420`	`420`	`cache.Remove(obj1);`
`421`	`421`	`}`
`422`	`422`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`using System;`
`2`		`-using System.Collections.Concurrent;`
`3`	`2`	`using System.Collections.Generic;`
`4`	`3`	`using System.Linq;`
`5`	`4`	`using NHibernate.Cache;`
Original file line number	Diff line number	Diff line change
`@@ -10,13 +10,11 @@`
`10`	`10`
`11`	`11`	`using System;`
`12`	`12`	`using System.Collections.Generic;`
`13`		`-using System.Linq;`
`14`		`-using System.Text;`
`15`		`-using System.Threading.Tasks;`
`16`	`13`	`using StackExchange.Redis;`
`17`	`14`
`18`	`15`	`namespace NHibernate.Caches.StackExRedis`
`19`	`16`	`{`
	`17`	`+ using System.Threading.Tasks;`
`20`	`18`	`using System.Threading;`
`21`	`19`	`public partial class FastRegionStrategy : AbstractRegionStrategy`
`22`	`20`	`{`
Original file line number	Diff line number	Diff line change
`@@ -9,15 +9,14 @@`
`9`	`9`
`10`	`10`
`11`	`11`	`using System;`
`12`		`-using System.Diagnostics;`
`13`	`12`	`using System.Linq;`
`14`		`-using System.Threading;`
`15`	`13`	`using NHibernate.Cache;`
`16`	`14`	`using StackExchange.Redis;`
`17`	`15`
`18`	`16`	`namespace NHibernate.Caches.StackExRedis`
`19`	`17`	`{`
`20`	`18`	`using System.Threading.Tasks;`
	`19`	`+ using System.Threading;`
`21`	`20`	`internal partial class RedisKeyLocker`
`22`	`21`	`{`
`23`	`22`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`using System.IO;`
`2`	`2`	`using System.Runtime.Serialization.Formatters.Binary;`
`3`		`-using StackExchange.Redis;`
`4`	`3`
`5`	`4`	`namespace NHibernate.Caches.StackExRedis`
`6`	`5`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,3 @@`
`1`		`-using System;`
`2`		`-`
`3`	`1`	`namespace NHibernate.Caches.StackExRedis`
`4`	`2`	`{`
`5`	`3`	`/// <summary>`