public CostCommand(ITariffSource source)
{
Spec = CommandSpec.Named(
"cost",
new[] { "POWER_USAGE_KWH", "GAS_USAGE_KWH" },
ctx =>
{
// model 0's explicitly as no fuel supply for that type
var p = ctx.GetRequiredDecimal("POWER_USAGE_KWH");
var powerKwh = p == 0 ? new Kwh <Power>?() : new Kwh <Power>(p);
var g = ctx.GetRequiredDecimal("GAS_USAGE_KWH");
var gasKwh = g == 0 ? new Kwh <Gas>?() : new Kwh <Gas>(g);
// calculate the costs and output
foreach (var line in FuelCalculator
.CostsPerTariff(source.GetAll(), powerKwh, gasKwh)
.Select(cost => $"{cost.Tariff.Name} {cost.Total.PostTax:F2}"))
{
ctx.Output.WriteLine(line);
}
return(Commands.Ok());
});
}
public PuzzleApp(
ResourceFactory resourceFactory,
FuelCalculator fuelCalculator)
{
_resourceFactory = resourceFactory;
_fuelCalculator = fuelCalculator;
}
public void Test_GetConsumedFuel_WithPartialExcessFuelAndPartialInsuffiecientFuel()
{
var fuelTank = new FuelTank(
new FuelComponent(0.5, 100000),
new FuelComponent(0.5, 0));
var dryMass = 10000;
var fuelAMass = 100000;
var exhaustVelocity = 350 * 9.81;
var deltaVelocity = 9400d;
var exhaustMass = FuelCalculator.GetConsumedFuel(
deltaVelocity,
dryMass,
fuelTank,
exhaustVelocity,
0.01);
var expectedBurnedFuelMass = 193256d;
var expectedBurnedFuelAMass = expectedBurnedFuelMass / 2;
var expectedExceedingFuelAMass = fuelAMass - expectedBurnedFuelAMass;
var confirmedDeltaVelocity = Physics.GetDeltaVelocityBudget(
dryMass + expectedExceedingFuelAMass,
exhaustMass,
exhaustVelocity);
Assert.Equal(deltaVelocity, confirmedDeltaVelocity, 0);
Assert.True(Math.Abs(expectedBurnedFuelMass - exhaustMass) < expectedBurnedFuelMass / 1000);
}
public void GetRequiredMassFuel(int mass, int expectedRequiredFuel)
{
var fuelCalculator = new FuelCalculator();
var fuel = fuelCalculator.GetRequiredFuelForModuleMass(mass);
Assert.AreEqual(expectedRequiredFuel, fuel);
}
public void ReturnNecessaryFuel(int inputMass, int neededFuel)
{
var calculator = new FuelCalculator();
var calculatedFuel = calculator.CalcFuelForMass(inputMass);
calculatedFuel.ShouldBe(neededFuel);
}
public void Starts_Mass_Should_Be_Equal_To_Sum()
{
var sut = new FuelCalculator();
var result = sut.Calculate(new [] { 12, 16 });
Assert.That(result, Is.EqualTo(5));
}
public void AccumulateFuelIfNotZero()
{
var calculator = new FuelCalculator();
var fuelForFuel = calculator.CalcFuelforModuleAndFuel(654);
fuelForFuel.ShouldBe(966);
}
public void ReturnFuelNeededForFuel()
{
var calculator = new FuelCalculator();
var fuelForFuel = calculator.CalcFuelforModuleAndFuel(2);
fuelForFuel.ShouldBe(2);
}
public void CalculateSpacecraftFuelRequirementsInfIncludingFuelMass()
{
var modulesMasses = File.ReadAllText("Input.txt")
.Split(Environment.NewLine)
.Select(x => Convert.ToInt32(x));
Assert.Equal(4967616, FuelCalculator.CalculateSpacecraftFuelRequirementIncludingFuelMass(modulesMasses));
}
public void Test_KnownMasses()
{
foreach (var testTup in TestTups)
{
var fuel = FuelCalculator.CalculateFuelFromMass(testTup.Item1);
Assert.IsTrue(fuel == testTup.Item2);
}
}
public void Test_KnownMassesAndFuels()
{
foreach (var testTup in TestTupsTwo)
{
var fuel = FuelCalculator.CalculateFuelForMassAndFuel(testTup.Item1);
Assert.IsTrue(fuel == testTup.Item2);
}
}
public void ReturnFuelForAllMassesInList()
{
var calculator = new FuelCalculator("testData.txt");
var totalFuel = calculator.CalculateFuelForAllModules();
totalFuel.ShouldBe(51316);
}
public void Test_GetConsumedFuel_WithInsufficientFuel()
{
var x = Physics.GetRequiredExhaustMass(9400, 10000, 350 * 9.81);
Assert.Equal(144518.9, FuelCalculator.GetConsumedFuel(9400, 10000, new FuelTank(0), 350 * 9.81, 0.1), 1);
Assert.Equal(144518.9, FuelCalculator.GetConsumedFuel(9400, 10000, new FuelTank(1), 350 * 9.81, 0.1), 1);
Assert.Equal(144518.9, FuelCalculator.GetConsumedFuel(9400, 10000, new FuelTank(10000), 350 * 9.81, 0.1), 1);
Assert.Equal(144518.9, FuelCalculator.GetConsumedFuel(9400, 10000, new FuelTank(100000), 350 * 9.81, 0.1), 1);
}
public void CreateListOfFuelNeedsWhenGivenFileName()
{
var calculator = new FuelCalculator("testData.txt");
calculator.FuelNeeds.ShouldBeOfType <List <FuelNeed> >();
calculator.FuelNeeds.First().ModuleMass.ShouldBe(12);
calculator.FuelNeeds.First().ForModule.ShouldBe(2);
calculator.FuelNeeds.First().WithFuel.ShouldBe(2);
}
public void GetTotalRequiredFuel(int moduleMass, int expectedFuel)
{
// Arrange
var sut = new FuelCalculator();
// Act
var result = sut.GetTotalRequiredFuel(moduleMass);
// Assert
result.ShouldBe(expectedFuel);
}
public void InitalExamples(int weight, int expectedResult)
{
// Arrange
var sut = new FuelCalculator();
// Act
var result = sut.RequiredFuel(weight);
//Assert
Assert.Equal(expectedResult, result);
}
public void AnnualPowerUsage_TariffWithNoGas_ReturnsNothing()
{
// Arrange
var tariff = new Tariff("test", null, null, 3m);
// Act
var actual = FuelCalculator.AnnualPowerUsage(tariff, TaxedValue.FromPreTaxValue(100, x => x));
// Assert
actual.HasValue.Should().BeFalse();
}
public void Test_DayOne_PartTwo()
{
//< Parse the test module masses into memory
var testFile = Path.Combine(TestHelper.TestDir, @"Day1.Input.txt");
var masses = File.ReadLines(testFile).Where(line => line != "").Select(line => int.Parse(line));
//< Calculate the fuel needs for each module
var fuelNeeds = masses.Select(mass => FuelCalculator.CalculateFuelForMassAndFuel(mass));
//< Calculate the total sum of fuel requirements
var totalFuel = fuelNeeds.Sum();
Assert.IsTrue(totalFuel == 5265045);
}
public void AnnualPowerUsage_TariffWithGas_ReturnsUsage()
{
// Arrange
var tariff = new Tariff("test", 2m, null, 3m);
// Act
var actual = FuelCalculator.AnnualPowerUsage(tariff, TaxedValue.FromPreTaxValue(100, x => x));
// Assert
actual.HasValue.Should().BeTrue();
actual.Value.Value.Should().Be((100 - 3) * 12 * 2);
}
private static void FuelCalculator()
{
Console.Write("What file contains the module masses? ");
var file = Console.ReadLine();
Console.WriteLine("Standby...\n\n\n");
var calculator = new FuelCalculator(file);
var fuelNeeded = calculator.CalculateFuelForAllModules();
Console.WriteLine($"The amount of fuel required is: {fuelNeeded}");
}
public UsageCommand(ITariffSource source)
{
Spec = CommandSpec.Named(
"usage",
new[] { "TARIFF_NAME", "FUEL_TYPE", "TARGET_MONTHLY_SPEND" },
ctx =>
{
var tariffName = ctx.GetRequiredString("TARIFF_NAME");
var fuelType = ctx.GetRequiredEnum <FuelType>("FUEL_TYPE");
var monthlyBudget = TaxedValue.FromPostTaxValue(
ctx.GetRequiredDecimal("TARGET_MONTHLY_SPEND"),
TaxHelper.RemoveTax);
if (!source.TryGet(tariffName, out var tariff))
{
return(Commands.Error($"The specified tariff doesn't exist '{tariffName}'."));
}
// c# has no proper pattern matching, so I've run out of functional luck here, apologies for the switch statement...
switch (fuelType)
{
case FuelType.Gas:
if (!tariff.GasRate.HasValue)
{
return(Commands.Error($"Tariff '{tariff.Name}' does not include {FuelType.Gas}."));
}
ctx.Output.WriteLine(
FuelCalculator.AnnualGasUsage(tariff, monthlyBudget).GetValueOrDefault().Value); // just output 0 if tariff doesn't include fuel type
break;
case FuelType.Power:
if (!tariff.PowerRate.HasValue)
{
return(Commands.Error($"Tariff '{tariff.Name}' does not include {FuelType.Power}."));
}
ctx.Output.WriteLine(
FuelCalculator.AnnualPowerUsage(tariff, monthlyBudget).GetValueOrDefault().Value);
break;
default:
return(Commands.Error($"Unsupported fuel type : {fuelType}"));
}
return(Commands.Ok());
});
}
public void CostsPerTariff_PowerNotInTariff_ReturnsCosts()
{
// Arrange
var tariff = new Tariff("test", null, 3m, 4m);
// Act
var actual = FuelCalculator.CostsPerTariff(new[] { tariff }, null, new Kwh <Gas>(2000)).ToList();
// Assert
actual.Should().HaveCount(1);
var actualCost = actual.First();
actualCost.Tariff.Should().Be(tariff);
actualCost.Total.PostTax.Should().Be(((4 * 12) + (2000 * 3)) * 1.05M);
}
public void CostsPerTariff_GasNotInTariff_TariffIgnored()
{
// Arrange
var tariff = new Tariff("test", 2m, 3m, 4m);
var tariff2 = new Tariff("test2", 4m, null, 8m);
// Act
var actual = FuelCalculator.CostsPerTariff(new[] { tariff, tariff2 }, new Kwh <Power>(1000), new Kwh <Gas>(2000)).ToList();
// Assert
actual.Should().HaveCount(1);
var actualCost = actual.First();
actualCost.Tariff.Should().Be(tariff);
actualCost.Total.PostTax.Should().Be(((4 * 12) + (1000 * 2) + (4 * 12) + (2000 * 3)) * 1.05M);
}
public void CostsPerTariff_PowerUsageNotSupplied_ReturnsCostsForValidTariffs()
{
// Arrange
var tariff1 = new Tariff("test1", 2m, null, 4m);
var tariff2 = new Tariff("test2", 4m, 6m, 8m);
// Act
var actual = FuelCalculator.CostsPerTariff(new[] { tariff1, tariff2 }, null, new Kwh <Gas>(2000)).ToList();
// Assert
actual.Should().HaveCount(1);
var actualCost = actual.First();
actualCost.Tariff.Should().Be(tariff2);
actualCost.Total.PostTax.Should().Be(((8 * 12) + (2000 * 6)) * 1.05M);
}
public double GetRequiredFuelMass(double deltaVelocity)
{
var totalMass = Mass;
// TODO: Refactor Enginge.Components to be more user friendly, dont do this shit here
var massPerCycleSum = Engine.FuelComponents.Sum(i => i.Mass);
var componentsByItems = Engine.FuelComponents.ToDictionary(i => i.Item);
var fuelTank = new FuelTank(Engine.GetAvailableFuel(CargoBay).Select(i =>
{
var portion = componentsByItems[i.Item].Mass / massPerCycleSum;
return(new FuelComponent(portion, i.Mass));
}).ToList());
var dryMass = totalMass - fuelTank.GetAvailableMass();
return(FuelCalculator.GetConsumedFuel(deltaVelocity, dryMass, fuelTank, Engine.ExhaustVelocity, 1.MeterPerSecond()));
}
public void CostsPerTariff_AllFuelTypesSupported_ReturnsCostsInOrder()
{
// Arrange
var tariff1 = new Tariff("test1", 2m, 3m, 4m);
var tariff2 = new Tariff("test2", 4m, 6m, 8m);
// Act
var actual = FuelCalculator.CostsPerTariff(new[] { tariff1, tariff2 }, new Kwh <Power>(1000), new Kwh <Gas>(2000)).ToList();
// Assert
actual.Should().HaveCount(2);
var actualCost = actual.First();
actualCost.Tariff.Should().Be(tariff1);
actualCost.Total.PostTax.Should().Be(((4 * 12) + (1000 * 2) + (4 * 12) + (2000 * 3)) * 1.05M);
actual.ElementAt(1).Tariff.Should().Be(tariff2);
}
public void FuelConsumptionCalculations()
{
// Setup
FuelCalculator fuelCalculator = new FuelCalculator();
fuelCalculator.SetCurrentReading(900);
fuelCalculator.SetPreviousReading(100);
fuelCalculator.SetFuelAmount(40);
fuelCalculator.SetUnitPrice(12.84);
// Exercise and validate
Assert.AreEqual(20, fuelCalculator.CalcConsumptionKilometerPerLiter(), 0.01);
Assert.AreEqual(0.05, fuelCalculator.CalcFuelConsumptionPerKm(), 0.01);
Assert.AreEqual(0.08, fuelCalculator.CalcConsumptionPerUsMile(), 0.01);
Assert.AreEqual(0.5, fuelCalculator.CalcFuelConsumptionPerSweMil(), 0.01);
Assert.AreEqual(0.64, fuelCalculator.CalcCostPerKm(), 0.01);
// Tear down by garbage collection.
}
public IActionResult DisplayResult(FuelCalculator calculator)
{
calculator.CalculateMiles();
calculator.Trip();
return(View(calculator));
}
public void Should_Calculate_Correct_Fuel_From_Mass_Part_Two(int mass, int result)
{
var output = FuelCalculator.CalculateFuelPartTwo(mass);
Assert.Equal(result, output);
}
public FuelCalculatorTests()
{
this.calculator = new FuelCalculator();
}
public MainForm(string[] arguments)
{
m_loading = true;
Visible = false;
m_prefences = new Preferences(getPreferencesPath);
Localization.SetCulture(m_prefences.General.Culture);
InitializeComponent();
m_Port_ECU_Status = new MainForm.UltraStatusBarEx(m_statusPortECU);
this.Icon = OCTech.OBD2.Applications.Properties.Resources.Application;
this.Text = MainForm.ApplicationName;
string titleBarCompany = Localization.GetTitleBarCompany(m_prefences.General.Culture);
if (!string.IsNullOrEmpty(titleBarCompany))
Text = string.Format("{0} - {1}", Text, titleBarCompany);
m_statusErrorECU = Localization.GetStatusBarBanner(m_prefences.General.Culture);
m_mainForm = (Form)this;
processCommandOptions(arguments);
this.Disposed += new EventHandler(mainForm_Disposed);
Version version = m_scanTool.GetType().Assembly.GetName().Version;
int unlock = version.Major ^ version.Minor ^ version.Build ^ version.Revision;
m_scanTool.Unlock(unlock);
FileUtility.PathResolverReplacements.Add("[ApplicationName]", MainForm.ApplicationName);
LoggableItem.RegisterLoggableItem(
typeof(PIDLoggableItem),
new LoggableItemXmlReader(PIDLoggableItem.FromXml)
);
LoggableItem.RegisterLoggableItem(
typeof(FuelLoggableItem),
new LoggableItemXmlReader(FuelLoggableItem.FromXml)
);
LoggableItem.RegisterLoggableItem(
typeof(UserPIDLoggableItem),
new LoggableItemXmlReader(UserPIDLoggableItem.FromXml)
);
LoggableItem.RegisterLoggableItem(
typeof(PIDPluginLoggableItem),
new LoggableItemXmlReader(PIDPluginLoggableItem.FromXml)
);
if (m_prefences.Layout.TouchScreenSize)
{
customListView.ItemSpacing = ListViewItemSpacing.Small;
toolStripContainer.TopToolStripPanelVisible = false;
}
customListView.Add(
OCTech.OBD2.Applications.Properties.Resources.SetupPageName,
"Setup",
OCTech.OBD2.Applications.Properties.Resources.p000075
);
customListView.Add(
OCTech.OBD2.Applications.Properties.Resources.DiagPageName,
"Diagnostics",
OCTech.OBD2.Applications.Properties.Resources.p000026
);
customListView.Add(
OCTech.OBD2.Applications.Properties.Resources.MonitorsPageName,
"Monitors",
OCTech.OBD2.Applications.Properties.Resources.p000045
);
customListView.Add(
OCTech.OBD2.Applications.Properties.Resources.DashboardPageName,
"Dashboard",
OCTech.OBD2.Applications.Properties.Resources.p000015
);
customListView.Add(
OCTech.OBD2.Applications.Properties.Resources.LogsPageName,
"Logs",
OCTech.OBD2.Applications.Properties.Resources.p000043
);
customListView.Add(
OCTech.OBD2.Applications.Properties.Resources.ExitText,
"Exit",
OCTech.OBD2.Applications.Properties.Resources.p000032,
true
);
customListView.ItemSelected += new EventHandler<CustomListViewItemSelectedEventArgs>(customListView_ItemSelected);
customListView.Font = this.Font;
CurrentOperationStatus = OCTech.OBD2.Applications.Properties.Resources.SystemReadyText;
ConnectedStatus = ConnectionStatus.NotConnected;
if (m_prefences.Layout.SelectedPageKey == "Exit"
|| !m_prefences.Layout.RememberLastPageOnStartup
|| string.IsNullOrEmpty(m_prefences.Layout.SelectedPageKey)
)
m_prefences.Layout.SelectedPageKey = "Setup";
m_scanTool.CommunicationErrorOccurred += new EventHandler<MessageEventArgs>(m_scanTool_CommunicationErrorOccurred);
m_scanTool.SelectECU += new EventHandler<SelectedECUEventArgs>(m_scanTool_SelectECU);
m_scanTool.ConnectionChanged += new EventHandler(m_scanTool_ConnectionChanged);
m_scanTool.ConnectionStatusChanged += new EventHandler<ConnectionStatusChangedEventArgs>(m_scanTool_ConnectionStatusChanged);
m_pidMonitor = new PIDMonitor(m_scanTool);
m_pidMonitor.SetCulture(m_prefences.General.Culture);
m_pidMonitor.ErrorOccurred += new EventHandler<OCTech.Utilities.ExceptionEventArgs>(utilities_ErrorOccurred);
m_pidMonitor.NewPIDResponseArrived += new EventHandler<PIDResponseEventArgs>(m_pidMonitor_NewPIDResponseArrived);
m_pidMonitor.NewPIDTimingAvailable += new EventHandler<PIDMonitorTimingEventArgs>(m_pidMonitor_NewPIDTimingAvailable);
m_pidMonitor.Playback.RecordedPlaybackChanged += new EventHandler<RecordedDataPlayBackEventArgs>(m_pidMonitor_RecordedPlaybackChanged);
FuelCalculator fuelCalculator = new FuelCalculator(m_pidMonitor, m_scanTool);
fuelCalculator.ErrorOccurred += new EventHandler<OCTech.Utilities.ExceptionEventArgs>(utilities_ErrorOccurred);
vehicleManagement = new VehicleManagement(this, m_scanTool, m_pidMonitor, fuelCalculator, this, MainForm.MyDocumentsPath);
m_context = new AppContext(m_prefences, this, m_scanTool, m_pidMonitor, fuelCalculator, MainForm.MyDocumentsPath, MainForm.ApplicationDataDirectory, m_messageDispatcher, this, this, vehicleManagement);
MainForm.m_StaticContext = m_context;
TripManager.Initialize(m_context.ScanTool, m_context.PidMonitor, m_context.FuelCalculator, MainForm.ApplicationDataDirectory);
TripManager.ErrorOccurred += new EventHandler<OCTech.Utilities.ExceptionEventArgs>(utilities_ErrorOccurred);
pluginInitialize();
sensorCalibration = new SensorCalibration();
sensorCalibration.Initialize(m_context);
DispatchPID.Initialize(m_context);
m_setupPage = new SetupPage(m_context);
m_setupPage.ColorModeChanged += new EventHandler<ColorModeChangedEventArgs>(m_setupPage_ColorModeChanged);
m_diagnostic = new DiagnosticsPage(m_context);
m_monitors = new MonitorsPage(m_context);
m_dashboard = new CustomDashboard(m_context);
m_logs = new LogsPage(m_context);
m_TabPages.Add("Setup", m_setupPage);
m_TabPages.Add("Diagnostics", m_diagnostic);
m_TabPages.Add("Monitors", m_monitors);
m_TabPages.Add("Dashboard", m_dashboard);
m_TabPages.Add("Logs", m_logs);
pagePanel.SuspendLayout();
addPageToPanel(m_setupPage);
addPageToPanel(m_diagnostic);
addPageToPanel(m_monitors);
addPageToPanel(m_dashboard);
addPageToPanel(m_logs);
pagePanel.ResumeLayout();
m_StripMenus.Add("Setup", setupToolStripMenuItem);
m_StripMenus.Add("Diagnostics", diagnosticsToolStripMenuItem);
m_StripMenus.Add("Monitors", monitorsToolStripMenuItem);
m_StripMenus.Add("Dashboard", dashboardToolStripMenuItem);
m_StripMenus.Add("Logs", logsToolStripMenuItem);
setControlsText();
setConnectButtonState();
loadOCTechPlugins();
if (m_PluginsInfo.Plugins.Count == 0 && !PIDPluginController.AreAnyPIDPluginAssembliesLoaded)
pluginManagerToolStripMenuItem.Visible = false;
if (!m_TabPages.ContainsKey(m_prefences.Layout.SelectedPageKey))
m_prefences.Layout.SelectedPageKey = "Setup";
switchPageByName(m_prefences.Layout.SelectedPageKey);
customListView.SelectItem(m_prefences.Layout.SelectedPageKey);
loadDataDashboard(getDataPath);
try
{
m_pidMonitor.LoadSettings(MainForm.ApplicationDataDirectory);
}
catch { }
m_setupPage.m001d9a(m_PluginsInfo);
setColorTheme(ActiveTheme);
m_scanTool.DebugEnabled = true;
Gauge.ErrorOccurred += new EventHandler<Controls.ExceptionEventArgs>(controls_ErrorOccurred);
PowerBar.ErrorOccurred += new EventHandler<Controls.ExceptionEventArgs>(controls_ErrorOccurred);
RoundedLabel.ErrorOccurred += new EventHandler<Controls.ExceptionEventArgs>(controls_ErrorOccurred);
LinearGauge.ErrorOccurred += new EventHandler<Controls.ExceptionEventArgs>(controls_ErrorOccurred);
}
