Package org.djunits.quantity.def

Class AbsoluteQuantityTest

java.lang.Object

org.djunits.quantity.def.AbsoluteQuantityTest

public class AbsoluteQuantityTest
extends Object

Unit tests for the abstract AbsoluteQuantity API using Position and its nested Position.Reference.

Goals and coverage:

• Reference-aware comparisons and Comparable rules
• Reference transformations via AbsoluteQuantity.relativeTo(AbstractReference)
• Parsing helpers: AbsoluteQuantity.valueOf(String, AbsoluteQuantity, AbstractReference) and AbsoluteQuantity.of(double, String, AbsoluteQuantity, AbstractReference)
• Stringification and SI-prefix formatting
• Static helpers: AbsoluteQuantity.interpolate(AbsoluteQuantity, AbsoluteQuantity, double), AbsoluteQuantity.max(AbsoluteQuantity, AbsoluteQuantity[]), AbsoluteQuantity.min(AbsoluteQuantity, AbsoluteQuantity[]), AbsoluteQuantity.sum(AbsoluteQuantity, AbsoluteQuantity[]), AbsoluteQuantity.mean(AbsoluteQuantity, AbsoluteQuantity[])
• Arithmetic with relative quantities: AbsoluteQuantity.add(Quantity) and AbsoluteQuantity.subtract(Quantity) and AbsoluteQuantity.subtract(AbsoluteQuantity)
• equals/hashCode contract

Deliberately out of scope: We do not re-test domain specifics of Position/Length. Those are covered by their dedicated tests; here, Position provides a concrete vehicle to exercise the abstract API.

Locale pinning: The suite pins Locale.Category.FORMAT to Locale.US for deterministic formatting/parsing behavior; the original locale is restored afterwards.

Reference registry hygiene: Each created Position.Reference is unregistered in cleanup() to avoid cross-test pollution of the static per-class registry. Copyright (c) 2025-2026 Delft University of Technology, Jaffalaan 5, 2628 BX Delft, the Netherlands. All rights reserved. See for project information https://djunits.org. The DJUNITS project is distributed under a three-clause BSD-style license.

Author:

Alexander Verbraeck (specifications); Test implementation by Copilot.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) static class	AbsoluteQuantityTest.AbsoluteExampleQuantityAQxyz	Absolute quantity class for test.

Constructor Summary

Constructors

Constructor	Description
AbsoluteQuantityTest()

Method Summary

Modifier and Type	Method	Description
(package private) void	addSubtractRelative()	Verifies AbsoluteQuantity.add(Quantity) and AbsoluteQuantity.subtract(Quantity) adjust the inner relative quantity while preserving the absolute reference and the display unit.
(package private) void	cleanup()	Unregisters created references from the per-class registry to avoid cross-test pollution.
(package private) void	compactStrings()	Verifies concise textual and display strings for absolute quantities.
(package private) void	comparisonsAndReferenceConstraints()	Verifies that comparisons (lt/le/gt/ge) and Comparable.compareTo(Object) require identical references, otherwise an IllegalArgumentException is thrown.
(package private) void	constructorNulls()	Verifies that the constructor of Position (as a representative of AbsoluteQuantity) rejects null for either the relative quantity or the reference.
(package private) void	displayUnitAccessors()	Verifies that AbsoluteQuantity.getDisplayUnit() and AbsoluteQuantity.setDisplayUnit(org.djunits.unit.UnitInterface) delegate correctly to the inner relative quantity and that the setter is fluent.
(package private) void	equalsHashCode()	Verifies equals/hashCode consider both the inner relative quantity and the reference identity.
(package private) void	formatVariants()	Verifies AbsoluteQuantity.format(double) and AbsoluteQuantity.format(double, String) paths: fixed format range and E-notation range.
(package private) void	getInUnitVariants()	Verifies AbsoluteQuantity.getInUnit() and AbsoluteQuantity.getInUnit(org.djunits.unit.UnitInterface).
(package private) void	getNameFormatsPrettyForAbsoluteQuantity()	Tests AbsoluteQuantity.getName() using Position as the representative absolute quantity.
(package private) void	interpolateAbsolute()	Verifies AbsoluteQuantity.interpolate(AbsoluteQuantity, AbsoluteQuantity, double).
(package private) void	maxMin()	Verifies AbsoluteQuantity.max(AbsoluteQuantity, AbsoluteQuantity[]) and AbsoluteQuantity.min(AbsoluteQuantity, AbsoluteQuantity[]) for identical references and that mixing references raises an IllegalArgumentException.
(package private) void	numberConversions()	Verifies that Number-derived conversions reflect the SI value semantics for AbsoluteQuantity.
(package private) void	ofParses()	Verifies successful parsing via AbsoluteQuantity.of(double, String, AbsoluteQuantity, AbstractReference) and error branches for null parameters, empty unit string, and unknown units.
(package private) static void	pinLocale()	Pin the default Locale for predictable formatting/parsing behavior.
(package private) void	quantityAndReferenceAccessors()	Verifies the accessors AbsoluteQuantity.getQuantity() and AbsoluteQuantity.getReference().
(package private) void	relativeToVariants()	Verifies AbsoluteQuantity.relativeTo(AbstractReference) for: identity transform (same reference) direct parent/child transform (A ⇄ B) multi-level transform (C ⇄ A via B) unrelated roots (should throw) Graph (SI offsets): A=0, B=A+2, C=B+1 (=A+3).
(package private) static void	restoreLocale()	Restore the default Locale for the FORMAT category.
(package private) void	setup()	Establishes a small reference graph for tests.
(package private) void	subtractAbsolute()	Verifies AbsoluteQuantity.subtract(AbsoluteQuantity) aligns references and returns the relative difference.
(package private) void	sumMean()	Verifies AbsoluteQuantity.sum(AbsoluteQuantity, AbsoluteQuantity[]) and AbsoluteQuantity.mean(AbsoluteQuantity, AbsoluteQuantity[]) for identical references, and ensures that the reference and display unit of the first argument are preserved.
(package private) void	toStringSIPrefixed()	Verifies that AbsoluteQuantity.toStringSIPrefixed() delegates to the inner relative quantity and produces a sensible SI prefix when possible.
(package private) void	toStringVariants()	Verifies AbsoluteQuantity.toString() variants, ensuring that when withUnit=true the reference id is appended as " (refId)" and that the verbose flag adds the "Abs " prefix.
(package private) void	valueOfParses()	Verifies successful parsing via AbsoluteQuantity.valueOf(String, AbsoluteQuantity, AbstractReference) and error branches for null parameters, empty text, and unknown units.
(package private) void	zeroComparisons()	Verifies zero-comparison helpers (lt0/le0/gt0/ge0/eq0/ne0) for AbsoluteQuantity.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details

AbsoluteQuantityTest

public AbsoluteQuantityTest()

Method Details

pinLocale

@BeforeAll
static void pinLocale()

Pin the default Locale for predictable formatting/parsing behavior.

restoreLocale

@AfterAll
static void restoreLocale()

Restore the default Locale for the FORMAT category.

setup

@BeforeEach
void setup()

Establishes a small reference graph for tests.

• A: root
• B: A + 2 m
• C: B + 1 m (i.e., A + 3 m)
• X: unrelated root

cleanup

@AfterEach
void cleanup()

Unregisters created references from the per-class registry to avoid cross-test pollution.

constructorNulls

@Test
void constructorNulls()

Verifies that the constructor of Position (as a representative of AbsoluteQuantity) rejects null for either the relative quantity or the reference.

displayUnitAccessors

@Test
void displayUnitAccessors()

Verifies that AbsoluteQuantity.getDisplayUnit() and AbsoluteQuantity.setDisplayUnit(org.djunits.unit.UnitInterface) delegate correctly to the inner relative quantity and that the setter is fluent.

quantityAndReferenceAccessors

@Test
void quantityAndReferenceAccessors()

Verifies the accessors AbsoluteQuantity.getQuantity() and AbsoluteQuantity.getReference().

getInUnitVariants

@Test
void getInUnitVariants()

Verifies AbsoluteQuantity.getInUnit() and AbsoluteQuantity.getInUnit(org.djunits.unit.UnitInterface).

numberConversions

@Test
void numberConversions()

Verifies that Number-derived conversions reflect the SI value semantics for AbsoluteQuantity.

comparisonsAndReferenceConstraints

@Test
void comparisonsAndReferenceConstraints()

Verifies that comparisons (lt/le/gt/ge) and Comparable.compareTo(Object) require identical references, otherwise an IllegalArgumentException is thrown.

Also verifies eq/ne logic (which includes reference equality for absolute quantities).

zeroComparisons

@Test
void zeroComparisons()

Verifies zero-comparison helpers (lt0/le0/gt0/ge0/eq0/ne0) for AbsoluteQuantity.

valueOfParses

@Test
void valueOfParses()

Verifies successful parsing via AbsoluteQuantity.valueOf(String, AbsoluteQuantity, AbstractReference) and error branches for null parameters, empty text, and unknown units.

ofParses

@Test
void ofParses()

Verifies successful parsing via AbsoluteQuantity.of(double, String, AbsoluteQuantity, AbstractReference) and error branches for null parameters, empty unit string, and unknown units.

relativeToVariants

@Test
void relativeToVariants()

Verifies AbsoluteQuantity.relativeTo(AbstractReference) for:

• identity transform (same reference)
• direct parent/child transform (A ⇄ B)
• multi-level transform (C ⇄ A via B)
• unrelated roots (should throw)

Graph (SI offsets): A=0, B=A+2, C=B+1 (=A+3).

formatVariants

@Test
void formatVariants()

Verifies AbsoluteQuantity.format(double) and AbsoluteQuantity.format(double, String) paths: fixed format range and E-notation range.

toStringVariants

@Test
void toStringVariants()

Verifies AbsoluteQuantity.toString() variants, ensuring that when withUnit=true the reference id is appended as " (refId)" and that the verbose flag adds the "Abs " prefix.

toStringSIPrefixed

@Test
void toStringSIPrefixed()

Verifies that AbsoluteQuantity.toStringSIPrefixed() delegates to the inner relative quantity and produces a sensible SI prefix when possible.

compactStrings

@Test
void compactStrings()

Verifies concise textual and display strings for absolute quantities.

subtractAbsolute

@Test
void subtractAbsolute()

Verifies AbsoluteQuantity.subtract(AbsoluteQuantity) aligns references and returns the relative difference.

Case: pA = 10@A, pB = 8@B represent the same absolute point; the difference is 0.

addSubtractRelative

@Test
void addSubtractRelative()

Verifies AbsoluteQuantity.add(Quantity) and AbsoluteQuantity.subtract(Quantity) adjust the inner relative quantity while preserving the absolute reference and the display unit.

interpolateAbsolute

@Test
void interpolateAbsolute()

Verifies AbsoluteQuantity.interpolate(AbsoluteQuantity, AbsoluteQuantity, double). For:

• valid ratio in [0, 1]
• ratio out of bounds raising IllegalArgumentException
• reference mismatch raising IllegalArgumentException

maxMin

@Test
void maxMin()

Verifies AbsoluteQuantity.max(AbsoluteQuantity, AbsoluteQuantity[]) and AbsoluteQuantity.min(AbsoluteQuantity, AbsoluteQuantity[]) for identical references and that mixing references raises an IllegalArgumentException.

sumMean

@Test
void sumMean()

Verifies AbsoluteQuantity.sum(AbsoluteQuantity, AbsoluteQuantity[]) and AbsoluteQuantity.mean(AbsoluteQuantity, AbsoluteQuantity[]) for identical references, and ensures that the reference and display unit of the first argument are preserved. Mixing references must throw.

equalsHashCode

@Test
void equalsHashCode()

Verifies equals/hashCode consider both the inner relative quantity and the reference identity.

getNameFormatsPrettyForAbsoluteQuantity

@Test
void getNameFormatsPrettyForAbsoluteQuantity()

Tests AbsoluteQuantity.getName() using Position as the representative absolute quantity.

The "pretty name" algorithm mirrors Quantity.getName() and:

1. Keeps the first character of the localized simple name exactly as-is;
2. For each subsequent uppercase character, inserts a space if the previous character is not a space, and appends the lower-cased version of that uppercase character;
3. Otherwise, appends the character unchanged.

Coverage note: The class name Position contains only an initial uppercase, so this test covers the "no internal uppercase" path. If you want to also cover the branch that inserts spaces for internal capitals for absolute quantities, add a trivial test-only subclass, e.g., TestPositionAbsolute extends Position, and assert that new TestPositionAbsolute(...).getName() becomes "Test position absolute".

Expected: new Position(...).getName() yields "Position".