/// <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;
}
