Skip to content

Commit

Permalink
Fix throws in TU.
Browse files Browse the repository at this point in the history 
Signed-off-by: parvy <pierre.arvy@artelys.com>
  • Loading branch information
@p-arvy
p-arvy committed Nov 24, 2023
1 parent b60075a commit 36cf02e
Show file tree
Hide file tree
Showing 4 changed files with 54 additions and 29 deletions.
4 changes: 2 additions & 2 deletions open-reac/src/main/java/com/powsybl/openreac/parameters/input/OpenReacParameters.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -169,7 +169,7 @@ public double getMinPlausibleLowVoltageLimit() {

public OpenReacParameters setMinPlausibleLowVoltageLimit(double minPlausibleLowVoltageLimit) {
if (minPlausibleLowVoltageLimit < 0 || Double.isNaN(minPlausibleLowVoltageLimit)) {
throw new InvalidParametersException("Min plausible low voltage limit must be >= 0 and defined to be consistent.");
throw new IllegalArgumentException("Min plausible low voltage limit must be >= 0 and defined to be consistent.");
}
this.minPlausibleLowVoltageLimit = minPlausibleLowVoltageLimit;
return this;
Expand All @@ -184,7 +184,7 @@ public double getMaxPlausibleHighVoltageLimit() {

public OpenReacParameters setMaxPlausibleHighVoltageLimit(double maxPlausibleHighVoltageLimit) {
if (maxPlausibleHighVoltageLimit <= 0 || Double.isNaN(maxPlausibleHighVoltageLimit)) {
throw new InvalidParametersException("Max plausible high voltage limit must be > 0 and defined to be consistent.");
throw new IllegalArgumentException("Max plausible high voltage limit must be > 0 and defined to be consistent.");
}
this.maxPlausibleHighVoltageLimit = maxPlausibleHighVoltageLimit;
return this;
Expand Down
32 changes: 22 additions & 10 deletions open-reac/src/test/java/com/powsybl/openreac/OpenReacParametersTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -64,7 +64,7 @@ void testAmplLogLevelIntegrity() {
parameters.setLogLevelAmpl(OpenReacAmplLogLevel.ERROR);
assertEquals("ERROR", parameters.getLogLevelAmpl().toParam().getValue());

assertThrows(NullPointerException.class, () -> parameters.setLogLevelAmpl(null), "Can't set null ampl log level.");
assertThrows(NullPointerException.class, () -> parameters.setLogLevelAmpl(null));
}

@Test
Expand All @@ -77,30 +77,39 @@ void testSolverLogLevelIntegrity() {
parameters.setLogLevelSolver(OpenReacSolverLogLevel.ONLY_RESULTS);
assertEquals("1", parameters.getLogLevelSolver().toParam().getValue());

assertThrows(NullPointerException.class, () -> parameters.setLogLevelSolver(null), "Can't set null solver log level.");
assertThrows(NullPointerException.class, () -> parameters.setLogLevelSolver(null));
}

@Test
void testMinMaxVoltageLimitIntegrity() {
Network network = IeeeCdfNetworkFactory.create14();
setDefaultVoltageLimits(network); // set default voltage limits to every voltage levels of the network
OpenReacParameters parameters = new OpenReacParameters();

// Consistency of min plausible low voltage limit (>= 0)
assertEquals(0.5, parameters.getMinPlausibleLowVoltageLimit()); // default value
parameters.setMinPlausibleLowVoltageLimit(0.8);
assertEquals(0.8, parameters.getMinPlausibleLowVoltageLimit());
assertThrows(InvalidParametersException.class, () -> parameters.setMinPlausibleLowVoltageLimit(-0.25));
assertThrows(InvalidParametersException.class, () -> parameters.setMinPlausibleLowVoltageLimit(Double.NaN));
IllegalArgumentException e = assertThrows(IllegalArgumentException.class, () -> parameters.setMinPlausibleLowVoltageLimit(-0.25));
assertEquals("Min plausible low voltage limit must be >= 0 and defined to be consistent.", e.getMessage());
IllegalArgumentException e2 = assertThrows(IllegalArgumentException.class, () -> parameters.setMinPlausibleLowVoltageLimit(Double.NaN));
assertEquals("Min plausible low voltage limit must be >= 0 and defined to be consistent.", e2.getMessage());

// Consistency of max plausible high voltage limit (> 0)
assertEquals(1.5, parameters.getMaxPlausibleHighVoltageLimit()); // default value
parameters.setMaxPlausibleHighVoltageLimit(0.75);
assertEquals(0.75, parameters.getMaxPlausibleHighVoltageLimit());
assertThrows(InvalidParametersException.class, () -> parameters.setMaxPlausibleHighVoltageLimit(-0.15));
assertThrows(InvalidParametersException.class, () -> parameters.setMaxPlausibleHighVoltageLimit(0));
assertThrows(InvalidParametersException.class, () -> parameters.setMaxPlausibleHighVoltageLimit(Double.NaN));
IllegalArgumentException e3 = assertThrows(IllegalArgumentException.class, () -> parameters.setMaxPlausibleHighVoltageLimit(-0.15));
assertEquals("Max plausible high voltage limit must be > 0 and defined to be consistent.", e3.getMessage());
IllegalArgumentException e4 = assertThrows(IllegalArgumentException.class, () -> parameters.setMaxPlausibleHighVoltageLimit(0));
assertEquals("Max plausible high voltage limit must be > 0 and defined to be consistent.", e4.getMessage());
IllegalArgumentException e5 = assertThrows(IllegalArgumentException.class, () -> parameters.setMaxPlausibleHighVoltageLimit(Double.NaN));
assertEquals("Max plausible high voltage limit must be > 0 and defined to be consistent.", e5.getMessage());

// Check min < max
assertFalse(parameters.checkAlgorithmParametersIntegrity());
InvalidParametersException e6 = assertThrows(InvalidParametersException.class, () -> parameters.checkIntegrity(network));
assertEquals("At least one algorithm parameter is inconsistent.", e6.getMessage());
parameters.setMaxPlausibleHighVoltageLimit(1.2);
assertTrue(parameters.checkAlgorithmParametersIntegrity());
}
Expand Down Expand Up @@ -146,7 +155,8 @@ void testParametersIntegrity() {
assertDoesNotThrow(() -> lambdaParams.checkIntegrity(network), "Adding TwoWindingsTransformer network IDs should not throw.");
parameters.addVariableTwoWindingsTransformers(List.of(wrongId));
assertNull(network.getTwoWindingsTransformer(wrongId), "Please change wrong ID so it does not match any element in the network.");
assertThrows(InvalidParametersException.class, () -> lambdaParams.checkIntegrity(network), "An ID TwoWindingsTransformer not present in the network should throw to the user.");
InvalidParametersException e = assertThrows(InvalidParametersException.class, () -> lambdaParams.checkIntegrity(network));
assertEquals("Two windings transformer " + wrongId + " not found in the network.", e.getMessage());

// Reseting parameters
parameters = new OpenReacParameters();
Expand All @@ -158,7 +168,8 @@ void testParametersIntegrity() {
assertDoesNotThrow(() -> lambdaParamsShunts.checkIntegrity(network), "Adding ShuntCompensator network IDs should not throw.");
parameters.addVariableShuntCompensators(List.of(wrongId));
assertNull(network.getShuntCompensator(wrongId), "Please change wrong ID so it does not match any element in the network.");
assertThrows(InvalidParametersException.class, () -> lambdaParamsShunts.checkIntegrity(network), "An ShuntCompensator ID not present in the network should throw to the user.");
InvalidParametersException e2 = assertThrows(InvalidParametersException.class, () -> lambdaParamsShunts.checkIntegrity(network));
assertEquals("Shunt " + wrongId + " not found in the network.", e2.getMessage());

// Reseting parameters
parameters = new OpenReacParameters();
Expand All @@ -170,7 +181,8 @@ void testParametersIntegrity() {
assertDoesNotThrow(() -> lambdaParamsGenerators.checkIntegrity(network), "Adding Generator network IDs should not throw.");
parameters.addConstantQGenerators(List.of(wrongId));
assertNull(network.getGenerator(wrongId), "Please change wrong ID so it does not match any element in the network.");
assertThrows(InvalidParametersException.class, () -> lambdaParamsGenerators.checkIntegrity(network), "An Generator ID not present in the network should throw to the user.");
InvalidParametersException e3 = assertThrows(InvalidParametersException.class, () -> lambdaParamsGenerators.checkIntegrity(network));
assertEquals("Generator " + wrongId + " not found in the network.", e3.getMessage());
}

void setDefaultVoltageLimits(Network network) {
Expand Down
29 changes: 18 additions & 11 deletions .../test/java/com/powsybl/openreac/parameters/input/VoltageLevelLimitsOverrideInputTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -108,17 +108,20 @@ void testUndefinedVoltageLimitsWithoutOverride() {
// if one low voltage limit is undefined, invalid OpenReacParameters
vl.setLowVoltageLimit(Double.NaN);
vl.setHighVoltageLimit(480);
assertThrows(PowsyblException.class, () -> params.checkIntegrity(network));
PowsyblException e = assertThrows(PowsyblException.class, () -> params.checkIntegrity(network));
assertEquals("At least one voltage level has an undefined or incorrect voltage limit.", e.getMessage());

// if one high voltage limit is undefined, invalid OpenReacParameters
vl.setLowVoltageLimit(480);
vl.setHighVoltageLimit(Double.NaN);
assertThrows(PowsyblException.class, () -> params.checkIntegrity(network));
PowsyblException e2 = assertThrows(PowsyblException.class, () -> params.checkIntegrity(network));
assertEquals("At least one voltage level has an undefined or incorrect voltage limit.", e2.getMessage());

// if both low/high voltage limit are undefined, invalid OpenReacParameters
vl.setLowVoltageLimit(Double.NaN);
vl.setHighVoltageLimit(Double.NaN);
assertThrows(PowsyblException.class, () -> params.checkIntegrity(network));
PowsyblException e3 = assertThrows(PowsyblException.class, () -> params.checkIntegrity(network));
assertEquals("At least one voltage level has an undefined or incorrect voltage limit.", e3.getMessage());
}

@Test
Expand All @@ -135,9 +138,9 @@ void testVoltageOverrideWithNegativeVoltageLimit() {
List<VoltageLimitOverride> voltageLimitsOverride = new ArrayList<>();
voltageLimitsOverride.add(new VoltageLimitOverride(vl.getId(), VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT, true, -410));
params.addSpecificVoltageLimits(voltageLimitsOverride);
assertThrows(InvalidParametersException.class, () -> params.checkIntegrity(network));
InvalidParametersException e = assertThrows(InvalidParametersException.class, () -> params.checkIntegrity(network));
assertEquals("At least one voltage limit override is inconsistent.", e.getMessage());

// if low relative voltage override leads to null voltage limit, throws exception
params.getSpecificVoltageLimits().clear();
voltageLimitsOverride.clear();
voltageLimitsOverride.add(new VoltageLimitOverride(vl.getId(), VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT, true, -400));
Expand All @@ -149,9 +152,9 @@ void testVoltageOverrideWithNegativeVoltageLimit() {
List<VoltageLimitOverride> voltageLimitsOverride2 = new ArrayList<>();
voltageLimitsOverride2.add(new VoltageLimitOverride(vl.getId(), VoltageLimitOverride.VoltageLimitType.HIGH_VOLTAGE_LIMIT, true, -490));
params2.addSpecificVoltageLimits(voltageLimitsOverride2);
assertThrows(InvalidParametersException.class, () -> params2.checkIntegrity(network));
InvalidParametersException e2 = assertThrows(InvalidParametersException.class, () -> params2.checkIntegrity(network));
assertEquals("At least one voltage limit override is inconsistent.", e2.getMessage());

// if high relative voltage override leads to null voltage limit, throws exception
params2.getSpecificVoltageLimits().clear();
voltageLimitsOverride2.clear();
voltageLimitsOverride2.add(new VoltageLimitOverride(vl.getId(), VoltageLimitOverride.VoltageLimitType.HIGH_VOLTAGE_LIMIT, true, -480));
Expand Down Expand Up @@ -179,9 +182,12 @@ void testVoltageOverrideWithLowLimitGreaterHighLimit() {
voltageLimitsOverride3.add(new VoltageLimitOverride(vl.getId(), VoltageLimitOverride.VoltageLimitType.HIGH_VOLTAGE_LIMIT, false, 390));

// if after relative override, low limit > high limit, wrong parameters
assertThrows(InvalidParametersException.class, () -> new VoltageLevelLimitsOverrideInput(voltageLimitsOverride, network));
assertThrows(InvalidParametersException.class, () -> new VoltageLevelLimitsOverrideInput(voltageLimitsOverride2, network));
assertThrows(InvalidParametersException.class, () -> new VoltageLevelLimitsOverrideInput(voltageLimitsOverride3, network));
InvalidParametersException e = assertThrows(InvalidParametersException.class, () -> new VoltageLevelLimitsOverrideInput(voltageLimitsOverride, network));
assertEquals("Override on voltage level " + vl.getId() + " leads to low voltage limit >= high voltage limit.", e.getMessage());
InvalidParametersException e2 = assertThrows(InvalidParametersException.class, () -> new VoltageLevelLimitsOverrideInput(voltageLimitsOverride2, network));
assertEquals("Override on voltage level " + vl.getId() + " leads to low voltage limit >= high voltage limit.", e2.getMessage());
InvalidParametersException e3 = assertThrows(InvalidParametersException.class, () -> new VoltageLevelLimitsOverrideInput(voltageLimitsOverride3, network));
assertEquals("Override on voltage level " + vl.getId() + " leads to low voltage limit >= high voltage limit.", e3.getMessage());
}

@Test
Expand All @@ -194,7 +200,8 @@ void testVoltageOverrideOnInvalidVoltageLevel() {
List<VoltageLimitOverride> voltageLimitsOverride = new ArrayList<>();
voltageLimitsOverride.add(new VoltageLimitOverride("UNKNOWN_ID", VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT, true, 1));
params3.addSpecificVoltageLimits(voltageLimitsOverride);
assertThrows(InvalidParametersException.class, () -> params3.checkIntegrity(network));
InvalidParametersException e = assertThrows(InvalidParametersException.class, () -> params3.checkIntegrity(network));
assertEquals("At least one voltage limit override is inconsistent.", e.getMessage());
}

void setDefaultVoltageLimits(Network network) {
Expand Down
18 changes: 12 additions & 6 deletions open-reac/src/test/java/com/powsybl/openreac/parameters/input/VoltageLimitsOverrideTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,20 +24,26 @@ void testToStringOverrideType() {
@Test
void invalidVoltageLimitOverride() {
// Verify it is impossible to create voltage limit override with NaN value...
assertThrows(InvalidParametersException.class,
InvalidParametersException e = assertThrows(InvalidParametersException.class,
() -> new VoltageLimitOverride("vl", VoltageLimitOverride.VoltageLimitType.HIGH_VOLTAGE_LIMIT, true, Double.NaN));
assertThrows(InvalidParametersException.class,
assertEquals("The voltage limit override must be defined.", e.getMessage());
e = assertThrows(InvalidParametersException.class,
() -> new VoltageLimitOverride("vl", VoltageLimitOverride.VoltageLimitType.HIGH_VOLTAGE_LIMIT, false, Double.NaN));
assertThrows(InvalidParametersException.class,
assertEquals("The voltage limit override must be defined.", e.getMessage());
e = assertThrows(InvalidParametersException.class,
() -> new VoltageLimitOverride("vl", VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT, true, Double.NaN));
assertThrows(InvalidParametersException.class,
assertEquals("The voltage limit override must be defined.", e.getMessage());
e = assertThrows(InvalidParametersException.class,
() -> new VoltageLimitOverride("vl", VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT, false, Double.NaN));
assertEquals("The voltage limit override must be defined.", e.getMessage());

// Verify it is impossible to create absolute voltage limit override with negative value
assertThrows(InvalidParametersException.class,
InvalidParametersException e2 = assertThrows(InvalidParametersException.class,
() -> new VoltageLimitOverride("vl", VoltageLimitOverride.VoltageLimitType.HIGH_VOLTAGE_LIMIT, false, -1));
assertThrows(InvalidParametersException.class,
assertEquals("The voltage limit override is in absolute value: must be positive.", e2.getMessage());
e2 = assertThrows(InvalidParametersException.class,
() -> new VoltageLimitOverride("vl", VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT, false, -1));
assertEquals("The voltage limit override is in absolute value: must be positive.", e2.getMessage());
}

@Test
Expand Down

0 comments on commit 36cf02e

Please sign in to comment.