001/* 002 * GeoAPI - Java interfaces for OGC/ISO standards 003 * http://www.geoapi.org 004 * 005 * Copyright (C) 2011-2019 Open Geospatial Consortium, Inc. 006 * All Rights Reserved. http://www.opengeospatial.org/ogc/legal 007 * 008 * Permission to use, copy, and modify this software and its documentation, with 009 * or without modification, for any purpose and without fee or royalty is hereby 010 * granted, provided that you include the following on ALL copies of the software 011 * and documentation or portions thereof, including modifications, that you make: 012 * 013 * 1. The full text of this NOTICE in a location viewable to users of the 014 * redistributed or derivative work. 015 * 2. Notice of any changes or modifications to the OGC files, including the 016 * date changes were made. 017 * 018 * THIS SOFTWARE AND DOCUMENTATION IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE 019 * NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED 020 * TO, WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT 021 * THE USE OF THE SOFTWARE OR DOCUMENTATION WILL NOT INFRINGE ANY THIRD PARTY 022 * PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS. 023 * 024 * COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR 025 * CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE OR DOCUMENTATION. 026 * 027 * The name and trademarks of copyright holders may NOT be used in advertising or 028 * publicity pertaining to the software without specific, written prior permission. 029 * Title to copyright in this software and any associated documentation will at all 030 * times remain with copyright holders. 031 */ 032package org.opengis.test.referencing.gigs; 033 034import java.util.List; 035import javax.measure.Unit; 036import javax.measure.quantity.Length; 037 038import org.opengis.util.Factory; 039import org.opengis.util.FactoryException; 040import org.opengis.referencing.datum.Ellipsoid; 041import org.opengis.referencing.datum.DatumFactory; 042import org.opengis.test.Configuration; 043 044import org.junit.Test; 045import org.junit.runner.RunWith; 046import org.junit.runners.Parameterized; 047 048import static org.junit.Assume.*; 049import static org.junit.Assert.*; 050 051 052/** 053 * Verifies that the software allows correct definition of a user-defined ellipsoid. 054 * 055 * <table class="gigs" summary="Test description"><tr> 056 * <th>Test method:</th> 057 * <td>Create user-defined ellipsoid for each of several different ellipsoids.</td> 058 * </tr><tr> 059 * <th>Test data:</th> 060 * <td><a href="doc-files/GIGS_3002_userEllipsoid.csv">{@code GIGS_3002_userEllipsoid.csv}</a>.</td> 061 * </tr><tr> 062 * <th>Tested API:</th> 063 * <td>{@link DatumFactory#createEllipsoid(Map, double, double, Unit)} and<br> 064 * {@link DatumFactory#createFlattenedSphere(Map, double, double, Unit)}.</td> 065 * </tr><tr> 066 * <th>Expected result:</th> 067 * <td>The software should accept the test data. The properties of the created objects will 068 * be compared with the properties given to the factory method.</td> 069 * </tr></table> 070 * 071 * 072 * <div class="note"><b>Usage example:</b> 073 * in order to specify their factories and run the tests in a JUnit framework, implementors can 074 * define a subclass in their own test suite as in the example below: 075 * 076 * <blockquote><pre>import org.junit.runner.RunWith; 077 *import org.junit.runners.JUnit4; 078 *import org.opengis.test.referencing.gigs.GIGS3002; 079 * 080 *@RunWith(JUnit4.class) 081 *public class MyTest extends GIGS3002 { 082 * public MyTest() { 083 * super(new MyDatumFactory()); 084 * } 085 *}</pre></blockquote> 086 * </div> 087 * 088 * @author GIGS (IOGP) 089 * @author Martin Desruisseaux (Geomatys) 090 * @author Alexis Manin (Geomatys) 091 * @version 3.1 092 * @since 3.1 093 */ 094@RunWith(Parameterized.class) 095public strictfp class GIGS3002 extends UserObjectFactoryTestCase<Ellipsoid> { 096 /** 097 * The ellipsoid semi-major axis length, in unit of {@link #axisUnit}. 098 */ 099 public double semiMajorAxis; 100 101 /** 102 * The ellipsoid semi-minor axis length, in unit of {@link #axisUnit}. 103 */ 104 public double semiMinorAxis; 105 106 /** 107 * The {@link #semiMajorAxis} and {@link #semiMinorAxis} unit of measurement. 108 */ 109 public Unit<Length> axisUnit; 110 111 /** 112 * The inverse flattening factor (dimensionless), 113 * or {@link Double#POSITIVE_INFINITY} if the ellipsoid is a sphere. 114 */ 115 public double inverseFlattening; 116 117 /** 118 * {@code false} if the second defining parameter is the {@link #semiMinorAxis} length, or 119 * {@code true} if it is the {@link #inverseFlattening}. 120 */ 121 public boolean isIvfDefinitive; 122 123 /** 124 * {@code true} if the ellipsoid is a sphere. In such case, {@link #semiMinorAxis} = {@link #semiMajorAxis} 125 * and {@link #inverseFlattening} is infinite. 126 */ 127 public boolean isSphere; 128 129 /** 130 * The ellipsoid created by the factory, 131 * or {@code null} if not yet created or if the ellipsoid creation failed. 132 * 133 * @see #datumFactory 134 */ 135 private Ellipsoid ellipsoid; 136 137 /** 138 * Factory to use for building {@link Ellipsoid} instances, or {@code null} if none. 139 * This is the factory used by the {@link #getIdentifiedObject()} method. 140 */ 141 protected final DatumFactory datumFactory; 142 143 /** 144 * Returns a default set of factories to use for running the tests. Those factories are given 145 * in arguments to the constructor when this test class is instantiated directly by JUnit (for 146 * example as a {@linkplain org.junit.runners.Suite.SuiteClasses suite} element), instead than 147 * subclassed by the implementor. The factories are fetched as documented in the 148 * {@link #factories(Class[])} javadoc. 149 * 150 * @return the default set of arguments to be given to the {@code GIGS3002} constructor. 151 */ 152 @Parameterized.Parameters 153 @SuppressWarnings("unchecked") 154 public static List<Factory[]> factories() { 155 return factories(DatumFactory.class); 156 } 157 158 /** 159 * Creates a new test using the given factory. If a given factory is {@code null}, 160 * then the tests which depend on it will be skipped. 161 * 162 * @param datumFactory factory for creating {@link Ellipsoid} instances. 163 */ 164 public GIGS3002(final DatumFactory datumFactory) { 165 super(datumFactory); 166 this.datumFactory = datumFactory; 167 } 168 169 /** 170 * Returns information about the configuration of the test which has been run. 171 * This method returns a map containing: 172 * 173 * <ul> 174 * <li>All the following values associated to the {@link org.opengis.test.Configuration.Key} of the same name: 175 * <ul> 176 * <li>{@link #isFactoryPreservingUserValues}</li> 177 * <li>{@linkplain #datumFactory}</li> 178 * </ul> 179 * </li> 180 * </ul> 181 * 182 * @return the configuration of the test being run. 183 */ 184 @Override 185 public Configuration configuration() { 186 final Configuration op = super.configuration(); 187 assertNull(op.put(Configuration.Key.datumFactory, datumFactory)); 188 return op; 189 } 190 191 /** 192 * Sets the ellipsoid instance to verify. This method is invoked only by other test classes which need to 193 * verify the ellipsoid contained in a geodetic datum instead than the ellipsoid immediately after creation. 194 */ 195 final void setIdentifiedObject(final Ellipsoid instance) { 196 ellipsoid = instance; 197 } 198 199 /** 200 * Returns the ellipsoid instance to be tested. When this method is invoked for the first time, 201 * it creates the ellipsoid to test by invoking the corresponding method from {@link DatumFactory} 202 * with the current {@link #properties properties} map in argument. 203 * The created object is then cached and returned in all subsequent invocations of this method. 204 * 205 * @return the ellipsoid instance to test. 206 * @throws FactoryException if an error occurred while creating the ellipsoid instance. 207 */ 208 @Override 209 public Ellipsoid getIdentifiedObject() throws FactoryException { 210 if (ellipsoid == null) { 211 assumeNotNull(datumFactory); 212 if (isIvfDefinitive) { 213 ellipsoid = datumFactory.createFlattenedSphere(properties, semiMajorAxis, inverseFlattening, axisUnit); 214 } else { 215 ellipsoid = datumFactory.createEllipsoid(properties, semiMajorAxis, semiMinorAxis, axisUnit); 216 } 217 } 218 return ellipsoid; 219 } 220 221 /** 222 * Verifies the properties of the ellipsoid given by {@link #getIdentifiedObject()}. 223 */ 224 final void verifyEllipsoid() throws FactoryException { 225 if (skipTests) { 226 return; 227 } 228 final String name = getName(); 229 final String code = getCode(); 230 final Ellipsoid ellipsoid = getIdentifiedObject(); 231 assertNotNull("Ellipsoid", ellipsoid); 232 validators.validate(ellipsoid); 233 234 verifyFlattenedSphere(ellipsoid, name, semiMajorAxis, inverseFlattening, axisUnit); 235 verifyIdentification(ellipsoid, name, code); 236 if (isFactoryPreservingUserValues) { 237 configurationTip = Configuration.Key.isFactoryPreservingUserValues; 238 assertEquals("Ellipsoid.getAxisUnit()", axisUnit, ellipsoid.getAxisUnit()); 239 assertEquals("Ellipsoid.getSemiMajorAxis()", semiMajorAxis, ellipsoid.getSemiMajorAxis(), TOLERANCE*semiMajorAxis); 240 assertEquals("Ellipsoid.getSemiMinorAxis()", semiMinorAxis, ellipsoid.getSemiMinorAxis(), TOLERANCE*semiMinorAxis); 241 assertEquals("Ellipsoid.getInverseFlattening()", inverseFlattening, ellipsoid.getInverseFlattening(), TOLERANCE*inverseFlattening); 242 assertEquals("Ellipsoid.isIvfDefinitive()", isIvfDefinitive, ellipsoid.isIvfDefinitive()); 243 assertEquals("Ellipsoid.isSphere()", isSphere, ellipsoid.isSphere()); 244 configurationTip = null; 245 } 246 } 247 248 /** 249 * Tests “GIGS ellipsoid A” flattened sphere creation from the factory. 250 * 251 * <ul> 252 * <li>GIGS ellipsoid code: <b>67030</b></li> 253 * <li>GIGS ellipsoid name: <b>GIGS ellipsoid A</b></li> 254 * <li>EPSG equivalence: <b>7030 – WGS 84</b></li> 255 * <li>Semi-major axis (<var>a</var>): <b>6378137.0 metres</b></li> 256 * <li>Semi-minor axis (<var>b</var>): <b>6356752.314247833 metres</b></li> 257 * <li>Inverse flattening (1/<var>f</var>): <b>298.2572236</b></li> 258 * <li>Specific usage / Remarks: <b>Defined using a and 1/f</b></li> 259 * </ul> 260 * 261 * @throws FactoryException if an error occurred while creating the ellipsoid from the properties. 262 * 263 * @see GIGS2002#testWGS84() 264 */ 265 @Test 266 public void testWGS84() throws FactoryException { 267 setCodeAndName(67030, "GIGS ellipsoid A"); 268 semiMajorAxis = 6378137.0; 269 semiMinorAxis = 6356752.314247833; 270 axisUnit = units.metre(); 271 inverseFlattening = 298.2572236; 272 isIvfDefinitive = true; 273 verifyEllipsoid(); 274 } 275 276 /** 277 * Tests “GIGS ellipsoid B” flattened sphere creation from the factory. 278 * 279 * <ul> 280 * <li>GIGS ellipsoid code: <b>67001</b></li> 281 * <li>GIGS ellipsoid name: <b>GIGS ellipsoid B</b></li> 282 * <li>EPSG equivalence: <b>7001 – Airy 1830</b></li> 283 * <li>Semi-major axis (<var>a</var>): <b>6377563.396 metres</b></li> 284 * <li>Semi-minor axis (<var>b</var>): <b>6356256.909237285 metres</b></li> 285 * <li>Inverse flattening (1/<var>f</var>): <b>299.3249646</b></li> 286 * <li>Specific usage / Remarks: <b>Defined using a and 1/f</b></li> 287 * </ul> 288 * 289 * @throws FactoryException if an error occurred while creating the ellipsoid from the properties. 290 * 291 * @see GIGS2002#testAiry() 292 */ 293 @Test 294 public void testAiry() throws FactoryException { 295 setCodeAndName(67001, "GIGS ellipsoid B"); 296 semiMajorAxis = 6377563.396; 297 semiMinorAxis = 6356256.909237285; 298 axisUnit = units.metre(); 299 inverseFlattening = 299.3249646; 300 isIvfDefinitive = true; 301 verifyEllipsoid(); 302 } 303 304 /** 305 * Tests “GIGS ellipsoid C” flattened sphere creation from the factory. 306 * 307 * <ul> 308 * <li>GIGS ellipsoid code: <b>67004</b></li> 309 * <li>GIGS ellipsoid name: <b>GIGS ellipsoid C</b></li> 310 * <li>EPSG equivalence: <b>7004 – Bessel 1841</b></li> 311 * <li>Semi-major axis (<var>a</var>): <b>6377397.155 metres</b></li> 312 * <li>Semi-minor axis (<var>b</var>): <b>6356078.962818189 metres</b></li> 313 * <li>Inverse flattening (1/<var>f</var>): <b>299.1528128</b></li> 314 * <li>Specific usage / Remarks: <b>Defined using a and 1/f</b></li> 315 * </ul> 316 * 317 * @throws FactoryException if an error occurred while creating the ellipsoid from the properties. 318 * 319 * @see GIGS2002#testBessel() 320 */ 321 @Test 322 public void testBessel() throws FactoryException { 323 setCodeAndName(67004, "GIGS ellipsoid C"); 324 semiMajorAxis = 6377397.155; 325 semiMinorAxis = 6356078.962818189; 326 axisUnit = units.metre(); 327 inverseFlattening = 299.1528128; 328 isIvfDefinitive = true; 329 verifyEllipsoid(); 330 } 331 332 /** 333 * Tests “GIGS ellipsoid E” flattened sphere creation from the factory. 334 * 335 * <ul> 336 * <li>GIGS ellipsoid code: <b>67022</b></li> 337 * <li>GIGS ellipsoid name: <b>GIGS ellipsoid E</b></li> 338 * <li>EPSG equivalence: <b>7022 – International 1924</b></li> 339 * <li>Semi-major axis (<var>a</var>): <b>6378388.0 metres</b></li> 340 * <li>Semi-minor axis (<var>b</var>): <b>6356911.9461279465 metres</b></li> 341 * <li>Inverse flattening (1/<var>f</var>): <b>297</b></li> 342 * <li>Specific usage / Remarks: <b>Defined using a and 1/f</b></li> 343 * </ul> 344 * 345 * @throws FactoryException if an error occurred while creating the ellipsoid from the properties. 346 * 347 * @see GIGS2002#testInternational1924() 348 */ 349 @Test 350 public void testInternational1924() throws FactoryException { 351 setCodeAndName(67022, "GIGS ellipsoid E"); 352 semiMajorAxis = 6378388.0; 353 semiMinorAxis = 6356911.9461279465; 354 axisUnit = units.metre(); 355 inverseFlattening = 297.0; 356 isIvfDefinitive = true; 357 verifyEllipsoid(); 358 } 359 360 /** 361 * Tests “GIGS ellipsoid F” flattened sphere creation from the factory. 362 * 363 * <ul> 364 * <li>GIGS ellipsoid code: <b>67019</b></li> 365 * <li>GIGS ellipsoid name: <b>GIGS ellipsoid F</b></li> 366 * <li>EPSG equivalence: <b>7019 – GRS 1980</b></li> 367 * <li>Semi-major axis (<var>a</var>): <b>6378.137 kilometres (6378137.0 metres)</b></li> 368 * <li>Semi-minor axis (<var>b</var>): <b>6356.7523141402835 kilometres (6356752.3141402835 metres)</b></li> 369 * <li>Inverse flattening (1/<var>f</var>): <b>298.2572221</b></li> 370 * <li>Specific usage / Remarks: <b>not metres</b></li> 371 * </ul> 372 * 373 * @throws FactoryException if an error occurred while creating the ellipsoid from the properties. 374 * 375 * @see GIGS2002#testGRS1980() 376 */ 377 @Test 378 public void testGRS1980() throws FactoryException { 379 setCodeAndName(67019, "GIGS ellipsoid F"); 380 semiMajorAxis = 6378.137; 381 semiMinorAxis = 6356.7523141402835; 382 axisUnit = units.kilometre(); 383 inverseFlattening = 298.2572221; 384 isIvfDefinitive = true; 385 verifyEllipsoid(); 386 } 387 388 /** 389 * Tests “GIGS ellipsoid H” ellipsoid creation from the factory. 390 * 391 * <ul> 392 * <li>GIGS ellipsoid code: <b>67011</b></li> 393 * <li>GIGS ellipsoid name: <b>GIGS ellipsoid H</b></li> 394 * <li>EPSG equivalence: <b>7011 – Clarke 1880 (IGN)</b></li> 395 * <li>Semi-major axis (<var>a</var>): <b>6378249.2 metres</b></li> 396 * <li>Semi-minor axis (<var>b</var>): <b>6356515.0 metres</b></li> 397 * <li>Inverse flattening (1/<var>f</var>): <b>293.4660212936269</b></li> 398 * <li>Specific usage / Remarks: <b>Defined using a and b. Calculated 1/f = 293.4660213</b></li> 399 * </ul> 400 * 401 * @throws FactoryException if an error occurred while creating the ellipsoid from the properties. 402 * 403 * @see GIGS2002#testClarkeIGN() 404 */ 405 @Test 406 public void testClarkeIGN() throws FactoryException { 407 setCodeAndName(67011, "GIGS ellipsoid H"); 408 semiMajorAxis = 6378249.2; 409 semiMinorAxis = 6356515.0; 410 axisUnit = units.metre(); 411 inverseFlattening = 293.4660212936269; 412 verifyEllipsoid(); 413 } 414 415 /** 416 * Tests “GIGS ellipsoid I” sphere creation from the factory. 417 * 418 * <ul> 419 * <li>GIGS ellipsoid code: <b>67052</b></li> 420 * <li>GIGS ellipsoid name: <b>GIGS ellipsoid I</b></li> 421 * <li>EPSG equivalence: <b>7052 – Clarke 1866 Authalic Sphere</b></li> 422 * <li>Semi-major axis (<var>a</var>): <b>6370997.0 metres</b></li> 423 * <li>Semi-minor axis (<var>b</var>): <b>6370997.0 metres</b></li> 424 * <li>Inverse flattening (1/<var>f</var>): <b>Infinity</b></li> 425 * <li>Specific usage / Remarks: <b>Sphere</b></li> 426 * </ul> 427 * 428 * @throws FactoryException if an error occurred while creating the ellipsoid from the properties. 429 * 430 * @see GIGS2002#testClarkeAuthalicSphere() 431 */ 432 @Test 433 public void testClarkeAuthalicSphere() throws FactoryException { 434 setCodeAndName(67052, "GIGS ellipsoid I"); 435 semiMajorAxis = 6370997.0; 436 semiMinorAxis = 6370997.0; 437 axisUnit = units.metre(); 438 inverseFlattening = Double.POSITIVE_INFINITY; 439 isSphere = true; 440 verifyEllipsoid(); 441 } 442 443 /** 444 * Tests “GIGS ellipsoid J” flattened sphere creation from the factory. 445 * 446 * <ul> 447 * <li>GIGS ellipsoid code: <b>67008</b></li> 448 * <li>GIGS ellipsoid name: <b>GIGS ellipsoid J</b></li> 449 * <li>EPSG equivalence: <b>7008 – Clarke 1866</b></li> 450 * <li>Semi-major axis (<var>a</var>): <b>20925832.16 US survey foot (6378206.4 metres)</b></li> 451 * <li>Semi-minor axis (<var>b</var>): <b>20854892.013176885 US survey foot (6356583.807100443 metres)</b></li> 452 * <li>Inverse flattening (1/<var>f</var>): <b>294.9786982</b></li> 453 * <li>Specific usage / Remarks: <b>not metres</b></li> 454 * </ul> 455 * 456 * @throws FactoryException if an error occurred while creating the ellipsoid from the properties. 457 * 458 * @see GIGS2002#testClarke1866() 459 */ 460 @Test 461 public void testClarke1866() throws FactoryException { 462 setCodeAndName(67008, "GIGS ellipsoid J"); 463 semiMajorAxis = 20925832.16; 464 semiMinorAxis = 20854892.013176885; 465 axisUnit = units.footSurveyUS(); 466 inverseFlattening = 294.9786982; 467 isIvfDefinitive = true; 468 verifyEllipsoid(); 469 } 470 471 /** 472 * Tests “GIGS ellipsoid K” flattened sphere creation from the factory. 473 * 474 * <ul> 475 * <li>GIGS ellipsoid code: <b>67036</b></li> 476 * <li>GIGS ellipsoid name: <b>GIGS ellipsoid K</b></li> 477 * <li>EPSG equivalence: <b>7036 – GRS 1967</b></li> 478 * <li>Semi-major axis (<var>a</var>): <b>6378160.0 metres</b></li> 479 * <li>Semi-minor axis (<var>b</var>): <b>6356774.516088779 metres</b></li> 480 * <li>Inverse flattening (1/<var>f</var>): <b>298.2471674</b></li> 481 * <li>Specific usage / Remarks: <b>Defined using a and 1/f</b></li> 482 * </ul> 483 * 484 * @throws FactoryException if an error occurred while creating the ellipsoid from the properties. 485 * 486 * @see GIGS2002#testGRS1967() 487 */ 488 @Test 489 public void testGRS1967() throws FactoryException { 490 setCodeAndName(67036, "GIGS ellipsoid K"); 491 semiMajorAxis = 6378160.0; 492 semiMinorAxis = 6356774.516088779; 493 axisUnit = units.metre(); 494 inverseFlattening = 298.2471674; 495 isIvfDefinitive = true; 496 verifyEllipsoid(); 497 } 498 499 /** 500 * Tests “GIGS ellipsoid X” flattened sphere creation from the factory. 501 * 502 * <ul> 503 * <li>GIGS ellipsoid code: <b>67003</b></li> 504 * <li>GIGS ellipsoid name: <b>GIGS ellipsoid X</b></li> 505 * <li>EPSG equivalence: <b>7003 – Australian National Spheroid</b></li> 506 * <li>Semi-major axis (<var>a</var>): <b>6378160.0 metres</b></li> 507 * <li>Semi-minor axis (<var>b</var>): <b>6356774.719195306 metres</b></li> 508 * <li>Inverse flattening (1/<var>f</var>): <b>298.25</b></li> 509 * <li>Specific usage / Remarks: <b>Defined using a and 1/f</b></li> 510 * </ul> 511 * 512 * @throws FactoryException if an error occurred while creating the ellipsoid from the properties. 513 * 514 * @see GIGS2002#testAustralianNationalSpheroid() 515 */ 516 @Test 517 public void testAustralianNationalSpheroid() throws FactoryException { 518 setCodeAndName(67003, "GIGS ellipsoid X"); 519 semiMajorAxis = 6378160.0; 520 semiMinorAxis = 6356774.719195306; 521 axisUnit = units.metre(); 522 inverseFlattening = 298.25; 523 isIvfDefinitive = true; 524 verifyEllipsoid(); 525 } 526 527 /** 528 * Tests “GIGS ellipsoid Y” flattened sphere creation from the factory. 529 * 530 * <ul> 531 * <li>GIGS ellipsoid code: <b>67024</b></li> 532 * <li>GIGS ellipsoid name: <b>GIGS ellipsoid Y</b></li> 533 * <li>EPSG equivalence: <b>7024 – Krassowsky 1940</b></li> 534 * <li>Semi-major axis (<var>a</var>): <b>6378245.0 metres</b></li> 535 * <li>Semi-minor axis (<var>b</var>): <b>6356863.018773047 metres</b></li> 536 * <li>Inverse flattening (1/<var>f</var>): <b>298.3</b></li> 537 * <li>Specific usage / Remarks: <b>Defined using a and 1/f</b></li> 538 * </ul> 539 * 540 * @throws FactoryException if an error occurred while creating the ellipsoid from the properties. 541 * 542 * @see GIGS2002#testKrassowsky() 543 */ 544 @Test 545 public void testKrassowsky() throws FactoryException { 546 setCodeAndName(67024, "GIGS ellipsoid Y"); 547 semiMajorAxis = 6378245.0; 548 semiMinorAxis = 6356863.018773047; 549 axisUnit = units.metre(); 550 inverseFlattening = 298.3; 551 isIvfDefinitive = true; 552 verifyEllipsoid(); 553 } 554}