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>(); }