/// <summary>Verifies that the <paramref name="@delegate"/> throws the specified exception type.</summary> /// <typeparam name="T">The type of exception expected to be thrown.</typeparam> /// <param name="delegate">A <see cref="Assert.ThrowsDelegate"/> which represents the action which should throw the exception.</param> /// <param name="exceptionChecker">Additional checks on the exception object.</param> public static void ShouldThrow <T>(this Assert.ThrowsDelegate @delegate, Action <T> exceptionChecker = null) where T : Exception { var exception = Assert.Throws <T>(@delegate); exceptionChecker?.Invoke(exception); }
public static ArgumentNullException ThrowsArgumentNull(Assert.ThrowsDelegate del, string paramName) { var e = Assert.Throws <ArgumentNullException>(del); Assert.Equal(paramName, e.ParamName); return(e); }
public static bool GetConfigurations(string projectPath, string absPath) { bool result = false; Assert.True(File.Exists(projectPath), "Project file does not exist."); string ProjectConnStr = "MGA=" + Path.GetFullPath(projectPath); MgaProject project = new MgaProject(); project.OpenEx(ProjectConnStr, "CyPhyML", null); try { var terr = project.BeginTransactionInNewTerr(); var testObj = project.ObjectByPath[absPath] as MgaFCO; project.AbortTransaction(); using (var masterInterpreter = new CyPhyMasterInterpreter.CyPhyMasterInterpreterAPI(project)) { IMgaFCOs configurations = null; Assert.ThrowsDelegate d = () => { configurations = masterInterpreter.GetConfigurations(testObj as MgaModel); }; Assert.DoesNotThrow(d); } } finally { project.Close(true); } return(result); }
public void TestValidateResponse_ServerReturnsNfieldErrorCodeAndMessage_ThrowsNfieldErrorExceptionWithErrorCodeAndMessage() { // Arrange const HttpStatusCode httpStatusCode = HttpStatusCode.NotFound; const NfieldErrorCode nfieldErrorCode = NfieldErrorCode.ArgumentIsNull; const string message = "Message #1"; var serverResponse = new HttpResponseMessage(httpStatusCode); var httpErrorMock = new Dictionary <string, object>() { { "NfieldErrorCode", nfieldErrorCode }, { "Message", message } }; HttpContent content = new ObjectContent <Dictionary <string, object> >(httpErrorMock, new JsonMediaTypeFormatter()); serverResponse.Content = content; // Act Assert.ThrowsDelegate actCode = () => serverResponse.ValidateResponse(); // Assert var ex = Assert.Throws <NfieldErrorException>(actCode); Assert.Equal(ex.HttpStatusCode, httpStatusCode); Assert.Equal(ex.NfieldErrorCode, nfieldErrorCode); Assert.Equal(ex.Message, message); }
public void Register_WhenCreatingHandleThrowsException_ThenFreeGlobalIsCalled() { // ARRANGE var mockedBroadcastDeviceInterfaceFactory = new Mock <IBroadcastDeviceInterfaceFactory>(); var mockedMarshallWrapper = new Mock <IMarshalWrapper>(); var mockedUnsafeNativeMethodsWrapper = new Mock <IUnsafeNativeMethodsWrapper>(); var mockedProcessHandleResultFactory = new Mock <IProcessHandleResultFactory>(); var deviceManagement = new DeviceNotifications( mockedBroadcastDeviceInterfaceFactory.Object, mockedMarshallWrapper.Object, mockedUnsafeNativeMethodsWrapper.Object, mockedProcessHandleResultFactory.Object); var handleReceivesNotifications = new IntPtr(42); var devBroadcastDeviceInterface = new BroadcastDeviceInterface(); var intPtrForBuffer = new IntPtr(111); mockedBroadcastDeviceInterfaceFactory.Setup(x => x.CreateBroadcastDeviceInterface()).Returns(devBroadcastDeviceInterface); mockedMarshallWrapper.Setup(x => x.AllocHGlobal(devBroadcastDeviceInterface.Size)).Returns(intPtrForBuffer); mockedUnsafeNativeMethodsWrapper.Setup(x => x.RegisterDeviceNotification(It.IsAny <IntPtr>(), It.IsAny <IntPtr>(), It.IsAny <uint>())); mockedProcessHandleResultFactory.Setup(x => x.Create(It.IsAny <IntPtr>())).Throws <InvalidOperationException>(); // ACT var testDelegate = new Assert.ThrowsDelegate(() => deviceManagement.Register(handleReceivesNotifications)); // ASSERT Assert.Throws <InvalidOperationException>(testDelegate); mockedMarshallWrapper.Verify(x => x.FreeHGlobal(intPtrForBuffer), Times.Once); }
public void SendRequest_Request_Null_Fails() { // Arrange _autoMockContainer .Register <IRequestService, RequestService>(); var mockUnitOfWork = _autoMockContainer .GetMock <IUnitOfWork>(); var requestEntity = new Domain.Entities.Request(); mockUnitOfWork .Setup(uow => uow.CreateEntity <Domain.Entities.Request>()) .Returns(requestEntity); _autoMockContainer .GetMock <IUnitOfWorkFactory>().Setup(uowf => uowf.Create()) .Returns(mockUnitOfWork.Object); _autoMockContainer .GetMock <IDateTimeService>() .Setup(dts => dts.GetCurrentDateAndTime()) .Returns(DateTime.Now); // Act Request request = null; Assert.ThrowsDelegate sendRequestAction = () => _autoMockContainer.Resolve <IRequestService>().CreateRequest(request); // Assert Assert.Throws <ArgumentNullException>(sendRequestAction); }
public void ShouldThrowNotSupportedExceptionForOtherThanRequestInitializationContextTypeOfContexts() { HttpContextProvider provider = new HttpContextProvider(); Assert.ThrowsDelegate action = () => provider.SetInitializationContext(new object()); Assert.Throws <NotSupportedException>(action); }
private static void AssertInvalidOperationExceptionIsThrown(Assert.ThrowsDelegate action) { var ex = Assert.Throws <InvalidOperationException>(action); Assert.Equal( ExceptionMessages.EnsureExtensions_InvalidOperationException.Inject(ParamName), ex.Message); }
public void ShouldThrowNotSupportedExceptionIfCalledWithOtherThanInitializationContextTypeOfContext() { TestInitializationActionDiscoverer actionDiscoverer = new TestInitializationActionDiscoverer(); Assert.ThrowsDelegate action = () => actionDiscoverer.GetInitializationActions(new object()); Assert.Throws <NotSupportedException>(action); }
public static void ThrowsArgumentException <TArgException>(Assert.ThrowsDelegate act, string paramName, string message) where TArgException : ArgumentException { Throws <TArgException>(act, ex => { Assert.Equal(paramName, ex.ParamName); Assert.Equal(String.Format(ArgumentExceptionMessageFormat, message, paramName), ex.Message); }); }
public void ShouldThrowNotSupportedExceptionForOtherThanTestApplicationInitializationContextTypesOfContexts() { TestApplicationInitializationActionDiscoverer discoverer = new TestApplicationInitializationActionDiscoverer(); Assert.ThrowsDelegate action = () => discoverer.GetInitializationActions("context"); Assert.Throws <NotSupportedException>(action); }
public void ShouldThrowNotSupportedExceptionForOtherThanRequestInitializationContextTypeOfContexts() { RequestInitializationActionDiscoverer discoverer = new RequestInitializationActionDiscoverer(); Assert.ThrowsDelegate action = () => discoverer.GetInitializationActions(new object()); Assert.Throws <NotSupportedException>(action); }
public void Null_Data_Set_Doesnt_Throw_Exception() { //act Assert.ThrowsDelegate act = () => new PagedList <object>(null, 1, 10); //assert Assert.DoesNotThrow(act); }
public void ShouldThrowInvalidOperationExceptionOnCleanupIfActionsCollectionIsEmpty() { const int MethodCallId = 123; Assert.ThrowsDelegate action = () => this.manager.Cleanup(MethodCallId, null); Assert.Throws <InvalidOperationException>(action); }
public void register_handler_ok() { Assert.ThrowsDelegate act = () => { _app.RegisterHandler <MyEvent>(ev => { }); }; Assert.DoesNotThrow(act); }
public void Parser_state_instance_should_not_pre_built() { var options = new FakeOptionsWithPreBuiltParserState(); Assert.ThrowsDelegate act = () => new CommandLine.Parser( with => with.HelpWriter = new StringWriter()).ParseArguments(new[] { "--bar" }, options); Assert.Throws <InvalidOperationException>(act); }
public void Parser_state_attribute_should_be_applied_to_a_property_of_the_correct_type() { var options = new FakeOptionsWithParserStateAttributeAppliedInWrongWay(); Assert.ThrowsDelegate act = () => new CommandLine.Parser( with => with.HelpWriter = new StringWriter()).ParseArguments(new[] { "--foo" }, options); Assert.Throws <InvalidOperationException>(act); }
public void ShouldBeAbleToCreateUninitializedTestInstance() { Test uninitializedTest = (Test)Test.CreateUninitializedTestInstance(typeof(Test)); Assert.ThrowsDelegate action = uninitializedTest.TestSomething; Assert.NotNull(uninitializedTest); Assert.Throws <RemotingException>(action); }
public static void Throws <TException>(Assert.ThrowsDelegate act, Action <TException> exceptionAssert) where TException : Exception { Exception ex = Record.Exception(act); Assert.NotNull(ex); TException tex = Assert.IsAssignableFrom <TException>(ex); exceptionAssert(tex); }
public void Setting_instance_is_not_reusable() { var settings = new ParserSettings(helpWriter: Console.Out); var parser = new CommandLine.Parser(settings); Assert.ThrowsDelegate act = () => { var parser2 = new CommandLine.Parser(settings); }; Assert.Throws <InvalidOperationException>(act); }
public void PageSize_Below_One_Throws_ArgumentOutOfRange() { //arrange var data = new[] { 1, 2, 3 }; //act Assert.ThrowsDelegate act = () => data.ToPagedList(1, 0); //assert Assert.Throws <ArgumentOutOfRangeException>(act); }
public static void ThrowsArgumentException <TArgException>(Assert.ThrowsDelegate act, string paramName, string message) where TArgException : ArgumentException { Throws <TArgException>(act, ex => { Assert.Equal(paramName, ex.ParamName); var lines = ex.Message.Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries); Assert.Equal(2, lines.Length); Assert.Equal(message, lines[0]); Assert.True(lines[1].EndsWith(paramName)); }); }
public static TException ThrowsWithError <TException>(Assert.ThrowsDelegate act, string error) where TException : Exception { var e = Assert.Throws <TException>(act); if (e != null) { Assert.Equal(error, e.Message); } return(e); }
public void PageIndex_Below_Zero_Throws_ArgumentOutOfRange() { //arrange var data = new[] { 1, 2, 3 }; //act Assert.ThrowsDelegate act = () => data.ToPagedList(-1, 1); //assert Assert.Throws <ArgumentOutOfRangeException>(act); }
public void Setting_instance_became_immutable_after_being_consumed() { var settings = new ParserSettings { ParsingCulture = new CultureInfo("it-IT") }; var parser = new CommandLine.Parser(settings); Assert.ThrowsDelegate act = () => { settings.HelpWriter = Console.Out; }; Assert.Throws <InvalidOperationException>(act); }
public void ShouldCrashIfTestCleanupCrashes() { this.testApplication.CreateObject(typeof(Test), Arg.Is <object[]>(args => (args != null) && (args.Length == 1) && (args[0] == this.initializationManager))).Returns(this.realTest); Test test = new Test(this.initializationManager); this.initializationManager.WhenForAnyArgs(manager => manager.Cleanup(0, null)).Throw <Exception>(); Assert.ThrowsDelegate action = test.TestSomething; Assert.Throws <Exception>(action); }
public void Create_NullMyoErrorHandlerBridge_ThrowsNullArgumentException() { // Setup // Execute Assert.ThrowsDelegate method = () => MyoErrorHandlerDriver.Create(null); // Assert var exception = Assert.Throws <ArgumentNullException>(method); Assert.Equal("myoErrorHandlerBridge", exception.ParamName); }
public static ArgumentException ThrowsArgumentException(Assert.ThrowsDelegate del, string exceptionMessage, string paramName) { var e = Assert.Throws <ArgumentException>(del); if (UnitTestHelper.EnglishBuildAndOS) { Assert.Equal(exceptionMessage, e.Message); Assert.Equal(paramName, e.ParamName); } return(e); }
public void Create_NullChannelListener_ThrowsNullArgumentException() { // Setup // Execute Assert.ThrowsDelegate method = () => DeviceListener.Create(null); // Assert var exception = Assert.Throws <ArgumentNullException>(method); Assert.Equal("channelListener", exception.ParamName); }
/// <summary> /// Records any exception which is thrown by the given code. /// </summary> /// <param name="code">The code which may thrown an exception.</param> /// <returns>Returns the exception that was thrown by the code; null, otherwise.</returns> public static Exception Exception(Assert.ThrowsDelegate code) { try { code(); return(null); } catch (Exception ex) { return(ex); } }
public void Register_WhenStructureToPointerThrowsException_ThenFreeGlobalIsCalled() { // ARRANGE var mockedBroadcastDeviceInterfaceFactory = new Mock<IBroadcastDeviceInterfaceFactory>(); var mockedMarshallWrapper = new Mock<IMarshalWrapper>(); var mockedUnsafeNativeMethodsWrapper = new Mock<IUnsafeNativeMethodsWrapper>(); var mockedProcessHandleResultFactory = new Mock<IProcessHandleResultFactory>(); var deviceManagement = new DeviceNotifications( mockedBroadcastDeviceInterfaceFactory.Object, mockedMarshallWrapper.Object, mockedUnsafeNativeMethodsWrapper.Object, mockedProcessHandleResultFactory.Object); var handleReceivesNotifications = new IntPtr(42); var devBroadcastDeviceInterface = new BroadcastDeviceInterface(); var intPtrForBuffer = new IntPtr(111); mockedBroadcastDeviceInterfaceFactory.Setup(x => x.CreateBroadcastDeviceInterface()).Returns(devBroadcastDeviceInterface); mockedMarshallWrapper.Setup(x => x.AllocHGlobal(devBroadcastDeviceInterface.Size)).Returns(intPtrForBuffer); mockedMarshallWrapper.Setup(x => x.StructureToPointer(devBroadcastDeviceInterface, intPtrForBuffer, false)).Throws<InvalidOperationException>(); // ACT var testDelegate = new Assert.ThrowsDelegate(() => deviceManagement.Register(handleReceivesNotifications)); // ASSERT Assert.Throws<InvalidOperationException>(testDelegate); mockedMarshallWrapper.Verify(x => x.FreeHGlobal(intPtrForBuffer), Times.Once); }
public LambdaTestCommand(IMethodInfo method, Assert.ThrowsDelegate lambda) : base(method, null, 0) { this.lambda = lambda; }