private void HandleUSBChargeEvent(object s, CurrentEventArgs e)
{
CurrentCurrent = e.Current;
if (CurrentCurrent > 0 && CurrentCurrent <= 5)
{
usbCharger.StopCharge();
_Display.ShowMessage("Telefonen er fuldt opladt");
Connected = true;
}
else if (CurrentCurrent > 5 && CurrentCurrent <= 500)
{
_Display.ShowMessage("Oplader telefon...");
Connected = true;
}
else if (CurrentCurrent > 500)
{
usbCharger.StopCharge();
_Display.ShowMessage("Error...");
Connected = true;
}
else if (CurrentCurrent == 0)
{
Connected = false;
}
}
public void NewChargeHandler(object sender, CurrentEventArgs e)
{
double current = e.Current;
if (current < 0)
{
throw new ArgumentOutOfRangeException("Value was below 0");
}
else if (current == 0)
{
}
else if (current <= 5)
{
display.DisplayMessage("Telefonen er fuldt opladt");
}
else if (current <= 500)
{
display.DisplayMessage("Oplader");
}
else if (current > 500)
{
display.DisplayMessage("fejl i opladning");
StopCharge();
}
}
public void Setup()
{
//Creating stubs for dependencies
stubdoor = Substitute.For <IDoor>();
stubCharger = Substitute.For <IChargeControl>();
stubDisplay = Substitute.For <IDisplay>();
stubRFIDReader = Substitute.For <IRFIDReader>();
stubUsb = Substitute.For <IUsbCharger>();
//Initialising classes for tests
usb = new UsbChargerSimulator();
rfidReader = new RFIDReader();
display = new ConcreteDisplay();
door = new Door();
chargeControl = new ChargeControl(stubUsb);
stationControl = new StationControl(stubCharger, stubdoor, stubDisplay, stubRFIDReader);
_rfidEventArgs = null;
rfidReader.RFIDDetectedEvent += (o, args) => { _rfidEventArgs = args; };
_doorEventArgs = null;
door.DoorEvent += (o, args) => { _doorEventArgs = args; };
_currentEventArgs = null;
usb.CurrentValueEvent += (o, args) => { _currentEventArgs = args; };
}
private void NewCurrentValue(object sender, CurrentEventArgs e)
{
////Fjernet grundet genafleveringskommentar
//CurrentCurrent = e.Current;
if (e.Current == 0)
{
_usbCharger.SimulateConnected(false);
}
else if (e.Current > 0 && e.Current <= 5)
{
_displaySimulator.ShowFullyChargedMessage();
StopCharge();
}
else if (e.Current > 5 && e.Current <= 500)
{
_displaySimulator.ShowCurrentlyChargingMessage();
}
else if (e.Current > 500)
{
_displaySimulator.ShowCurrentErrorMessage();
_usbCharger.SimulateOverload(true);
StopCharge();
}
else
{
throw new ArgumentException("Index is out of range");
}
}
private void HandleChargerEvent(object sender, CurrentEventArgs e)
{
if (e.Current == 0)
{
Connected = false;
}
else if (e.Current > 0 && e.Current <= 5)
{
Connected = true;
_countToPrintOnce++;
if (_countToPrintOnce == 1)
{
_chargerDisplay.displayCommands(Chargedmessage);
}
}
else if (e.Current > 5 && e.Current <= 500)
{
Connected = true;
_countToPrintOnce++;
if (_countToPrintOnce == 1)
{
_chargerDisplay.displayCommands(Connectedmessage);
}
oldcurrent = e.Current;
}
else if (e.Current > 500)
{
Connected = true;
_countToPrintOnce++;
if (_countToPrintOnce == 1)
{
_chargerDisplay.displayCommands(Overloadmessage);
}
}
}
private void OnChargeCurrentUpdate(object sender, CurrentEventArgs e)
{
_chargingCurrent = e.Current;
ReadChargingCurrent = _chargingCurrent;
EvaluateChargerState();
UpdateDisplay();
}
private void _Charger_CurrentValueEvent(object sender, CurrentEventArgs e)
{
_current = e.Current;
readCurrent = _current;
checkChargerState();
sendToDisplay();
}
//Gets charge value from UsbCharger
private void ChargeChangedevent(object sender, CurrentEventArgs e)
{
if (CurrentCharge != e.Current)
{
CurrentCharge = e.Current;
updateDisplayPower(CurrentCharge);
}
}
public void Setup()
{
_receivedUsbEventArgs = null;
_uut = new UsbChargerSimulator();
_uut.CurrentValueEvent += (o, args) =>
{
_receivedUsbEventArgs = args;
};
}
public void OnUsbChargerCurrentValueEvent_InvokedWithIntMax_CalledUsbChargerStopCharge()
{
//ARRANGE
CurrentEventArgs args = new CurrentEventArgs();
args.Current = int.MaxValue;
//ACT
UsbChargerSubstitute.CurrentValueEvent += Raise.EventWith(new object(), args);
//ASSERT
UsbChargerSubstitute.Received().StopCharge();
}
public void OnUsbChargerCurrentValueEvent_InvokedWithIntMax_InvokedEventTypeIsChargingError()
{
//ARRANGE
CurrentEventArgs args = new CurrentEventArgs();
args.Current = int.MaxValue;
//ACT
UsbChargerSubstitute.CurrentValueEvent += Raise.EventWith(new object(), args);
//ASSERT
Assert.That(chargerEventArgs.Type, Is.EqualTo(ChargerEventType.ChargingError));
}
public void OnUsbChargerCurrentValueEvent_InvokedWithIntMax_InvokesChargeEvent()
{
//ARRANGE
CurrentEventArgs args = new CurrentEventArgs();
args.Current = int.MaxValue;
//ACT
UsbChargerSubstitute.CurrentValueEvent += Raise.EventWith(new object(), args);
//ASSERT
Assert.That(chargerEventInvoked, Is.True);
}
public void NewCurrentValueHandler_Invokes_Logger()
{
//arrange
CurrentEventArgs currentEvent = new CurrentEventArgs();
currentEvent.Current = 3;
//act
_uut.NewCurrentValueHandler(_uut, currentEvent);
//assert
_logger.Received(1).LogThis("Current current value: 3 mA");
}
public void HandleUsbChangedEvent(object sender, CurrentEventArgs e)
{
if (e.Current > 0 && e.Current <= 5.0)
{
StopCharge();
_display.ShowFullyCharged();
}
if (e.Current > 500.0)
{
StopCharge();
_display.ShowErrorCharging();
}
}
public void OnUsbChargerCurrentValueEvent_InvokedWithFive_InvokedEventTypeIsFinishedCharging()
{
//ARRANGE
CurrentEventArgs args = new CurrentEventArgs();
args.Current = 5;
//ACT
UsbChargerSubstitute.CurrentValueEvent += Raise.EventWith(new object(), args);
//ASSERT
Assert.That(chargerEventArgs.Type, Is.EqualTo(ChargerEventType.FinishedCharging));
}
public void OnUsbChargerCurrentValueEvent_InvokedWithFiveHundred_InvokedEventTypeIsChargingNormally()
{
//ARRANGE
CurrentEventArgs args = new CurrentEventArgs();
args.Current = 500;
//ACT
UsbChargerSubstitute.CurrentValueEvent += Raise.EventWith(new object(), args);
//ASSERT
Assert.That(chargerEventArgs.Type, Is.EqualTo(ChargerEventType.ChargingNormally));
}
public void Calls_Display_Correctly_On_Current_Event(double Current, string ExpectedMessage)
{
//Arrange
var e = new CurrentEventArgs()
{
Current = Current
};
//Act
_mockUsbCharger.CurrentValueEvent += Raise.EventWith <CurrentEventArgs>(_mockUsbCharger, e);
//Assert
_mockDisplay.Received().NotifyCharge(ExpectedMessage);
}
public void Setup()
{
_receivedEventArgs = null;
//_charge = Substitute.For<ICharge>();
_uut = new USBCharger();
_uut.CurrentValueEvent += (o, args) =>
{
_receivedEventArgs = args;
};
}
public void ChargingValueChanged(object o, CurrentEventArgs e) //Calls Display with current charging value in %
{
double val = ((500 - 2.5) - (e.Current - 2.5)) / (500 - 2.5) * 100;
if (val % 5 == 0 && !_fullyCharged)
{
_display.CurrentChargingValue(val);
}
if (val == 100)
{
_fullyCharged = true;
}
}
public void ChargeControl_CurrentValueChangedBetween0and5_DisplayChargingFinishedCalled(double currentValue)
{
//Arrange
CurrentEventArgs currentEventArgs = new CurrentEventArgs()
{
Current = currentValue,
};
//Act?
_usbCharger.CurrentValueEvent += Raise.EventWith(currentEventArgs);
//Assert
_display.Received().ShowChargingFinished();
}
public void ChargeControl_CurrentValueChangedOver500_DisplayOverCurrentErrorCalled(double currentValue)
{
//Arrange
CurrentEventArgs currentEventArgs = new CurrentEventArgs()
{
Current = currentValue,
};
//Act?
_usbCharger.CurrentValueEvent += Raise.EventWith(currentEventArgs);
//Assert
_display.Received().ShowOvercurrentError();
}
public void CurrentPowerValue()
{
CurrentEventArgs eventArgs = new CurrentEventArgs()
{
Current = 8
};
var output = new StringWriter();
Console.SetOut(output);
uut.CurrentPowerValue(eventArgs);
Assert.That(output.ToString(), Is.EqualTo("Strøm niveauet er: " + eventArgs.Current + "\r\n"));
}
public void ChargeControl_CurrentValueChanged0_DisplayDoesNotUpdate(double currentValue)
{
//Arrange
CurrentEventArgs currentEventArgs = new CurrentEventArgs()
{
Current = currentValue,
};
//Act?
_usbCharger.CurrentValueEvent += Raise.EventWith(currentEventArgs);
//Assert
var calls = _display.ReceivedCalls();
Assert.That(calls.Count() == 0);
}
private void Charger_CurrentValueEvent(object sender, CurrentEventArgs e)
{
if (e.Current > 0 && e.Current <= 5)
{
display.PhoneIsCharged();
}
else if (e.Current > 5 && e.Current <= 500)
{
display.PhoneIsCharging();
}
else if (e.Current > 500)
{
StopCharge();
display.PhoneChargingError();
}
}
private void chargerCurrent_CurrentValueEvent(object sender, CurrentEventArgs e)
{
if (e.Current > 0 && e.Current <= 5)
{
_display.DisplayMsg(MessageType.PhoneFullyCharged);
}
else if (e.Current > 5 && e.Current <= 500)
{
_display.DisplayMsg(MessageType.PhoneCharging);
}
else if (e.Current > 500)
{
StopCharge();
_display.DisplayMsg(MessageType.ChargeError);
}
}
protected virtual void CurrentChangeHandler(object sender, CurrentEventArgs e)
{
double Current = e.Current;
if (0 < Current && Current <= 5)
{
_display.NotifyCharge("Phone fully charged. It can be safely removed.");
}
else if (5 < Current && Current <= 500)
{
_display.NotifyCharge("Phone is charging.");
}
else if (Current > 500)
{
_display.NotifyCharge("ERROR: Potential short circuit. Disconnect phone immediately.");
}
}
public void Setup()
{
_currentEventArgs = null;
_connectedEventArgs = null;
_uut = new UsbCharger();
//_uut.UnlockedDoor();
_uut.currentValueEvent +=
(o, args) =>
{
_currentEventArgs = args;
};
_uut.connectedValueEvent +=
(o, args) =>
{
_connectedEventArgs = args;
};
}
private void _usbChargerSimulator_CurrentValueEvent(object sender, CurrentEventArgs e)
{
if (e.Current > 500)
{
StopCharge();
_display.CurrentChargeId = DisplayChargeId.ShortCircuit;
_display.UpdateDisplay();
}
else if (e.Current <= 500 && e.Current >= 5)
{
_display.CurrentChargeId = DisplayChargeId.Charging;
}
else if (e.Current > 0 && e.Current < 5)
{
StopCharge();
_display.CurrentChargeId = DisplayChargeId.FullyCharged;
_display.UpdateDisplay();
}
}
//Triggerhandler for UsbCharger
private void ChargingCurrentValue(object sender, CurrentEventArgs e)
{
// *** Equivalence partitions *** //
if (e.Current <= 0)
{
_state = ChargingState.NoConnection;
}
else if (e.Current > 0 && e.Current <= 5)
{
_state = ChargingState.FullyCharged;
}
else if (e.Current > 5 && e.Current <= 500)
{
_state = ChargingState.Charging;
}
else if (e.Current > 500)
{
_state = ChargingState.ChargingError;
}
switch (_state)
{
case ChargingState.NoConnection:
_display.ShowMessage("Din telefon er ikke ordentlig tilsluttet. Prøv igen.");
break;
case ChargingState.Charging:
_display.ShowMessage("Din telefon oplades.");
break;
case ChargingState.FullyCharged:
_display.ShowMessage("Din telefon er fuldt opladt.");
break;
case ChargingState.ChargingError:
_display.ShowMessage("Error: Prøv igen.");
break;
}
}
private void HandleCurrentChangedEvent(object sender, CurrentEventArgs e)
{
double current = e.Current;
if (current > 500)
{
StopCharge();
_display.DisplayString("Charging Error");
}
else if (current > 5 && current <= 500)
{
//Do nothing
}
else if (current > 0 && current <= 5)
{
_display.DisplayString("Fully Charged");
}
else if (current <= 0)
{
StopCharge();
}
}
