Source code

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;
035
036import org.opengis.util.Factory;
037import org.opengis.util.FactoryException;
038import org.opengis.util.NoSuchIdentifierException;
039import org.opengis.referencing.crs.CRSAuthorityFactory;
040import org.opengis.referencing.crs.ProjectedCRS;
041import org.opengis.referencing.cs.AxisDirection;
042import org.opengis.referencing.cs.CartesianCS;
043import org.opengis.test.Configuration;
044import org.opengis.test.FactoryFilter;
045
046import org.junit.Test;
047import org.junit.runner.RunWith;
048import org.junit.runners.Parameterized;
049
050import static org.junit.Assume.*;
051import static org.opengis.test.Assert.*;
052
053
054/**
055 * Verifies reference projected CRSs bundled with the geoscience software.
056 *
057 * <table class="gigs" summary="Test description"><tr>
058 *   <th>Test method:</th>
059 *   <td>Compare projected CRS definitions included in the software against the EPSG Dataset.</td>
060 * </tr><tr>
061 *   <th>Test data:</th>
062 *   <td><a href="doc-files/GIGS_2006_libProjectedCRS.csv">{@code GIGS_2006_libProjectedCRS.csv}</a>
063 *       and EPSG Dataset.</td>
064 * </tr><tr>
065 *   <th>Tested API:</th>
066 *   <td>{@link CRSAuthorityFactory#createProjectedCRS(String)}.</td>
067 * </tr><tr>
068 *   <th>Expected result:</th>
069 *   <td>Projected CRS definitions bundled with the software should have the same name, coordinate system
070 *       (including units and axes abbreviations and axes order) and map projection as in the EPSG Dataset.
071 *       CRSs missing from the software or at variance with those in the EPSG Dataset should be reported.</td>
072 * </tr></table>
073 *
074 *
075 * <div class="note"><b>Usage example:</b>
076 * in order to specify their factories and run the tests in a JUnit framework, implementors can
077 * define a subclass in their own test suite as in the example below:
078 *
079 * <blockquote><pre>import org.junit.runner.RunWith;
080 *import org.junit.runners.JUnit4;
081 *import org.opengis.test.referencing.gigs.GIGS2006;
082 *
083 *&#64;RunWith(JUnit4.class)
084 *public class MyTest extends GIGS2006 {
085 *    public MyTest() {
086 *        super(new MyCRSAuthorityFactory());
087 *    }
088 *}</pre></blockquote>
089 * </div>
090 *
091 * @author  GIGS (IOGP)
092 * @author  Martin Desruisseaux (Geomatys)
093 * @author  Alexis Manin (Geomatys)
094 * @version 3.1
095 * @since   3.1
096 */
097@RunWith(Parameterized.class)
098public strictfp class GIGS2006 extends AuthorityFactoryTestCase<ProjectedCRS> {
099    /**
100     * The EPSG code of the expected datum.
101     */
102    public int datumCode;
103
104    /**
105     * The names of map projection (informative). Projected CRS conversion should have one of those names.
106     * However those names are approximate. For example the “Argentina zones” name may apply to a wide
107     * range of names like “Argentina zone 1”, “Argentina zone 2”, <i>etc</i>.
108     */
109    public String[] projectionNames;
110
111    /**
112     * {@code true} if the expected axis directions are ({@link AxisDirection#NORTH NORTH},
113     * {@link AxisDirection#EAST EAST}) instead than the usual ({@code EAST}, {@code NORTH}).
114     */
115    public boolean isNorthAxisFirst;
116
117    /**
118     * {@code true} if the <var>x</var> values are increasing toward {@link AxisDirection#WEST WEST}
119     * instead than {@link AxisDirection#EAST EAST}.
120     */
121    public boolean isWestOrientated;
122
123    /**
124     * {@code true} if the <var>y</var> values are increasing toward {@link AxisDirection#SOUTH SOUTH}
125     * instead than {@link AxisDirection#NORTH NORTH}.
126     */
127    public boolean isSouthOrientated;
128
129    /**
130     * The CRS created by the factory, or {@code null} if not yet created or if CRS creation failed.
131     *
132     * @see #crsAuthorityFactory
133     */
134    private ProjectedCRS crs;
135
136    /**
137     * Factory to use for building {@link ProjectedCRS} instances, or {@code null} if none.
138     * This is the factory used by the {@link #getIdentifiedObject()} method.
139     */
140    protected final CRSAuthorityFactory crsAuthorityFactory;
141
142    /**
143     * Returns a default set of factories to use for running the tests. Those factories are given
144     * in arguments to the constructor when this test class is instantiated directly by JUnit (for
145     * example as a {@linkplain org.junit.runners.Suite.SuiteClasses suite} element), instead than
146     * subclassed by the implementor. The factories are fetched as documented in the
147     * {@link #factories(Class[])} javadoc.
148     *
149     * @return the default set of arguments to be given to the {@code GIGS2006} constructor.
150     */
151    @Parameterized.Parameters
152    @SuppressWarnings("unchecked")
153    public static List<Factory[]> factories() {
154        return factories(FactoryFilter.ByAuthority.EPSG, CRSAuthorityFactory.class);
155    }
156
157    /**
158     * Creates a new test using the given factory. If a given factory is {@code null},
159     * then the tests which depend on it will be skipped.
160     *
161     * @param crsFactory  factory for creating {@link ProjectedCRS} instances.
162     */
163    public GIGS2006(final CRSAuthorityFactory crsFactory) {
164        super(crsFactory);
165        crsAuthorityFactory = crsFactory;
166    }
167
168    /**
169     * Returns information about the configuration of the test which has been run.
170     * This method returns a map containing:
171     *
172     * <ul>
173     *   <li>All the following values associated to the {@link org.opengis.test.Configuration.Key} of the same name:
174     *     <ul>
175     *       <li>{@link #isStandardNameSupported}</li>
176     *       <li>{@link #isStandardAliasSupported}</li>
177     *       <li>{@link #isDependencyIdentificationSupported}</li>
178     *       <li>{@link #crsAuthorityFactory}</li>
179     *     </ul>
180     *   </li>
181     * </ul>
182     *
183     * @return the configuration of the test being run.
184     */
185    @Override
186    public Configuration configuration() {
187        final Configuration op = super.configuration();
188        assertNull(op.put(Configuration.Key.crsAuthorityFactory, crsAuthorityFactory));
189        return op;
190    }
191
192    /**
193     * Returns the projected CRS instance to be tested. When this method is invoked for the first time, it creates the
194     * CRS to test by invoking the {@link CRSAuthorityFactory#createProjectedCRS(String)} method with the current
195     * {@link #code} value in argument. The created object is then cached and returned in all subsequent invocations
196     * of this method.
197     *
198     * @return the projected CRS instance to test.
199     * @throws FactoryException if an error occurred while creating the projected CRS instance.
200     */
201    @Override
202    public ProjectedCRS getIdentifiedObject() throws FactoryException {
203        if (crs == null) {
204            assumeNotNull(crsAuthorityFactory);
205            try {
206                crs = crsAuthorityFactory.createProjectedCRS(String.valueOf(code));
207            } catch (NoSuchIdentifierException e) {
208                /*
209                 * Relaxed the exception type from NoSuchAuthorityCodeException because CoordinateOperation creation
210                 * will typically use MathTransformFactory under the hood, which throws NoSuchIdentifierException for
211                 * non-implemented operation methods (may be identified by their name rather than EPSG code).
212                 */
213                unsupportedCode(ProjectedCRS.class, code);
214                throw e;
215            }
216        }
217        return crs;
218    }
219
220    /**
221     * Verifies the properties of the projected CRS given by {@link #getIdentifiedObject()}.
222     */
223    private void createAndVerifyProjectedCRS(final int code) throws FactoryException {
224        this.code = code;
225        crs = null;                 // For forcing the fetch of a new projected CRS.
226
227        final ProjectedCRS crs = getIdentifiedObject();
228        assertNotNull("ProjectedCRS", crs);
229        validators.validate(crs);
230
231        // Projected CRS identifier.
232        assertContainsCode("ProjectedCRS.getIdentifiers()", "EPSG", code, crs.getIdentifiers());
233
234        // Projected CRS components.
235        if (isDependencyIdentificationSupported) {
236            configurationTip = Configuration.Key.isDependencyIdentificationSupported;
237
238            // Geodetic datum name.
239            assertContainsCode("ProjectedCRS.getDatum().getIdentifiers()",
240                    "EPSG", datumCode, crs.getDatum().getIdentifiers());
241
242            // Base geographic CRS name.
243            if (isStandardNameSupported) {
244                configurationTip = Configuration.Key.isStandardNameSupported;
245                assertEquals("ProjectedCRS.getBaseCRS().getName()", name, getVerifiableName(crs.getBaseCRS()));
246            }
247            configurationTip = null;
248        }
249
250        // Projected CRS coordinate system.
251        final CartesianCS cs = crs.getCoordinateSystem();
252        assertNotNull("ProjectedCRS.getCoordinateSystem()", crs);
253        assertEquals("ProjectedCRS.getCoordinateSystem().getDimension()", 2, cs.getDimension());
254
255        // Coordinate sytem axis directions.
256        final AxisDirection[] directions = new AxisDirection[2];
257        directions[isNorthAxisFirst ? 1 : 0] = isWestOrientated  ? AxisDirection.WEST  : AxisDirection.EAST;
258        directions[isNorthAxisFirst ? 0 : 1] = isSouthOrientated ? AxisDirection.SOUTH : AxisDirection.NORTH;
259        assertAxisDirectionsEqual("ProjectedCRS.getCoordinateSystem().getAxis(*)", cs, directions);
260    }
261
262    /**
263     * Tests “Abidjan 1987”-based projected CRS creation from the factory.
264     *
265     * <ul>
266     *   <li>Projected CRS codes: <b>2165</b>, <b>2043</b>, <b>2041</b></li>
267     *   <li>Geographic CRS name: <b>Abidjan 1987</b></li>
268     *   <li>Projection names (informative): <b>TM 5 NW</b>, <b>UTM</b></li>
269     *   <li>Particularly important to E&amp;P industry.</li>
270     * </ul>
271     *
272     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
273     */
274    @Test
275    public void testAbidjan() throws FactoryException {
276        important       = true;
277        name            = "Abidjan 1987";
278        projectionNames = new String[] {"TM 5 NW", "UTM"};
279        datumCode       = 6143;
280        createAndVerifyProjectedCRS(2165);
281        createAndVerifyProjectedCRS(2043);
282        createAndVerifyProjectedCRS(2041);
283    }
284
285    /**
286     * Tests “Accra”-based projected CRS creation from the factory.
287     *
288     * <ul>
289     *   <li>Projected CRS codes: <b>2136</b>, <b>2137</b></li>
290     *   <li>Geographic CRS name: <b>Accra</b></li>
291     *   <li>Projection names (informative): <b>TM 1 NW</b>, <b>Ghana National Grid</b></li>
292     *   <li>Particularly important to E&amp;P industry.</li>
293     * </ul>
294     *
295     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
296     */
297    @Test
298    public void testAccra() throws FactoryException {
299        important       = true;
300        name            = "Accra";
301        projectionNames = new String[] {"TM 1 NW", "Ghana National Grid"};
302        datumCode       = 6168;
303        createAndVerifyProjectedCRS(2136);
304        createAndVerifyProjectedCRS(2137);
305    }
306
307    /**
308     * Tests “AGD66”-based projected CRS creation from the factory.
309     *
310     * <ul>
311     *   <li>Projected CRS codes: <b>20249</b>, <b>20250</b>, <b>20251</b>, <b>20252</b>, <b>20253</b>,
312     *       <b>20254</b>, <b>20255</b>, <b>20256</b></li>
313     *   <li>Geographic CRS name: <b>AGD66</b></li>
314     *   <li>Projection names (informative): <b>Australian Map Grid zones</b></li>
315     *   <li>Particularly important to E&amp;P industry.</li>
316     * </ul>
317     *
318     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
319     */
320    @Test
321    public void testAGD66() throws FactoryException {
322        important       = true;
323        name            = "AGD66";
324        projectionNames = new String[] {"Australian Map Grid zones"};
325        datumCode       = 6202;
326        for (int code = 20249; code <= 20256; code++) {    // Loop over 8 codes
327            createAndVerifyProjectedCRS(code);
328        }
329    }
330
331    /**
332     * Tests “AGD84”-based projected CRS creation from the factory.
333     *
334     * <ul>
335     *   <li>Projected CRS codes: <b>20349</b>, <b>20350</b>, <b>20351</b>, <b>20352</b>, <b>20353</b>,
336     *       <b>20354</b>, <b>20355</b>, <b>20356</b></li>
337     *   <li>Geographic CRS name: <b>AGD84</b></li>
338     *   <li>Projection names (informative): <b>Australian Map Grid zones</b></li>
339     *   <li>Particularly important to E&amp;P industry.</li>
340     * </ul>
341     *
342     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
343     */
344    @Test
345    public void testAGD84() throws FactoryException {
346        important       = true;
347        name            = "AGD84";
348        projectionNames = new String[] {"Australian Map Grid zones"};
349        datumCode       = 6203;
350        for (int code = 20349; code <= 20356; code++) {    // Loop over 8 codes
351            createAndVerifyProjectedCRS(code);
352        }
353    }
354
355    /**
356     * Tests “Ain el Abd”-based projected CRS creation from the factory.
357     *
358     * <ul>
359     *   <li>Projected CRS codes: <b>2318</b>, <b>20436</b>, <b>20437</b></li>
360     *   <li>Geographic CRS name: <b>Ain el Abd</b></li>
361     *   <li>Projection names (informative): <b>Aramco Lambert</b>, <b>UTM</b></li>
362     *   <li>Particularly important to E&amp;P industry.</li>
363     * </ul>
364     *
365     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
366     */
367    @Test
368    public void testAinElAbd() throws FactoryException {
369        important       = true;
370        name            = "Ain el Abd";
371        projectionNames = new String[] {"Aramco Lambert", "UTM"};
372        datumCode       = 6204;
373        createAndVerifyProjectedCRS(2318);
374        createAndVerifyProjectedCRS(20436);
375        createAndVerifyProjectedCRS(20437);
376    }
377
378    /**
379     * Tests “Amersfoort”-based projected CRS creation from the factory.
380     *
381     * <ul>
382     *   <li>Projected CRS codes: <b>28992</b></li>
383     *   <li>Geographic CRS name: <b>Amersfoort</b></li>
384     *   <li>Projection names (informative): <b>RD New</b></li>
385     *   <li>Particularly important to E&amp;P industry.</li>
386     * </ul>
387     *
388     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
389     */
390    @Test
391    public void testAmersfoort() throws FactoryException {
392        important       = true;
393        name            = "Amersfoort";
394        projectionNames = new String[] {"RD New"};
395        datumCode       = 6289;
396        createAndVerifyProjectedCRS(28992);
397    }
398
399    /**
400     * Tests “Aratu”-based projected CRS creation from the factory.
401     *
402     * <ul>
403     *   <li>Projected CRS codes: <b>20822</b>, <b>20823</b>, <b>20824</b></li>
404     *   <li>Geographic CRS name: <b>Aratu</b></li>
405     *   <li>Projection names (informative): <b>UTM</b></li>
406     *   <li>Particularly important to E&amp;P industry.</li>
407     * </ul>
408     *
409     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
410     */
411    @Test
412    public void testAratu() throws FactoryException {
413        important       = true;
414        name            = "Aratu";
415        projectionNames = new String[] {"UTM"};
416        datumCode       = 6208;
417        createAndVerifyProjectedCRS(20822);
418        createAndVerifyProjectedCRS(20823);
419        createAndVerifyProjectedCRS(20824);
420    }
421
422    /**
423     * Tests “Batavia”-based projected CRS creation from the factory.
424     *
425     * <ul>
426     *   <li>Projected CRS codes: <b>3001</b>, <b>2308</b></li>
427     *   <li>Geographic CRS name: <b>Batavia</b></li>
428     *   <li>Projection names (informative): <b>NEIEZ</b>, <b>TM 109 SE</b>, <b>UTM</b></li>
429     *   <li>Particularly important to E&amp;P industry.</li>
430     * </ul>
431     *
432     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
433     */
434    @Test
435    public void testBatavia() throws FactoryException {
436        important       = true;
437        name            = "Batavia";
438        projectionNames = new String[] {"NEIEZ", "TM 109 SE", "UTM"};
439        datumCode       = 6211;
440        createAndVerifyProjectedCRS(3001);
441        createAndVerifyProjectedCRS(2308);
442    }
443
444    /**
445     * Tests “Beijing 1954”-based projected CRS creation from the factory.
446     *
447     * <ul>
448     *   <li>Projected CRS codes: <b>21413</b>, <b>21414</b>, <b>21415</b>, <b>21416</b>, <b>21417</b>, <b>21418</b>,
449     *       <b>21419</b>, <b>21420</b>, <b>21421</b>, <b>21422</b>, <b>21423</b></li>
450     *   <li>Geographic CRS name: <b>Beijing 1954</b></li>
451     *   <li>Projection names (informative): <b>6-degree Gauss-Kruger</b></li>
452     *   <li>Specific usage / Remarks: <b>Check axes order and abbreviations</b></li>
453     *   <li>Particularly important to E&amp;P industry.</li>
454     * </ul>
455     *
456     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
457     */
458    @Test
459    public void testBeijing() throws FactoryException {
460        important        = true;
461        name             = "Beijing 1954";
462        projectionNames  = new String[] {"6-degree Gauss-Kruger"};
463        datumCode        = 6214;
464        isNorthAxisFirst = true;
465        for (int code = 21413; code <= 21423; code++) {    // Loop over 11 codes
466            createAndVerifyProjectedCRS(code);
467        }
468    }
469
470    /**
471     * Tests “Bogota 1975”-based projected CRS creation from the factory.
472     *
473     * <ul>
474     *   <li>Projected CRS codes: <b>21896</b>, <b>21897</b>, <b>21898</b>, <b>21899</b></li>
475     *   <li>Geographic CRS name: <b>Bogota 1975</b></li>
476     *   <li>Projection names (informative): <b>Colombia zones</b></li>
477     *   <li>Particularly important to E&amp;P industry.</li>
478     * </ul>
479     *
480     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
481     */
482    @Test
483    public void testBogota() throws FactoryException {
484        important        = true;
485        name             = "Bogota 1975";
486        projectionNames      = new String[] {"Colombia zones"};
487        datumCode            = 6218;
488        isNorthAxisFirst = true;
489        for (int code = 21896; code <= 21899; code++) {    // Loop over 4 codes
490            createAndVerifyProjectedCRS(code);
491        }
492    }
493
494    /**
495     * Tests “Camacupa”-based projected CRS creation from the factory.
496     *
497     * <ul>
498     *   <li>Projected CRS codes: <b>22091</b>, <b>22092</b>, <b>22032</b>, <b>22033</b></li>
499     *   <li>Geographic CRS name: <b>Camacupa</b></li>
500     *   <li>Projection names (informative): <b>TM 11.30 SE</b>, <b>TM 12 SE</b>, <b>UTM</b></li>
501     *   <li>Particularly important to E&amp;P industry.</li>
502     * </ul>
503     *
504     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
505     */
506    @Test
507    public void testCamacupa() throws FactoryException {
508        important       = true;
509        name            = "Camacupa";
510        projectionNames = new String[] {"TM 11.30 SE", "TM 12 SE", "UTM"};
511        datumCode       = 6220;
512        createAndVerifyProjectedCRS(22091);
513        createAndVerifyProjectedCRS(22092);
514        createAndVerifyProjectedCRS(22032);
515        createAndVerifyProjectedCRS(22033);
516    }
517
518    /**
519     * Tests “Campo Inchauspe”-based projected CRS creation from the factory.
520     *
521     * <ul>
522     *   <li>Projected CRS codes: <b>22191</b>, <b>22192</b>, <b>22193</b>, <b>22194</b>, <b>22195</b>, <b>22196</b>, <b>22197</b>, <b>2315</b>, <b>2316</b></li>
523     *   <li>Geographic CRS name: <b>Campo Inchauspe</b></li>
524     *   <li>Projection names (informative): <b>Argentina zones</b>, <b>UTM</b></li>
525     *   <li>Particularly important to E&amp;P industry.</li>
526     * </ul>
527     *
528     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
529     */
530    @Test
531    public void testCampoInchauspe() throws FactoryException {
532        important        = true;
533        name             = "Campo Inchauspe";
534        projectionNames  = new String[] {"Argentina zones", "UTM"};
535        datumCode        = 6221;
536        isNorthAxisFirst = true;
537        for (int code = 22191; code <= 22197; code++) {    // Loop over 7 codes
538            createAndVerifyProjectedCRS(code);
539        }
540        isNorthAxisFirst = false;
541        createAndVerifyProjectedCRS(2315);
542        createAndVerifyProjectedCRS(2316);
543    }
544
545    /**
546     * Tests “Carthage”-based projected CRS creation from the factory.
547     *
548     * <ul>
549     *   <li>Projected CRS codes: <b>22391</b>, <b>22392</b></li>
550     *   <li>Geographic CRS name: <b>Carthage</b></li>
551     *   <li>Projection names (informative): <b>Tunisia zones</b></li>
552     *   <li>Particularly important to E&amp;P industry.</li>
553     * </ul>
554     *
555     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
556     */
557    @Test
558    public void testCarthage() throws FactoryException {
559        important       = true;
560        name            = "Carthage";
561        projectionNames = new String[] {"Tunisia zones"};
562        datumCode       = 6223;
563        createAndVerifyProjectedCRS(22391);
564        createAndVerifyProjectedCRS(22392);
565    }
566
567    /**
568     * Tests “Dealul Piscului 1930”-based projected CRS creation from the factory.
569     *
570     * <ul>
571     *   <li>Projected CRS codes: <b>31600</b></li>
572     *   <li>Geographic CRS name: <b>Dealul Piscului 1930</b></li>
573     *   <li>Projection names (informative): <b>Stereo 30</b></li>
574     *   <li>Specific usage / Remarks: <b>Check axes order and abbreviations</b></li>
575     *   <li>Particularly important to E&amp;P industry.</li>
576     * </ul>
577     *
578     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
579     */
580    @Test
581    public void testDealulPiscului() throws FactoryException {
582        important       = true;
583        name            = "Dealul Piscului 1930";
584        projectionNames = new String[] {"Stereo 30"};
585        datumCode       = 6316;
586        createAndVerifyProjectedCRS(31600);
587    }
588
589    /**
590     * Tests “Deir ez Zor”-based projected CRS creation from the factory.
591     *
592     * <ul>
593     *   <li>Projected CRS codes: <b>22700</b>, <b>22770</b></li>
594     *   <li>Geographic CRS name: <b>Deir ez Zor</b></li>
595     *   <li>Projection names (informative): <b>Levant zone, Syria Lambert</b></li>
596     *   <li>Particularly important to E&amp;P industry.</li>
597     * </ul>
598     *
599     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
600     */
601    @Test
602    public void testDeirEzZor() throws FactoryException {
603        important       = true;
604        name            = "Deir ez Zor";
605        projectionNames = new String[] {"Levant zone, Syria Lambert"};
606        datumCode       = 6227;
607        createAndVerifyProjectedCRS(22700);
608        createAndVerifyProjectedCRS(22770);
609    }
610
611    /**
612     * Tests “DGN95”-based projected CRS creation from the factory.
613     *
614     * <ul>
615     *   <li>Projected CRS codes: <b>23866</b>, <b>23867</b>, <b>23868</b>, <b>23869</b>, <b>23870</b>,
616     *       <b>23871</b>, <b>23872</b>, <b>23877</b>, <b>23878</b>, <b>23879</b>, <i>…5 more</i></li>
617     *   <li>Geographic CRS name: <b>DGN95</b></li>
618     *   <li>Projection names (informative): <b>UTM</b></li>
619     *   <li>Particularly important to E&amp;P industry.</li>
620     * </ul>
621     *
622     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
623     */
624    @Test
625    public void testDGN95() throws FactoryException {
626        important       = true;
627        name            = "DGN95";
628        projectionNames = new String[] {"UTM"};
629        datumCode       = 6755;
630        for (int code = 23866; code <= 23872; code++) {    // Loop over 7 codes
631            createAndVerifyProjectedCRS(code);
632        }
633        for (int code = 23877; code <= 23884; code++) {    // Loop over 8 codes
634            createAndVerifyProjectedCRS(code);
635        }
636    }
637
638    /**
639     * Tests “DHDN”-based projected CRS creation from the factory.
640     *
641     * <ul>
642     *   <li>Projected CRS codes: <b>31466</b>, <b>31467</b>, <b>31468</b>, <b>31469</b></li>
643     *   <li>Geographic CRS name: <b>DHDN</b></li>
644     *   <li>Projection names (informative): <b>3-degree Gauss-Kruger</b></li>
645     *   <li>Specific usage / Remarks: <b>Check axes order and abbreviations</b></li>
646     *   <li>Particularly important to E&amp;P industry.</li>
647     * </ul>
648     *
649     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
650     */
651    @Test
652    public void testDHDN() throws FactoryException {
653        important        = true;
654        name             = "DHDN";
655        projectionNames  = new String[] {"3-degree Gauss-Kruger"};
656        datumCode        = 6314;
657        isNorthAxisFirst = true;
658        for (int code = 31466; code <= 31469; code++) {    // Loop over 4 codes
659            createAndVerifyProjectedCRS(code);
660        }
661    }
662
663    /**
664     * Tests “ED50”-based projected CRS creation from the factory.
665     *
666     * <ul>
667     *   <li>Projected CRS codes: <b>23028</b>, <b>23029</b>, <b>23030</b>, <b>23031</b>, <b>23032</b>,
668     *       <b>23033</b>, <b>23034</b>, <b>23035</b>, <b>23090</b>, <b>23095</b></li>
669     *   <li>Geographic CRS name: <b>ED50</b></li>
670     *   <li>Projection names (informative): <b>UTM</b>, <b>TM 5 NE</b>, <b>TM 0 N</b></li>
671     *   <li>Particularly important to E&amp;P industry.</li>
672     * </ul>
673     *
674     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
675     */
676    @Test
677    public void testED50() throws FactoryException {
678        important       = true;
679        name            = "ED50";
680        projectionNames = new String[] {"UTM", "TM 5 NE", "TM 0 N"};
681        datumCode       = 6230;
682        for (int code = 23028; code <= 23035; code++) {    // Loop over 8 codes
683            createAndVerifyProjectedCRS(code);
684        }
685        createAndVerifyProjectedCRS(23090);
686        createAndVerifyProjectedCRS(23095);
687    }
688
689    /**
690     * Tests “ED50(ED77)”-based projected CRS creation from the factory.
691     *
692     * <ul>
693     *   <li>Projected CRS codes: <b>2058</b>, <b>2059</b>, <b>2060</b></li>
694     *   <li>Geographic CRS name: <b>ED50(ED77)</b></li>
695     *   <li>Projection names (informative): <b>UTM</b></li>
696     *   <li>Particularly important to E&amp;P industry.</li>
697     * </ul>
698     *
699     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
700     */
701    @Test
702    public void testED50_77() throws FactoryException {
703        important       = true;
704        name            = "ED50(ED77)";
705        projectionNames = new String[] {"UTM"};
706        datumCode       = 6154;
707        createAndVerifyProjectedCRS(2058);
708        createAndVerifyProjectedCRS(2059);
709        createAndVerifyProjectedCRS(2060);
710    }
711
712    /**
713     * Tests “Egypt 1907”-based projected CRS creation from the factory.
714     *
715     * <ul>
716     *   <li>Projected CRS codes: <b>22991</b>, <b>22992</b>, <b>22993</b>, <b>22994</b></li>
717     *   <li>Geographic CRS name: <b>Egypt 1907</b></li>
718     *   <li>Projection names (informative): <b>Egypt belts</b></li>
719     *   <li>Particularly important to E&amp;P industry.</li>
720     * </ul>
721     *
722     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
723     */
724    @Test
725    public void testEgypt() throws FactoryException {
726        important       = true;
727        name            = "Egypt 1907";
728        projectionNames = new String[] {"Egypt belts"};
729        datumCode       = 6229;
730        for (int code = 22991; code <= 22994; code++) {    // Loop over 4 codes
731            createAndVerifyProjectedCRS(code);
732        }
733    }
734
735    /**
736     * Tests “Egypt Gulf of Suez S-650 TL”-based projected CRS creation from the factory.
737     *
738     * <ul>
739     *   <li>Projected CRS codes: <b>3355</b></li>
740     *   <li>Geographic CRS name: <b>Egypt Gulf of Suez S-650 TL</b></li>
741     *   <li>Projection names (informative): <b>Egypt Red belt</b></li>
742     *   <li>Particularly important to E&amp;P industry.</li>
743     * </ul>
744     *
745     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
746     */
747    @Test
748    public void testGulfOfSuez() throws FactoryException {
749        important       = true;
750        name            = "Egypt Gulf of Suez S-650 TL";
751        projectionNames = new String[] {"Egypt Red belt"};
752        datumCode       = 6706;
753        createAndVerifyProjectedCRS(3355);
754    }
755
756    /**
757     * Tests “ELD79”-based projected CRS creation from the factory.
758     *
759     * <ul>
760     *   <li>Projected CRS codes: <b>2068</b>, <b>2069</b>, <b>2070</b>, <b>2071</b>, <b>2072</b>, <b>2073</b>,
761     *       <b>2074</b>, <b>2075</b>, <b>2076</b>, <b>2077</b>, <i>…3 more</i></li>
762     *   <li>Geographic CRS name: <b>ELD79</b></li>
763     *   <li>Projection names (informative): <b>Libya zones</b>, <b>UTM</b></li>
764     *   <li>Particularly important to E&amp;P industry.</li>
765     * </ul>
766     *
767     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
768     */
769    @Test
770    public void testELD79() throws FactoryException {
771        important       = true;
772        name            = "ELD79";
773        projectionNames = new String[] {"Libya zones", "UTM"};
774        datumCode       = 6159;
775        for (int code = 2068; code <= 2080; code++) {    // Loop over 13 codes
776            createAndVerifyProjectedCRS(code);
777        }
778    }
779
780    /**
781     * Tests “ETRS89”-based projected CRS creation from the factory.
782     *
783     * <ul>
784     *   <li>Projected CRS codes: <b>25828</b>, <b>25829</b>, <b>25830</b>, <b>25831</b>, <b>25832</b>,
785     *       <b>25833</b>, <b>25834</b>, <b>25835</b></li>
786     *   <li>Geographic CRS name: <b>ETRS89</b></li>
787     *   <li>Projection names (informative): <b>UTM</b></li>
788     *   <li>Particularly important to E&amp;P industry.</li>
789     * </ul>
790     *
791     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
792     */
793    @Test
794    public void testETRS89() throws FactoryException {
795        important       = true;
796        name            = "ETRS89";
797        projectionNames = new String[] {"UTM"};
798        datumCode       = 6258;
799        for (int code = 25828; code <= 25835; code++) {    // Loop over 8 codes
800            createAndVerifyProjectedCRS(code);
801        }
802    }
803
804    /**
805     * Tests “Fahud”-based projected CRS creation from the factory.
806     *
807     * <ul>
808     *   <li>Projected CRS codes: <b>23239</b>, <b>23240</b></li>
809     *   <li>Geographic CRS name: <b>Fahud</b></li>
810     *   <li>Projection names (informative): <b>UTM</b></li>
811     *   <li>Particularly important to E&amp;P industry.</li>
812     * </ul>
813     *
814     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
815     */
816    @Test
817    public void testFahud() throws FactoryException {
818        important       = true;
819        name            = "Fahud";
820        projectionNames = new String[] {"UTM"};
821        datumCode       = 6232;
822        createAndVerifyProjectedCRS(23239);
823        createAndVerifyProjectedCRS(23240);
824    }
825
826    /**
827     * Tests “FD58”-based projected CRS creation from the factory.
828     *
829     * <ul>
830     *   <li>Projected CRS codes: <b>3200</b></li>
831     *   <li>Geographic CRS name: <b>FD58</b></li>
832     *   <li>Projection names (informative): <b>Iraq zone</b></li>
833     *   <li>Particularly important to E&amp;P industry.</li>
834     * </ul>
835     *
836     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
837     */
838    @Test
839    public void testFD58() throws FactoryException {
840        important       = true;
841        name            = "FD58";
842        projectionNames = new String[] {"Iraq zone"};
843        datumCode       = 6132;
844        createAndVerifyProjectedCRS(3200);
845    }
846
847    /**
848     * Tests “GDA94”-based projected CRS creation from the factory.
849     *
850     * <ul>
851     *   <li>Projected CRS codes: <b>28349</b>, <b>28350</b>, <b>28351</b>, <b>28352</b>, <b>28353</b>,
852     *       <b>28354</b>, <b>28355</b>, <b>28356</b></li>
853     *   <li>Geographic CRS name: <b>GDA94</b></li>
854     *   <li>Projection names (informative): <b>Australian Map Grid zones</b></li>
855     *   <li>Particularly important to E&amp;P industry.</li>
856     * </ul>
857     *
858     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
859     */
860    @Test
861    public void testGDA94() throws FactoryException {
862        important       = true;
863        name            = "GDA94";
864        projectionNames = new String[] {"Australian Map Grid zones"};
865        datumCode       = 6283;
866        for (int code = 28349; code <= 28356; code++) {    // Loop over 8 codes
867            createAndVerifyProjectedCRS(code);
868        }
869    }
870
871    /**
872     * Tests “GDM2000”-based projected CRS creation from the factory.
873     *
874     * <ul>
875     *   <li>Projected CRS codes: <b>3375</b>, <b>3376</b></li>
876     *   <li>Geographic CRS name: <b>GDM2000</b></li>
877     *   <li>Projection names (informative): <b>RSO grids</b></li>
878     *   <li>Particularly important to E&amp;P industry.</li>
879     * </ul>
880     *
881     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
882     */
883    @Test
884    public void testGDM2000() throws FactoryException {
885        important       = true;
886        name            = "GDM2000";
887        projectionNames = new String[] {"RSO grids"};
888        datumCode       = 6742;
889        createAndVerifyProjectedCRS(3375);
890        createAndVerifyProjectedCRS(3376);
891    }
892
893    /**
894     * Tests “HD72”-based projected CRS creation from the factory.
895     *
896     * <ul>
897     *   <li>Projected CRS codes: <b>23700</b></li>
898     *   <li>Geographic CRS name: <b>HD72</b></li>
899     *   <li>Projection names (informative): <b>EOV</b></li>
900     *   <li>Particularly important to E&amp;P industry.</li>
901     * </ul>
902     *
903     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
904     */
905    @Test
906    public void testHD72() throws FactoryException {
907        important       = true;
908        name            = "HD72";
909        projectionNames = new String[] {"EOV"};
910        datumCode       = 6237;
911        createAndVerifyProjectedCRS(23700);
912    }
913
914    /**
915     * Tests “IGN Astro 1960”-based projected CRS creation from the factory.
916     *
917     * <ul>
918     *   <li>Projected CRS codes: <b>3367</b>, <b>3368</b>, <b>3369</b></li>
919     *   <li>Geographic CRS name: <b>IGN Astro 1960</b></li>
920     *   <li>Projection names (informative): <b>UTM</b></li>
921     *   <li>Particularly important to E&amp;P industry.</li>
922     * </ul>
923     *
924     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
925     */
926    @Test
927    public void testIGNAstro() throws FactoryException {
928        important       = true;
929        name            = "IGN Astro 1960";
930        projectionNames = new String[] {"UTM"};
931        datumCode       = 6700;
932        createAndVerifyProjectedCRS(3367);
933        createAndVerifyProjectedCRS(3368);
934        createAndVerifyProjectedCRS(3369);
935    }
936
937    /**
938     * Tests “Indian 1954”-based projected CRS creation from the factory.
939     *
940     * <ul>
941     *   <li>Projected CRS codes: <b>23946</b>, <b>23947</b>, <b>23948</b></li>
942     *   <li>Geographic CRS name: <b>Indian 1954</b></li>
943     *   <li>Projection names (informative): <b>UTM</b></li>
944     *   <li>Particularly important to E&amp;P industry.</li>
945     * </ul>
946     *
947     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
948     */
949    @Test
950    public void testIndian1954() throws FactoryException {
951        important       = true;
952        name            = "Indian 1954";
953        projectionNames = new String[] {"UTM"};
954        datumCode       = 6239;
955        createAndVerifyProjectedCRS(23946);
956        createAndVerifyProjectedCRS(23947);
957        createAndVerifyProjectedCRS(23948);
958    }
959
960    /**
961     * Tests “Indian 1960”-based projected CRS creation from the factory.
962     *
963     * <ul>
964     *   <li>Projected CRS codes: <b>3148</b>, <b>3149</b></li>
965     *   <li>Geographic CRS name: <b>Indian 1960</b></li>
966     *   <li>Projection names (informative): <b>UTM</b></li>
967     *   <li>Particularly important to E&amp;P industry.</li>
968     * </ul>
969     *
970     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
971     */
972    @Test
973    public void testIndian1960() throws FactoryException {
974        important       = true;
975        name            = "Indian 1960";
976        projectionNames = new String[] {"UTM"};
977        datumCode       = 6131;
978        createAndVerifyProjectedCRS(3148);
979        createAndVerifyProjectedCRS(3149);
980    }
981
982    /**
983     * Tests “Indian 1975”-based projected CRS creation from the factory.
984     *
985     * <ul>
986     *   <li>Projected CRS codes: <b>24047</b>, <b>24048</b></li>
987     *   <li>Geographic CRS name: <b>Indian 1975</b></li>
988     *   <li>Projection names (informative): <b>UTM</b></li>
989     *   <li>Particularly important to E&amp;P industry.</li>
990     * </ul>
991     *
992     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
993     */
994    @Test
995    public void testIndian1975() throws FactoryException {
996        important       = true;
997        name            = "Indian 1975";
998        projectionNames = new String[] {"UTM"};
999        datumCode       = 6240;
1000        createAndVerifyProjectedCRS(24047);
1001        createAndVerifyProjectedCRS(24048);
1002    }
1003
1004    /**
1005     * Tests “Kalianpur 1937”-based projected CRS creation from the factory.
1006     *
1007     * <ul>
1008     *   <li>Projected CRS codes: <b>24305</b>, <b>24306</b>, <b>24375</b></li>
1009     *   <li>Geographic CRS name: <b>Kalianpur 1937</b></li>
1010     *   <li>Projection names (informative): <b>India zones</b>, <b>UTM</b></li>
1011     *   <li>Particularly important to E&amp;P industry.</li>
1012     * </ul>
1013     *
1014     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1015     */
1016    @Test
1017    public void testKalianpur1937() throws FactoryException {
1018        important       = true;
1019        name            = "Kalianpur 1937";
1020        projectionNames = new String[] {"India zones", "UTM"};
1021        datumCode       = 6144;
1022        createAndVerifyProjectedCRS(24305);
1023        createAndVerifyProjectedCRS(24306);
1024        createAndVerifyProjectedCRS(24375);
1025    }
1026
1027    /**
1028     * Tests “Kalianpur 1962”-based projected CRS creation from the factory.
1029     *
1030     * <ul>
1031     *   <li>Projected CRS codes: <b>24312</b>, <b>24313</b>, <b>24376</b>, <b>24377</b></li>
1032     *   <li>Geographic CRS name: <b>Kalianpur 1962</b></li>
1033     *   <li>Projection names (informative): <b>India zones</b>, <b>UTM</b></li>
1034     *   <li>Particularly important to E&amp;P industry.</li>
1035     * </ul>
1036     *
1037     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1038     */
1039    @Test
1040    public void testKalianpur1962() throws FactoryException {
1041        important       = true;
1042        name            = "Kalianpur 1962";
1043        projectionNames = new String[] {"India zones", "UTM"};
1044        datumCode       = 6145;
1045        createAndVerifyProjectedCRS(24312);
1046        createAndVerifyProjectedCRS(24313);
1047        createAndVerifyProjectedCRS(24376);
1048        createAndVerifyProjectedCRS(24377);
1049    }
1050
1051    /**
1052     * Tests “Kalianpur 1975”-based projected CRS creation from the factory.
1053     *
1054     * <ul>
1055     *   <li>Projected CRS codes: <b>24342</b>, <b>24343</b>, <b>24379</b>, <b>24380</b></li>
1056     *   <li>Geographic CRS name: <b>Kalianpur 1975</b></li>
1057     *   <li>Projection names (informative): <b>India zones</b>, <b>UTM</b></li>
1058     *   <li>Particularly important to E&amp;P industry.</li>
1059     * </ul>
1060     *
1061     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1062     */
1063    @Test
1064    public void testKalianpur1975() throws FactoryException {
1065        important       = true;
1066        name            = "Kalianpur 1975";
1067        projectionNames = new String[] {"India zones", "UTM"};
1068        datumCode       = 6146;
1069        createAndVerifyProjectedCRS(24342);
1070        createAndVerifyProjectedCRS(24343);
1071        createAndVerifyProjectedCRS(24379);
1072        createAndVerifyProjectedCRS(24380);
1073    }
1074
1075    /**
1076     * Tests “Kertau 1968”-based projected CRS creation from the factory.
1077     *
1078     * <ul>
1079     *   <li>Projected CRS codes: <b>24547</b>, <b>24548</b></li>
1080     *   <li>Geographic CRS name: <b>Kertau 1968</b></li>
1081     *   <li>Projection names (informative): <b>UTM</b></li>
1082     *   <li>Particularly important to E&amp;P industry.</li>
1083     * </ul>
1084     *
1085     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1086     */
1087    @Test
1088    public void testKertau() throws FactoryException {
1089        important       = true;
1090        name            = "Kertau 1968";
1091        projectionNames = new String[] {"UTM"};
1092        datumCode       = 6245;
1093        createAndVerifyProjectedCRS(24547);
1094        createAndVerifyProjectedCRS(24548);
1095    }
1096
1097    /**
1098     * Tests “Kertau (RSO)”-based projected CRS creation from the factory.
1099     *
1100     * <ul>
1101     *   <li>Projected CRS codes: <b>3167</b>, <b>3168</b></li>
1102     *   <li>Geographic CRS name: <b>Kertau (RSO)</b></li>
1103     *   <li>Projection names (informative): <b>RSO</b></li>
1104     *   <li>Particularly important to E&amp;P industry.</li>
1105     * </ul>
1106     *
1107     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1108     */
1109    @Test
1110    public void testKertau_RSO() throws FactoryException {
1111        important       = true;
1112        name            = "Kertau (RSO)";
1113        projectionNames = new String[] {"RSO"};
1114        datumCode       = 6751;
1115        createAndVerifyProjectedCRS(3167);
1116        createAndVerifyProjectedCRS(3168);
1117    }
1118
1119    /**
1120     * Tests “KOC”-based projected CRS creation from the factory.
1121     *
1122     * <ul>
1123     *   <li>Projected CRS codes: <b>24600</b></li>
1124     *   <li>Geographic CRS name: <b>KOC</b></li>
1125     *   <li>Projection names (informative): <b>KOC Lambert</b></li>
1126     *   <li>Particularly important to E&amp;P industry.</li>
1127     * </ul>
1128     *
1129     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1130     */
1131    @Test
1132    public void testKOC() throws FactoryException {
1133        important       = true;
1134        name            = "KOC";
1135        projectionNames = new String[] {"KOC Lambert"};
1136        datumCode       = 6246;
1137        createAndVerifyProjectedCRS(24600);
1138    }
1139
1140    /**
1141     * Tests “LGD2006”-based projected CRS creation from the factory.
1142     *
1143     * <ul>
1144     *   <li>Projected CRS codes: <b>3177</b>, <b>3190</b>, <b>3191</b>, <b>3192</b>, <b>3193</b>, <b>3194</b>,
1145     *       <b>3195</b>, <b>3196</b>, <b>3197</b>, <b>3198</b>, <i>…4 more</i></li>
1146     *   <li>Geographic CRS name: <b>LGD2006</b></li>
1147     *   <li>Projection names (informative): <b>Libya zones</b>, <b>UTM</b></li>
1148     *   <li>Particularly important to E&amp;P industry.</li>
1149     * </ul>
1150     *
1151     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1152     */
1153    @Test
1154    public void testLGD2006() throws FactoryException {
1155        important       = true;
1156        name            = "LGD2006";
1157        projectionNames = new String[] {"Libya zones", "UTM"};
1158        datumCode       = 6754;
1159        createAndVerifyProjectedCRS(3177);
1160        for (int code = 3190; code <= 3199; code++) {    // Loop over 10 codes
1161            createAndVerifyProjectedCRS(code);
1162        }
1163        createAndVerifyProjectedCRS(3201);
1164        createAndVerifyProjectedCRS(3202);
1165        createAndVerifyProjectedCRS(3203);
1166    }
1167
1168    /**
1169     * Tests “Luzon 1911”-based projected CRS creation from the factory.
1170     *
1171     * <ul>
1172     *   <li>Projected CRS codes: <b>25391</b>, <b>25392</b>, <b>25393</b>, <b>25394</b>, <b>25395</b></li>
1173     *   <li>Geographic CRS name: <b>Luzon 1911</b></li>
1174     *   <li>Projection names (informative): <b>Philippine zones</b></li>
1175     *   <li>Particularly important to E&amp;P industry.</li>
1176     * </ul>
1177     *
1178     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1179     */
1180    @Test
1181    public void testLuzon() throws FactoryException {
1182        important       = true;
1183        name            = "Luzon 1911";
1184        projectionNames = new String[] {"Philippine zones"};
1185        datumCode       = 6253;
1186        for (int code = 25391; code <= 25395; code++) {    // Loop over 5 codes
1187            createAndVerifyProjectedCRS(code);
1188        }
1189    }
1190
1191    /**
1192     * Tests “MAGNA-SIRGAS”-based projected CRS creation from the factory.
1193     *
1194     * <ul>
1195     *   <li>Projected CRS codes: <b>3114</b>, <b>3115</b>, <b>3116</b>, <b>3117</b>, <b>3118</b></li>
1196     *   <li>Geographic CRS name: <b>MAGNA-SIRGAS</b></li>
1197     *   <li>Projection names (informative): <b>Colombia zones</b></li>
1198     *   <li>Particularly important to E&amp;P industry.</li>
1199     * </ul>
1200     *
1201     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1202     */
1203    @Test
1204    public void testMAGNA_SIRGAS() throws FactoryException {
1205        important        = true;
1206        name             = "MAGNA-SIRGAS";
1207        projectionNames  = new String[] {"Colombia zones"};
1208        datumCode        = 6686;
1209        isNorthAxisFirst = true;
1210        for (int code = 3114; code <= 3118; code++) {    // Loop over 5 codes
1211            createAndVerifyProjectedCRS(code);
1212        }
1213    }
1214
1215    /**
1216     * Tests “Malongo 1987”-based projected CRS creation from the factory.
1217     *
1218     * <ul>
1219     *   <li>Projected CRS codes: <b>25932</b></li>
1220     *   <li>Geographic CRS name: <b>Malongo 1987</b></li>
1221     *   <li>Projection names (informative): <b>UTM</b></li>
1222     *   <li>Particularly important to E&amp;P industry.</li>
1223     * </ul>
1224     *
1225     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1226     */
1227    @Test
1228    public void testMalongo() throws FactoryException {
1229        important       = true;
1230        name            = "Malongo 1987";
1231        projectionNames = new String[] {"UTM"};
1232        datumCode       = 6259;
1233        createAndVerifyProjectedCRS(25932);
1234    }
1235
1236    /**
1237     * Tests “Manoca 1962”-based projected CRS creation from the factory.
1238     *
1239     * <ul>
1240     *   <li>Projected CRS codes: <b>2215</b></li>
1241     *   <li>Geographic CRS name: <b>Manoca 1962</b></li>
1242     *   <li>Projection names (informative): <b>UTM</b></li>
1243     *   <li>Particularly important to E&amp;P industry.</li>
1244     * </ul>
1245     *
1246     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1247     */
1248    @Test
1249    public void testManoca() throws FactoryException {
1250        important       = true;
1251        name            = "Manoca 1962";
1252        projectionNames = new String[] {"UTM"};
1253        datumCode       = 6193;
1254        createAndVerifyProjectedCRS(2215);
1255    }
1256
1257    /**
1258     * Tests “Mauritania 1999”-based projected CRS creation from the factory.
1259     *
1260     * <ul>
1261     *   <li>Projected CRS codes: <b>3343</b>, <b>3344</b>, <b>3345</b></li>
1262     *   <li>Geographic CRS name: <b>Mauritania 1999</b></li>
1263     *   <li>Projection names (informative): <b>UTM</b></li>
1264     *   <li>Particularly important to E&amp;P industry.</li>
1265     * </ul>
1266     *
1267     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1268     */
1269    @Test
1270    public void testMauritania() throws FactoryException {
1271        important       = true;
1272        name            = "Mauritania 1999";
1273        projectionNames = new String[] {"UTM"};
1274        datumCode       = 6702;
1275        createAndVerifyProjectedCRS(3343);
1276        createAndVerifyProjectedCRS(3344);
1277        createAndVerifyProjectedCRS(3345);
1278    }
1279
1280    /**
1281     * Tests “LKS94”-based projected CRS creation from the factory.
1282     *
1283     * <ul>
1284     *   <li>Projected CRS codes: <b>3346</b></li>
1285     *   <li>Geographic CRS name: <b>LKS94</b></li>
1286     *   <li>Projection names (informative): <b>UTM</b></li>
1287     *   <li>Particularly important to E&amp;P industry.</li>
1288     * </ul>
1289     *
1290     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1291     */
1292    @Test
1293    public void testLKS94() throws FactoryException {
1294        important        = true;
1295        name             = "LKS94";
1296        projectionNames  = new String[] {"UTM"};
1297        datumCode        = 6126;
1298        isNorthAxisFirst = true;
1299        createAndVerifyProjectedCRS(3346);
1300    }
1301
1302    /**
1303     * Tests “Pulkovo 1942”-based projected CRS creation from the factory.
1304     *
1305     * <ul>
1306     *   <li>Projected CRS codes: <b>3350</b>, <b>3351</b>, <b>3352</b></li>
1307     *   <li>Geographic CRS name: <b>Pulkovo 1942</b></li>
1308     *   <li>Projection names (informative): <b>UTM</b></li>
1309     *   <li>Particularly important to E&amp;P industry.</li>
1310     * </ul>
1311     *
1312     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1313     */
1314    @Test
1315    public void testPulkovo1942_UTM() throws FactoryException {
1316        important        = true;
1317        name             = "Pulkovo 1942";
1318        projectionNames  = new String[] {"UTM"};
1319        datumCode        = 6284;
1320        isNorthAxisFirst = true;
1321        createAndVerifyProjectedCRS(3350);
1322        createAndVerifyProjectedCRS(3351);
1323        createAndVerifyProjectedCRS(3352);
1324    }
1325
1326    /**
1327     * Tests “Mhast (offshore)”-based projected CRS creation from the factory.
1328     *
1329     * <ul>
1330     *   <li>Projected CRS codes: <b>3354</b></li>
1331     *   <li>Geographic CRS name: <b>Mhast (offshore)</b></li>
1332     *   <li>Projection names (informative): <b>UTM</b></li>
1333     *   <li>Particularly important to E&amp;P industry.</li>
1334     * </ul>
1335     *
1336     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1337     */
1338    @Test
1339    public void testMhast_offshore() throws FactoryException {
1340        important       = true;
1341        name            = "Mhast (offshore)";
1342        projectionNames = new String[] {"UTM"};
1343        datumCode       = 6705;
1344        createAndVerifyProjectedCRS(3354);
1345    }
1346
1347    /**
1348     * Tests “Mhast (onshore)”-based projected CRS creation from the factory.
1349     *
1350     * <ul>
1351     *   <li>Projected CRS codes: <b>3353</b></li>
1352     *   <li>Geographic CRS name: <b>Mhast (onshore)</b></li>
1353     *   <li>Projection names (informative): <b>UTM</b></li>
1354     *   <li>Particularly important to E&amp;P industry.</li>
1355     * </ul>
1356     *
1357     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1358     */
1359    @Test
1360    public void testMhast_onshore() throws FactoryException {
1361        important       = true;
1362        name            = "Mhast (onshore)";
1363        projectionNames = new String[] {"UTM"};
1364        datumCode       = 6704;
1365        createAndVerifyProjectedCRS(3353);
1366    }
1367
1368    /**
1369     * Tests “Minna”-based projected CRS creation from the factory.
1370     *
1371     * <ul>
1372     *   <li>Projected CRS codes: <b>26331</b>, <b>26332</b>, <b>26391</b>, <b>26392</b>, <b>26393</b></li>
1373     *   <li>Geographic CRS name: <b>Minna</b></li>
1374     *   <li>Projection names (informative): <b>Nigeria belts</b>, <b>UTM</b></li>
1375     *   <li>Particularly important to E&amp;P industry.</li>
1376     * </ul>
1377     *
1378     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1379     */
1380    @Test
1381    public void testMinna() throws FactoryException {
1382        important       = true;
1383        name            = "Minna";
1384        projectionNames = new String[] {"Nigeria belts", "UTM"};
1385        datumCode       = 6263;
1386        createAndVerifyProjectedCRS(26331);
1387        createAndVerifyProjectedCRS(26332);
1388        createAndVerifyProjectedCRS(26391);
1389        createAndVerifyProjectedCRS(26392);
1390        createAndVerifyProjectedCRS(26393);
1391    }
1392
1393    /**
1394     * Tests “Monte Mario”-based projected CRS creation from the factory.
1395     *
1396     * <ul>
1397     *   <li>Projected CRS codes: <b>3003</b>, <b>3004</b></li>
1398     *   <li>Geographic CRS name: <b>Monte Mario</b></li>
1399     *   <li>Projection names (informative): <b>Italy zones</b></li>
1400     *   <li>Particularly important to E&amp;P industry.</li>
1401     * </ul>
1402     *
1403     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1404     */
1405    @Test
1406    public void testMonteMario() throws FactoryException {
1407        important       = true;
1408        name            = "Monte Mario";
1409        projectionNames = new String[] {"Italy zones"};
1410        datumCode       = 6265;
1411        createAndVerifyProjectedCRS(3003);
1412        createAndVerifyProjectedCRS(3004);
1413    }
1414
1415    /**
1416     * Tests “M'poraloko”-based projected CRS creation from the factory.
1417     *
1418     * <ul>
1419     *   <li>Projected CRS codes: <b>26632</b>, <b>26692</b></li>
1420     *   <li>Geographic CRS name: <b>M'poraloko</b></li>
1421     *   <li>Projection names (informative): <b>UTM</b></li>
1422     *   <li>Particularly important to E&amp;P industry.</li>
1423     * </ul>
1424     *
1425     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1426     */
1427    @Test
1428    public void testMPoraloko() throws FactoryException {
1429        important       = true;
1430        name            = "M'poraloko";
1431        projectionNames = new String[] {"UTM"};
1432        datumCode       = 6266;
1433        createAndVerifyProjectedCRS(26632);
1434        createAndVerifyProjectedCRS(26692);
1435    }
1436
1437    /**
1438     * Tests “NAD27”-based projected CRS creation from the factory.
1439     *
1440     * <ul>
1441     *   <li>Projected CRS codes: <b>26711</b>, <b>26712</b>, <b>32012</b>, <b>32040</b>, <b>32064</b>, <b>32065</b>, <b>32066</b></li>
1442     *   <li>Geographic CRS name: <b>NAD27</b></li>
1443     *   <li>Projection names (informative): <b>State Plane zones</b>, <b>BLM zones</b>, <b>UTM</b></li>
1444     *   <li>Particularly important to E&amp;P industry.</li>
1445     * </ul>
1446     *
1447     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1448     */
1449    @Test
1450    public void testNAD27() throws FactoryException {
1451        important       = true;
1452        name            = "NAD27";
1453        projectionNames = new String[] {"State Plane zones", "BLM zones", "UTM"};
1454        datumCode       = 6267;
1455        createAndVerifyProjectedCRS(26711);
1456        createAndVerifyProjectedCRS(26712);
1457        createAndVerifyProjectedCRS(32012);
1458        createAndVerifyProjectedCRS(32040);
1459        createAndVerifyProjectedCRS(32064);
1460        createAndVerifyProjectedCRS(32065);
1461        createAndVerifyProjectedCRS(32066);
1462    }
1463
1464    /**
1465     * Tests “NAD27 Michigan”-based projected CRS creation from the factory.
1466     *
1467     * <ul>
1468     *   <li>Projected CRS codes: <b>6201</b>, <b>6202</b></li>
1469     *   <li>Geographic CRS name: <b>NAD27</b></li>
1470     *   <li>Projection names (informative): <b>State Plane zones</b></li>
1471     *   <li>Particularly important to E&amp;P industry.</li>
1472     * </ul>
1473     *
1474     * If {@link #isDeprecatedObjectCreationSupported} is {@code true}, then this method tests also:
1475     *
1476     * <ul>
1477     *   <li>Projected CRS codes: <b>26811</b>, <b>26812</b>, <b>26813</b></li>
1478     *   <li>Geographic CRS name: <b>NAD27 Michigan</b></li>
1479     *   <li>Projection names (informative): <b>State Plane zones</b></li>
1480     * </ul>
1481     *
1482     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1483     */
1484    @Test
1485    public void testNAD27_Michigan() throws FactoryException {
1486        important       = true;
1487        name            = "NAD27";
1488        projectionNames = new String[] {"State Plane zones"};
1489        datumCode       = 6267;
1490        createAndVerifyProjectedCRS(6201);
1491        createAndVerifyProjectedCRS(6202);
1492        if (isDeprecatedObjectCreationSupported) {
1493            name      = "NAD27 Michigan";
1494            datumCode = 6268;
1495            createAndVerifyProjectedCRS(26811);
1496            createAndVerifyProjectedCRS(26812);
1497            createAndVerifyProjectedCRS(26813);
1498        }
1499    }
1500
1501    /**
1502     * Tests “NAD83”-based projected CRS creation from the factory.
1503     *
1504     * <ul>
1505     *   <li>Projected CRS codes: <b>3347</b>, <b>26911</b>, <b>26912</b>, <b>32156</b>, <b>3736</b>, <b>26990</b>,
1506     *       <b>2253</b>, <b>32140</b>, <b>2278</b></li>
1507     *   <li>Geographic CRS name: <b>NAD83</b></li>
1508     *   <li>Projection names (informative): <b>State Plane zones</b>, <b>UTM</b></li>
1509     *   <li>Specific usage / Remarks: <b>Check units</b></li>
1510     *   <li>Particularly important to E&amp;P industry.</li>
1511     * </ul>
1512     *
1513     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1514     */
1515    @Test
1516    public void testNAD83() throws FactoryException {
1517        important       = true;
1518        name            = "NAD83";
1519        projectionNames = new String[] {"State Plane zones", "UTM"};
1520        datumCode       = 6269;
1521        createAndVerifyProjectedCRS(3347);
1522        createAndVerifyProjectedCRS(26911);
1523        createAndVerifyProjectedCRS(26912);
1524        createAndVerifyProjectedCRS(32156);
1525        createAndVerifyProjectedCRS(3736);
1526        createAndVerifyProjectedCRS(26990);
1527        createAndVerifyProjectedCRS(2253);
1528        createAndVerifyProjectedCRS(32140);
1529        createAndVerifyProjectedCRS(2278);
1530    }
1531
1532    /**
1533     * Tests “NAD83(CSRS)”-based projected CRS creation from the factory.
1534     *
1535     * <ul>
1536     *   <li>Projected CRS codes: <b>3348</b>, <b>2955</b>, <b>2956</b></li>
1537     *   <li>Geographic CRS name: <b>NAD83(CSRS)</b></li>
1538     *   <li>Projection names (informative): <b>UTM</b></li>
1539     *   <li>Particularly important to E&amp;P industry.</li>
1540     * </ul>
1541     *
1542     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1543     */
1544    @Test
1545    public void testNAD83_CSRS() throws FactoryException {
1546        important       = true;
1547        name            = "NAD83(CSRS)";
1548        projectionNames = new String[] {"UTM"};
1549        datumCode       = 6140;
1550        createAndVerifyProjectedCRS(3348);
1551        createAndVerifyProjectedCRS(2955);
1552        createAndVerifyProjectedCRS(2956);
1553    }
1554
1555    /**
1556     * Tests “NAD83(HARN)”-based projected CRS creation from the factory.
1557     *
1558     * <ul>
1559     *   <li>Projected CRS codes: <b>2845</b>, <b>2917</b>, <b>2809</b>, <b>2898</b></li>
1560     *   <li>Geographic CRS name: <b>NAD83(HARN)</b></li>
1561     *   <li>Projection names (informative): <b>State Plane zones</b>, <b>UTM</b></li>
1562     *   <li>Particularly important to E&amp;P industry.</li>
1563     * </ul>
1564     *
1565     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1566     */
1567    @Test
1568    public void testNAD83_HARN() throws FactoryException {
1569        important       = true;
1570        name            = "NAD83(HARN)";
1571        projectionNames = new String[] {"State Plane zones", "UTM"};
1572        datumCode       = 6152;
1573        createAndVerifyProjectedCRS(2845);
1574        createAndVerifyProjectedCRS(2917);
1575        createAndVerifyProjectedCRS(2809);
1576        createAndVerifyProjectedCRS(2898);
1577    }
1578
1579    /**
1580     * Tests “Nahrwan 1967”-based projected CRS creation from the factory.
1581     *
1582     * <ul>
1583     *   <li>Projected CRS codes: <b>27039</b>, <b>27040</b></li>
1584     *   <li>Geographic CRS name: <b>Nahrwan 1967</b></li>
1585     *   <li>Projection names (informative): <b>Nahrwan 1967</b></li>
1586     *   <li>Particularly important to E&amp;P industry.</li>
1587     * </ul>
1588     *
1589     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1590     */
1591    @Test
1592    public void testNahrwan() throws FactoryException {
1593        important       = true;
1594        name            = "Nahrwan 1967";
1595        projectionNames = new String[] {"Nahrwan 1967"};
1596        datumCode       = 6270;
1597        createAndVerifyProjectedCRS(27039);
1598        createAndVerifyProjectedCRS(27040);
1599    }
1600
1601    /**
1602     * Tests “Naparima 1955”-based projected CRS creation from the factory.
1603     *
1604     * <ul>
1605     *   <li>Projected CRS codes: <b>2067</b></li>
1606     *   <li>Geographic CRS name: <b>Naparima 1955</b></li>
1607     *   <li>Projection names (informative): <b>UTM</b></li>
1608     *   <li>Particularly important to E&amp;P industry.</li>
1609     * </ul>
1610     *
1611     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1612     */
1613    @Test
1614    public void testNaparima() throws FactoryException {
1615        important       = true;
1616        name            = "Naparima 1955";
1617        projectionNames = new String[] {"UTM"};
1618        datumCode       = 6158;
1619        createAndVerifyProjectedCRS(2067);
1620    }
1621
1622    /**
1623     * Tests “Nord Sahara 1959”-based projected CRS creation from the factory.
1624     *
1625     * <ul>
1626     *   <li>Projected CRS codes: <b>30791</b>, <b>30792</b>, <b>30730</b>, <b>30731</b>, <b>30732</b></li>
1627     *   <li>Geographic CRS name: <b>Nord Sahara 1959</b></li>
1628     *   <li>Projection names (informative): <b>Voirol Unifie</b>, <b>UTM</b></li>
1629     *   <li>Specific usage / Remarks: <b>Check old Voirol</b></li>
1630     *   <li>Particularly important to E&amp;P industry.</li>
1631     * </ul>
1632     *
1633     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1634     */
1635    @Test
1636    public void testNordSahara() throws FactoryException {
1637        important       = true;
1638        name            = "Nord Sahara 1959";
1639        projectionNames = new String[] {"Voirol Unifie", "UTM"};
1640        datumCode       = 6307;
1641        createAndVerifyProjectedCRS(30791);
1642        createAndVerifyProjectedCRS(30792);
1643        createAndVerifyProjectedCRS(30730);
1644        createAndVerifyProjectedCRS(30731);
1645        createAndVerifyProjectedCRS(30732);
1646    }
1647
1648    /**
1649     * Tests “NTF (Paris)”-based projected CRS creation from the factory.
1650     *
1651     * <ul>
1652     *   <li>Projected CRS codes: <b>27571</b>, <b>27572</b>, <b>27573</b></li>
1653     *   <li>Geographic CRS name: <b>NTF (Paris)</b></li>
1654     *   <li>Projection names (informative): <b>Lambert zones</b></li>
1655     *   <li>Particularly important to E&amp;P industry.</li>
1656     * </ul>
1657     *
1658     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1659     */
1660    @Test
1661    public void testNTF_Paris() throws FactoryException {
1662        important       = true;
1663        name            = "NTF (Paris)";
1664        projectionNames = new String[] {"Lambert zones"};
1665        datumCode       = 6807;
1666        createAndVerifyProjectedCRS(27571);
1667        createAndVerifyProjectedCRS(27572);
1668        createAndVerifyProjectedCRS(27573);
1669    }
1670
1671    /**
1672     * Tests “NZGD2000”-based projected CRS creation from the factory.
1673     *
1674     * <ul>
1675     *   <li>Projected CRS codes: <b>2193</b>, <b>2133</b>, <b>2134</b>, <b>2135</b></li>
1676     *   <li>Geographic CRS name: <b>NZGD2000</b></li>
1677     *   <li>Projection names (informative): <b>TM</b></li>
1678     *   <li>Particularly important to E&amp;P industry.</li>
1679     * </ul>
1680     *
1681     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1682     */
1683    @Test
1684    public void testNZGD2000() throws FactoryException {
1685        important        = true;
1686        name             = "NZGD2000";
1687        projectionNames  = new String[] {"TM"};
1688        datumCode        = 6167;
1689        isNorthAxisFirst = true;
1690        createAndVerifyProjectedCRS(2193);
1691        isNorthAxisFirst = false;
1692        createAndVerifyProjectedCRS(2133);
1693        createAndVerifyProjectedCRS(2134);
1694        createAndVerifyProjectedCRS(2135);
1695    }
1696
1697    /**
1698     * Tests “NZGD49”-based projected CRS creation from the factory.
1699     *
1700     * <ul>
1701     *   <li>Projected CRS codes: <b>27200</b>, <b>27291</b>, <b>27292</b></li>
1702     *   <li>Geographic CRS name: <b>NZGD49</b></li>
1703     *   <li>Projection names (informative): <b>NZMG</b>, <b>TM zones</b></li>
1704     *   <li>Particularly important to E&amp;P industry.</li>
1705     * </ul>
1706     *
1707     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1708     */
1709    @Test
1710    public void testNZGD49() throws FactoryException {
1711        important       = true;
1712        name            = "NZGD49";
1713        projectionNames = new String[] {"NZMG", "TM zones"};
1714        datumCode       = 6272;
1715        createAndVerifyProjectedCRS(27200);
1716        createAndVerifyProjectedCRS(27291);
1717        createAndVerifyProjectedCRS(27292);
1718    }
1719
1720    /**
1721     * Tests “OSGB 1936”-based projected CRS creation from the factory.
1722     *
1723     * <ul>
1724     *   <li>Projected CRS codes: <b>27700</b></li>
1725     *   <li>Geographic CRS name: <b>OSGB 1936</b></li>
1726     *   <li>Projection names (informative): <b>TM</b></li>
1727     *   <li>Particularly important to E&amp;P industry.</li>
1728     * </ul>
1729     *
1730     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1731     */
1732    @Test
1733    public void testOSGB1936() throws FactoryException {
1734        important       = true;
1735        name            = "OSGB 1936";
1736        projectionNames = new String[] {"TM"};
1737        datumCode       = 6277;
1738        createAndVerifyProjectedCRS(27700);
1739    }
1740
1741    /**
1742     * Tests “PSD93”-based projected CRS creation from the factory.
1743     *
1744     * <ul>
1745     *   <li>Projected CRS codes: <b>3440</b></li>
1746     *   <li>Geographic CRS name: <b>PSD93</b></li>
1747     *   <li>Projection names (informative): <b>UTM</b></li>
1748     *   <li>Particularly important to E&amp;P industry.</li>
1749     * </ul>
1750     *
1751     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1752     */
1753    @Test
1754    public void testPSD93() throws FactoryException {
1755        important       = true;
1756        name            = "PSD93";
1757        projectionNames = new String[] {"UTM"};
1758        datumCode       = 6134;
1759        createAndVerifyProjectedCRS(3440);
1760    }
1761
1762    /**
1763     * Tests “Pointe Noire”-based projected CRS creation from the factory.
1764     *
1765     * <ul>
1766     *   <li>Projected CRS codes: <b>28232</b></li>
1767     *   <li>Geographic CRS name: <b>Pointe Noire</b></li>
1768     *   <li>Projection names (informative): <b>UTM</b></li>
1769     *   <li>Particularly important to E&amp;P industry.</li>
1770     * </ul>
1771     *
1772     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1773     */
1774    @Test
1775    public void testPointeNoire() throws FactoryException {
1776        important       = true;
1777        name            = "Pointe Noire";
1778        projectionNames = new String[] {"UTM"};
1779        datumCode       = 6282;
1780        createAndVerifyProjectedCRS(28232);
1781    }
1782
1783    /**
1784     * Tests “POSGAR 94”-based projected CRS creation from the factory.
1785     *
1786     * <ul>
1787     *   <li>Projected CRS codes: <b>22181</b>, <b>22182</b>, <b>22183</b>, <b>22184</b>, <b>22185</b>, <b>22186</b>, <b>22187</b></li>
1788     *   <li>Geographic CRS name: <b>POSGAR 94</b></li>
1789     *   <li>Projection names (informative): <b>Argentina zones</b></li>
1790     *   <li>Particularly important to E&amp;P industry.</li>
1791     * </ul>
1792     *
1793     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1794     */
1795    @Test
1796    public void testPOSGAR94() throws FactoryException {
1797        important        = true;
1798        name             = "POSGAR 94";
1799        projectionNames  = new String[] {"Argentina zones"};
1800        datumCode        = 6694;
1801        isNorthAxisFirst = true;
1802        for (int code = 22181; code <= 22187; code++) {    // Loop over 7 codes
1803            createAndVerifyProjectedCRS(code);
1804        }
1805    }
1806
1807    /**
1808     * Tests “POSGAR 98”-based projected CRS creation from the factory.
1809     *
1810     * <ul>
1811     *   <li>Projected CRS codes: <b>22171</b>, <b>22172</b>, <b>22173</b>, <b>22174</b>, <b>22175</b>, <b>22176</b>, <b>22177</b></li>
1812     *   <li>Geographic CRS name: <b>POSGAR 98</b></li>
1813     *   <li>Projection names (informative): <b>Argentina zones</b></li>
1814     *   <li>Particularly important to E&amp;P industry.</li>
1815     * </ul>
1816     *
1817     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1818     */
1819    @Test
1820    public void testPOSGAR98() throws FactoryException {
1821        important        = true;
1822        name             = "POSGAR 98";
1823        projectionNames  = new String[] {"Argentina zones"};
1824        datumCode        = 6190;
1825        isNorthAxisFirst = true;
1826        for (int code = 22171; code <= 22177; code++) {    // Loop over 7 codes
1827            createAndVerifyProjectedCRS(code);
1828        }
1829    }
1830
1831    /**
1832     * Tests “PRS92”-based projected CRS creation from the factory.
1833     *
1834     * <ul>
1835     *   <li>Projected CRS codes: <b>3121</b>, <b>3122</b>, <b>3123</b>, <b>3124</b>, <b>3125</b></li>
1836     *   <li>Geographic CRS name: <b>PRS92</b></li>
1837     *   <li>Projection names (informative): <b>Philippine zones</b></li>
1838     *   <li>Particularly important to E&amp;P industry.</li>
1839     * </ul>
1840     *
1841     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1842     */
1843    @Test
1844    public void testPRS92() throws FactoryException {
1845        important       = true;
1846        name            = "PRS92";
1847        projectionNames = new String[] {"Philippine zones"};
1848        datumCode       = 6683;
1849        for (int code = 3121; code <= 3125; code++) {    // Loop over 5 codes
1850            createAndVerifyProjectedCRS(code);
1851        }
1852    }
1853
1854    /**
1855     * Tests “PSAD56”-based projected CRS creation from the factory.
1856     *
1857     * <ul>
1858     *   <li>Projected CRS codes: <b>24817</b>, <b>24818</b>, <b>24819</b>, <b>24820</b>, <b>24877</b>, <b>24878</b>,
1859     *       <b>24879</b>, <b>24891</b>, <b>24892</b>, <b>24893</b></li>
1860     *   <li>Geographic CRS name: <b>PSAD56</b></li>
1861     *   <li>Projection names (informative): <b>UTM</b>, <b>Peru zones</b></li>
1862     *   <li>Particularly important to E&amp;P industry.</li>
1863     * </ul>
1864     *
1865     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1866     */
1867    @Test
1868    public void testPSAD56() throws FactoryException {
1869        important       = true;
1870        name            = "PSAD56";
1871        projectionNames = new String[] {"UTM", "Peru zones"};
1872        datumCode       = 6248;
1873        for (int code = 24817; code <= 24820; code++) {    // Loop over 4 codes
1874            createAndVerifyProjectedCRS(code);
1875        }
1876        createAndVerifyProjectedCRS(24877);
1877        createAndVerifyProjectedCRS(24878);
1878        createAndVerifyProjectedCRS(24879);
1879        createAndVerifyProjectedCRS(24891);
1880        createAndVerifyProjectedCRS(24892);
1881        createAndVerifyProjectedCRS(24893);
1882    }
1883
1884    /**
1885     * Tests “Pulkovo 1942”-based projected CRS creation from the factory.
1886     *
1887     * <ul>
1888     *   <li>Projected CRS codes: <b>28409</b>, <b>28416</b>, <b>28424</b></li>
1889     *   <li>Geographic CRS name: <b>Pulkovo 1942</b></li>
1890     *   <li>Projection names (informative): <b>6-degree Gauss-Kruger</b></li>
1891     *   <li>Specific usage / Remarks: <b>Check axes order and abbreviations</b></li>
1892     *   <li>Particularly important to E&amp;P industry.</li>
1893     * </ul>
1894     *
1895     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1896     */
1897    @Test
1898    public void testPulkovo1942() throws FactoryException {
1899        important        = true;
1900        name             = "Pulkovo 1942";
1901        projectionNames  = new String[] {"6-degree Gauss-Kruger"};
1902        datumCode        = 6284;
1903        isNorthAxisFirst = true;
1904        createAndVerifyProjectedCRS(28409);
1905        createAndVerifyProjectedCRS(28416);
1906        createAndVerifyProjectedCRS(28424);
1907    }
1908
1909    /**
1910     * Tests “Pulkovo 1942(58)”-based projected CRS creation from the factory.
1911     *
1912     * <ul>
1913     *   <li>Projected CRS codes: <b>3334</b>, <b>3335</b>, <b>3844</b></li>
1914     *   <li>Geographic CRS name: <b>Pulkovo 1942(58)</b></li>
1915     *   <li>Projection names (informative): <b>6-degree Gauss-Kruger</b>, <b>Stereo70</b></li>
1916     *   <li>Specific usage / Remarks: <b>Check axes order and abbreviations</b></li>
1917     *   <li>Particularly important to E&amp;P industry.</li>
1918     * </ul>
1919     *
1920     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1921     */
1922    @Test
1923    public void testPulkovo1942_58() throws FactoryException {
1924        important        = true;
1925        name             = "Pulkovo 1942(58)";
1926        projectionNames  = new String[] {"6-degree Gauss-Kruger", "Stereo70"};
1927        datumCode        = 6179;
1928        isNorthAxisFirst = true;
1929        createAndVerifyProjectedCRS(3334);
1930        createAndVerifyProjectedCRS(3335);
1931        createAndVerifyProjectedCRS(3844);
1932    }
1933
1934    /**
1935     * Tests “Pulkovo 1942(83)”-based projected CRS creation from the factory.
1936     *
1937     * <ul>
1938     *   <li>Projected CRS codes: <b>3836</b></li>
1939     *   <li>Geographic CRS name: <b>Pulkovo 1942(83)</b></li>
1940     *   <li>Projection names (informative): <b>6-degree Gauss-Kruger</b></li>
1941     *   <li>Specific usage / Remarks: <b>Check axes order and abbreviations</b></li>
1942     *   <li>Particularly important to E&amp;P industry.</li>
1943     * </ul>
1944     *
1945     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1946     */
1947    @Test
1948    public void testPulkovo1942_83() throws FactoryException {
1949        important        = true;
1950        name             = "Pulkovo 1942(83)";
1951        projectionNames  = new String[] {"6-degree Gauss-Kruger"};
1952        datumCode        = 6178;
1953        isNorthAxisFirst = true;
1954        createAndVerifyProjectedCRS(3836);
1955    }
1956
1957    /**
1958     * Tests “Qatar 1948”-based projected CRS creation from the factory.
1959     *
1960     * <ul>
1961     *   <li>Projected CRS codes: <b>2099</b></li>
1962     *   <li>Geographic CRS name: <b>Qatar 1948</b></li>
1963     *   <li>Projection names (informative): <b>Qatar Grid</b></li>
1964     *   <li>Particularly important to E&amp;P industry.</li>
1965     * </ul>
1966     *
1967     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1968     */
1969    @Test
1970    public void testQatar1948() throws FactoryException {
1971        important       = true;
1972        name            = "Qatar 1948";
1973        projectionNames = new String[] {"Qatar Grid"};
1974        datumCode       = 6286;
1975        createAndVerifyProjectedCRS(2099);
1976    }
1977
1978    /**
1979     * Tests “Qatar 1974”-based projected CRS creation from the factory.
1980     *
1981     * <ul>
1982     *   <li>Projected CRS codes: <b>28600</b></li>
1983     *   <li>Geographic CRS name: <b>Qatar 1974</b></li>
1984     *   <li>Projection names (informative): <b>Qatar National Grid</b></li>
1985     *   <li>Particularly important to E&amp;P industry.</li>
1986     * </ul>
1987     *
1988     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
1989     */
1990    @Test
1991    public void testQatar1974() throws FactoryException {
1992        important       = true;
1993        name            = "Qatar 1974";
1994        projectionNames = new String[] {"Qatar National Grid"};
1995        datumCode       = 6285;
1996        createAndVerifyProjectedCRS(28600);
1997    }
1998
1999    /**
2000     * Tests “QND95”-based projected CRS creation from the factory.
2001     *
2002     * <ul>
2003     *   <li>Projected CRS codes: <b>2932</b></li>
2004     *   <li>Geographic CRS name: <b>QND95</b></li>
2005     *   <li>Projection names (informative): <b>Qatar National Grid</b></li>
2006     *   <li>Particularly important to E&amp;P industry.</li>
2007     * </ul>
2008     *
2009     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
2010     */
2011    @Test
2012    public void testQND95() throws FactoryException {
2013        important       = true;
2014        name            = "QND95";
2015        projectionNames = new String[] {"Qatar National Grid"};
2016        datumCode       = 6614;
2017        createAndVerifyProjectedCRS(2932);
2018    }
2019
2020    /**
2021     * Tests “REGVEN”-based projected CRS creation from the factory.
2022     *
2023     * <ul>
2024     *   <li>Projected CRS codes: <b>2201</b>, <b>2202</b>, <b>2203</b></li>
2025     *   <li>Geographic CRS name: <b>REGVEN</b></li>
2026     *   <li>Projection names (informative): <b>UTM</b></li>
2027     *   <li>Particularly important to E&amp;P industry.</li>
2028     * </ul>
2029     *
2030     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
2031     */
2032    @Test
2033    public void testREGVEN() throws FactoryException {
2034        important       = true;
2035        name            = "REGVEN";
2036        projectionNames = new String[] {"UTM"};
2037        datumCode       = 6189;
2038        createAndVerifyProjectedCRS(2201);
2039        createAndVerifyProjectedCRS(2202);
2040        createAndVerifyProjectedCRS(2203);
2041    }
2042
2043    /**
2044     * Tests “RGF93”-based projected CRS creation from the factory.
2045     *
2046     * <ul>
2047     *   <li>Projected CRS codes: <b>2154</b></li>
2048     *   <li>Geographic CRS name: <b>RGF93</b></li>
2049     *   <li>Projection names (informative): <b>Lambert 93</b></li>
2050     *   <li>Particularly important to E&amp;P industry.</li>
2051     * </ul>
2052     *
2053     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
2054     */
2055    @Test
2056    public void testRGF93() throws FactoryException {
2057        important       = true;
2058        name            = "RGF93";
2059        projectionNames = new String[] {"Lambert 93"};
2060        datumCode       = 6171;
2061        createAndVerifyProjectedCRS(2154);
2062    }
2063
2064    /**
2065     * Tests “SAD69”-based projected CRS creation from the factory.
2066     *
2067     * <ul>
2068     *   <li>Projected CRS codes: <b>29101</b>, <b>29194</b></li>
2069     *   <li>Geographic CRS name: <b>SAD69</b></li>
2070     *   <li>Projection names (informative): <b>UTM</b>, <b>Brazil Polyconic</b></li>
2071     *   <li>Particularly important to E&amp;P industry.</li>
2072     * </ul>
2073     *
2074     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
2075     */
2076    @Test
2077    public void testSAD69() throws FactoryException {
2078        important       = true;
2079        name            = "SAD69";
2080        projectionNames = new String[] {"UTM", "Brazil Polyconic"};
2081        datumCode       = 6618;
2082        createAndVerifyProjectedCRS(29101);
2083        createAndVerifyProjectedCRS(29194);
2084    }
2085
2086    /**
2087     * Tests “Schwarzeck”-based projected CRS creation from the factory.
2088     *
2089     * <ul>
2090     *   <li>Projected CRS codes: <b>29371</b>, <b>29333</b></li>
2091     *   <li>Geographic CRS name: <b>Schwarzeck</b></li>
2092     *   <li>Projection names (informative): <b>Lo/22 zones</b>, <b>UTM</b></li>
2093     *   <li>Particularly important to E&amp;P industry.</li>
2094     * </ul>
2095     *
2096     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
2097     */
2098    @Test
2099    public void testSchwarzeck() throws FactoryException {
2100        important         = true;
2101        name              = "Schwarzeck";
2102        projectionNames   = new String[] {"Lo/22 zones", "UTM"};
2103        datumCode         = 6293;
2104        isWestOrientated  = true;
2105        isSouthOrientated = true;
2106        createAndVerifyProjectedCRS(29371);
2107        isWestOrientated  = false;
2108        isSouthOrientated = false;
2109        createAndVerifyProjectedCRS(29333);
2110    }
2111
2112    /**
2113     * Tests “SIRGAS 1995”-based projected CRS creation from the factory.
2114     *
2115     * <ul>
2116     *   <li>Projected CRS codes: <b>31997</b></li>
2117     *   <li>Geographic CRS name: <b>SIRGAS 1995</b></li>
2118     *   <li>Projection names (informative): <b>UTM</b></li>
2119     *   <li>Particularly important to E&amp;P industry.</li>
2120     * </ul>
2121     *
2122     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
2123     */
2124    @Test
2125    public void testSIRGAS1995() throws FactoryException {
2126        important       = true;
2127        name            = "SIRGAS 1995";
2128        projectionNames = new String[] {"UTM"};
2129        datumCode       = 6170;
2130        createAndVerifyProjectedCRS(31997);
2131    }
2132
2133    /**
2134     * Tests “SIRGAS 2000”-based projected CRS creation from the factory.
2135     *
2136     * <ul>
2137     *   <li>Projected CRS codes: <b>31982</b></li>
2138     *   <li>Geographic CRS name: <b>SIRGAS 2000</b></li>
2139     *   <li>Projection names (informative): <b>UTM</b></li>
2140     *   <li>Particularly important to E&amp;P industry.</li>
2141     * </ul>
2142     *
2143     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
2144     */
2145    @Test
2146    public void testSIRGAS2000() throws FactoryException {
2147        important       = true;
2148        name            = "SIRGAS 2000";
2149        projectionNames = new String[] {"UTM"};
2150        datumCode       = 6674;
2151        createAndVerifyProjectedCRS(31982);
2152    }
2153
2154    /**
2155     * Tests “Tananarive”-based projected CRS creation from the factory.
2156     *
2157     * <ul>
2158     *   <li>Projected CRS codes: <b>29738</b></li>
2159     *   <li>Geographic CRS name: <b>Tananarive</b></li>
2160     *   <li>Projection names (informative): <b>UTM</b></li>
2161     *   <li>Particularly important to E&amp;P industry.</li>
2162     * </ul>
2163     *
2164     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
2165     */
2166    @Test
2167    public void testTananarive() throws FactoryException {
2168        important       = true;
2169        name            = "Tananarive";
2170        projectionNames = new String[] {"UTM"};
2171        datumCode       = 6297;
2172        createAndVerifyProjectedCRS(29738);
2173    }
2174
2175    /**
2176     * Tests “Tananarive (Paris)”-based projected CRS creation from the factory.
2177     *
2178     * <ul>
2179     *   <li>Projected CRS codes: <b>29701</b>, <b>29702</b></li>
2180     *   <li>Geographic CRS name: <b>Tananarive (Paris)</b></li>
2181     *   <li>Projection names (informative): <b>Laborde</b></li>
2182     *   <li>Particularly important to E&amp;P industry.</li>
2183     * </ul>
2184     *
2185     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
2186     */
2187    @Test
2188    public void testTananarive_Paris() throws FactoryException {
2189        important       = true;
2190        name            = "Tananarive (Paris)";
2191        projectionNames = new String[] {"Laborde"};
2192        datumCode       = 6810;
2193        createAndVerifyProjectedCRS(29701);
2194        createAndVerifyProjectedCRS(29702);
2195    }
2196
2197    /**
2198     * Tests “TC(1948)”-based projected CRS creation from the factory.
2199     *
2200     * <ul>
2201     *   <li>Projected CRS codes: <b>30339</b></li>
2202     *   <li>Geographic CRS name: <b>TC(1948)</b></li>
2203     *   <li>Projection names (informative): <b>UTM</b></li>
2204     *   <li>Particularly important to E&amp;P industry.</li>
2205     * </ul>
2206     *
2207     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
2208     */
2209    @Test
2210    public void testTC_1948() throws FactoryException {
2211        important       = true;
2212        name            = "TC(1948)";
2213        projectionNames = new String[] {"UTM"};
2214        datumCode       = 6303;
2215        createAndVerifyProjectedCRS(30339);
2216    }
2217
2218    /**
2219     * Tests “Timbalai 1948”-based projected CRS creation from the factory.
2220     *
2221     * <ul>
2222     *   <li>Projected CRS codes: <b>29850</b>, <b>29871</b>, <b>29872</b>, <b>29873</b></li>
2223     *   <li>Geographic CRS name: <b>Timbalai 1948</b></li>
2224     *   <li>Projection names (informative): <b>RSO</b>, <b>UTM</b></li>
2225     *   <li>Particularly important to E&amp;P industry.</li>
2226     * </ul>
2227     *
2228     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
2229     */
2230    @Test
2231    public void testTimbalai() throws FactoryException {
2232        important       = true;
2233        name            = "Timbalai 1948";
2234        projectionNames = new String[] {"RSO", "UTM"};
2235        datumCode       = 6298;
2236        createAndVerifyProjectedCRS(29850);
2237        createAndVerifyProjectedCRS(29871);
2238        createAndVerifyProjectedCRS(29872);
2239        createAndVerifyProjectedCRS(29873);
2240    }
2241
2242    /**
2243     * Tests “Trinidad 1903”-based projected CRS creation from the factory.
2244     *
2245     * <ul>
2246     *   <li>Projected CRS codes: <b>30200</b>, <b>2314</b></li>
2247     *   <li>Geographic CRS name: <b>Trinidad 1903</b></li>
2248     *   <li>Projection names (informative): <b>Cassini</b></li>
2249     *   <li>Particularly important to E&amp;P industry.</li>
2250     * </ul>
2251     *
2252     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
2253     */
2254    @Test
2255    public void testTrinidad() throws FactoryException {
2256        important       = true;
2257        name            = "Trinidad 1903";
2258        projectionNames = new String[] {"Cassini"};
2259        datumCode       = 6302;
2260        createAndVerifyProjectedCRS(30200);
2261        createAndVerifyProjectedCRS(2314);
2262    }
2263
2264    /**
2265     * Tests “WGS 72BE”-based projected CRS creation from the factory.
2266     *
2267     * <ul>
2268     *   <li>Projected CRS codes: <b>32488</b></li>
2269     *   <li>Geographic CRS name: <b>WGS 72BE</b></li>
2270     *   <li>Projection names (informative): <b>UTM</b></li>
2271     *   <li>Particularly important to E&amp;P industry.</li>
2272     * </ul>
2273     *
2274     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
2275     */
2276    @Test
2277    public void testWGS72BE() throws FactoryException {
2278        important       = true;
2279        name            = "WGS 72BE";
2280        projectionNames = new String[] {"UTM"};
2281        datumCode       = 6324;
2282        createAndVerifyProjectedCRS(32488);
2283    }
2284
2285    /**
2286     * Tests “WGS 84”-based projected CRS creation from the factory.
2287     *
2288     * <ul>
2289     *   <li>Projected CRS codes: <b>3832</b>, <b>32601</b>, <b>32602</b>, <b>32603</b>, <b>32604</b>, <b>32605</b>,
2290     *       <b>32606</b>, <b>32607</b>, <b>32608</b>, <b>32609</b>, <b>32610</b>, <i>…110 more</i></li>
2291     *   <li>Geographic CRS name: <b>WGS 84</b></li>
2292     *   <li>Projection names (informative): <b>UTM</b></li>
2293     *   <li>Specific usage / Remarks: <b>Check axes abbreviations</b></li>
2294     *   <li>Particularly important to E&amp;P industry.</li>
2295     * </ul>
2296     *
2297     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
2298     */
2299    @Test
2300    public void testWGS84() throws FactoryException {
2301        important       = true;
2302        name            = "WGS 84";
2303        projectionNames = new String[] {"UTM"};
2304        datumCode       = 6326;
2305        createAndVerifyProjectedCRS(3832);
2306        for (int code = 32601; code <= 32660; code++) {    // Loop over 60 codes
2307            createAndVerifyProjectedCRS(code);
2308        }
2309        for (int code = 32701; code <= 32760; code++) {    // Loop over 60 codes
2310            createAndVerifyProjectedCRS(code);
2311        }
2312    }
2313
2314    /**
2315     * Tests “Xian 1980”-based projected CRS creation from the factory.
2316     *
2317     * <ul>
2318     *   <li>Projected CRS codes: <b>2338</b>, <b>2339</b>, <b>2340</b>, <b>2341</b>, <b>2342</b>, <b>2343</b>, <b>2344</b>, <b>2345</b>, <b>2346</b>, <b>2347</b>, <i>…1 more</i></li>
2319     *   <li>Geographic CRS name: <b>Xian 1980</b></li>
2320     *   <li>Projection names (informative): <b>6-degree Gauss-Kruger</b></li>
2321     *   <li>Specific usage / Remarks: <b>Check axes order and abbreviations</b></li>
2322     *   <li>Particularly important to E&amp;P industry.</li>
2323     * </ul>
2324     *
2325     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
2326     */
2327    @Test
2328    public void testXian() throws FactoryException {
2329        important        = true;
2330        name             = "Xian 1980";
2331        projectionNames  = new String[] {"6-degree Gauss-Kruger"};
2332        datumCode        = 6610;
2333        isNorthAxisFirst = true;
2334        for (int code = 2338; code <= 2348; code++) {    // Loop over 11 codes
2335            createAndVerifyProjectedCRS(code);
2336        }
2337    }
2338
2339    /**
2340     * Tests “Yemen NGN96”-based projected CRS creation from the factory.
2341     *
2342     * <ul>
2343     *   <li>Projected CRS codes: <b>2089</b>, <b>2090</b></li>
2344     *   <li>Geographic CRS name: <b>Yemen NGN96</b></li>
2345     *   <li>Projection names (informative): <b>UTM</b></li>
2346     *   <li>Particularly important to E&amp;P industry.</li>
2347     * </ul>
2348     *
2349     * @throws FactoryException if an error occurred while creating the projected CRS from the EPSG code.
2350     */
2351    @Test
2352    public void testYemen() throws FactoryException {
2353        important       = true;
2354        name            = "Yemen NGN96";
2355        projectionNames = new String[] {"UTM"};
2356        datumCode       = 6163;
2357        createAndVerifyProjectedCRS(2089);
2358        createAndVerifyProjectedCRS(2090);
2359    }
2360}