summaryrefslogtreecommitdiff
path: root/src/org/unitConverter/unit
diff options
context:
space:
mode:
Diffstat (limited to 'src/org/unitConverter/unit')
-rw-r--r--src/org/unitConverter/unit/SI.java59
-rw-r--r--src/org/unitConverter/unit/Unit.java250
-rw-r--r--src/org/unitConverter/unit/UnitTest.java12
3 files changed, 192 insertions, 129 deletions
diff --git a/src/org/unitConverter/unit/SI.java b/src/org/unitConverter/unit/SI.java
index a4fbd5f..f36cf28 100644
--- a/src/org/unitConverter/unit/SI.java
+++ b/src/org/unitConverter/unit/SI.java
@@ -17,6 +17,7 @@
package org.unitConverter.unit;
import java.util.Arrays;
+import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
@@ -91,6 +92,9 @@ public final class SI {
public static final BaseUnit DOLLAR = BaseUnit
.valueOf(BaseDimensions.CURRENCY, "dollar", "$");
+ public static final Set<BaseUnit> BASE_UNITS = setOf(METRE, KILOGRAM,
+ SECOND, AMPERE, KELVIN, MOLE, CANDELA, BIT);
+
// You may NOT get SI.BaseUnits instances!
private BaseUnits() {
throw new AssertionError();
@@ -210,6 +214,7 @@ public final class SI {
/// The units of the SI
public static final LinearUnit ONE = LinearUnit
.valueOf(ObjectProduct.empty(), 1);
+
public static final LinearUnit METRE = BaseUnits.METRE.asLinearUnit()
.withName(NameSymbol.of("metre", "m", "meter"));
public static final LinearUnit KILOGRAM = BaseUnits.KILOGRAM.asLinearUnit()
@@ -228,10 +233,10 @@ public final class SI {
.withName(NameSymbol.of("bit", "b"));
public static final LinearUnit DOLLAR = BaseUnits.DOLLAR.asLinearUnit()
.withName(NameSymbol.of("dollar", "$"));
-
// Non-base units
public static final LinearUnit RADIAN = METRE.dividedBy(METRE)
.withName(NameSymbol.of("radian", "rad"));
+
public static final LinearUnit STERADIAN = RADIAN.times(RADIAN)
.withName(NameSymbol.of("steradian", "sr"));
public static final LinearUnit HERTZ = ONE.dividedBy(SECOND)
@@ -277,10 +282,10 @@ public final class SI {
// for dose equivalent
public static final LinearUnit KATAL = MOLE.dividedBy(SECOND)
.withName(NameSymbol.of("katal", "kat"));
-
// common derived units included for convenience
public static final LinearUnit GRAM = KILOGRAM.dividedBy(1000)
.withName(NameSymbol.of("gram", "g"));
+
public static final LinearUnit SQUARE_METRE = METRE.toExponent(2)
.withName(NameSymbol.of("square metre", "m^2", "square meter",
"metre squared", "meter squared"));
@@ -290,12 +295,12 @@ public final class SI {
public static final LinearUnit METRE_PER_SECOND = METRE.dividedBy(SECOND)
.withName(
NameSymbol.of("metre per second", "m/s", "meter per second"));
-
// Non-SI units included for convenience
public static final Unit CELSIUS = Unit
.fromConversionFunctions(KELVIN.getBase(), tempK -> tempK - 273.15,
tempC -> tempC + 273.15)
.withName(NameSymbol.of("degree Celsius", "\u00B0C"));
+
public static final LinearUnit MINUTE = SECOND.times(60)
.withName(NameSymbol.of("minute", "min"));
public static final LinearUnit HOUR = MINUTE.times(60)
@@ -324,7 +329,7 @@ public final class SI {
.withName(NameSymbol.of("tonne", "t", "metric ton"));
public static final LinearUnit DALTON = KILOGRAM.times(1.660539040e-27)
.withName(NameSymbol.of("dalton", "Da", "atomic unit", "u")); // approximate
- // value
+ // value
public static final LinearUnit ELECTRONVOLT = JOULE.times(1.602176634e-19)
.withName(NameSymbol.of("electron volt", "eV"));
public static final LinearUnit BYTE = BIT.times(8)
@@ -339,11 +344,11 @@ public final class SI {
.fromConversionFunctions(ONE.getBase(), pr -> 10 * Math.log10(pr),
dB -> Math.pow(10, dB / 10))
.withName(NameSymbol.of("decibel", "dB"));
-
/// The prefixes of the SI
// expanding decimal prefixes
public static final UnitPrefix KILO = UnitPrefix.valueOf(1e3)
.withName(NameSymbol.of("kilo", "k", "K"));
+
public static final UnitPrefix MEGA = UnitPrefix.valueOf(1e6)
.withName(NameSymbol.of("mega", "M"));
public static final UnitPrefix GIGA = UnitPrefix.valueOf(1e9)
@@ -358,10 +363,10 @@ public final class SI {
.withName(NameSymbol.of("zetta", "Z"));
public static final UnitPrefix YOTTA = UnitPrefix.valueOf(1e24)
.withName(NameSymbol.of("yotta", "Y"));
-
// contracting decimal prefixes
public static final UnitPrefix MILLI = UnitPrefix.valueOf(1e-3)
.withName(NameSymbol.of("milli", "m"));
+
public static final UnitPrefix MICRO = UnitPrefix.valueOf(1e-6)
.withName(NameSymbol.of("micro", "\u03BC", "u")); // mu
public static final UnitPrefix NANO = UnitPrefix.valueOf(1e-9)
@@ -376,10 +381,10 @@ public final class SI {
.withName(NameSymbol.of("zepto", "z"));
public static final UnitPrefix YOCTO = UnitPrefix.valueOf(1e-24)
.withName(NameSymbol.of("yocto", "y"));
-
// prefixes that don't match the pattern of thousands
public static final UnitPrefix DEKA = UnitPrefix.valueOf(1e1)
.withName(NameSymbol.of("deka", "da", "deca", "D"));
+
public static final UnitPrefix HECTO = UnitPrefix.valueOf(1e2)
.withName(NameSymbol.of("hecto", "h", "H", "hekto"));
public static final UnitPrefix DECI = UnitPrefix.valueOf(1e-1)
@@ -398,25 +403,29 @@ public final class SI {
.withName(NameSymbol.of("pebi", "Pi"));
public static final UnitPrefix EXBI = PEBI.times(1024)
.withName(NameSymbol.of("exbi", "Ei"));
-
// sets of prefixes
- public static final Set<UnitPrefix> ALL_PREFIXES = new HashSet<>(
- Arrays.asList(DEKA, HECTO, KILO, MEGA, GIGA, TERA, PETA, EXA, ZETTA,
- YOTTA, DECI, CENTI, MILLI, MICRO, NANO, PICO, FEMTO, ATTO, ZEPTO,
- YOCTO, KIBI, MEBI, GIBI, TEBI, PEBI, EXBI));
- public static final Set<UnitPrefix> DECIMAL_PREFIXES = new HashSet<>(
- Arrays.asList(DEKA, HECTO, KILO, MEGA, GIGA, TERA, PETA, EXA, ZETTA,
- YOTTA, DECI, CENTI, MILLI, MICRO, NANO, PICO, FEMTO, ATTO, ZEPTO,
- YOCTO));
- public static final Set<UnitPrefix> THOUSAND_PREFIXES = new HashSet<>(
- Arrays.asList(KILO, MEGA, GIGA, TERA, PETA, EXA, ZETTA, YOTTA, MILLI,
- MICRO, NANO, PICO, FEMTO, ATTO, ZEPTO, YOCTO));
- public static final Set<UnitPrefix> MAGNIFYING_PREFIXES = new HashSet<>(
- Arrays.asList(DEKA, HECTO, KILO, MEGA, GIGA, TERA, PETA, EXA, ZETTA,
- YOTTA, KIBI, MEBI, GIBI, TEBI, PEBI, EXBI));
- public static final Set<UnitPrefix> REDUCING_PREFIXES = new HashSet<>(
- Arrays.asList(DECI, CENTI, MILLI, MICRO, NANO, PICO, FEMTO, ATTO,
- ZEPTO, YOCTO));
+ public static final Set<UnitPrefix> ALL_PREFIXES = setOf(DEKA, HECTO, KILO,
+ MEGA, GIGA, TERA, PETA, EXA, ZETTA, YOTTA, DECI, CENTI, MILLI, MICRO,
+ NANO, PICO, FEMTO, ATTO, ZEPTO, YOCTO, KIBI, MEBI, GIBI, TEBI, PEBI,
+ EXBI);
+
+ public static final Set<UnitPrefix> DECIMAL_PREFIXES = setOf(DEKA, HECTO,
+ KILO, MEGA, GIGA, TERA, PETA, EXA, ZETTA, YOTTA, DECI, CENTI, MILLI,
+ MICRO, NANO, PICO, FEMTO, ATTO, ZEPTO, YOCTO);
+ public static final Set<UnitPrefix> THOUSAND_PREFIXES = setOf(KILO, MEGA,
+ GIGA, TERA, PETA, EXA, ZETTA, YOTTA, MILLI, MICRO, NANO, PICO, FEMTO,
+ ATTO, ZEPTO, YOCTO);
+ public static final Set<UnitPrefix> MAGNIFYING_PREFIXES = setOf(DEKA, HECTO,
+ KILO, MEGA, GIGA, TERA, PETA, EXA, ZETTA, YOTTA, KIBI, MEBI, GIBI,
+ TEBI, PEBI, EXBI);
+ public static final Set<UnitPrefix> REDUCING_PREFIXES = setOf(DECI, CENTI,
+ MILLI, MICRO, NANO, PICO, FEMTO, ATTO, ZEPTO, YOCTO);
+
+ // this method just calls Arrays.asList, which is itself safe.
+ @SafeVarargs
+ private static final <T> Set<T> setOf(T... args) {
+ return Collections.unmodifiableSet(new HashSet<>(Arrays.asList(args)));
+ }
// You may NOT get SI instances!
private SI() {
diff --git a/src/org/unitConverter/unit/Unit.java b/src/org/unitConverter/unit/Unit.java
index 35b32fc..eb9b000 100644
--- a/src/org/unitConverter/unit/Unit.java
+++ b/src/org/unitConverter/unit/Unit.java
@@ -25,6 +25,7 @@ import java.util.Optional;
import java.util.Set;
import java.util.function.DoubleUnaryOperator;
+import org.unitConverter.math.DecimalComparison;
import org.unitConverter.math.ObjectProduct;
/**
@@ -35,209 +36,211 @@ import org.unitConverter.math.ObjectProduct;
*/
public abstract class Unit {
/**
- * Returns a unit from its base and the functions it uses to convert to and from its base.
+ * Returns a unit from its base and the functions it uses to convert to and
+ * from its base.
*
* <p>
- * For example, to get a unit representing the degree Celsius, the following code can be used:
+ * For example, to get a unit representing the degree Celsius, the following
+ * code can be used:
*
* {@code Unit.fromConversionFunctions(SI.KELVIN, tempK -> tempK - 273.15, tempC -> tempC + 273.15);}
* </p>
*
- * @param base
- * unit's base
- * @param converterFrom
- * function that accepts a value expressed in the unit's base and returns that value expressed in this
- * unit.
- * @param converterTo
- * function that accepts a value expressed in the unit and returns that value expressed in the unit's
- * base.
+ * @param base unit's base
+ * @param converterFrom function that accepts a value expressed in the unit's
+ * base and returns that value expressed in this unit.
+ * @param converterTo function that accepts a value expressed in the unit
+ * and returns that value expressed in the unit's base.
* @return a unit that uses the provided functions to convert.
* @since 2019-05-22
- * @throws NullPointerException
- * if any argument is null
+ * @throws NullPointerException if any argument is null
*/
- public static final Unit fromConversionFunctions(final ObjectProduct<BaseUnit> base,
- final DoubleUnaryOperator converterFrom, final DoubleUnaryOperator converterTo) {
+ public static final Unit fromConversionFunctions(
+ final ObjectProduct<BaseUnit> base,
+ final DoubleUnaryOperator converterFrom,
+ final DoubleUnaryOperator converterTo) {
return new FunctionalUnit(base, converterFrom, converterTo);
}
-
+
/**
- * Returns a unit from its base and the functions it uses to convert to and from its base.
+ * Returns a unit from its base and the functions it uses to convert to and
+ * from its base.
*
* <p>
- * For example, to get a unit representing the degree Celsius, the following code can be used:
+ * For example, to get a unit representing the degree Celsius, the following
+ * code can be used:
*
* {@code Unit.fromConversionFunctions(SI.KELVIN, tempK -> tempK - 273.15, tempC -> tempC + 273.15);}
* </p>
*
- * @param base
- * unit's base
- * @param converterFrom
- * function that accepts a value expressed in the unit's base and returns that value expressed in this
- * unit.
- * @param converterTo
- * function that accepts a value expressed in the unit and returns that value expressed in the unit's
- * base.
- * @param ns
- * names and symbol of unit
+ * @param base unit's base
+ * @param converterFrom function that accepts a value expressed in the unit's
+ * base and returns that value expressed in this unit.
+ * @param converterTo function that accepts a value expressed in the unit
+ * and returns that value expressed in the unit's base.
+ * @param ns names and symbol of unit
* @return a unit that uses the provided functions to convert.
* @since 2019-05-22
- * @throws NullPointerException
- * if any argument is null
+ * @throws NullPointerException if any argument is null
*/
- public static final Unit fromConversionFunctions(final ObjectProduct<BaseUnit> base,
- final DoubleUnaryOperator converterFrom, final DoubleUnaryOperator converterTo, final NameSymbol ns) {
+ public static final Unit fromConversionFunctions(
+ final ObjectProduct<BaseUnit> base,
+ final DoubleUnaryOperator converterFrom,
+ final DoubleUnaryOperator converterTo, final NameSymbol ns) {
return new FunctionalUnit(base, converterFrom, converterTo, ns);
}
-
+
/**
* The combination of units that this unit is based on.
*
* @since 2019-10-16
*/
private final ObjectProduct<BaseUnit> unitBase;
-
+
/**
* The primary name used by this unit.
*/
private final Optional<String> primaryName;
-
+
/**
* A short symbol used to represent this unit.
*/
private final Optional<String> symbol;
-
+
/**
* A set of any additional names and/or spellings that the unit uses.
*/
private final Set<String> otherNames;
-
+
/**
* Cache storing the result of getDimension()
*
* @since 2019-10-16
*/
private transient ObjectProduct<BaseDimension> dimension = null;
-
+
/**
* Creates the {@code AbstractUnit}.
*
- * @param unitBase
- * base of unit
- * @param ns
- * names and symbol of unit
+ * @param unitBase base of unit
+ * @param ns names and symbol of unit
* @since 2019-10-16
- * @throws NullPointerException
- * if unitBase or ns is null
+ * @throws NullPointerException if unitBase or ns is null
*/
protected Unit(final ObjectProduct<BaseUnit> unitBase, final NameSymbol ns) {
- this.unitBase = Objects.requireNonNull(unitBase, "unitBase must not be null.");
- this.primaryName = Objects.requireNonNull(ns, "ns must not be null.").getPrimaryName();
+ this.unitBase = Objects.requireNonNull(unitBase,
+ "unitBase must not be null.");
+ this.primaryName = Objects.requireNonNull(ns, "ns must not be null.")
+ .getPrimaryName();
this.symbol = ns.getSymbol();
this.otherNames = ns.getOtherNames();
}
-
+
/**
* A constructor that constructs {@code BaseUnit} instances.
*
* @since 2019-10-16
*/
- Unit(final String primaryName, final String symbol, final Set<String> otherNames) {
+ Unit(final String primaryName, final String symbol,
+ final Set<String> otherNames) {
if (this instanceof BaseUnit) {
this.unitBase = ObjectProduct.oneOf((BaseUnit) this);
} else
throw new AssertionError();
this.primaryName = Optional.of(primaryName);
this.symbol = Optional.of(symbol);
- this.otherNames = Collections.unmodifiableSet(
- new HashSet<>(Objects.requireNonNull(otherNames, "additionalNames must not be null.")));
+ this.otherNames = Collections.unmodifiableSet(new HashSet<>(Objects
+ .requireNonNull(otherNames, "additionalNames must not be null.")));
}
-
+
/**
- * Checks if a value expressed in this unit can be converted to a value expressed in {@code other}
+ * Checks if a value expressed in this unit can be converted to a value
+ * expressed in {@code other}
*
- * @param other
- * unit to test with
+ * @param other unit to test with
* @return true if the units are compatible
* @since 2019-01-13
* @since v0.1.0
- * @throws NullPointerException
- * if other is null
+ * @throws NullPointerException if other is null
*/
public final boolean canConvertTo(final Unit other) {
Objects.requireNonNull(other, "other must not be null.");
return Objects.equals(this.getBase(), other.getBase());
}
-
+
/**
- * Converts from a value expressed in this unit's base unit to a value expressed in this unit.
+ * Converts from a value expressed in this unit's base unit to a value
+ * expressed in this unit.
* <p>
- * This must be the inverse of {@code convertToBase}, so {@code convertFromBase(convertToBase(value))} must be equal
- * to {@code value} for any value, ignoring precision loss by roundoff error.
+ * This must be the inverse of {@code convertToBase}, so
+ * {@code convertFromBase(convertToBase(value))} must be equal to
+ * {@code value} for any value, ignoring precision loss by roundoff error.
* </p>
* <p>
- * If this unit <i>is</i> a base unit, this method should return {@code value}.
+ * If this unit <i>is</i> a base unit, this method should return
+ * {@code value}.
* </p>
*
- * @implSpec This method is used by {@link #convertTo}, and its behaviour affects the behaviour of
- * {@code convertTo}.
+ * @implSpec This method is used by {@link #convertTo}, and its behaviour
+ * affects the behaviour of {@code convertTo}.
*
- * @param value
- * value expressed in <b>base</b> unit
+ * @param value value expressed in <b>base</b> unit
* @return value expressed in <b>this</b> unit
* @since 2018-12-22
* @since v0.1.0
*/
protected abstract double convertFromBase(double value);
-
+
/**
- * Converts a value expressed in this unit to a value expressed in {@code other}.
+ * Converts a value expressed in this unit to a value expressed in
+ * {@code other}.
*
* @implSpec If unit conversion is possible, this implementation returns
- * {@code other.convertFromBase(this.convertToBase(value))}. Therefore, overriding either of those methods
- * will change the output of this method.
+ * {@code other.convertFromBase(this.convertToBase(value))}.
+ * Therefore, overriding either of those methods will change the
+ * output of this method.
*
- * @param other
- * unit to convert to
- * @param value
- * value to convert
+ * @param other unit to convert to
+ * @param value value to convert
* @return converted value
* @since 2019-05-22
- * @throws IllegalArgumentException
- * if {@code other} is incompatible for conversion with this unit (as tested by
- * {@link Unit#canConvertTo}).
- * @throws NullPointerException
- * if other is null
+ * @throws IllegalArgumentException if {@code other} is incompatible for
+ * conversion with this unit (as tested by
+ * {@link Unit#canConvertTo}).
+ * @throws NullPointerException if other is null
*/
public final double convertTo(final Unit other, final double value) {
Objects.requireNonNull(other, "other must not be null.");
if (this.canConvertTo(other))
return other.convertFromBase(this.convertToBase(value));
else
- throw new IllegalArgumentException(String.format("Cannot convert from %s to %s.", this, other));
+ throw new IllegalArgumentException(
+ String.format("Cannot convert from %s to %s.", this, other));
}
-
+
/**
- * Converts from a value expressed in this unit to a value expressed in this unit's base unit.
+ * Converts from a value expressed in this unit to a value expressed in this
+ * unit's base unit.
* <p>
- * This must be the inverse of {@code convertFromBase}, so {@code convertToBase(convertFromBase(value))} must be
- * equal to {@code value} for any value, ignoring precision loss by roundoff error.
+ * This must be the inverse of {@code convertFromBase}, so
+ * {@code convertToBase(convertFromBase(value))} must be equal to
+ * {@code value} for any value, ignoring precision loss by roundoff error.
* </p>
* <p>
- * If this unit <i>is</i> a base unit, this method should return {@code value}.
+ * If this unit <i>is</i> a base unit, this method should return
+ * {@code value}.
* </p>
*
- * @implSpec This method is used by {@link #convertTo}, and its behaviour affects the behaviour of
- * {@code convertTo}.
+ * @implSpec This method is used by {@link #convertTo}, and its behaviour
+ * affects the behaviour of {@code convertTo}.
*
- * @param value
- * value expressed in <b>this</b> unit
+ * @param value value expressed in <b>this</b> unit
* @return value expressed in <b>base</b> unit
* @since 2018-12-22
* @since v0.1.0
*/
protected abstract double convertToBase(double value);
-
+
/**
* @return combination of units that this unit is based on
* @since 2018-12-22
@@ -246,7 +249,7 @@ public abstract class Unit {
public final ObjectProduct<BaseUnit> getBase() {
return this.unitBase;
}
-
+
/**
* @return dimension measured by this unit
* @since 2018-12-22
@@ -256,16 +259,16 @@ public abstract class Unit {
if (this.dimension == null) {
final Map<BaseUnit, Integer> mapping = this.unitBase.exponentMap();
final Map<BaseDimension, Integer> dimensionMap = new HashMap<>();
-
+
for (final BaseUnit key : mapping.keySet()) {
dimensionMap.put(key.getBaseDimension(), mapping.get(key));
}
-
+
this.dimension = ObjectProduct.fromExponentMapping(dimensionMap);
}
return this.dimension;
}
-
+
/**
* @return additionalNames
* @since 2019-10-21
@@ -273,7 +276,7 @@ public abstract class Unit {
public final Set<String> getOtherNames() {
return this.otherNames;
}
-
+
/**
* @return primaryName
* @since 2019-10-21
@@ -281,7 +284,7 @@ public abstract class Unit {
public final Optional<String> getPrimaryName() {
return this.primaryName;
}
-
+
/**
* @return symbol
* @since 2019-10-21
@@ -289,25 +292,64 @@ public abstract class Unit {
public final Optional<String> getSymbol() {
return this.symbol;
}
-
+
+ /**
+ * Returns true iff this unit is metric.
+ * <p>
+ * "Metric" is defined by three conditions:
+ * <ul>
+ * <li>Must be an instance of {@link LinearUnit}.</li>
+ * <li>Must be based on the SI base units (as determined by getBase())</li>
+ * <li>The conversion factor must be a power of 10.</li>
+ * </ul>
+ * <p>
+ * Note that this definition excludes some units that many would consider
+ * "metric", such as the degree Celsius (fails the first condition),
+ * calories, minutes and hours (fail the third condition).
+ * <p>
+ * All SI units (as designated by the BIPM) except the degree Celsius are
+ * considered "metric" by this definition.
+ *
+ * @since 2020-08-27
+ */
+ public final boolean isMetric() {
+ // first condition - check that it is a linear unit
+ if (!(this instanceof LinearUnit))
+ return false;
+ final LinearUnit linear = (LinearUnit) this;
+
+ // second condition - check that
+ for (final BaseUnit b : linear.getBase().getBaseSet()) {
+ if (!SI.BaseUnits.BASE_UNITS.contains(b))
+ return false;
+ }
+
+ // third condition - check that conversion factor is a power of 10
+ return DecimalComparison
+ .equals(Math.log10(linear.getConversionFactor()) % 1.0, 0);
+ }
+
@Override
public String toString() {
return this.getPrimaryName().orElse("Unnamed unit")
- + (this.getSymbol().isPresent() ? String.format(" (%s)", this.getSymbol().get()) : "")
- + ", derived from " + this.getBase().toString(u -> u.getSymbol().get())
- + (this.getOtherNames().isEmpty() ? "" : ", also called " + String.join(", ", this.getOtherNames()));
+ + (this.getSymbol().isPresent()
+ ? String.format(" (%s)", this.getSymbol().get())
+ : "")
+ + ", derived from "
+ + this.getBase().toString(u -> u.getSymbol().get())
+ + (this.getOtherNames().isEmpty() ? ""
+ : ", also called " + String.join(", ", this.getOtherNames()));
}
-
+
/**
- * @param ns
- * name(s) and symbol to use
+ * @param ns name(s) and symbol to use
* @return a copy of this unit with provided name(s) and symbol
* @since 2019-10-21
- * @throws NullPointerException
- * if ns is null
+ * @throws NullPointerException if ns is null
*/
public Unit withName(final NameSymbol ns) {
- return fromConversionFunctions(this.getBase(), this::convertFromBase, this::convertToBase,
+ return fromConversionFunctions(this.getBase(), this::convertFromBase,
+ this::convertToBase,
Objects.requireNonNull(ns, "ns must not be null."));
}
}
diff --git a/src/org/unitConverter/unit/UnitTest.java b/src/org/unitConverter/unit/UnitTest.java
index 2cf3126..ff83805 100644
--- a/src/org/unitConverter/unit/UnitTest.java
+++ b/src/org/unitConverter/unit/UnitTest.java
@@ -16,6 +16,7 @@
*/
package org.unitConverter.unit;
+import static org.junit.Assert.assertFalse;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -105,6 +106,17 @@ class UnitTest {
}
@Test
+ public void testIsMetric() {
+ final Unit metre = SI.METRE;
+ final Unit megasecond = SI.SECOND.withPrefix(SI.MEGA);
+ final Unit hour = SI.HOUR;
+
+ assertTrue(metre.isMetric());
+ assertTrue(megasecond.isMetric());
+ assertFalse(hour.isMetric());
+ }
+
+ @Test
public void testMultiplicationAndDivision() {
// test unit-times-unit multiplication
final LinearUnit generatedJoule = SI.KILOGRAM
generated by cgit v1.2.3 (git 2.46.0) at 2025-10-03 18:51:48 +0000