public void Finally_unit_result_E_executes_on_failure_returns_K()
{
UnitResult <E> result = UnitResult.Failure(E.Value);
K output = result.Finally(Func_Unit_Result_E);
AssertCalled(result, output);
}
public static void Prefix(UnitResult ___UnitData)
{
try
{
mechEjections = 0;
vehicleEjections = 0;
// get the total and decrement it globally
var MechsEjected = ___UnitData.pilot.StatCollection.GetStatistic("MechsEjected");
if (MechsEjected != null)
{
mechEjections = MechsEjected.Value <int>();
LogDebug($"{___UnitData.pilot.Callsign} MechsEjected {mechEjections}");
}
var VehiclesEjected = ___UnitData.pilot.StatCollection.GetStatistic("VehiclesEjected");
if (VehiclesEjected != null)
{
vehicleEjections = VehiclesEjected.Value <int>();
LogDebug($"{___UnitData.pilot.Callsign} vehicleEjections {vehicleEjections}");
}
}
catch (Exception ex)
{
LogDebug(ex);
}
}
public UnitResult <CoffeeMachineEntity> Execute(int coffeeGrams, int waterMl)
{
if (coffeeMachine.IsClean)
{
coffeeMachine.SetCoffee(coffeeGrams);
coffeeMachine.GetWater(waterMl);
}
bool ranSuccessfully = false;
if (coffeeMachine.IsReadyForEspresso())
{
ICoffeeMachineService coffeeMachineService = new CoffeeMachineService(); //external service
ranSuccessfully = coffeeMachineService.SetCoffee(coffeeMachine.CoffeeQty);
ranSuccessfully = ranSuccessfully && coffeeMachineService.GetWater(coffeeMachine.WaterQty);
ranSuccessfully = ranSuccessfully && coffeeMachineService.Run();
}
UnitResult <CoffeeMachineEntity> operationResult = new UnitResult <CoffeeMachineEntity>
{
IsSuccessful = ranSuccessfully,
Value = coffeeMachine
};
return(operationResult);
}
public void Finally_unit_result_E_executes_on_success_returns_K()
{
UnitResult <E> result = UnitResult.Success <E>();
K output = result.Finally(Func_Unit_Result_E);
AssertCalled(result, output);
}
public async Task Finally_LeftAsync_unit_result_E_executes_on_success_returns_K()
{
UnitResult <E> result = UnitResult.Success <E>();
K output = await result.AsTask().Finally(Func_Unit_Result_E);
AssertCalled(result, output);
}
public async Task Finally_LeftAsync_unit_result_E_executes_on_failure_returns_K()
{
UnitResult <E> result = UnitResult.Failure(E.Value);
K output = await result.AsTask().Finally(Func_Unit_Result_E);
AssertCalled(result, output);
}
UnitResult Undo()
{
if (globallyRepeatableUnits.Count < 1)
{
throw new InvalidOperationException("No unit to undo.");
}
IUndoableUnit undoableUnit = globallyUndoableUnits.Pop();
IInternalUnit repeatableUnit = globallyRepeatableUnits.Pop();
var eventArgs = new CancellableUndoServiceEventArgs(undoableUnit);
OnUndoing(eventArgs);
if (eventArgs.Cancel)
{
globallyUndoableUnits.AddLast(undoableUnit);
globallyRepeatableUnits.AddLast(repeatableUnit);
return(UnitResult.Cancelled);
}
globallyRedoableUnits.AddLast(undoableUnit);
UnitResult result = undoableUnit.Undo();
OnUndone(new UndoServiceEventArgs(undoableUnit));
return(result);
}
public static void Postfix(AAR_UnitStatusWidget __instance, SimGameState ___simState)
{
if (!Core.Settings.RepairRearm)
{
return;
}
var sim = UnityGameInstance.BattleTechGame.Simulation;
UnitResult unitResult = Traverse.Create(__instance).Field("UnitData").GetValue <UnitResult>();
float currentArmor = unitResult.mech.MechDefCurrentArmor;
float assignedArmor = unitResult.mech.MechDefAssignedArmor;
float armorDamage = currentArmor / assignedArmor;
string armorDamageTag = "XLRPArmor_" + armorDamage.ToString();
if (!unitResult.mech.MechTags.Contains("XLRP_R&R") && currentArmor < assignedArmor)
{
unitResult.mech.MechTags.Add("XLRP_R&R");
unitResult.mech.MechTags.Add(armorDamageTag);
Core.CombatMechs.Add(unitResult.mech);
}
else if (currentArmor < assignedArmor)
{
unitResult.mech.MechTags.Where(tag => tag.StartsWith("XLRPArmor")).Do(x => unitResult.mech.MechTags.Remove(x));
unitResult.mech.MechTags.Add(armorDamageTag);
Core.CombatMechs.Add(unitResult.mech);
}
}
public static bool VanilaRecovery(UnitResult result, ContractHelper contract)
{
var mech = result.mech;
Control.LogDebug($"-- Recovery {mech.Name} vanila method");
var simgame = contract.Contract.BattleTechGame.Simulation;
float num = simgame.NetworkRandom.Float(0f, 1f);
if (mech.IsLocationDestroyed(ChassisLocations.CenterTorso))
{
Control.LogDebug($"--- CenterTorso Destroyed - no recovery");
return(false);
}
else
{
var chance = simgame.Constants.Salvage.DestroyedMechRecoveryChance;
var recover = chance > num;
Control.LogDebug(recover
? $"--- {num:0.00} vs {chance:0.00} - roll success, recovery"
: $"--- {num:0.00} vs {chance:0.00} - roll failed, no recovery");
return(recover);
}
}
public void Can_create_a_unit_result_using_UnitResult_entry_point()
{
UnitResult <MyErrorClass> result = UnitResult.Success <MyErrorClass>();
result.IsFailure.Should().Be(false);
result.IsSuccess.Should().Be(true);
}
internal static int GetVehicleEjectionCount(UnitResult unitResult)
{
LogDebug("GetVehicleEjectionCount");
return(unitResult.pilot.StatCollection.GetStatistic("VehiclesEjected") == null
? 0
: unitResult.pilot.StatCollection.GetStatistic("VehiclesEjected").Value <int>());
}
protected UnitResult <E2> GetErrorUnitResult(E _)
{
funcExecuted.Should().BeFalse();
funcExecuted = true;
return(UnitResult.Failure(E2.Value));
}
protected UnitResult <E2> GetSuccessUnitResult(E _)
{
funcExecuted.Should().BeFalse();
funcExecuted = true;
return(UnitResult.Success <E2>());
}
public static void SalvageItems(UnitResult unit, ContractHelper contract)
{
foreach (var item in unit.mech.Inventory.Where(i => i.DamageLevel != ComponentDamageLevel.Destroyed && !unit.mech.IsLocationDestroyed(i.MountedLocation)))
{
contract.AddComponentToPotentialSalvage(item.Def, item.DamageLevel, false);
}
}
protected UnitResult <E> FailureErrorAction()
{
actionExecuted.Should().BeFalse();
actionExecuted = true;
return(UnitResult.Failure(E.Value2));
}
public void CleanFeatureShouldReturnFalseWhenInvalidInput(int seconds, int waterMl)
{
var cleaningUnit = new SteamBlastUnit(new CoffeeMachineEntity());
UnitResult <CoffeeMachineEntity> result = cleaningUnit.Execute(seconds, waterMl);
Assert.IsFalse(result.IsSuccessful);
}
public static void Postfix(UnitResult ___UnitData, RectTransform ___KillGridParent)
{
try
{
var statCollection = ___UnitData.pilot.StatCollection;
if (modSettings.VehiclesCanPanic)
{
for (var x = 0; x < vehicleEjections; x++)
{
AARIcons.AddEjectedVehicle(___KillGridParent);
}
statCollection.Set("VehiclesEjected", 0);
}
// weird loop
for (var x = 0; x < mechEjections; x++)
{
AARIcons.AddEjectedMech(___KillGridParent);
}
statCollection.Set("MechsEjected", 0);
}
catch (Exception ex)
{
LogDebug(ex);
}
}
protected UnitResult <E> SuccessErrorAction()
{
actionExecuted.Should().BeFalse();
actionExecuted = true;
return(UnitResult.Success <E>());
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Assignment1Mark,Assignment2Mark,ExamMark,Grade,StudentId,StudentName,TotalMark")] UnitResult unitResult)
{
if (id != unitResult.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(unitResult);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UnitResultExists(unitResult.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index"));
}
return(View(unitResult));
}
public void EspressoUnitShouldReturnTrueWhenValidInputAndCleanMachine(int coffeeGrams, int waterMl)
{
var espressoUnit = new EspressoUnit(new CoffeeMachineEntity());
UnitResult <CoffeeMachineEntity> result = espressoUnit.Execute(coffeeGrams, waterMl);
Assert.IsTrue(result.IsSuccessful);
}
public void Compensate_E_returns_success_and_does_not_execute_func()
{
UnitResult <E> input = UnitResult.Success <E>();
Result output = input.Compensate(GetErrorResult);
AssertSuccess(output, executed: false);
}
public void UnitResult_can_not_convert_okResult_with_value_to_okResult_with_value()
{
var okResultWithValue = UnitResult.Success <E>();
Action action = () => okResultWithValue.ConvertFailure <K>();
action.Should().Throw <InvalidOperationException>();
}
public void Compensate_returns_E_success_and_execute_func()
{
Result input = Result.Failure(ErrorMessage);
UnitResult <E> output = input.Compensate(GetErrorUnitResult);
AssertFailure(output, executed: true);
}
public void Compensate_returns_E_success_and_does_not_execute_func()
{
Result input = Result.Success();
UnitResult <E> output = input.Compensate(GetErrorUnitResult);
AssertSuccess(output, executed: false);
}
public void Compensate_returns_E_failure_and_does_not_execute_func()
{
Result input = Result.Failure(ErrorMessage);
UnitResult <E> output = input.Compensate(GetSuccessUnitResult);
AssertSuccess(output);
}
public void Compensate_T_E_returns_E2_success_and_execute_func()
{
Result <T, E> input = Result.Failure <T, E>(E.Value);
UnitResult <E2> output = input.Compensate(GetErrorUnitResult);
AssertFailure(output, executed: true);
}
public void Compensate_T_E_returns_E2_failure_and_does_not_execute_func()
{
Result <T, E> input = Result.Failure <T, E>(E.Value);
UnitResult <E2> output = input.Compensate(GetSuccessUnitResult);
AssertSuccess(output);
}
public void Compensate_T_E_returns_E2_success_and_does_not_execute_func()
{
Result <T, E> input = Result.Success <T, E>(T.Value);
UnitResult <E2> output = input.Compensate(GetErrorUnitResult);
AssertSuccess(output, executed: false);
}
public void Compensate_E_returns_success_and_execute_func()
{
UnitResult <E> input = UnitResult.Failure(E.Value);
Result output = input.Compensate(GetErrorResult);
AssertFailure(output, executed: true);
}
public void Compensate_E_returns_failure_and_does_not_execute_func()
{
UnitResult <E> input = UnitResult.Failure(E.Value);
Result output = input.Compensate(GetSuccessResult);
AssertSuccess(output);
}
