public void A_custom_exception_can_be_specified()
{
Action ensuring = () => Ensure.Argument("foobarbaz")
.DoesNotMatch(new Regex("^.*baz$"), _ => new IndexOutOfRangeException("bar"));
ensuring.ShouldThrowExactly <IndexOutOfRangeException>().WithMessage("bar");
}
public void The_default_exception_is_ArgumentException()
{
Action ensuring = () => Ensure.Argument(@"Z:\foo\bar\baz").DirectoryExists();
ensuring.ShouldThrowExactly <ArgumentException>()
.WithMessage(@"Directory 'Z:\foo\bar\baz' does not exist.");
}
public void The_default_exception_is_ArgumentException()
{
Action ensuring = () => Ensure.Argument("foobarbaz").DoesNotMatch("^.*baz$");
ensuring.ShouldThrowExactly <ArgumentException>()
.WithMessage("'foobarbaz' does not match the required regex '^.*baz$'.");
}
public void No_exception_is_thrown_if_the_directory_exists()
{
var directory = Directory.GetCurrentDirectory();
Action ensuring = () => Ensure.Argument(directory).DirectoryExists();
ensuring.ShouldNotThrow();
}
public void The_default_exception_is_ArgumentOutOfRangeException()
{
Action ensuring = () => Ensure.Argument(1).GreaterThanOrEqualTo(2);
ensuring.ShouldThrowExactly <ArgumentOutOfRangeException>()
.WithMessage("Value must be greater than or equal to 2 but was 1.");
}
static Real ComputeLoss(FunctionStack model, NdArray[] sequences)
{
Ensure.Argument(model).NotNull();
Ensure.Argument(sequences).NotNull();
// Total error in the whole
Real totalLoss = 0;
NdArray x = new NdArray(new[] { 1 }, MINI_BATCH_SIZE, (Function)null);
NdArray t = new NdArray(new[] { 1 }, MINI_BATCH_SIZE, (Function)null);
Stack <NdArray[]> backNdArrays = new Stack <NdArray[]>();
for (int i = 0; i < LENGTH_OF_SEQUENCE - 1; i++)
{
for (int j = 0; j < MINI_BATCH_SIZE; j++)
{
x.Data[j] = sequences[j].Data[i];
t.Data[j] = sequences[j].Data[i + 1];
}
NdArray[] result = model.Forward(true, x);
totalLoss += new MeanSquaredError().Evaluate(result, t);
backNdArrays.Push(result);
}
for (int i = 0; backNdArrays.Count > 0; i++)
{
model.Backward(true, backNdArrays.Pop());
}
return(totalLoss / (LENGTH_OF_SEQUENCE - 1));
}
public void The_name_and_value_can_be_derived_from_a_lambda()
{
var theTimeNow = DateTime.Now;
Ensure.Argument(() => theTimeNow).Should()
.Match(arg => (Ensurable <DateTime>)arg == theTimeNow && ((EnsurableArgument <DateTime>)arg).Name == "theTimeNow");
}
public void A_custom_exception_can_be_specified()
{
Action ensuring = () => Ensure.Argument(Enumerable.Empty <int>())
.NotEmpty(_ => new FileNotFoundException("bar"));
ensuring.ShouldThrowExactly <FileNotFoundException>().WithMessage("bar");
}
static Bitmap CreateMonoImage([NotNull] Real[] data, int width, int height, bool isNorm)
{
Ensure.Argument(data).NotNull("data is null");
Bitmap result = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
Real norm = isNorm ? 255 : 1;
ColorPalette pal = result.Palette;
for (int i = 0; i < 255; i++)
{
pal.Entries[i] = Color.FromArgb(i, i, i);
}
result.Palette = pal;
BitmapData bmpdat = result.LockBits(new Rectangle(0, 0, result.Width, result.Height), ImageLockMode.WriteOnly, result.PixelFormat);
byte[] resultData = new byte[bmpdat.Stride * height];
Real datamax = data.Max();
for (int y = 0; y < result.Height; y++)
{
for (int x = 0; x < result.Width; x++)
{
resultData[y * bmpdat.Stride + x] = (byte)(data[y * width + x] / datamax * norm);
}
}
Marshal.Copy(resultData, 0, bmpdat.Scan0, resultData.Length);
result.UnlockBits(bmpdat);
return(result);
}
public void A_custom_exception_can_be_specified()
{
Action ensuring = () => Ensure.Argument("foobarbaz")
.Matches(".*[0-9]", _ => new IndexOutOfRangeException("bar"));
ensuring.ShouldThrowExactly <IndexOutOfRangeException>().WithMessage("bar");
}
public void The_default_exception_is_ArgumentException()
{
Action ensuring = () => Ensure.Argument(typeof(int)).IsAssignableTo <long>();
ensuring.ShouldThrowExactly <ArgumentException>()
.WithMessage("Type System.Int32 is not assignable to type System.Int64.");
}
public void The_default_exception_is_ArgumentException()
{
Action ensuring = () => Ensure.Argument("foobarbaz").Matches(".*[0-9]");
ensuring.ShouldThrowExactly <ArgumentException>()
.WithMessage("'foobarbaz' does not match the required regex '.*[0-9]'.");
}
public void FileExists_ArgNotNullExistingFileName_ReturnsArgument()
{
const string fileName = @"C:\temp_dir\test.txt";
var mockFileSystem = new MockFileSystemEx(
new Dictionary <string, MockFileData>
{
{ fileName, MockFileData.NullObject }
},
@"C:\");
mockFileSystem.Install();
// Act
var argument = Ensure.Argument(fileName, nameof(fileName)).NotNull().FileExists();
// Assert
argument
.Should()
.BeOfType <ArgumentNotNull <string> >();
argument.Value
.Should()
.Be(fileName);
}
public void The_default_exception_is_ArgumentException()
{
Action ensuring = () => Ensure.Argument(0).In(new[] { 1, 2, 3 });
ensuring.ShouldThrowExactly <ArgumentException>()
.WithMessage("Value was not contained in the specified collection.");
}
public void The_ensurable_is_returned()
{
var directory = Directory.GetCurrentDirectory();
var theEnsurable = Ensure.Argument(directory);
theEnsurable.DirectoryExists().Should().Be(theEnsurable);
}
public void Argument_ParamNameIsNull_ThrowsException()
{
// Act
Action act = () => Ensure.Argument("Test", null);
// Assert
act
.Should()
.Throw <ArgumentNullException>();
}
public void InRange_ItemsCountIsNotInRange_ThrowsException(int[] items, int minCount, int maxCount)
{
// Act
Action act = () => Ensure.Argument(items, nameof(items)).NotNull().InRange(minCount, maxCount);
// Assert
act
.Should()
.Throw <ArgumentException>();
}
public void MaxCount_ItemsCountNotMeetsMaxCount_ThrowsException(int[] items, int maxCount)
{
// Act
Action act = () => Ensure.Argument(items, nameof(items)).NotNull().MaxCount(maxCount);
// Assert
act
.Should()
.Throw <ArgumentException>();
}
public void InRange_ItemsCountIsInRange_ReturnsArgumentNotNullWithItems(
int[] items, int minCount, int maxCount)
{
// Act
var argument = Ensure.Argument(items, nameof(items)).NotNull().InRange(minCount, maxCount);
// Assert
argument.Value
.Should()
.HaveCount(items.Length);
}
public void MaxCount_ItemsCountMeetsMaxCount_ReturnsArgumentNotNullWithItems(int[] items,
int maxCount)
{
// Act
var argument = Ensure.Argument(items, nameof(items)).NotNull().MaxCount(maxCount);
// Assert
argument.Value
.Should()
.HaveCount(items.Length);
}
public void NotEmpty_NewGuidNullable_ReturnsArgumentWithGuid()
{
Guid?guid = Guid.NewGuid();
// Act
var argument = Ensure.Argument(guid, nameof(guid)).NotEmpty();
// Assert
argument.Value
.Should()
.Be(guid);
}
public void Null_ValueIsNotNull_ThrowsException()
{
const string testValue = "TestText";
// Act
Action act = () => Ensure.Argument(testValue, nameof(testValue)).Null();
// Assert
act
.Should()
.Throw <ArgumentException>();
}
public void Null_ValueNull_ReturnsNull()
{
const string?testValue = null;
// Act
var value = Ensure.Argument(testValue, nameof(testValue)).Null();
// Assert
value
.Should()
.BeNull();
}
public void NotNullOrEmpty_ArrayContainingItems_ReturnsArgument()
{
var items = new[] { 1, 2, 3 };
// Act
var argument = Ensure.Argument(items, nameof(items)).NotNullOrEmpty();
// Assert
argument.Value
.Should()
.BeSameAs(items);
}
public void NotEmpty_EnumerableContainingItems_ReturnsArgument()
{
var items = new[] { 1, 2, 3 }.Where(_ => true);
// Act
var argument = Ensure.Argument(items, nameof(items)).NotNull().NotEmpty();
// Assert
argument.Value
.Should()
.BeSameAs(items);
}
public void NotNullOrEmpty_ArrayEmpty_ThrowsException()
{
var items = Array.Empty <int>();
// Act
Action act = () => Ensure.Argument(items, nameof(items)).NotNullOrEmpty();
// Assert
act
.Should()
.Throw <ArgumentException>();
}
public void NotNull_ValueIsNull_ThrowsException()
{
string?testValue = null;
// Act
Action act = () => Ensure.Argument(testValue, nameof(testValue)).NotNull();
// Assert
act
.Should()
.Throw <ArgumentNullException>();
}
public void NotEmpty_EmptyGuidNullable_ThrowsException()
{
Guid?guid = Guid.Empty;
// Act
Action act = () => Ensure.Argument(guid, nameof(guid)).NotEmpty();
// Assert
act
.Should()
.Throw <ArgumentException>();
}
public void NotNullOrEmpty_ArrayNull_ThrowsException()
{
int[]? items = null;
// Act
Action act = () => Ensure.Argument(items, nameof(items)).NotNullOrEmpty();
// Assert
act
.Should()
.Throw <ArgumentNullException>();
}
public void NotEmpty_ArgNotNullNullGuidNullable_ThrowsException()
{
Guid?guid = null;
// Act
Action act = () => Ensure.Argument(guid, nameof(guid)).NotNull().NotEmpty();
// Assert
act
.Should()
.Throw <ArgumentNullException>();
}
