Fixed typos

maca88 · maca88 · commit 8afd725e0ce6 · 2018-06-21T16:47:42.000+02:00
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis.Tests/Async/RedisCacheDefaultStrategyFixture.cs b/StackExRedis/NHibernate.Caches.StackExRedis.Tests/Async/RedisCacheDefaultStrategyFixture.cs
@@ -37,7 +37,7 @@ public async Task TestMaxAllowedVersionAsync()
 
 			await (cache.ClearAsync(CancellationToken.None));
 
-			Assert.That(strategy.CurrentVersion, Is.EqualTo(1L), "The version was not reset to 1");
+			Assert.That(strategy.CurrentVersion, Is.EqualTo(1L), "the version was not reset to 1");
 		}
 
 		[Test]
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis.Tests/Async/RedisCacheFixture.cs b/StackExRedis/NHibernate.Caches.StackExRedis.Tests/Async/RedisCacheFixture.cs
@@ -146,7 +146,7 @@ public async Task TestLockUnlockManyAsync()
 			// Test partial locks by locking the first 5 keys and afterwards try to lock last 6 keys.
 			var lockValue = await (cache.LockManyAsync(keys.Take(5).ToArray(), CancellationToken.None));
 
-			Assert.ThrowsAsync<CacheException>(() => cache.LockManyAsync(keys.Skip(4).ToArray(), CancellationToken.None), "The fifth key should be locked");
+			Assert.ThrowsAsync<CacheException>(() => cache.LockManyAsync(keys.Skip(4).ToArray(), CancellationToken.None), "the fifth key should be locked");
 
 			Assert.DoesNotThrowAsync(async () =>
 			{
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis.Tests/RedisCacheDefaultStrategyFixture.cs b/StackExRedis/NHibernate.Caches.StackExRedis.Tests/RedisCacheDefaultStrategyFixture.cs
@@ -19,7 +19,7 @@ public void TestNoExpiration()
 			var props = GetDefaultProperties();
 			props["expiration"] = "0";
 			Assert.Throws<CacheException>(() => DefaultProvider.BuildCache(DefaultRegion, props), 
-				"Default region strategy should not allow to have no expiration");
+				"default region strategy should not allow to have no expiration");
 		}
 
 		[Test]
@@ -36,7 +36,7 @@ public void TestMaxAllowedVersion()
 
 			cache.Clear();
 
-			Assert.That(strategy.CurrentVersion, Is.EqualTo(1L), "The version was not reset to 1");
+			Assert.That(strategy.CurrentVersion, Is.EqualTo(1L), "the version was not reset to 1");
 		}
 
 		[Test]
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis.Tests/RedisCacheFixture.cs b/StackExRedis/NHibernate.Caches.StackExRedis.Tests/RedisCacheFixture.cs
@@ -143,7 +143,7 @@ public void TestLockUnlockMany()
 			// Test partial locks by locking the first 5 keys and afterwards try to lock last 6 keys.
 			var lockValue = cache.LockMany(keys.Take(5).ToArray());
 
-			Assert.Throws<CacheException>(() => cache.LockMany(keys.Skip(4).ToArray()), "The fifth key should be locked");
+			Assert.Throws<CacheException>(() => cache.LockMany(keys.Skip(4).ToArray()), "the fifth key should be locked");
 
 			Assert.DoesNotThrow(() =>
 			{
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis.Tests/RedisCacheProviderFixture.cs b/StackExRedis/NHibernate.Caches.StackExRedis.Tests/RedisCacheProviderFixture.cs
@@ -30,23 +30,23 @@ public void TestExpiration()
 
 			var strategy = cache.RegionStrategy;
 			Assert.That(strategy, Is.Not.Null, "strategy was not set for the pre-configured foo cache");
-			Assert.That(strategy, Is.TypeOf<DefaultRegionStrategy>(), "Unexpected strategy type for foo region");
-			Assert.That(strategy.Expiration, Is.EqualTo(TimeSpan.FromSeconds(500)), "Unexpected expiration value for foo region");
+			Assert.That(strategy, Is.TypeOf<DefaultRegionStrategy>(), "unexpected strategy type for foo region");
+			Assert.That(strategy.Expiration, Is.EqualTo(TimeSpan.FromSeconds(500)), "unexpected expiration value for foo region");
 
 			cache = (RedisCache) DefaultProvider.BuildCache("noExplicitExpiration", null);
 			Assert.That(cache.RegionStrategy.Expiration, Is.EqualTo(TimeSpan.FromSeconds(300)),
-				"Unexpected expiration value for noExplicitExpiration region");
-			Assert.That(cache.RegionStrategy.UseSlidingExpiration, Is.True, "Unexpected sliding value for noExplicitExpiration region");
+				"unexpected expiration value for noExplicitExpiration region");
+			Assert.That(cache.RegionStrategy.UseSlidingExpiration, Is.True, "unexpected sliding value for noExplicitExpiration region");
 
 			cache = (RedisCache) DefaultProvider
 				.BuildCache("noExplicitExpiration", new Dictionary<string, string> { { "expiration", "100" } });
 			Assert.That(cache.RegionStrategy.Expiration, Is.EqualTo(TimeSpan.FromSeconds(100)),
-				"Unexpected expiration value for noExplicitExpiration region with default expiration");
+				"unexpected expiration value for noExplicitExpiration region with default expiration");
 
 			cache = (RedisCache) DefaultProvider
 				.BuildCache("noExplicitExpiration", new Dictionary<string, string> { { Cfg.Environment.CacheDefaultExpiration, "50" } });
 			Assert.That(cache.RegionStrategy.Expiration, Is.EqualTo(TimeSpan.FromSeconds(50)),
-				"Unexpected expiration value for noExplicitExpiration region with cache.default_expiration");
+				"unexpected expiration value for noExplicitExpiration region with cache.default_expiration");
 		}
 
 	}
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/AbstractRegionStrategy.cs b/StackExRedis/NHibernate.Caches.StackExRedis/AbstractRegionStrategy.cs
@@ -47,7 +47,7 @@ public abstract partial class AbstractRegionStrategy
 		/// even if an exception occurs which we are also abusing in order to avoid having a special mechanism to 
 		/// clear the dictionary in order to prevent memory leaks.
 		/// </summary>
-		private readonly ConcurrentDictionary<string, string> _aquiredKeyLocks = new ConcurrentDictionary<string, string>();
+		private readonly ConcurrentDictionary<string, string> _acquiredKeyLocks = new ConcurrentDictionary<string, string>();
 
 
 		/// <summary>
@@ -150,7 +150,7 @@ protected AbstractRegionStrategy(ConnectionMultiplexer connectionMultiplexer,
 		public bool ExpirationEnabled => Expiration != TimeSpan.Zero;
 
 		/// <summary>
-		/// The timeout of an aquired lock.
+		/// The timeout of an acquired lock.
 		/// </summary>
 		public TimeSpan LockTimeout { get; }
 
@@ -372,7 +372,7 @@ public virtual string Lock(object key)
 			var cacheKey = GetCacheKey(key);
 			var lockValue = _keyLocker.Lock(cacheKey, LockScript, GetAdditionalKeys(), GetAdditionalValues());
 
-			_aquiredKeyLocks.AddOrUpdate(cacheKey, _ => lockValue, (_, currValue) =>
+			_acquiredKeyLocks.AddOrUpdate(cacheKey, _ => lockValue, (_, currValue) =>
 			{
 				Log.Warn(
 					$"Calling {nameof(Lock)} method for key:'{cacheKey}' that was already locked. " +
@@ -419,7 +419,7 @@ public virtual bool Unlock(object key)
 			}
 			var cacheKey = GetCacheKey(key);
 
-			if (!_aquiredKeyLocks.TryRemove(cacheKey, out var lockValue))
+			if (!_acquiredKeyLocks.TryRemove(cacheKey, out var lockValue))
 			{
 				Log.Warn(
 					$"Calling {nameof(Unlock)} method for key:'{cacheKey}' that was not locked with {nameof(Lock)} method before.");
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/Async/AbstractRegionStrategy.cs b/StackExRedis/NHibernate.Caches.StackExRedis/Async/AbstractRegionStrategy.cs
@@ -300,7 +300,7 @@ async Task<string> InternalLockAsync()
 				var cacheKey = GetCacheKey(key);
 				var lockValue = await (_keyLocker.LockAsync(cacheKey, LockScript, GetAdditionalKeys(), GetAdditionalValues(), cancellationToken)).ConfigureAwait(false);
 
-				_aquiredKeyLocks.AddOrUpdate(cacheKey, _ => lockValue, (_, currValue) =>
+				_acquiredKeyLocks.AddOrUpdate(cacheKey, _ => lockValue, (_, currValue) =>
 				{
 					Log.Warn(
 					$"Calling {nameof(LockAsync)} method for key:'{cacheKey}' that was already locked. " +
@@ -367,7 +367,7 @@ public virtual Task<bool> UnlockAsync(object key, CancellationToken cancellation
 			{
 				var cacheKey = GetCacheKey(key);
 
-				if (!_aquiredKeyLocks.TryRemove(cacheKey, out var lockValue))
+				if (!_acquiredKeyLocks.TryRemove(cacheKey, out var lockValue))
 				{
 					Log.Warn(
 					$"Calling {nameof(UnlockAsync)} method for key:'{cacheKey}' that was not locked with {nameof(LockAsync)} method before.");
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/Async/DefaultRegionStrategy.cs b/StackExRedis/NHibernate.Caches.StackExRedis/Async/DefaultRegionStrategy.cs
@@ -164,7 +164,7 @@ public override async Task<bool> UnlockAsync(object key, CancellationToken cance
 			{
 				cancellationToken.ThrowIfCancellationRequested();
 				await (InitializeVersionAsync()).ConfigureAwait(false);
-				// If the lock was aquired in the old version we are unable to unlock the key.
+				// If the lock was acquired in the old version we are unable to unlock the key.
 				return false;
 			}
 		}
@@ -181,7 +181,7 @@ public override async Task<int> UnlockManyAsync(object[] keys, string lockValue,
 			{
 				cancellationToken.ThrowIfCancellationRequested();
 				await (InitializeVersionAsync()).ConfigureAwait(false);
-				// If the lock was aquired in the old version we are unable to unlock the keys.
+				// If the lock was acquired in the old version we are unable to unlock the keys.
 				return 0;
 			}
 		}
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/Async/RedisKeyLocker.cs b/StackExRedis/NHibernate.Caches.StackExRedis/Async/RedisKeyLocker.cs
@@ -30,7 +30,7 @@ internal partial class RedisKeyLocker
 		/// <param name="extraValues">The extra values that will be provided to the <paramref name="luaScript"/></param>
 		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
 		/// <returns>The lock value used to lock the key.</returns>
-		/// <exception cref="CacheException">Thrown if the lock was not aquired.</exception>
+		/// <exception cref="CacheException">Thrown if the lock was not acquired.</exception>
 		public Task<string> LockAsync(string key, string luaScript, RedisKey[] extraKeys, RedisValue[] extraValues, CancellationToken cancellationToken)
 		{
 			if (key == null)
@@ -44,7 +44,7 @@ public Task<string> LockAsync(string key, string luaScript, RedisKey[] extraKeys
 			return InternalLockAsync();
 			async Task<string> InternalLockAsync()
 			{
-				var lockKey = $"{key}{_lockKeyPostfix}";
+				var lockKey = $"{key}{_lockKeySuffix}";
 				var totalAttempts = 0;
 				var lockTimer = new Stopwatch();
 				lockTimer.Restart();
@@ -81,7 +81,7 @@ async Task<string> InternalLockAsync()
 					}
 					totalAttempts++;
 
-				} while (_retryTimes > totalAttempts - 1 && lockTimer.ElapsedMilliseconds < _aquireLockTimeout);
+				} while (_retryTimes > totalAttempts - 1 && lockTimer.ElapsedMilliseconds < _acquireLockTimeout);
 
 				throw new CacheException("Unable to acquire cache lock: " +
 												$"region='{_regionName}', " +
@@ -100,7 +100,7 @@ async Task<string> InternalLockAsync()
 		/// <param name="extraValues">The extra values that will be provided to the <paramref name="luaScript"/></param>
 		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
 		/// <returns>The lock value used to lock the keys.</returns>
-		/// <exception cref="CacheException">Thrown if the lock was not aquired.</exception>
+		/// <exception cref="CacheException">Thrown if the lock was not acquired.</exception>
 		public Task<string> LockManyAsync(string[] keys, string luaScript, RedisKey[] extraKeys, RedisValue[] extraValues, CancellationToken cancellationToken)
 		{
 			if (keys == null)
@@ -122,7 +122,7 @@ async Task<string> InternalLockManyAsync()
 				var lockKeys = new RedisKey[keys.Length];
 				for (var i = 0; i < keys.Length; i++)
 				{
-					lockKeys[i] = $"{keys[i]}{_lockKeyPostfix}";
+					lockKeys[i] = $"{keys[i]}{_lockKeySuffix}";
 				}
 				var totalAttempts = 0;
 				var lockTimer = new Stopwatch();
@@ -152,7 +152,7 @@ async Task<string> InternalLockManyAsync()
 					}
 					totalAttempts++;
 
-				} while (_retryTimes > totalAttempts - 1 && lockTimer.ElapsedMilliseconds < _aquireLockTimeout);
+				} while (_retryTimes > totalAttempts - 1 && lockTimer.ElapsedMilliseconds < _acquireLockTimeout);
 
 				throw new CacheException("Unable to acquire cache lock: " +
 			                                    $"region='{_regionName}', " +
@@ -185,7 +185,7 @@ public Task<bool> UnlockAsync(string key, string lockValue, string luaScript, Re
 			return InternalUnlockAsync();
 			async Task<bool> InternalUnlockAsync()
 			{
-				var lockKey = $"{key}{_lockKeyPostfix}";
+				var lockKey = $"{key}{_lockKeySuffix}";
 				if (string.IsNullOrEmpty(luaScript))
 				{
 					cancellationToken.ThrowIfCancellationRequested();
@@ -239,7 +239,7 @@ async Task<int> InternalUnlockManyAsync()
 				var lockKeys = new RedisKey[keys.Length];
 				for (var i = 0; i < keys.Length; i++)
 				{
-					lockKeys[i] = $"{keys[i]}{_lockKeyPostfix}";
+					lockKeys[i] = $"{keys[i]}{_lockKeySuffix}";
 				}
 				if (extraKeys != null)
 				{
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/ConfigurationHelper.cs b/StackExRedis/NHibernate.Caches.StackExRedis/ConfigurationHelper.cs
@@ -73,7 +73,7 @@ public static System.Type GetSystemType(string key, IDictionary<string, string>
 			}
 			catch (Exception e)
 			{
-				throw new CacheException($"Unable to aquire type '{typeName}' from the configuration property '{key}'", e);
+				throw new CacheException($"Unable to acquire type '{typeName}' from the configuration property '{key}'", e);
 			}
 		}
 
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/DefaultRegionStrategy.cs b/StackExRedis/NHibernate.Caches.StackExRedis/DefaultRegionStrategy.cs
@@ -8,7 +8,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. Event if the event was not sent to all clients, each operation has a
+	/// clients so that they can update thier 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
@@ -327,7 +327,7 @@ public override bool Unlock(object key)
 			catch (RedisServerException e) when (e.Message == InvalidVersionMessage)
 			{
 				InitializeVersion();
-				// If the lock was aquired in the old version we are unable to unlock the key.
+				// If the lock was acquired in the old version we are unable to unlock the key.
 				return false;
 			}
 		}
@@ -342,7 +342,7 @@ public override int UnlockMany(object[] keys, string lockValue)
 			catch (RedisServerException e) when (e.Message == InvalidVersionMessage)
 			{
 				InitializeVersion();
-				// If the lock was aquired in the old version we are unable to unlock the keys.
+				// If the lock was acquired in the old version we are unable to unlock the keys.
 				return 0;
 			}
 		}
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/RedisCacheLockConfiguration.cs b/StackExRedis/NHibernate.Caches.StackExRedis/RedisCacheLockConfiguration.cs
@@ -14,27 +14,27 @@ public class RedisCacheLockConfiguration
 		public TimeSpan KeyTimeout { get; set; } = TimeSpan.FromSeconds(5);
 
 		/// <summary>
-		/// The postfix for the lock key.
+		/// The suffix for the lock key.
 		/// </summary>
-		public string KeyPostfix { get; set; } = ":lock";
+		public string KeySuffix { get; set; } = ":lock";
 
 		/// <summary>
-		/// The time limit to aquire the lock.
+		/// The time limit to acquire the lock.
 		/// </summary>
-		public TimeSpan AquireTimeout { get; set; } = TimeSpan.FromSeconds(5);
+		public TimeSpan AcquireTimeout { get; set; } = TimeSpan.FromSeconds(5);
 
 		/// <summary>
 		/// The number of retries for acquiring the lock.
 		/// </summary>
 		public int RetryTimes { get; set; } = 3;
 
 		/// <summary>
-		/// The maximum delay before retrying to aquire the lock.
+		/// The maximum delay before retrying to acquire the lock.
 		/// </summary>
 		public TimeSpan MaxRetryDelay { get; set; } = TimeSpan.FromMilliseconds(400);
 
 		/// <summary>
-		/// The minumum delay before retrying to aquire the lock.
+		/// The minumum delay before retrying to acquire the lock.
 		/// </summary>
 		public TimeSpan MinRetryDelay { get; set; } = TimeSpan.FromMilliseconds(10);
 
@@ -53,8 +53,8 @@ public override string ToString()
 		{
 			var sb = new StringBuilder();
 			sb.AppendFormat("KeyTimeout={0}s", KeyTimeout.TotalSeconds);
-			sb.AppendFormat("KeyPostfix=({0})", KeyPostfix);
-			sb.AppendFormat("AquireTimeout={0}s", AquireTimeout.TotalSeconds);
+			sb.AppendFormat("KeySuffix=({0})", KeySuffix);
+			sb.AppendFormat("AcquireTimeout={0}s", AcquireTimeout.TotalSeconds);
 			sb.AppendFormat("RetryTimes={0}", RetryTimes);
 			sb.AppendFormat("MaxRetryDelay={0}ms", MaxRetryDelay.TotalMilliseconds);
 			sb.AppendFormat("MinRetryDelay={0}ms", MinRetryDelay.TotalMilliseconds);
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/RedisCacheProvider.cs b/StackExRedis/NHibernate.Caches.StackExRedis/RedisCacheProvider.cs
@@ -205,8 +205,8 @@ private RedisCacheConfiguration BuildDefaultConfiguration(IDictionary<string, st
 			lockConfig.KeyTimeout = GetTimeSpanFromSeconds(RedisEnvironment.LockKeyTimeout, properties, lockConfig.KeyTimeout);
 			Log.Debug("Lock key timeout: {0} seconds", lockConfig.KeyTimeout.TotalSeconds);
 
-			lockConfig.AquireTimeout = GetTimeSpanFromSeconds(RedisEnvironment.LockAquireTimeout, properties, lockConfig.AquireTimeout);
-			Log.Debug("Lock aquire timeout: {0} seconds", lockConfig.AquireTimeout.TotalSeconds);
+			lockConfig.AcquireTimeout = GetTimeSpanFromSeconds(RedisEnvironment.LockAcquireTimeout, properties, lockConfig.AcquireTimeout);
+			Log.Debug("Lock acquire timeout: {0} seconds", lockConfig.AcquireTimeout.TotalSeconds);
 
 			lockConfig.RetryTimes = GetInteger(RedisEnvironment.LockRetryTimes, properties, lockConfig.RetryTimes);
 			Log.Debug("Lock retry times: {0}", lockConfig.RetryTimes);
@@ -223,8 +223,8 @@ private RedisCacheConfiguration BuildDefaultConfiguration(IDictionary<string, st
 			lockConfig.RetryDelayProvider = GetInstanceOfType(RedisEnvironment.LockRetryDelayProvider, properties, lockConfig.RetryDelayProvider);
 			Log.Debug("Lock retry delay provider: {0}", lockConfig.RetryDelayProvider);
 
-			lockConfig.KeyPostfix = GetString(RedisEnvironment.LockKeyPostfix, properties, lockConfig.KeyPostfix);
-			Log.Debug("Lock key postfix: {0}", lockConfig.KeyPostfix);
+			lockConfig.KeySuffix = GetString(RedisEnvironment.LockKeySuffix, properties, lockConfig.KeySuffix);
+			Log.Debug("Lock key suffix: {0}", lockConfig.KeySuffix);
 
 			return config;
 		}
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/RedisEnvironment.cs b/StackExRedis/NHibernate.Caches.StackExRedis/RedisEnvironment.cs
@@ -55,22 +55,22 @@ public static class RedisEnvironment
 		public const string LockKeyTimeout = "cache.lock.key_timeout";
 
 		/// <summary>
-		/// The time limit to aquire the lock in seconds.
+		/// The time limit to acquire the lock in seconds.
 		/// </summary>
-		public const string LockAquireTimeout = "cache.lock.aquire_timeout";
+		public const string LockAcquireTimeout = "cache.lock.acquire_timeout";
 
 		/// <summary>
 		/// The number of retries for acquiring the lock.
 		/// </summary>
 		public const string LockRetryTimes = "cache.lock.retry_times";
 
 		/// <summary>
-		/// The maximum delay before retrying to aquire the lock in milliseconds.
+		/// The maximum delay before retrying to acquire the lock in milliseconds.
 		/// </summary>
 		public const string LockMaxRetryDelay = "cache.lock.max_retry_delay";
 
 		/// <summary>
-		/// The minumum delay before retrying to aquire the lock in milliseconds.
+		/// The minumum delay before retrying to acquire the lock in milliseconds.
 		/// </summary>
 		public const string LockMinRetryDelay = "cache.lock.min_retry_delay";
 
@@ -85,8 +85,8 @@ public static class RedisEnvironment
 		public const string LockRetryDelayProvider = "cache.lock.retry_delay_provider";
 
 		/// <summary>
-		/// The postfix for the lock key.
+		/// The suffix for the lock key.
 		/// </summary>
-		public const string LockKeyPostfix = "cache.lock.key_postfix";
+		public const string LockKeySuffix = "cache.lock.key_suffix";
 	}
 }
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/RedisKeyLocker.cs b/StackExRedis/NHibernate.Caches.StackExRedis/RedisKeyLocker.cs
diff --git a/StackExRedis/NHibernate.Caches.StackExRedis/RedisSectionHandler.cs b/StackExRedis/NHibernate.Caches.StackExRedis/RedisSectionHandler.cs

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ public async Task TestMaxAllowedVersionAsync()`
`37`	`37`
`38`	`38`	`await (cache.ClearAsync(CancellationToken.None));`
`39`	`39`
`40`		`- Assert.That(strategy.CurrentVersion, Is.EqualTo(1L), "The version was not reset to 1");`
	`40`	`+ Assert.That(strategy.CurrentVersion, Is.EqualTo(1L), "the version was not reset to 1");`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`[Test]`
Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,7 @@ public async Task TestLockUnlockManyAsync()`
`146`	`146`	`// Test partial locks by locking the first 5 keys and afterwards try to lock last 6 keys.`
`147`	`147`	`var lockValue = await (cache.LockManyAsync(keys.Take(5).ToArray(), CancellationToken.None));`
`148`	`148`
`149`		`- Assert.ThrowsAsync<CacheException>(() => cache.LockManyAsync(keys.Skip(4).ToArray(), CancellationToken.None), "The fifth key should be locked");`
	`149`	`+ Assert.ThrowsAsync<CacheException>(() => cache.LockManyAsync(keys.Skip(4).ToArray(), CancellationToken.None), "the fifth key should be locked");`
`150`	`150`
`151`	`151`	`Assert.DoesNotThrowAsync(async () =>`
`152`	`152`	`{`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public void TestNoExpiration()`
`19`	`19`	`var props = GetDefaultProperties();`
`20`	`20`	`props["expiration"] = "0";`
`21`	`21`	`Assert.Throws<CacheException>(() => DefaultProvider.BuildCache(DefaultRegion, props),`
`22`		`- "Default region strategy should not allow to have no expiration");`
	`22`	`+ "default region strategy should not allow to have no expiration");`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`[Test]`
`@@ -36,7 +36,7 @@ public void TestMaxAllowedVersion()`
`36`	`36`
`37`	`37`	`cache.Clear();`
`38`	`38`
`39`		`- Assert.That(strategy.CurrentVersion, Is.EqualTo(1L), "The version was not reset to 1");`
	`39`	`+ Assert.That(strategy.CurrentVersion, Is.EqualTo(1L), "the version was not reset to 1");`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`[Test]`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ public void TestLockUnlockMany()`
`143`	`143`	`// Test partial locks by locking the first 5 keys and afterwards try to lock last 6 keys.`
`144`	`144`	`var lockValue = cache.LockMany(keys.Take(5).ToArray());`
`145`	`145`
`146`		`- Assert.Throws<CacheException>(() => cache.LockMany(keys.Skip(4).ToArray()), "The fifth key should be locked");`
	`146`	`+ Assert.Throws<CacheException>(() => cache.LockMany(keys.Skip(4).ToArray()), "the fifth key should be locked");`
`147`	`147`
`148`	`148`	`Assert.DoesNotThrow(() =>`
`149`	`149`	`{`
Original file line number	Diff line number	Diff line change
`@@ -300,7 +300,7 @@ async Task<string> InternalLockAsync()`
`300`	`300`	`var cacheKey = GetCacheKey(key);`
`301`	`301`	`var lockValue = await (_keyLocker.LockAsync(cacheKey, LockScript, GetAdditionalKeys(), GetAdditionalValues(), cancellationToken)).ConfigureAwait(false);`
`302`	`302`
`303`		`- _aquiredKeyLocks.AddOrUpdate(cacheKey, _ => lockValue, (_, currValue) =>`
	`303`	`+ _acquiredKeyLocks.AddOrUpdate(cacheKey, _ => lockValue, (_, currValue) =>`
`304`	`304`	`{`
`305`	`305`	`Log.Warn(`
`306`	`306`	`$"Calling {nameof(LockAsync)} method for key:'{cacheKey}' that was already locked. " +`
`@@ -367,7 +367,7 @@ public virtual Task<bool> UnlockAsync(object key, CancellationToken cancellation`
`367`	`367`	`{`
`368`	`368`	`var cacheKey = GetCacheKey(key);`
`369`	`369`
`370`		`- if (!_aquiredKeyLocks.TryRemove(cacheKey, out var lockValue))`
	`370`	`+ if (!_acquiredKeyLocks.TryRemove(cacheKey, out var lockValue))`
`371`	`371`	`{`
`372`	`372`	`Log.Warn(`
`373`	`373`	`$"Calling {nameof(UnlockAsync)} method for key:'{cacheKey}' that was not locked with {nameof(LockAsync)} method before.");`
Original file line number	Diff line number	Diff line change
`@@ -164,7 +164,7 @@ public override async Task<bool> UnlockAsync(object key, CancellationToken cance`
`164`	`164`	`{`
`165`	`165`	`cancellationToken.ThrowIfCancellationRequested();`
`166`	`166`	`await (InitializeVersionAsync()).ConfigureAwait(false);`
`167`		`- // If the lock was aquired in the old version we are unable to unlock the key.`
	`167`	`+ // If the lock was acquired in the old version we are unable to unlock the key.`
`168`	`168`	`return false;`
`169`	`169`	`}`
`170`	`170`	`}`
`@@ -181,7 +181,7 @@ public override async Task<int> UnlockManyAsync(object[] keys, string lockValue,`
`181`	`181`	`{`
`182`	`182`	`cancellationToken.ThrowIfCancellationRequested();`
`183`	`183`	`await (InitializeVersionAsync()).ConfigureAwait(false);`
`184`		`- // If the lock was aquired in the old version we are unable to unlock the keys.`
	`184`	`+ // If the lock was acquired in the old version we are unable to unlock the keys.`
`185`	`185`	`return 0;`
`186`	`186`	`}`
`187`	`187`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ internal partial class RedisKeyLocker`
`30`	`30`	`/// <param name="extraValues">The extra values that will be provided to the <paramref name="luaScript"/></param>`
`31`	`31`	`/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>`
`32`	`32`	`/// <returns>The lock value used to lock the key.</returns>`
`33`		`- /// <exception cref="CacheException">Thrown if the lock was not aquired.</exception>`
	`33`	`+ /// <exception cref="CacheException">Thrown if the lock was not acquired.</exception>`
`34`	`34`	`public Task<string> LockAsync(string key, string luaScript, RedisKey[] extraKeys, RedisValue[] extraValues, CancellationToken cancellationToken)`
`35`	`35`	`{`
`36`	`36`	`if (key == null)`
`@@ -44,7 +44,7 @@ public Task<string> LockAsync(string key, string luaScript, RedisKey[] extraKeys`
`44`	`44`	`return InternalLockAsync();`
`45`	`45`	`async Task<string> InternalLockAsync()`
`46`	`46`	`{`
`47`		`- var lockKey = $"{key}{_lockKeyPostfix}";`
	`47`	`+ var lockKey = $"{key}{_lockKeySuffix}";`
`48`	`48`	`var totalAttempts = 0;`
`49`	`49`	`var lockTimer = new Stopwatch();`
`50`	`50`	`lockTimer.Restart();`
`@@ -81,7 +81,7 @@ async Task<string> InternalLockAsync()`
`81`	`81`	`}`
`82`	`82`	`totalAttempts++;`
`83`	`83`
`84`		`- } while (_retryTimes > totalAttempts - 1 && lockTimer.ElapsedMilliseconds < _aquireLockTimeout);`
	`84`	`+ } while (_retryTimes > totalAttempts - 1 && lockTimer.ElapsedMilliseconds < _acquireLockTimeout);`
`85`	`85`
`86`	`86`	`throw new CacheException("Unable to acquire cache lock: " +`
`87`	`87`	`$"region='{_regionName}', " +`
`@@ -100,7 +100,7 @@ async Task<string> InternalLockAsync()`
`100`	`100`	`/// <param name="extraValues">The extra values that will be provided to the <paramref name="luaScript"/></param>`
`101`	`101`	`/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>`
`102`	`102`	`/// <returns>The lock value used to lock the keys.</returns>`
`103`		`- /// <exception cref="CacheException">Thrown if the lock was not aquired.</exception>`
	`103`	`+ /// <exception cref="CacheException">Thrown if the lock was not acquired.</exception>`
`104`	`104`	`public Task<string> LockManyAsync(string[] keys, string luaScript, RedisKey[] extraKeys, RedisValue[] extraValues, CancellationToken cancellationToken)`
`105`	`105`	`{`
`106`	`106`	`if (keys == null)`
`@@ -122,7 +122,7 @@ async Task<string> InternalLockManyAsync()`
`122`	`122`	`var lockKeys = new RedisKey[keys.Length];`
`123`	`123`	`for (var i = 0; i < keys.Length; i++)`
`124`	`124`	`{`
`125`		`- lockKeys[i] = $"{keys[i]}{_lockKeyPostfix}";`
	`125`	`+ lockKeys[i] = $"{keys[i]}{_lockKeySuffix}";`
`126`	`126`	`}`
`127`	`127`	`var totalAttempts = 0;`
`128`	`128`	`var lockTimer = new Stopwatch();`
`@@ -152,7 +152,7 @@ async Task<string> InternalLockManyAsync()`
`152`	`152`	`}`
`153`	`153`	`totalAttempts++;`
`154`	`154`
`155`		`- } while (_retryTimes > totalAttempts - 1 && lockTimer.ElapsedMilliseconds < _aquireLockTimeout);`
	`155`	`+ } while (_retryTimes > totalAttempts - 1 && lockTimer.ElapsedMilliseconds < _acquireLockTimeout);`
`156`	`156`
`157`	`157`	`throw new CacheException("Unable to acquire cache lock: " +`
`158`	`158`	`$"region='{_regionName}', " +`
`@@ -185,7 +185,7 @@ public Task<bool> UnlockAsync(string key, string lockValue, string luaScript, Re`
`185`	`185`	`return InternalUnlockAsync();`
`186`	`186`	`async Task<bool> InternalUnlockAsync()`
`187`	`187`	`{`
`188`		`- var lockKey = $"{key}{_lockKeyPostfix}";`
	`188`	`+ var lockKey = $"{key}{_lockKeySuffix}";`
`189`	`189`	`if (string.IsNullOrEmpty(luaScript))`
`190`	`190`	`{`
`191`	`191`	`cancellationToken.ThrowIfCancellationRequested();`
`@@ -239,7 +239,7 @@ async Task<int> InternalUnlockManyAsync()`
`239`	`239`	`var lockKeys = new RedisKey[keys.Length];`
`240`	`240`	`for (var i = 0; i < keys.Length; i++)`
`241`	`241`	`{`
`242`		`- lockKeys[i] = $"{keys[i]}{_lockKeyPostfix}";`
	`242`	`+ lockKeys[i] = $"{keys[i]}{_lockKeySuffix}";`
`243`	`243`	`}`
`244`	`244`	`if (extraKeys != null)`
`245`	`245`	`{`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ public static System.Type GetSystemType(string key, IDictionary<string, string>`
`73`	`73`	`}`
`74`	`74`	`catch (Exception e)`
`75`	`75`	`{`
`76`		`- throw new CacheException($"Unable to aquire type '{typeName}' from the configuration property '{key}'", e);`
	`76`	`+ throw new CacheException($"Unable to acquire type '{typeName}' from the configuration property '{key}'", e);`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`