protected internal void RaiseZplTemplateChanged()
{
if (EventRaiser != null)
{
EventRaiser.Raise(ref ZplTemplateChanged, ZplTemplateFile);
}
}
protected internal void RaiseZebraIpChangedEvent()
{
if (EventRaiser != null)
{
EventRaiser.Raise(ref ZebraIpChanged, ZebraPrinterIP);
}
}
/// <summary>
/// Provides the ability to raise an event that has had an expectation created
/// </summary>
/// <typeparam name="T">the mocked type</typeparam>
/// <param name="instance">the mocked instance</param>
/// <param name="eventSubscription">the event that has had an expectation created</param>
/// <param name="args">arguments used to the raise event</param>
/// <returns>collection of the actual calls</returns>
/// <exception cref="System.ArgumentNullException">thrown when the instance is null</exception>
/// <exception cref="System.ArgumentOutOfRangeException">
/// thrown when the instance cannot be identified as a mocked object or the given method is not an event
/// </exception>
public static void Raise <T>(this T instance, Action <T> eventSubscription, object[] args)
where T : class
{
if (instance == null)
{
throw new ArgumentNullException("instance", "Events cannot be raised from a null object or instance.");
}
var container = GetExpectationContainer(instance);
if (container == null)
{
throw new ArgumentOutOfRangeException("instance", "Events can only be raised from a mocked object or instance.");
}
var expectation = new ExpectEvent();
container.MarkForAssertion(expectation);
try
{
eventSubscription(instance);
}
catch (Exception ex)
{
throw new InvalidOperationException("Exception caught while identifying event", ex);
}
if (container.ExpectationMarked)
{
throw new InvalidOperationException();
}
var method = expectation.Method;
if (!method.IsSpecialName)
{
throw new InvalidOperationException("Raise method can only be used against events.");
}
var methodName = method.Name;
if (!methodName.StartsWith("add_"))
{
throw new InvalidOperationException("Raise method can only be used against events.");
}
var eventName = methodName.Substring(4);
var subscription = container.GetEventSubscribers(eventName);
if (subscription == null)
{
return;
}
var raiser = new EventRaiser(instance);
raiser.Raise(subscription, args);
}
public void WriteAll()
{
int b;
while ((b = _source.ReadByte()) != -1)
{
_destination.WriteByte((byte)b);
EventRaiser.Raise(ProgressChanged, this); // Just one call here! Can't be less
}
}
/// <summary>
/// Raises the metrics changed event.
/// </summary>
/// <param name="oee">A value between 0 and 1 indicating the speedometer (for whatever metric).</param>
protected internal void RaiseMetricsChangedEvent()
{
// callbacks will be raised in any case even if the state hasn't changed. to update WCF clients.
if (EventRaiser != null)
{
var metrics = new MetricsDTO(
OverallItemCount,
Metrics.UpTime,
Metrics.DownTime,
Metrics.OverallEquipmentEfficiency);
EventRaiser.Raise(ref MetricsChangedCallback, metrics);
}
}
public void TriggerAndVerifyRespondingToEvents()
{
MockRepository mocks = new MockRepository();
IView viewStub = mocks.Stub <IView>();
IWebService serviceMock = mocks.CreateMock <IWebService>();
using (mocks.Record())
{
serviceMock.LogInfo("view loaded");
}
new Presenter(viewStub, serviceMock);
IEventRaiser eventer = new EventRaiser((IMockedObject)viewStub, "Load");
eventer.Raise(null, EventArgs.Empty);
mocks.VerifyAll();
}
internal protected void RaiseModuleStateChangedEvent()
{
// callbacks will be raised in any case even if the state hasn't changed. to update WCF clients.
if (EventRaiser != null)
{
EventRaiser.Raise(ref ModuleStateChangedCallback, this.ToDTO());
}
if (State != _oldModuleState)
{
var handle = ModuleStateChangedEvent;
if (handle != null)
{
handle(this, State);
}
_oldModuleState = State;
}
}
public void TriggerCallbackEvent()
{
EventRaiser.Raise(ref AlarmsChanged, _moduleName);
}
public void RaiseEvent(string eventName)
{
EventRaiser.Raise(eventName);
}
