tsai
/
ImageSharp
mirror of https://github.com/SixLabors/ImageSharp
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

[SL.Core] Fix test names + additional overloads

af/octree-no-pixelmap
Scott Williams 9 years ago
committed by Dirk Lemstra
parent
cefda3870a
commit
b5a0ab7f76
4 changed files with 81 additions and 25 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      src/SixLabors.Core/Helpers/DebugGuard.cs
  2. 18
      src/SixLabors.Core/Helpers/Guard.cs
  3. 30
      tests/SixLabors.Core.Tests/Helpers/DebugGuardTests.cs
  4. 50
      tests/SixLabors.Core.Tests/Helpers/GuardTests.cs

8
src/SixLabors.Core/Helpers/DebugGuard.cs
View File

@ -174,7 +174,7 @@ namespace SixLabors
{
if (target.Length != other.Length)
{
throw new ArgumentException("Span-s must be the same size!", parameterName);
throw new ArgumentException("Span-s must be the same size.", parameterName);
}
}
@ -194,7 +194,7 @@ namespace SixLabors
{
if (target.Length != other.Length)
{
throw new ArgumentException("Span-s must be the same size!", parameterName);
throw new ArgumentException("Span-s must be the same size.", parameterName);
}
}
@ -214,7 +214,7 @@ namespace SixLabors
{
if (target.Length < minSpan.Length)
{
throw new ArgumentException($"Span-s must be at least of length {minSpan.Length}!", parameterName);
throw new ArgumentException($"Span-s must be at least of length {minSpan.Length}.", parameterName);
}
}
@ -234,7 +234,7 @@ namespace SixLabors
{
if (target.Length < minSpan.Length)
{
throw new ArgumentException($"Span-s must be at least of length {minSpan.Length}!", parameterName);
throw new ArgumentException($"Span-s must be at least of length {minSpan.Length}.", parameterName);
}
}

18
src/SixLabors.Core/Helpers/Guard.cs
View File

@ -227,6 +227,24 @@ namespace SixLabors
}
}
/// <summary>
/// Verifies, that the `target` span has the length of 'minLength', or longer.
/// </summary>
/// <typeparam name="T">The element type of the spans</typeparam>
/// <param name="value">The target span.</param>
/// <param name="minLength">The minimum length.</param>
/// <param name="parameterName">The name of the parameter that is to be checked.</param>
/// <exception cref="ArgumentException">
/// The length of <paramref name="value"/> is less than <paramref name="minLength"/>.
/// </exception>
public static void MustBeSizedAtLeast<T>(T[] value, int minLength, string parameterName)
{
if (value.Length < minLength)
{
throw new ArgumentException($"The size must be at least {minLength}.", parameterName);
}
}
/// <summary>
/// Verifies, that the `target` span has the length of 'minLength', or longer.
/// </summary>

30
tests/SixLabors.Core.Tests/Helpers/DebugGuardTests.cs
View File

@ -43,7 +43,6 @@ namespace SixLabors.Helpers.Tests
});
}
[Fact]
public void MustBeLessThan_IsLess_ThrowsNoException()
{
@ -163,13 +162,13 @@ namespace SixLabors.Helpers.Tests
[Theory]
[InlineData(new int[] { 1, 2 }, 1)]
[InlineData(new int[] { 1, 2 }, 2)]
public void MustBeSizedAtLeast_LengthIsGreaterOrEqual_ThrowsNoException(int[] value, int minLength)
public void MustBeSizedAtLeast_Array_LengthIsGreaterOrEqual_ThrowsNoException(int[] value, int minLength)
{
DebugGuard.MustBeSizedAtLeast<int>(value, minLength, "myParamName");
}
[Fact]
public void MustBeSizedAtLeast_LengthIsLess_ThrowsException()
public void MustBeSizedAtLeast_Array_LengthIsLess_ThrowsException()
{
var exception = Assert.Throws<ArgumentException>(() =>
{
@ -181,7 +180,7 @@ namespace SixLabors.Helpers.Tests
}
[Fact]
public void ReadOnlySpan_MustBeSizedAtLeast_LengthIsLess_ThrowsException()
public void MustBeSizedAtLeast_ReadOnlySpan_LengthIsLess_ThrowsException()
{
var exception = Assert.Throws<ArgumentException>(() =>
{
@ -189,11 +188,11 @@ namespace SixLabors.Helpers.Tests
});
Assert.Equal("myParamName", exception.ParamName);
Assert.Contains($"Span-s must be at least of length 3!", exception.Message);
Assert.Contains($"Span-s must be at least of length 3.", exception.Message);
}
[Fact]
public void Span_MustBeSizedAtLeast_LengthIsLess_ThrowsException()
public void MustBeSizedAtLeast_Span_LengthIsLess_ThrowsException()
{
var exception = Assert.Throws<ArgumentException>(() =>
{
@ -201,12 +200,11 @@ namespace SixLabors.Helpers.Tests
});
Assert.Equal("myParamName", exception.ParamName);
Assert.Contains($"Span-s must be at least of length 3!", exception.Message);
Assert.Contains($"Span-s must be at least of length 3.", exception.Message);
}
[Fact]
public void ReadOnlySpan_MustBeSameSized_LengthIsLess_ThrowsException()
public void MustBeSameSized_ReadOnlySpan_LengthIsLess_ThrowsException()
{
var exception = Assert.Throws<ArgumentException>(() =>
{
@ -214,11 +212,11 @@ namespace SixLabors.Helpers.Tests
});
Assert.Equal("myParamName", exception.ParamName);
Assert.Contains($"Span-s must be the same size!", exception.Message);
Assert.Contains($"Span-s must be the same size.", exception.Message);
}
[Fact]
public void Span_MustBeSameSized_LengthIsLess_ThrowsException()
public void MustBeSameSized_Span_LengthIsLess_ThrowsException()
{
var exception = Assert.Throws<ArgumentException>(() =>
{
@ -226,13 +224,13 @@ namespace SixLabors.Helpers.Tests
});
Assert.Equal("myParamName", exception.ParamName);
Assert.Contains($"Span-s must be the same size!", exception.Message);
Assert.Contains($"Span-s must be the same size.", exception.Message);
}
[Theory]
[InlineData(2, 2)]
[InlineData(4, 3)]
public void ReadOnlySpan_MustBeSizedAtLeast_DoesNotThowException(int leftSize, int rightSize)
public void MustBeSizedAtLeast_ReadOnlySpan_DoesNotThowException(int leftSize, int rightSize)
{
DebugGuard.MustBeSizedAtLeast(new ReadOnlySpan<int>(new int[leftSize]), new ReadOnlySpan<int>(new int[rightSize]), "myParamName");
}
@ -240,19 +238,19 @@ namespace SixLabors.Helpers.Tests
[Theory]
[InlineData(2, 2)]
[InlineData(4, 3)]
public void Span_MustBeSizedAtLeast_DoesNotThowException(int leftSize, int rightSize)
public void MustBeSizedAtLeast_Span_DoesNotThowException(int leftSize, int rightSize)
{
DebugGuard.MustBeSizedAtLeast(new Span<int>(new int[leftSize]), new Span<int>(new int[rightSize]), "myParamName");
}
[Fact]
public void ReadOnlySpan_MustBeSameSized_LengthIsEqual_DoesNotThrowException()
public void MustBeSameSized_ReadOnlySpan_LengthIsEqual_DoesNotThrowException()
{
DebugGuard.MustBeSameSized(new ReadOnlySpan<int>(new int[2]), new ReadOnlySpan<int>(new int[2]), "myParamName");
}
[Fact]
public void Span_MustBeSameSized_LengthIsEqual_DoesNotThrowException()
public void MustBeSameSized_Span_LengthIsEqual_DoesNotThrowException()
{
DebugGuard.MustBeSameSized(new Span<int>(new int[2]), new Span<int>(new int[2]), "myParamName");
}

50
tests/SixLabors.Core.Tests/Helpers/GuardTests.cs
View File

@ -264,15 +264,31 @@ namespace SixLabors.Helpers.Tests
}
[Theory]
[InlineData(new int[] { 1, 2 }, 1)]
[InlineData(new int[] { 1, 2 }, 2)]
public void MustBeSizedAtLeast_LengthIsGreaterOrEqual_ThrowsNoException(int[] value, int minLength)
[InlineData(2, 1)]
[InlineData(2, 2)]
public void MustBeSizedAtLeast_Array_LengthIsGreaterOrEqual_ThrowsNoException(int valueLength, int minLength)
{
Guard.MustBeSizedAtLeast<int>(new int[valueLength], minLength, "myParamName");
}
[Theory]
[InlineData(2, 1)]
[InlineData(2, 2)]
public void MustBeSizedAtLeast_Span_LengthIsGreaterOrEqual_ThrowsNoException(int valueLength, int minLength)
{
Guard.MustBeSizedAtLeast<int>(new Span<int>(new int[valueLength]), minLength, "myParamName");
}
[Theory]
[InlineData(2, 1)]
[InlineData(2, 2)]
public void MustBeSizedAtLeast_ReadOnlySpan_LengthIsGreaterOrEqual_ThrowsNoException(int valueLength, int minLength)
{
Guard.MustBeSizedAtLeast<int>(value, minLength, "myParamName");
Guard.MustBeSizedAtLeast<int>(new ReadOnlySpan<int>(new int[valueLength]), minLength, "myParamName");
}
[Fact]
public void MustBeSizedAtLeast_LengthIsLess_ThrowsException()
public void MustBeSizedAtLeast_Array_LengthIsLess_ThrowsException()
{
var exception = Assert.Throws<ArgumentException>(() =>
{
@ -282,5 +298,29 @@ namespace SixLabors.Helpers.Tests
Assert.Equal("myParamName", exception.ParamName);
Assert.True(exception.Message.Contains($"The size must be at least 3."));
}
[Fact]
public void MustBeSizedAtLeast_Span_LengthIsLess_ThrowsException()
{
var exception = Assert.Throws<ArgumentException>(() =>
{
Guard.MustBeSizedAtLeast<int>(new Span<int>(new int[2]), 3, "myParamName");
});
Assert.Equal("myParamName", exception.ParamName);
Assert.True(exception.Message.Contains($"The size must be at least 3."));
}
[Fact]
public void MustBeSizedAtLeast_ReadOnlySpan_LengthIsLess_ThrowsException()
{
var exception = Assert.Throws<ArgumentException>(() =>
{
Guard.MustBeSizedAtLeast<int>(new ReadOnlySpan<int>(new int[2]), 3, "myParamName");
});
Assert.Equal("myParamName", exception.ParamName);
Assert.True(exception.Message.Contains($"The size must be at least 3."));
}
}
}

Write Preview
Loading…
Cancel
Save