diff --git a/.gitignore b/.gitignore index 6bdd20d..ce73626 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,7 @@ # Except: !LICENSE.txt +!Mod Energy Conversion.md # Sources !/src diff --git a/Mod Energy Conversion.md b/Mod Energy Conversion.md new file mode 100644 index 0000000..483bb70 --- /dev/null +++ b/Mod Energy Conversion.md @@ -0,0 +1,56 @@ +###Author: +[ExE Boss](https://github.com/ExE-Boss) + +### About +This file contains my docs of mod energy conversion. +It was created by observing what ratios other mods used when implementing energy conversion. + +# Recalculated Energy Conversions to remove infinite power generation loops +- Defined by Player: + - 1 EU = 1 FZ-Charge + - 3 EU = 25 RF +- Defined by Eloraam: + - 1 kW (RP2) = 1 McJ +- Defined by Thermal Expansion: + - 1 McJ = 25 RF + +## Derived conversions: +- 3 EU = 1 McJ +- 3 EU = 1 kW (RP2) +- 1 EU = 40 J (Defined by AE) +- 1 McJ = 120 J (Prevents infinite loop) + +--- + +Original file: + +# Mod Energy Conversion by Unit +- 1 McJ = 3 EU (Probably from Forestry) +- 1 EU = 2 Unit +- 1 McJ = 5 Unit (<^ These lead to an infinite power generation loop, should redefine McJ:Unit to 1:6) +- 1 EU = 45 J (Average of AE and MMMPS) +- 1 McJ = 60 J (Leads to infinite loop) +- 1 kW (RP2) = 1 McJ (As defined by Eloraam) +- 1 kW (RP2) = ~3 EU +- 1 kW (RP2) = 60 J +- 1 kW (RP2) = 5-ish Units +- 3 EU = 25 RF +- 1 EU = 1 FZ-Charge +- 1 McJ = 25 RF + +## Math behind some of the conversions +- 1 McJ = 3 EU = 1 kW (RP2) +- ~3 EU = 1 kW (RP2) +- 1 McJ = 5 Units = 2.5 EU +- 1 EU = 2 Units +- 20 J = 1 Unit = 0.5 EU +- 40 J = 1 EU (AE) +- 50 J = 1 EU (MMMPS) +- 60 J = 1 McJ = 1 kW (RP2) + +--- + +# Licence +This work by [ExE Boss](https://github.com/ExE-Boss) is dual-licensed +under a [Creative Commons Attribution-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-sa/4.0/) +and a [GNU Lesser General Public License (LGPL) version 3](https://www.gnu.org/licenses/lgpl-3.0.html). diff --git a/build.gradle b/build.gradle index 8658ce0..26a97de 100644 --- a/build.gradle +++ b/build.gradle @@ -1,16 +1,25 @@ plugins { id "java" - id "nova.gradle" version "0.2.5" + id "nova.gradle" version "0.2.6" id "maven-publish" id "com.jfrog.artifactory" version "3.1.1" } - apply from: "https://raw.githubusercontent.com/NOVA-Team/NOVA-Gradle/master/shared-scripts/java.gradle" dependencies { - compile "nova.core:NovaCore:$novaVersion" - testCompile "nova.core:NovaCore:$novaVersion:wrappertests" + compile nova(nova_version) +} + +nova { + wrappers { + "17" { + wrapper "nova.core:NOVA-Core-Wrapper-MC1.7:$nova_version" + } + "18" { + wrapper "nova.core:NOVA-Core-Wrapper-MC1.8:$nova_version" + } + } } publishing { @@ -35,4 +44,4 @@ artifactory { publishPom = true } } -} \ No newline at end of file +} diff --git a/gradle.properties b/gradle.properties index 169896f..f54cb5d 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,6 +1,6 @@ version = 0.0.1-SNAPSHOT group = nova.energy -novaVersion = 0.1.0-SNAPSHOT +nova_version = 0.1.0-SNAPSHOT packaging = jar info.inceptionYear = 2016 diff --git a/settings.gradle b/settings.gradle index 33e60a6..0f85d03 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1 +1 @@ -rootProject.name = 'NOVA-Energy' \ No newline at end of file +rootProject.name = 'NOVA-Energy' diff --git a/src/main/java/nova/energy/EnergyStorage.java b/src/main/java/nova/energy/EnergyStorage.java new file mode 100644 index 0000000..8e45a14 --- /dev/null +++ b/src/main/java/nova/energy/EnergyStorage.java @@ -0,0 +1,132 @@ +/* + * Copyright (c) 2015 NOVA, All rights reserved. + * This library is free software, licensed under GNU Lesser General Public License version 3 + * + * This file is part of NOVA. + * + * NOVA is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * NOVA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with NOVA. If not, see . + */ +package nova.energy; + +import nova.core.component.Component; +import nova.core.retention.Storable; +import nova.core.retention.Store; + +/** + * A component for items and blocks that store energy in joules. + * + * @author ExE Boss + */ +public class EnergyStorage extends Component implements Storable { + + @Store + protected double energy; + protected double maxEnergy; + protected double maxRecharge; + protected double maxDischarge; + + protected EnergyStorage() { + } + + public EnergyStorage(double maxEnergy) { + this(maxEnergy, maxEnergy, maxEnergy); + } + + public EnergyStorage(double maxEnergy, double maxTransfer) { + this(maxEnergy, maxTransfer, maxTransfer); + } + + public EnergyStorage(double maxEnergy, double maxRecharge, double maxDischarge) { + this.maxEnergy = maxEnergy; + this.maxRecharge = Math.min(0, Math.max(maxRecharge, maxEnergy)); + this.maxDischarge = Math.min(0, Math.max(maxDischarge, maxEnergy)); + } + + public EnergyStorage(double energy, double maxEnergy, double maxRecharge, double maxDischarge) { + this.maxEnergy = maxEnergy; + this.setEnergy(energy); + this.maxRecharge = maxRecharge; + this.maxDischarge = maxDischarge; + } + + /** + * Adds energy to an item. Returns the quantity of energy that was accepted. This should always + * return 0 if the item cannot be externally charged. + * + * @param energy Maximum amount of energy to be sent into the item (in Joules). + * @param doRecharge If false, the charge will only be simulated. + * @return Amount of energy that was accepted by the item (in Joules). + */ + public double recharge(double energy, boolean doRecharge) { + if (!canRecharge()) return 0; + + energy = Math.min(this.maxEnergy - this.energy, Math.min(this.maxRecharge, energy)); + if (doRecharge) this.energy += energy; + + return energy; + } + + /** + * Removes energy from an item. Returns the quantity of energy that was removed. This should + * always return 0 if the item cannot be externally discharged. + * + * @param energy Maximum amount of energy to be removed from the item (in Joules). + * @param doDischarge If false, the discharge will only be simulated. + * @return Amount of energy that was removed from the item (in Joules). + */ + public double discharge(double energy, boolean doDischarge) { + if (!canRecharge()) return 0; + + energy = Math.min(this.energy, Math.min(this.maxDischarge, energy)); + if (doDischarge) this.energy -= energy; + + return energy; + } + + /** + * Get the amount of energy currently stored in the item. + */ + public double getEnergy() { + return this.energy; + } + + /** + * Sets the amount of energy in the ItemStack. + * @param energy - Amount of electrical energy (in Joules). + */ + public void setEnergy(double energy) { + this.energy = Math.min(0, Math.max(energy, maxEnergy)); + } + + /** + * Get the max amount of energy that can be stored in the item. + */ + public double getEnergyCapacity() { + return maxEnergy; + } + + /** + * @return Whether or not this item can be externally recharged. + */ + public boolean canRecharge() { + return maxRecharge > 0; + } + + /** + * @return Whether or not this item can be externally discharged. + */ + public boolean canDischarge() { + return maxDischarge > 0; + } +} diff --git a/src/main/java/nova/energy/Unit.java b/src/main/java/nova/energy/Unit.java new file mode 100644 index 0000000..781e515 --- /dev/null +++ b/src/main/java/nova/energy/Unit.java @@ -0,0 +1,189 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package nova.energy; + +import nova.core.util.Identifiable; +import nova.core.util.registry.Registry; + +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; +import java.util.Optional; +import java.util.Set; +import java.util.stream.Collectors; + +/** + * @author ExE Boss + */ +public final class Unit implements Identifiable { + private static final Registry REGISTRY = new Registry<>(); + + public static final Unit METRE = getOrCreateUnit("nova:metre", "Meter", "m"); + public static final Unit GRAM = getOrCreateUnit("nova:gram", "Gram", "g", Prefix.KILO); + + public static final Unit AMPERE = getOrCreateUnit("nova:ampere", "Amp", "I"); + public static final Unit AMP_HOUR = getOrCreateUnit("nova:amp_hour", "Amp Hour", "Ah"); + public static final Unit VOLTAGE = getOrCreateUnit("nova:voltage", "Volt", "V"); + public static final Unit WATT = getOrCreateUnit("nova:watt", "Watt", "W"); + public static final Unit WATT_HOUR = getOrCreateUnit("nova:watt_hour", "Watt Hour", "Wh"); + public static final Unit RESISTANCE = getOrCreateUnit("nova:resistance", "Ohm", "R"); + public static final Unit CONDUCTANCE = getOrCreateUnit("nova:conductance", "Siemen", "S"); + public static final Unit JOULE = getOrCreateUnit("nova:joule", "Joule", "J"); + public static final Unit LITER = getOrCreateUnit("nova:liter", "Liter", "L"); + public static final Unit NEWTON_METER = getOrCreateUnit("nova:newton_meter", "Newton Meter", "Nm"); + + /** + * Redstone Flux, the default energy unit in Minecraft Forge since 1.10-ish. + */ + public static final Unit REDFLUX = getOrCreateUnit("forge:redstone_flux", "Redstone-Flux", "RF", "Redstone-Flux"); + public static final Unit MINECRAFT_JOULES = getOrCreateUnit("buildcraft:minecraft_joule", "Minecraft-Joule", "McJ"); // MJ is confusable with Megajoules + public static final Unit ELECTRICAL_UNITS = getOrCreateUnit("ic2:electrical_unit", "Electrical-Unit", "EU"); + + private final String id; + public final String name; + public final String symbol; + private String plural = null; + private Prefix basePrefix = null; + + private Unit(String id, String name, String symbol) { + this.id = id; + this.name = name; + this.symbol = symbol; + } + + private Unit setPlural(String plural) { + if (this.plural == null) + this.plural = plural; + return this; + } + + private Unit setBasePrefix(Prefix basePrefix) { + if (this.basePrefix == null) + this.basePrefix = basePrefix; + return this; + } + + public String getPlural() { + return this.plural == null ? this.name + "s" : this.plural; + } + + @Override + public String getID() { + return id; + } + + public Set getUnitsFromMod(String modId) { + return REGISTRY.stream().filter((e) -> { + String id = e.getID(); + if (id.contains(":")) { + return id.substring(0, id.lastIndexOf(':')).startsWith(modId); + } else { + return modId == null || modId.isEmpty(); + } + }).collect(Collectors.toSet()); + } + + public Optional getUnit(String id) { + return REGISTRY.get(id); + } + + public static Unit getOrCreateUnit(String id, String name, String unit) { + if (REGISTRY.contains(id)) return REGISTRY.get(id).get(); + return REGISTRY.register(new Unit(id, name, unit)); + } + + public static Unit getOrCreateUnit(String id, String name, String unit, String plural) { + if (REGISTRY.contains(id)) return REGISTRY.get(id).get(); + return REGISTRY.register(new Unit(id, name, unit)).setPlural(plural); + } + + public static Unit getOrCreateUnit(String id, String name, String unit, Prefix basePrefix) { + if (REGISTRY.contains(id)) return REGISTRY.get(id).get(); + return REGISTRY.register(new Unit(id, name, unit)).setBasePrefix(basePrefix); + } + + public static Unit getOrCreateUnit(String id, String name, String unit, String plural, Prefix basePrefix) { + if (REGISTRY.contains(id)) return REGISTRY.get(id).get(); + return REGISTRY.register(new Unit(id, name, unit)).setPlural(plural).setBasePrefix(basePrefix); + } + + /** + * Metric system of measurement. + */ + public static class Prefix { + private static final List UNIT_PREFIXES = new LinkedList<>(); + +// public static final Prefix YOCTO = new Prefix("Yocto", "y", 0.000000000000000000000001); +// public static final Prefix ZEPTO = new Prefix("Zepto", "z", 0.000000000000000000001); +// public static final Prefix ATTO = new Prefix("Atto", "a", 0.000000000000000001); +// public static final Prefix FEMTO = new Prefix("Femto", "p", 0.000000000000001); +// public static final Prefix PICO = new Prefix("Pico", "p", 0.000000000001); +// public static final Prefix NANO = new Prefix("Nano", "n", 0.000000001); + public static final Prefix MICRO = new Prefix("Micro", "μ", 0.000001); + public static final Prefix MILLI = new Prefix("Milli", "m", 0.001); + public static final Prefix BASE = new Prefix("", "", 1); + public static final Prefix KILO = new Prefix("Kilo", "k", 1000); + public static final Prefix MEGA = new Prefix("Mega", "M", 1000000); + public static final Prefix GIGA = new Prefix("Giga", "G", 1000000000); + public static final Prefix TERA = new Prefix("Tera", "T", 1000000000000d); + public static final Prefix PETA = new Prefix("Peta", "P", 1000000000000000d); + public static final Prefix EXA = new Prefix("Exa", "E", 1000000000000000000d); + public static final Prefix ZETTA = new Prefix("Zetta", "Z", 1000000000000000000000d); + public static final Prefix YOTTA = new Prefix("Yotta", "Y", 1000000000000000000000000d); + /** + * long name for the unit + */ + public final String name; + /** + * short unit version of the unit + */ + public final String symbol; + /** + * Point by which a number is consider to be of this unit + */ + public final double value; + + private Prefix(String name, String symbol, double value) { + this.name = name; + this.symbol = symbol; + this.value = value; + UNIT_PREFIXES.add(this); + } + + public String getName(boolean getShort) { + if (getShort) { + return symbol; + } else { + return name; + } + } + + /** + * Divides the value by the unit value start + */ + public double process(double value) { + return value / this.value; + } + + /** + * Checks if a value is above the unit value start + */ + public boolean isAbove(double value) { + return value > this.value; + } + + /** + * Checks if a value is lower than the unit value start + */ + public boolean isBellow(double value) { + return value < this.value; + } + + public static List getPrefixes() { + return Collections.unmodifiableList(UNIT_PREFIXES); + } + } +} diff --git a/src/main/java/nova/energy/UnitConversion.java b/src/main/java/nova/energy/UnitConversion.java new file mode 100644 index 0000000..a755396 --- /dev/null +++ b/src/main/java/nova/energy/UnitConversion.java @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2015 NOVA, All rights reserved. + * This library is free software, licensed under GNU Lesser General Public License version 3 + * + * This file is part of NOVA. + * + * NOVA is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * NOVA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with NOVA. If not, see . + */ + +package nova.energy; + +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +/** + * Convert between different units. (Where supported) + * + * @author ExE Boss + */ +public class UnitConversion { + + private static final Map> CONVERSION = new HashMap<>(); + + private final Unit unit1, unit2; + private final double ratio, reverseRatio; + private final UnitConversion reverse; + + private UnitConversion(Unit unit1, Unit unit2, double ratio) { + this.unit1 = unit1; + this.unit2 = unit2; + this.ratio = ratio; + this.reverseRatio = 1/ratio; + this.reverse = new UnitConversion(unit1, unit2, this.reverseRatio, this); + } + private UnitConversion(Unit unit1, Unit unit2, double ratio, UnitConversion reverse) { + this.unit1 = unit1; + this.unit2 = unit2; + this.ratio = ratio; + this.reverse = reverse; + this.reverseRatio = this.reverse.ratio; + } + public double convert(double value) { + return (this.reverseRatio == 0 && this.ratio != 0 ? value / ratio : value * this.reverseRatio); + } + + public Unit unit1() { + return unit1; + } + public Unit unit2() { + return unit2; + } + public double ratio() { + return ratio; + } + public UnitConversion reverse() { + return reverse; + } + + public static Optional getConvertion(Unit unit1, Unit unit2) { + Map conv = CONVERSION.get(unit1); + if (conv == null) return Optional.empty(); + return Optional.ofNullable(conv.get(unit2)); + } + + /** + * + * @param unit1 The unit to convert from + * @param unit2 The unit to convert to + * @param ratio unit1/unit2 + * @return The UnitConversion instance. + * @throws IllegalArgumentException If ratio is 0 + */ + public static UnitConversion registerConversion(Unit unit1, Unit unit2, double ratio) throws IllegalArgumentException { + if (ratio == 0) + throw new IllegalArgumentException("Ratio cannot be 0"); + + Map conv1 = CONVERSION.get(unit1); + if (conv1 == null) { + conv1 = new HashMap<>(); + CONVERSION.put(unit1, conv1); + } + if (conv1.containsKey(unit2)) return conv1.get(unit2); + + Map conv2 = CONVERSION.get(unit2); + if (conv2 == null) { + conv2 = new HashMap<>(); + CONVERSION.put(unit2, conv2); + } + + UnitConversion uc = new UnitConversion(unit1, unit2, ratio); + + conv1.put(unit2, uc); + conv2.put(unit1, uc.reverse()); + + calculateConversions(); + return uc; + } + + /** + * If UnitA can be converted to UnitB + * and UnitB can be converted to UnitC, + * then UnitA must be convertible to UnitC. + */ + public static void calculateConversions() { + // TODO + } + + static { + registerConversion(Unit.ELECTRICAL_UNITS, Unit.JOULE, 40d/1d); + registerConversion(Unit.REDFLUX, Unit.JOULE, 24/5d); + registerConversion(Unit.MINECRAFT_JOULES, Unit.JOULE, 40d/3d/1d); + + // This should also happen automatically + registerConversion(Unit.ELECTRICAL_UNITS, Unit.REDFLUX, 3d/25d); + registerConversion(Unit.ELECTRICAL_UNITS, Unit.MINECRAFT_JOULES, 3d/1d); + registerConversion(Unit.REDFLUX, Unit.MINECRAFT_JOULES, 25d/1d); + } +} diff --git a/src/main/java/nova/energy/UnitDisplay.java b/src/main/java/nova/energy/UnitDisplay.java new file mode 100644 index 0000000..f5e87b2 --- /dev/null +++ b/src/main/java/nova/energy/UnitDisplay.java @@ -0,0 +1,162 @@ +/* + * Copyright (c) 2015 NOVA, All rights reserved. + * This library is free software, licensed under GNU Lesser General Public License version 3 + * + * This file is part of NOVA. + * + * NOVA is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * NOVA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with NOVA. If not, see . + */ + +package nova.energy; + +/** + * An easy way to display information on electricity for the client. + * + * @author Calclavia + */ +public class UnitDisplay { + public final Unit unit; + public final double value; + public final boolean useSymbol; + public final int decimalPlaces; + public final boolean isSimple; + + public UnitDisplay(Unit unit, double value, boolean useSymbol, int decimalPlaces, boolean simple) { + this.unit = unit; + this.value = value; + this.useSymbol = useSymbol; + this.decimalPlaces = decimalPlaces; + this.isSimple = simple; + } + + public UnitDisplay(Unit unit, double value, boolean useSymbol, boolean simple) { + this(unit, value, useSymbol, 2, simple); + } + + public UnitDisplay(Unit unit, double value, int decimalPlaces, boolean simple) { + this(unit, value, false, decimalPlaces, simple); + } + + public UnitDisplay(Unit unit, double value, boolean useSymbol, int decimalPlaces) { + this(unit, value, useSymbol, decimalPlaces, false); + } + + public UnitDisplay(Unit unit, double value, int decimalPlaces) { + this(unit, value, false, decimalPlaces, false); + } + + public UnitDisplay(Unit unit, double value, boolean simple) { + this(unit, value, false, 2, simple); + } + + public UnitDisplay(Unit unit, double value) { + this(unit, value, false, 2, false); + } + + /** + * Rounds a number to a specific number place places + * + * @param d - the number + * @return The rounded number + */ + public static double roundDecimals(double d, int decimalPlaces) { + long j = Math.round(d * Math.pow(10, decimalPlaces)); + return j / Math.pow(10, decimalPlaces); + } + + public static double roundDecimals(double d) { + return roundDecimals(d, 2); + } + + public UnitDisplay multiply(double value) { + return new UnitDisplay(unit, value * this.value); + } + + public UnitDisplay simple() { + return (isSimple ? this : new UnitDisplay(unit, value, true)); + } + + public UnitDisplay notSimple() { + return (!isSimple ? this : new UnitDisplay(unit, value, false)); + } + + public UnitDisplay symbol() { + return symbol(true); + } + + public UnitDisplay symbol(boolean useSymbol) { + return (this.useSymbol ^ useSymbol ? new UnitDisplay(unit, value, isSimple, decimalPlaces, useSymbol) : this); + } + + public UnitDisplay decimal(int decimalPlaces) { + return (this.decimalPlaces == decimalPlaces ? this : new UnitDisplay(unit, value, isSimple, decimalPlaces, useSymbol)); + } + + @Override + public String toString() { + String unitName = unit.name; + String prefix = ""; + double value = this.value; + + if (isSimple) { + if (value > 1) { + if (decimalPlaces < 1) { + return (int) value + " " + unit.getPlural(); + } + + return roundDecimals(value, decimalPlaces) + " " + unit.getPlural(); + } + + if (decimalPlaces < 1) { + return (int) value + " " + unit.name; + } + + return roundDecimals(value, decimalPlaces) + " " + unit.name; + } + + if (value < 0) { + value = Math.abs(value); + prefix = "-"; + } + + if (useSymbol) { + unitName = unit.symbol; + } else if (value > 1) { + unitName = unit.getPlural(); + } + + if (value == 0) { + return value + " " + unitName; + } else { + for (int i = 0; i < Unit.Prefix.getPrefixes().size(); i++) { + Unit.Prefix lowerMeasure = Unit.Prefix.getPrefixes().get(i); + + if (lowerMeasure.isBellow(value) && i == 0) { + return prefix + roundDecimals(lowerMeasure.process(value), decimalPlaces) + " " + lowerMeasure.getName(useSymbol) + unitName; + } + if (i + 1 >= Unit.Prefix.getPrefixes().size()) { + return prefix + roundDecimals(lowerMeasure.process(value), decimalPlaces) + " " + lowerMeasure.getName(useSymbol) + unitName; + } + + Unit.Prefix upperMeasure = Unit.Prefix.getPrefixes().get(i + 1); + + if ((lowerMeasure.isAbove(value) && upperMeasure.isBellow(value)) || lowerMeasure.value == value) { + return prefix + roundDecimals(lowerMeasure.process(value), decimalPlaces) + " " + lowerMeasure.getName(useSymbol) + unitName; + } + } + } + + return prefix + roundDecimals(value, decimalPlaces) + " " + unitName; + } +} diff --git a/src/test/java/nova/energy/UnitConversionTest.java b/src/test/java/nova/energy/UnitConversionTest.java new file mode 100644 index 0000000..bad163c --- /dev/null +++ b/src/test/java/nova/energy/UnitConversionTest.java @@ -0,0 +1,30 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package nova.energy; + +import org.assertj.core.data.Offset; +import org.junit.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * + * @author ExE Boss + */ +public class UnitConversionTest { + + public UnitConversionTest() { + } + + @Test + public void testConvert() { + UnitConversion RF_JOULE = UnitConversion.getConvertion(Unit.REDFLUX, Unit.JOULE).get(); + UnitConversion JOULE_RF = UnitConversion.getConvertion(Unit.JOULE, Unit.REDFLUX).get(); + + assertThat(RF_JOULE.convert(24)).isEqualTo(5, Offset.offset(1 / 10_000_000D)); + assertThat(JOULE_RF.convert(5)).isEqualTo(24, Offset.offset(1 / 10_000_000D)); + } +}