diff --git a/src/main/java/org/orekit/rugged/api/RuggedBuilder.java b/src/main/java/org/orekit/rugged/api/RuggedBuilder.java
index af969352bbce1eab13819e6c3ac346c7d9a0c5a1..74578feb190b3cd2479b09de628088c93c87c284 100644
--- a/src/main/java/org/orekit/rugged/api/RuggedBuilder.java
+++ b/src/main/java/org/orekit/rugged/api/RuggedBuilder.java
@@ -405,7 +405,7 @@ public class RuggedBuilder {
* @see #setTrajectory(double, int, CartesianDerivativesFilter, AngularDerivativesFilter, Propagator)
* @see #setTrajectoryAndTimeSpan(InputStream)
* @see #getInertialFrame()
- * @see #getpositionsVelocities()
+ * @see #getPositionsVelocities()
* @see #getPVInterpolationNumber()
* @see #getPVInterpolationNumber()
* @see #getQuaternions()
@@ -440,7 +440,7 @@ public class RuggedBuilder {
* @see #setTrajectory(InertialFrameId, List, int, CartesianDerivativesFilter, List, int, AngularDerivativesFilter)
* @see #setTrajectory(double, int, CartesianDerivativesFilter, AngularDerivativesFilter, Propagator)
* @see #setTrajectoryAndTimeSpan(InputStream)
- * @see #getpositionsVelocities()
+ * @see #getPositionsVelocities()
* @see #getPVInterpolationNumber()
* @see #getPVInterpolationNumber()
* @see #getQuaternions()
@@ -510,7 +510,7 @@ public class RuggedBuilder {
* @return satellite position and velocity (m and m/s in inertial frame)
* @see #setTrajectory(double, int, CartesianDerivativesFilter, AngularDerivativesFilter, Propagator)
*/
- public List<TimeStampedPVCoordinates> getpositionsVelocities() {
+ public List<TimeStampedPVCoordinates> getPositionsVelocities() {
return pvSample;
}
diff --git a/src/main/java/org/orekit/rugged/errors/DumpReplayer.java b/src/main/java/org/orekit/rugged/errors/DumpReplayer.java
index 57dc751644dfb3dc04a46034d3930a02eb218a0d..6075cf7fd10075b3fb825de69b07141ed769d701 100644
--- a/src/main/java/org/orekit/rugged/errors/DumpReplayer.java
+++ b/src/main/java/org/orekit/rugged/errors/DumpReplayer.java
@@ -927,7 +927,7 @@ public class DumpReplayer {
public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global)
throws RuggedException {
try {
- if (fields.length < 5 || !fields[0].equals(SENSOR_NAME) ||
+ if (fields.length < 6 || !fields[0].equals(SENSOR_NAME) ||
!fields[2].equals(LINE_NUMBER) || !fields[4].equals(DATE)) {
throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
}
@@ -951,7 +951,7 @@ public class DumpReplayer {
@Override
public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global)
throws RuggedException {
- if (fields.length < 5 || !fields[0].equals(SENSOR_NAME) ||
+ if (fields.length < 6 || !fields[0].equals(SENSOR_NAME) ||
!fields[2].equals(LINE_NUMBER) || !fields[4].equals(RATE)) {
throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
}
@@ -984,11 +984,19 @@ public class DumpReplayer {
final String parsedKey = line.substring(0, colon).trim().replaceAll(" ", "_").toUpperCase();
try {
final LineParser parser = LineParser.valueOf(parsedKey);
- parser.parse(l, file, line, line.substring(colon + 1).trim().split("\\s+"), global);
+ final String[] fields;
+ if (colon + 1 >= line.length()) {
+ fields = new String[0];
+ } else {
+ fields = line.substring(colon + 1).trim().split("\\s+");
+ }
+ parser.parse(l, file, line, fields, global);
} catch (IllegalArgumentException iae) {
throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
}
+ } else {
+ throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
}
}
@@ -1260,33 +1268,6 @@ public class DumpReplayer {
}
- /** {@inheritDoc} */
- @Override
- public double getLine(final AbsoluteDate date) {
-
- if (datation.size() < 2) {
- return datation.get(0).getFirst();
- }
-
- // find entries bracketing the date
- int sup = 0;
- while (sup < datation.size() - 1) {
- if (datation.get(sup).getSecond().compareTo(date) >= 0) {
- break;
- }
- ++sup;
- }
- final int inf = (sup == 0) ? sup++ : (sup - 1);
-
- final double lInf = datation.get(inf).getFirst();
- final AbsoluteDate dInf = datation.get(inf).getSecond();
- final double lSup = datation.get(sup).getFirst();
- final AbsoluteDate dSup = datation.get(sup).getSecond();
- final double alpha = date.durationFrom(dInf) / dSup.durationFrom(dInf);
- return alpha * lSup + (1 - alpha) * lInf;
-
- }
-
/** Set a rate.
* @param lineNumber line number
* @param rate lines rate
diff --git a/src/main/java/org/orekit/rugged/errors/RuggedException.java b/src/main/java/org/orekit/rugged/errors/RuggedException.java
index dadc358e76064e0bdd6db96f11df7afba3954ee9..7bb5d728cfc6d5226990640010a2188b46ef047e 100644
--- a/src/main/java/org/orekit/rugged/errors/RuggedException.java
+++ b/src/main/java/org/orekit/rugged/errors/RuggedException.java
@@ -16,13 +16,12 @@
*/
package org.orekit.rugged.errors;
-import org.hipparchus.exception.Localizable;
-import org.hipparchus.exception.LocalizedException;
-import org.hipparchus.exception.MathRuntimeException;
-
import java.text.MessageFormat;
import java.util.Locale;
+import org.hipparchus.exception.Localizable;
+import org.hipparchus.exception.LocalizedException;
+
/** This class is the base class for all specific exceptions thrown by
* the rugged library classes.
@@ -57,26 +56,6 @@ public class RuggedException extends Exception implements LocalizedException {
this.parts = (parts == null) ? new Object[0] : parts.clone();
}
- /** Copy constructor.
- * @param exception exception to copy from
- */
- public RuggedException(final RuggedException exception) {
- super(exception);
- this.specifier = exception.specifier;
- this.parts = exception.parts.clone();
- }
-
- /** Simple constructor.
- * Build an exception from a cause and with a specified message
- * @param message descriptive message
- * @param cause underlying cause
- */
- public RuggedException(final Localizable message, final Throwable cause) {
- super(cause);
- this.specifier = message;
- this.parts = new Object[0];
- }
-
/** Simple constructor.
* Build an exception from a cause and with a translated and formatted message
* @param cause underlying cause
@@ -90,16 +69,6 @@ public class RuggedException extends Exception implements LocalizedException {
this.parts = (parts == null) ? new Object[0] : parts.clone();
}
- /** Simple constructor.
- * Build an exception from an Hipparchus exception
- * @param exception underlying Hipparchus exception
- */
- public RuggedException(final MathRuntimeException exception) {
- super(exception);
- this.specifier = exception.getSpecifier();
- this.parts = exception.getParts();
- }
-
/** {@inheritDoc} */
@Override
public String getMessage(final Locale locale) {
diff --git a/src/test/java/org/orekit/rugged/api/RuggedBuilderTest.java b/src/test/java/org/orekit/rugged/api/RuggedBuilderTest.java
index 758987401d2bcf1e0972c2342a2692a1cc4cb5dd..3f0e9bebdf1032cfa7b65e90bf8b1c052ace7af5 100644
--- a/src/test/java/org/orekit/rugged/api/RuggedBuilderTest.java
+++ b/src/test/java/org/orekit/rugged/api/RuggedBuilderTest.java
@@ -154,26 +154,126 @@ public class RuggedBuilderTest {
RuggedBuilder builder = new RuggedBuilder().
setDigitalElevationModel(updater, 8).
setAlgorithm(AlgorithmId.DUVENHAGE).
- setEllipsoid(EllipsoidId.GRS80, BodyRotatingFrameId.ITRF).
- setTimeSpan(pv.get(0).getDate(), pv.get(pv.size() - 1).getDate(), 0.001, 5.0).
- setTrajectory(InertialFrameId.EME2000,
- pv, 8, CartesianDerivativesFilter.USE_PV,
- q, 8, AngularDerivativesFilter.USE_R);
+ setTimeSpan(pv.get(0).getDate(), pv.get(pv.size() - 1).getDate(), 0.001, 5.0);
+ try {
+ builder.build();
+ Assert.fail("an exception should have been thrown");
+ } catch (RuggedException re) {
+ Assert.assertEquals(RuggedMessages.UNINITIALIZED_CONTEXT, re.getSpecifier());
+ Assert.assertEquals("RuggedBuilder.setEllipsoid()", re.getParts()[0]);
+ }
+ builder.setEllipsoid(EllipsoidId.GRS80, BodyRotatingFrameId.ITRF);
+ try {
+ builder.build();
+ Assert.fail("an exception should have been thrown");
+ } catch (RuggedException re) {
+ Assert.assertEquals(RuggedMessages.UNINITIALIZED_CONTEXT, re.getSpecifier());
+ Assert.assertEquals("RuggedBuilder.setTrajectory()", re.getParts()[0]);
+ }
+ builder.setTrajectory(InertialFrameId.EME2000,
+ pv, 8, CartesianDerivativesFilter.USE_PV,
+ q, 8, AngularDerivativesFilter.USE_R);
+ Assert.assertSame(FramesFactory.getEME2000(), builder.getInertialFrame());
// light time correction and aberration of light correction are enabled by default
Rugged rugged = builder.build();
Assert.assertTrue(rugged.isLightTimeCorrected());
Assert.assertTrue(rugged.isAberrationOfLightCorrected());
+ Assert.assertTrue(builder.getLightTimeCorrection());
+ Assert.assertTrue(builder.getAberrationOfLightCorrection());
builder.setLightTimeCorrection(false);
rugged = builder.build();
Assert.assertFalse(rugged.isLightTimeCorrected());
Assert.assertTrue(rugged.isAberrationOfLightCorrected());
+ Assert.assertFalse(builder.getLightTimeCorrection());
+ Assert.assertTrue(builder.getAberrationOfLightCorrection());
builder.setAberrationOfLightCorrection(false);
rugged = builder.build();
Assert.assertFalse(rugged.isLightTimeCorrected());
Assert.assertFalse(rugged.isAberrationOfLightCorrected());
+ Assert.assertFalse(builder.getLightTimeCorrection());
+ Assert.assertFalse(builder.getAberrationOfLightCorrection());
+
+ Assert.assertEquals(AlgorithmId.DUVENHAGE, builder.getAlgorithm());
+ Assert.assertEquals(6378137.0, builder.getEllipsoid().getEquatorialRadius(), 1.0e-9);
+ Assert.assertEquals(1.0 / 298.257222101, builder.getEllipsoid().getFlattening(), 1.0e-10);
+ Assert.assertSame(updater, builder.getTileUpdater());
+ Assert.assertEquals(8, builder.getMaxCachedTiles());
+ Assert.assertTrue(Double.isNaN(builder.getConstantElevation()));
+ Assert.assertEquals(pv.get(0).getDate(), builder.getMinDate());
+ Assert.assertEquals(pv.get(pv.size() - 1).getDate(), builder.getMaxDate());
+ Assert.assertEquals(0.001, builder.getTStep(), 1.0e-10);
+ Assert.assertEquals(5.0, builder.getOvershootTolerance(), 1.0e-10);
+ Assert.assertSame(FramesFactory.getEME2000(), builder.getInertialFrame());
+ Assert.assertSame(pv, builder.getPositionsVelocities());
+ Assert.assertEquals(8, builder.getPVInterpolationNumber());
+ Assert.assertEquals(CartesianDerivativesFilter.USE_PV, builder.getPVFilter());
+ Assert.assertSame(q, builder.getQuaternions());
+ Assert.assertEquals(8, builder.getAInterpolationNumber());
+ Assert.assertEquals(AngularDerivativesFilter.USE_R, builder.getAFilter());
+
+ Assert.assertTrue(builder.getLineSensors().isEmpty());
+ LineSensor lineSensor = new LineSensor("line", new LinearLineDatation(t0, 2000 / 2, 1.0 / 1.5e-3),
+ Vector3D.ZERO,
+ createLOSPerfectLine(Vector3D.PLUS_K,
+ Vector3D.PLUS_I, FastMath.toRadians(1.0), 2000));
+ builder.addLineSensor(lineSensor);
+ Assert.assertEquals(1, builder.getLineSensors().size());
+ Assert.assertSame(lineSensor, builder.getLineSensors().get(0));
+ builder.clearLineSensors();
+ Assert.assertTrue(builder.getLineSensors().isEmpty());
+
+ builder.setTrajectory(InertialFrameId.GCRF,
+ pv, 8, CartesianDerivativesFilter.USE_PV,
+ q, 8, AngularDerivativesFilter.USE_R);
+ Assert.assertSame(FramesFactory.getGCRF(), builder.getInertialFrame());
+ builder.setTrajectory(InertialFrameId.MOD,
+ pv, 8, CartesianDerivativesFilter.USE_PV,
+ q, 8, AngularDerivativesFilter.USE_R);
+ Assert.assertSame(FramesFactory.getMOD(IERSConventions.IERS_1996), builder.getInertialFrame());
+ builder.setTrajectory(InertialFrameId.TOD,
+ pv, 8, CartesianDerivativesFilter.USE_PV,
+ q, 8, AngularDerivativesFilter.USE_R);
+ Assert.assertSame(FramesFactory.getTOD(IERSConventions.IERS_1996, true), builder.getInertialFrame());
+ builder.setTrajectory(InertialFrameId.VEIS1950,
+ pv, 8, CartesianDerivativesFilter.USE_PV,
+ q, 8, AngularDerivativesFilter.USE_R);
+ Assert.assertSame(FramesFactory.getVeis1950(), builder.getInertialFrame());
+
+ builder.setAlgorithm(null);
+ try {
+ builder.build();
+ Assert.fail("an exception should have been thrown");
+ } catch (RuggedException re) {
+ Assert.assertEquals(RuggedMessages.UNINITIALIZED_CONTEXT, re.getSpecifier());
+ Assert.assertEquals("RuggedBuilder.setAlgorithmID()", re.getParts()[0]);
+ }
+
+ builder.setAlgorithm(AlgorithmId.CONSTANT_ELEVATION_OVER_ELLIPSOID);
+ builder.setConstantElevation(Double.NaN);
+ try {
+ builder.build();
+ Assert.fail("an exception should have been thrown");
+ } catch (RuggedException re) {
+ Assert.assertEquals(RuggedMessages.UNINITIALIZED_CONTEXT, re.getSpecifier());
+ Assert.assertEquals("RuggedBuilder.setConstantElevation()", re.getParts()[0]);
+ }
+ builder.setConstantElevation(100.0);
+ Assert.assertNotNull(builder.build());
+
+ builder.setAlgorithm(AlgorithmId.BASIC_SLOW_EXHAUSTIVE_SCAN_FOR_TESTS_ONLY);
+ builder.setDigitalElevationModel(null, 8);
+ try {
+ builder.build();
+ Assert.fail("an exception should have been thrown");
+ } catch (RuggedException re) {
+ Assert.assertEquals(RuggedMessages.UNINITIALIZED_CONTEXT, re.getSpecifier());
+ Assert.assertEquals("RuggedBuilder.setDigitalElevationModel()", re.getParts()[0]);
+ }
+ builder.setDigitalElevationModel(updater, 8);
+ Assert.assertNotNull(builder.build());
}
diff --git a/src/test/java/org/orekit/rugged/errors/DumpManagerTest.java b/src/test/java/org/orekit/rugged/errors/DumpManagerTest.java
index 98774339b1fd3d61a8fc371238103633a7dae9ff..f431a7483812de1822098b9ec92bca1414411ea6 100644
--- a/src/test/java/org/orekit/rugged/errors/DumpManagerTest.java
+++ b/src/test/java/org/orekit/rugged/errors/DumpManagerTest.java
@@ -17,16 +17,16 @@
package org.orekit.rugged.errors;
-import org.hipparchus.geometry.euclidean.threed.Rotation;
-import org.hipparchus.geometry.euclidean.threed.RotationConvention;
-import org.hipparchus.geometry.euclidean.threed.Vector3D;
-import org.hipparchus.util.FastMath;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.net.URISyntaxException;
+import org.hipparchus.geometry.euclidean.threed.Rotation;
+import org.hipparchus.geometry.euclidean.threed.RotationConvention;
+import org.hipparchus.geometry.euclidean.threed.Vector3D;
+import org.hipparchus.util.FastMath;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
@@ -47,6 +47,7 @@ import org.orekit.rugged.api.RuggedBuilder;
import org.orekit.rugged.linesensor.LineDatation;
import org.orekit.rugged.linesensor.LineSensor;
import org.orekit.rugged.linesensor.LinearLineDatation;
+import org.orekit.rugged.linesensor.SensorPixel;
import org.orekit.rugged.los.TimeDependentLOS;
import org.orekit.rugged.raster.RandomLandscapeUpdater;
import org.orekit.rugged.raster.TileUpdater;
@@ -66,71 +67,85 @@ public class DumpManagerTest {
File dump = tempFolder.newFile();
DumpManager.activate(dump);
- locationsinglePoint();
+ variousRuggedCalls();
DumpManager.deactivate();
- int countAlgorithm = 0;
- int countEllipsoid = 0;
- int countSpan = 0;
- int countTransform = 0;
- int countDEMTile = 0;
- int countDEMCell = 0;
- int countDirectLoc = 0;
- int countDirectLocResult = 0;
- int countSensor = 0;
- int countSensorLOS = 0;
- int countSensorDatation = 0;
- int countSensorRate = 0;
- BufferedReader br = new BufferedReader(new FileReader(dump));
- for (String line = br.readLine(); line != null; line = br.readLine()) {
- String trimmed = line.trim();
- if (trimmed.length() > 0 && !trimmed.startsWith("#")){
- if (trimmed.startsWith("algorithm:")) {
- ++countAlgorithm;
- } else if (trimmed.startsWith("ellipsoid:")) {
- ++countEllipsoid;
- } else if (trimmed.startsWith("span:")) {
- ++countSpan;
- } else if (trimmed.startsWith("transform:")) {
- ++countTransform;
- } else if (trimmed.startsWith("DEM tile:")) {
- ++countDEMTile;
- } else if (trimmed.startsWith("DEM cell:")) {
- ++countDEMCell;
- } else if (trimmed.startsWith("direct location:")) {
- ++countDirectLoc;
- } else if (trimmed.startsWith("direct location result:")) {
- ++countDirectLocResult;
- } else if (trimmed.startsWith("sensor:")) {
- ++countSensor;
- } else if (trimmed.startsWith("sensor datation:")) {
- ++countSensorDatation;
- } else if (trimmed.startsWith("sensor LOS:")) {
- ++countSensorLOS;
- } else if (trimmed.startsWith("sensor rate:")) {
- ++countSensorRate;
- } else {
- Assert.fail(line);
+ int countAlgorithm = 0;
+ int countEllipsoid = 0;
+ int countDirectLoc = 0;
+ int countDirectLocResult = 0;
+ int countSpan = 0;
+ int countTransform = 0;
+ int countDEMTile = 0;
+ int countDEMCell = 0;
+ int countInverseLoc = 0;
+ int countInverseLocResult = 0;
+ int countSensor = 0;
+ int countSensorMeanPlane = 0;
+ int countSensorLOS = 0;
+ int countSensorDatation = 0;
+ int countSensorRate = 0;
+ try (final FileReader fr = new FileReader(dump);
+ final BufferedReader br = new BufferedReader(fr)) {
+ for (String line = br.readLine(); line != null; line = br.readLine()) {
+ String trimmed = line.trim();
+ if (trimmed.length() > 0 && !trimmed.startsWith("#")){
+ if (trimmed.startsWith("algorithm:")) {
+ ++countAlgorithm;
+ } else if (trimmed.startsWith("ellipsoid:")) {
+ ++countEllipsoid;
+ } else if (trimmed.startsWith("direct location:")) {
+ ++countDirectLoc;
+ } else if (trimmed.startsWith("direct location result:")) {
+ ++countDirectLocResult;
+ } else if (trimmed.startsWith("span:")) {
+ ++countSpan;
+ } else if (trimmed.startsWith("transform:")) {
+ ++countTransform;
+ } else if (trimmed.startsWith("DEM tile:")) {
+ ++countDEMTile;
+ } else if (trimmed.startsWith("DEM cell:")) {
+ ++countDEMCell;
+ } else if (trimmed.startsWith("inverse location:")) {
+ ++countInverseLoc;
+ } else if (trimmed.startsWith("inverse location result:")) {
+ ++countInverseLocResult;
+ } else if (trimmed.startsWith("sensor:")) {
+ ++countSensor;
+ } else if (trimmed.startsWith("sensor mean plane:")) {
+ ++countSensorMeanPlane;
+ } else if (trimmed.startsWith("sensor LOS:")) {
+ ++countSensorLOS;
+ } else if (trimmed.startsWith("sensor datation:")) {
+ ++countSensorDatation;
+ } else if (trimmed.startsWith("sensor rate:")) {
+ ++countSensorRate;
+ } else {
+ Assert.fail(line);
+ }
}
}
}
- br.close();
+
Assert.assertEquals(1, countAlgorithm);
Assert.assertEquals(1, countEllipsoid);
+ Assert.assertEquals(400, countDirectLoc);
+ Assert.assertEquals(400, countDirectLocResult);
Assert.assertEquals(1, countSpan);
- Assert.assertEquals(1, countTransform);
+ Assert.assertEquals(2, countTransform);
Assert.assertEquals(2, countDEMTile);
Assert.assertEquals(812, countDEMCell);
- Assert.assertEquals(400, countDirectLoc);
- Assert.assertEquals(400, countDirectLocResult);
+ Assert.assertEquals(5, countInverseLoc);
+ Assert.assertEquals(5, countInverseLocResult);
Assert.assertEquals(1, countSensor);
- Assert.assertEquals(200, countSensorLOS);
- Assert.assertEquals(3, countSensorDatation);
- Assert.assertEquals(0, countSensorRate);
+ Assert.assertEquals(1, countSensorMeanPlane);
+ Assert.assertEquals(422, countSensorLOS);
+ Assert.assertEquals(19, countSensorDatation);
+ Assert.assertEquals(6, countSensorRate);
}
- public void locationsinglePoint()
+ public void variousRuggedCalls()
throws RuggedException, OrekitException, URISyntaxException {
int dimension = 200;
@@ -183,8 +198,50 @@ public class DumpManagerTest {
Assert.assertEquals(gpLine[i].getLatitude(), gpPixel.getLatitude(), 1.0e-10);
Assert.assertEquals(gpLine[i].getLongitude(), gpPixel.getLongitude(), 1.0e-10);
Assert.assertEquals(gpLine[i].getAltitude(), gpPixel.getAltitude(), 1.0e-10);
+
+ if (i % 45 == 0) {
+ SensorPixel sp = rugged.inverseLocation(lineSensor.getName(), gpPixel, 0, 179);
+ Assert.assertEquals(100, sp.getLineNumber(), 1.0e-5);
+ Assert.assertEquals(i, sp.getPixelNumber(), 6.0e-9);
+ }
}
}
+ @Test
+ public void testAlreadyActive() throws URISyntaxException, IOException, OrekitException, RuggedException {
+
+ DumpManager.activate(tempFolder.newFile());
+ try {
+ DumpManager.activate(tempFolder.newFile());
+ Assert.fail("an exception should have been thrown");
+ } catch (RuggedException re) {
+ Assert.assertEquals(RuggedMessages.DEBUG_DUMP_ALREADY_ACTIVE, re.getSpecifier());
+ } finally {
+ DumpManager.deactivate();
+ }
+ }
+
+ @Test
+ public void testNotActive() throws URISyntaxException, IOException, OrekitException, RuggedException {
+ try {
+ DumpManager.deactivate();
+ Assert.fail("an exception should have been thrown");
+ } catch (RuggedException re) {
+ Assert.assertEquals(RuggedMessages.DEBUG_DUMP_NOT_ACTIVE, re.getSpecifier());
+ }
+ }
+
+ @Test
+ public void testWriteError() throws URISyntaxException, IOException, OrekitException, RuggedException {
+ try {
+ File dump = tempFolder.newFile();
+ dump.setReadOnly();
+ DumpManager.activate(dump);
+ Assert.fail("an exception should have been thrown");
+ } catch (RuggedException re) {
+ Assert.assertEquals(RuggedMessages.DEBUG_DUMP_ACTIVATION_ERROR, re.getSpecifier());
+ }
+ }
+
}
diff --git a/src/test/java/org/orekit/rugged/errors/DumpReplayerTest.java b/src/test/java/org/orekit/rugged/errors/DumpReplayerTest.java
index 5258ed15c7b00b9245a9a5e64fc4cb07fe4485a5..426e84b9fa558bbf4db49bc20e4c7622a3d070f8 100644
--- a/src/test/java/org/orekit/rugged/errors/DumpReplayerTest.java
+++ b/src/test/java/org/orekit/rugged/errors/DumpReplayerTest.java
@@ -17,13 +17,20 @@
package org.orekit.rugged.errors;
-import org.hipparchus.geometry.euclidean.threed.Vector3D;
+import java.io.BufferedReader;
import java.io.File;
+import java.io.FileReader;
import java.io.IOException;
+import java.io.PrintWriter;
import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.List;
+import org.hipparchus.geometry.euclidean.threed.Vector3D;
import org.junit.Assert;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
import org.orekit.bodies.GeodeticPoint;
import org.orekit.data.DataProvidersManager;
import org.orekit.data.DirectoryCrawler;
@@ -33,6 +40,9 @@ import org.orekit.rugged.linesensor.SensorPixel;
public class DumpReplayerTest {
+ @Rule
+ public TemporaryFolder tempFolder = new TemporaryFolder();
+
@Test
public void testDirectLoc01() throws URISyntaxException, IOException, OrekitException, RuggedException {
@@ -102,6 +112,37 @@ public class DumpReplayerTest {
}
+ @Test
+ public void testDirectLoc04() throws URISyntaxException, IOException, OrekitException, RuggedException {
+
+ String orekitPath = getClass().getClassLoader().getResource("orekit-data").toURI().getPath();
+ DataProvidersManager.getInstance().addProvider(new DirectoryCrawler(new File(orekitPath)));
+
+ String dumpPath = getClass().getClassLoader().getResource("replay/replay-direct-loc-04.txt").toURI().getPath();
+ File dump = tempFolder.newFile();
+ DumpManager.activate(dump);
+ DumpReplayer replayer = new DumpReplayer();
+ replayer.parse(new File(dumpPath));
+ Rugged rugged = replayer.createRugged();
+ DumpReplayer.Result[] results = replayer.execute(rugged);
+ DumpManager.deactivate();
+
+ Assert.assertEquals(3, results.length);
+ for (final DumpReplayer.Result result : results) {
+ GeodeticPoint expectedGP = (GeodeticPoint) result.getExpected();
+ GeodeticPoint replayedGP = (GeodeticPoint) result.getReplayed();
+ double distance = Vector3D.distance(rugged.getEllipsoid().transform(expectedGP),
+ rugged.getEllipsoid().transform(replayedGP));
+ Assert.assertEquals(0.0, distance, 1.0e-8);
+ }
+
+ try (FileReader fr = new FileReader(dump);
+ BufferedReader br = new BufferedReader(fr)) {
+ Assert.assertEquals(12, br.lines().count());
+ }
+
+ }
+
@Test
public void testInverseLoc01() throws URISyntaxException, IOException, OrekitException, RuggedException {
@@ -168,4 +209,54 @@ public class DumpReplayerTest {
}
+ @Test
+ public void testCorruptedFiles() throws URISyntaxException, IOException, OrekitException, RuggedException {
+
+ String orekitPath = getClass().getClassLoader().getResource("orekit-data").toURI().getPath();
+ DataProvidersManager.getInstance().addProvider(new DirectoryCrawler(new File(orekitPath)));
+
+ File folder = new File(getClass().getClassLoader().getResource("replay/replay-direct-loc-01.txt").toURI().getPath()).getParentFile();
+ for (final File file : folder.listFiles()) {
+
+ // split all data lines into fields
+ final List<String[]> lines = new ArrayList<>();
+ try (FileReader fr = new FileReader(file);
+ BufferedReader br = new BufferedReader(fr)) {
+ br.lines().
+ filter(line -> {
+ String trimmed = line.trim();
+ return trimmed.length() > 0 && !trimmed.startsWith("#");
+ }).
+ forEach(line -> lines.add(line.split("\\s+")));
+ }
+
+ // for each field of each line, delete the field and check parsing fails
+ for (int i = 0; i < lines.size(); ++i) {
+ for (int j = 0; j < lines.get(i).length; ++j) {
+ File corrupted = tempFolder.newFile();
+ try (PrintWriter pw = new PrintWriter(corrupted)) {
+ for (int k = 0; k < lines.size(); ++k) {
+ for (int l = 0; l < lines.get(k).length; ++l) {
+ if (k != i || l != j) {
+ pw.print(' ');
+ pw.print(lines.get(k)[l]);
+ }
+ }
+ pw.println();
+ }
+ }
+ try {
+ new DumpReplayer().parse(corrupted);
+ Assert.fail("an exception should have been thrown");
+ } catch (RuggedException re) {
+ Assert.assertEquals(RuggedMessages.CANNOT_PARSE_LINE, re.getSpecifier());
+ Assert.assertEquals(i + 1, ((Integer) re.getParts()[0]).intValue());
+ Assert.assertEquals(corrupted, re.getParts()[1]);
+ }
+ }
+ }
+ }
+
+ }
+
}
diff --git a/src/test/java/org/orekit/rugged/errors/RuggedExceptionTest.java b/src/test/java/org/orekit/rugged/errors/RuggedExceptionTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4bfc24cadc5e9c0b73ec15f2f324a32dc2585949
--- /dev/null
+++ b/src/test/java/org/orekit/rugged/errors/RuggedExceptionTest.java
@@ -0,0 +1,72 @@
+/* Copyright 2013-2016 CS Systèmes d'Information
+ * Licensed to CS Systèmes d'Information (CS) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * CS licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.orekit.rugged.errors;
+
+
+import java.util.Locale;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class RuggedExceptionTest {
+
+ @Test
+ public void testTranslation() {
+ RuggedException re = new RuggedException(RuggedMessages.DUPLICATED_PARAMETER_NAME, "dummy");
+ Assert.assertFalse(re.getMessage(Locale.FRENCH).contains("parameter"));
+ Assert.assertTrue(re.getMessage(Locale.FRENCH).contains("paramètre"));
+ Assert.assertTrue(re.getMessage(Locale.FRENCH).contains("dummy"));
+ Assert.assertTrue(re.getMessage(Locale.US).contains("parameter"));
+ Assert.assertFalse(re.getMessage(Locale.US).contains("paramètre"));
+ Assert.assertTrue(re.getMessage(Locale.US).contains("dummy"));
+ Assert.assertEquals(re.getMessage(), re.getMessage(Locale.US));
+ }
+
+ @Test
+ public void testParameters() {
+ RuggedException re = new RuggedException(RuggedMessages.DUPLICATED_PARAMETER_NAME, "dummy");
+ Assert.assertEquals(RuggedMessages.DUPLICATED_PARAMETER_NAME, re.getSpecifier());
+ Assert.assertEquals("dummy", re.getParts()[0]);
+ }
+
+ @Test
+ public void testNullSpecifier() {
+ RuggedException re = new RuggedException(null, (Object[]) null);
+ Assert.assertEquals("", re.getMessage());
+ }
+
+ @Test
+ public void testNullParts() {
+ RuggedException re1 = new RuggedException(RuggedMessages.NO_PARAMETERS_SELECTED, (Object[]) null);
+ Assert.assertEquals(RuggedMessages.NO_PARAMETERS_SELECTED, re1.getSpecifier());
+ Assert.assertEquals(0, re1.getParts().length);
+ RuggedException re2 = new RuggedException(new RuntimeException(),
+ RuggedMessages.NO_PARAMETERS_SELECTED, (Object[]) null);
+ Assert.assertEquals(RuggedMessages.NO_PARAMETERS_SELECTED, re2.getSpecifier());
+ Assert.assertEquals(0, re2.getParts().length);
+ }
+
+ @Test
+ public void testInternalError() {
+ RuggedException re = new RuggedException(RuggedMessages.DUPLICATED_PARAMETER_NAME, "dummy");
+ RuntimeException rte = RuggedException.createInternalError(re);
+ Assert.assertFalse(re.getLocalizedMessage().contains("rugged-developers@orekit.org"));
+ Assert.assertTrue(rte.getLocalizedMessage().contains("rugged-developers@orekit.org"));
+ Assert.assertTrue(rte.getMessage().contains("rugged-developers@orekit.org"));
+ }
+
+}
diff --git a/src/test/java/org/orekit/rugged/errors/RuggedMessagesTest.java b/src/test/java/org/orekit/rugged/errors/RuggedMessagesTest.java
index 0dd7a08111f024d3f8f68b945cef6c343ec742fb..ed059b2efad41c430482e7e8cd546b84b3e87eac 100644
--- a/src/test/java/org/orekit/rugged/errors/RuggedMessagesTest.java
+++ b/src/test/java/org/orekit/rugged/errors/RuggedMessagesTest.java
@@ -88,6 +88,14 @@ public class RuggedMessagesTest {
}
}
+ @Test
+ public void testMissingLanguageFallback() {
+ for (RuggedMessages message : RuggedMessages.values()) {
+ String translated = message.getLocalizedString(Locale.TRADITIONAL_CHINESE);
+ Assert.assertEquals(message.getSourceString(), translated);
+ }
+ }
+
@Test
public void testVariablePartsConsistency() {
for (final String language : new String[] { "de", "en", "es", "fr", "gl", "it", "no", "ro" } ) {
diff --git a/src/test/resources/replay/replay-direct-loc-04.txt b/src/test/resources/replay/replay-direct-loc-04.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c0f72295b154107887802b1190c2c0558d78df94
--- /dev/null
+++ b/src/test/resources/replay/replay-direct-loc-04.txt
@@ -0,0 +1,17 @@
+# Rugged library dump file, created on 2016-08-25T11:36:58Z
+# all units are SI units (m, m/s, rad ...)
+sensor: sensorName s0 nbPixels 200 position 1.500000000000000e+00 0.000000000000000e+00 -2.000000000000000e-01
+sensor datation: sensorName s0 lineNumber 1.000000000000000e+02 date 2012-01-01T12:30:00.00000000000000Z
+sensor LOS: sensorName s0 date 2012-01-01T12:30:00.00000000000000Z pixelNumber 0 los 0.000000000000000e+00 -7.547095802227720e-01 6.560590289905073e-01
+direct location: date 2012-01-01T12:30:00.00000000000000Z position 1.500000000000000e+00 0.000000000000000e+00 -2.000000000000000e-01 los 0.000000000000000e+00 -7.547095802227720e-01 6.560590289905073e-01 lightTime true aberration true
+span: minDate 2012-01-01T12:29:59.85000000000000Z maxDate 2012-01-01T12:30:00.15000000000000Z tStep 1.000000000000000e-03 tolerance 5.000000000000000e+00 inertialFrame EME2000
+transform: index 150 body r -8.085963389171905e-01 -3.465415132634738e-04 4.896468952577882e-04 -5.883634938068593e-01 Ω -8.740475539607400e-08 1.215132816692757e-09 -7.292109805268452e-05 ΩDot -1.641702845856317e-16 8.967282378770661e-17 1.982686818602039e-19 spacecraft p 1.384771423699730e+04 3.157872644810937e+03 -7.179504513218164e+06 v -3.193269795630194e+01 -8.025701643721955e+00 8.276060585691415e+00 a -9.306383564355984e-01 -8.320024052654388e+00 1.352798609222994e-03 r -6.828948932119083e-01 4.142451147050121e-01 -3.878489669751732e-01 4.600312256623658e-01 Ω -1.009835943938631e-03 1.982939067387613e-04 1.645926841490188e-04 ΩDot -3.647402648477413e-07 2.008713174452711e-07 -1.257148546282535e-06
+ellipsoid: ae 6.378137000000000e+06 f 3.352810664747481e-03 frame ITRF_CIO_CONV_2010_SIMPLE_EOP
+algorithm: CONSTANT_ELEVATION_OVER_ELLIPSOID elevation 1.000000000000000e+02
+direct location result: latitude -3.947439031048142e-01 longitude 2.499247813392400e+00 elevation 1.000000008142965e+02
+sensor LOS: sensorName s0 date 2012-01-01T12:30:00.00000000000000Z pixelNumber 1 los 0.000000000000000e+00 -7.548246479094037e-01 6.559266353095021e-01
+direct location: date 2012-01-01T12:30:00.00000000000000Z position 1.500000000000000e+00 0.000000000000000e+00 -2.000000000000000e-01 los 0.000000000000000e+00 -7.548246479094037e-01 6.559266353095021e-01 lightTime true aberration true
+direct location result: latitude -3.947552846081879e-01 longitude 2.499172490136166e+00 elevation 1.000000008170387e+02
+sensor LOS: sensorName s0 date 2012-01-01T12:30:00.00000000000000Z pixelNumber 2 los 0.000000000000000e+00 -7.549396923710934e-01 6.557942214465139e-01
+direct location: date 2012-01-01T12:30:00.00000000000000Z position 1.500000000000000e+00 0.000000000000000e+00 -2.000000000000000e-01 los 0.000000000000000e+00 -7.549396923710934e-01 6.557942214465139e-01 lightTime true aberration true
+direct location result: latitude -3.947666718219440e-01 longitude 2.499097114958829e+00 elevation 1.000000008196107e+02