proj4rb 3.0.0 → 4.0.0

data/test/grid_cache_test.rb

@@ -0,0 +1,72 @@
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class GridCacheTest < AbstractTest
+  def download(grid)
+    begin
+      grid.download
+    ensure
+      grid.delete
+    end
+  end
+
+  def test_clear
+    context = Proj::Context.new
+    context.network_enabled = true
+    context.cache.enabled = true
+
+    cache_path = File.join(context.user_directory, "cache.db")
+    context.cache.clear
+    refute(File.exist?(cache_path))
+  end
+
+  def test_disable
+    context = Proj::Context.new
+    cache_path = File.join(context.user_directory, "cache.db")
+
+    context.network_enabled = true
+    context.cache.clear
+    context.cache.enabled = false
+    refute(File.exist?(cache_path))
+
+    database = Proj::Database.new(context)
+    grid = database.grid("au_icsm_GDA94_GDA2020_conformal.tif")
+
+    # Download the file to create the cache
+    download(grid)
+
+    refute(File.exist?(cache_path))
+  end
+
+  def test_set_path
+    context = Proj::Context.new
+    context.network_enabled = true
+    database = Proj::Database.new(context)
+    grid = database.grid("au_icsm_GDA94_GDA2020_conformal.tif")
+
+    # Custom path
+    cache_path = context.cache.path = File.join(Dir.tmpdir, "proj_cache_test.db")
+    refute(File.exist?(cache_path))
+
+    # Download the file to create the cache
+    download(grid)
+
+    assert(File.exist?(cache_path))
+
+    context.cache.clear
+    refute(File.exist?(cache_path))
+  end
+
+  def test_ttl
+    context = Proj::Context.new
+    context.cache.ttl = 60
+    assert(true)
+  end
+
+  def test_max_size
+    context = Proj::Context.new
+    context.cache.max_size = 100
+    assert(true)
+  end
+end

data/test/grid_test.rb

@@ -0,0 +1,141 @@
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class GridTest < AbstractTest
+  def test_grid
+    database = Proj::Database.new(Proj::Context.current)
+    grid = database.grid("au_icsm_GDA94_GDA2020_conformal.tif")
+
+    assert_equal("au_icsm_GDA94_GDA2020_conformal.tif", grid.name)
+    assert(grid.full_name.empty?)
+    assert(grid.package_name.empty?)
+    assert_equal("https://cdn.proj.org/au_icsm_GDA94_GDA2020_conformal.tif", grid.url.to_s)
+    assert(grid.downloadable?)
+    assert(grid.open_license?)
+    refute(grid.available?)
+  end
+
+  def test_grid_proj6_name
+    database = Proj::Database.new(Proj::Context.current)
+    grid = database.grid("GDA94_GDA2020_conformal.gsb")
+
+    assert_equal("GDA94_GDA2020_conformal.gsb", grid.name)
+    assert(grid.full_name.empty?)
+    assert(grid.package_name.empty?)
+    assert_instance_of(URI::HTTPS, grid.url)
+    assert_equal("https://cdn.proj.org/au_icsm_GDA94_GDA2020_conformal.tif", grid.url.to_s)
+    assert(grid.downloadable?)
+    assert(grid.open_license?)
+    refute(grid.available?)
+  end
+
+  def test_downloaded_network_disabled
+    context = Proj::Context.new
+    context.network_enabled = false
+
+    grid = Proj::Grid.new("dk_sdfe_dvr90.tif", context)
+    refute(grid.downloaded?)
+  end
+
+  def test_downloaded_network_enabled
+    context = Proj::Context.new
+    context.network_enabled = true
+
+    grid = Proj::Grid.new("dk_sdfe_dvr90.tif", context)
+    refute(grid.downloaded?)
+  end
+
+  def test_download
+    context = Proj::Context.new
+    context.network_enabled = true
+
+    grid = Proj::Grid.new("dk_sdfe_dvr90.tif", context)
+    refute(grid.path)
+
+    begin
+      grid.download
+      assert(grid.path)
+      assert(grid.downloaded?)
+    ensure
+      grid.delete
+    end
+  end
+
+  def test_download_with_progress
+    context = Proj::Context.new
+    context.network_enabled = true
+
+    database = Proj::Database.new(context)
+    grid = database.grid("au_icsm_GDA94_GDA2020_conformal.tif")
+
+    progress_values = Array.new
+    begin
+      downloaded = grid.download do |progress|
+        progress_values << progress
+      end
+      assert(downloaded)
+    ensure
+      grid.delete
+    end
+
+    assert(progress_values.count > 1)
+    assert(progress_values.include?(1.0))
+  end
+
+  def test_download_with_progress_cancel
+    context = Proj::Context.new
+    context.network_enabled = true
+
+    database = Proj::Database.new(context)
+    grid = database.grid("au_icsm_GDA94_GDA2020_conformal.tif")
+
+    progress_values = Array.new
+    begin
+      downloaded = grid.download do |progress|
+        progress_values << progress
+        # Cancel download
+        false
+      end
+      refute(downloaded)
+    ensure
+      grid.delete
+    end
+
+    assert_equal(1, progress_values.count)
+    refute(progress_values.include?(1.0))
+  end
+
+  def test_grid_info
+    context = Proj::Context.new
+    context.network_enabled = true
+    grid = Proj::Grid.new("dk_sdfe_dvr90.tif", context)
+
+    begin
+      assert(grid.info.filename.empty?)
+      #assert_equal("dk_sdfe_dvr90.tif", grid.info.gridname)
+      # assert_equal("gtiff", grid.info.format)
+      # assert_in_delta(0, grid.info.lower_left[:lam])
+      # assert_in_delta(0, grid.info.lower_left[:phi])
+      # assert_in_delta(0, grid.info.upper_right[:lam])
+      # assert_in_delta(0, grid.info.upper_right[:phi])
+      # assert_in_delta(0, grid.info.size_lon)
+      # assert_in_delta(0, grid.info.size_lat)
+      # assert_in_delta(0, grid.info.cell_size_lon)
+      # assert_in_delta(0, grid.info.cell_size_lat)
+    ensure
+      grid.delete
+    end
+  end
+
+  def test_grid_invalid
+    skip "This test sometimes raises an error and sometimes doesn't."
+    database = Proj::Database.new(Proj::Context.current)
+    grid = database.grid("invalid")
+
+    error = assert_raises(Proj::Error) do
+      grid = database.grid("invalid")
+    end
+    assert_equal("Unknown error (code 4096)", error.to_s)
+  end
+end

data/test/network_api_test.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class NetworkApiTest < AbstractTest
+  def setup
+    super
+    # Make sure downloader callbacks are not GCed
+    #GC.stress = true
+  end
+
+  def teardown
+    super
+    GC.stress = false
+  end
+
+  def test_download
+    skip "This test causes a segfault due to the way Proj cleans up on shutdown"
+
+    context = Proj::Context.new
+    context.network_enabled = true
+
+    # Create a grid
+    grid = Proj::Grid.new("dk_sdfe_dvr90.tif", context)
+    grid.delete
+
+    context.cache.clear
+
+    # Install custom network api
+    context.set_network_api(Proj::NetworkApiImpl)
+
+    conversion = Proj::Conversion.new(<<~EOS, context)
+          +proj=pipeline
+          +step +proj=unitconvert +xy_in=deg +xy_out=rad
+          +step +proj=vgridshift +grids=dk_sdfe_dvr90.tif +multiplier=1
+          +step +proj=unitconvert +xy_in=rad +xy_out=deg
+        EOS
+
+    coord = Proj::Coordinate.new(lon: 12, lat: 56, z: 0)
+    new_coord = conversion.forward(coord)
+    assert_in_delta(12, new_coord.lon)
+    assert_in_delta(56, new_coord.lat)
+    assert_in_delta(36.5909996032715, new_coord.z, 1e-10)
+  end
+end

data/test/operation_factory_context_test.rb

@@ -0,0 +1,201 @@
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class OperationFactoryContextTest < AbstractTest
+  def test_create
+    context = Proj::Context.new
+    factory_context = Proj::OperationFactoryContext.new(context)
+    assert(context.to_ptr)
+  end
+
+  def test_finalize
+    100.times do
+      context = Proj::Context.new
+      factory_context = Proj::OperationFactoryContext.new(context)
+      assert(context.to_ptr)
+      GC.start
+    end
+    assert(true)
+  end
+
+  def test_create_operations
+    context = Proj::Context.new
+    source = Proj::Crs.create_from_database("EPSG", "4267", :PJ_CATEGORY_CRS)
+    target = Proj::Crs.create_from_database("EPSG", "4269", :PJ_CATEGORY_CRS)
+
+    factory_context = Proj::OperationFactoryContext.new(context)
+    factory_context.spatial_criterion = :PROJ_SPATIAL_CRITERION_PARTIAL_INTERSECTION
+    factory_context.grid_availability = :PROJ_GRID_AVAILABILITY_IGNORED
+
+    operations = factory_context.create_operations(source, target)
+    assert_equal(10, operations.count)
+
+    operation = operations[0]
+    assert_equal("NAD27 to NAD83 (4)", operation.name)
+    refute(operation.ballpark_transformation?)
+  end
+
+  def test_suggested_operation
+    context = Proj::Context.new
+    source = Proj::Crs.create_from_database("EPSG", "4267", :PJ_CATEGORY_CRS)
+    target = Proj::Crs.create_from_database("EPSG", "4269", :PJ_CATEGORY_CRS)
+
+    factory_context = Proj::OperationFactoryContext.new(context)
+    factory_context.spatial_criterion = :PROJ_SPATIAL_CRITERION_PARTIAL_INTERSECTION
+    factory_context.grid_availability = :PROJ_GRID_AVAILABILITY_IGNORED
+
+    operations = factory_context.create_operations(source, target)
+
+    coord = Proj::Coordinate.new(x: 40, y: -100)
+    index = operations.suggested_operation(:PJ_FWD, coord)
+
+    expected = case
+               when proj9?
+                 2
+               else
+                 7
+               end
+    assert_equal(expected, index)
+
+    operation = operations[index]
+
+    expected = case
+               when proj9?
+                 "NAD27 to NAD83 (1)"
+               else
+                 "Ballpark geographic offset from NAD27 to NAD83"
+               end
+
+    assert_equal(expected, operation.name)
+  end
+
+  def test_ballpark_transformations
+    context = Proj::Context.new
+    source = Proj::Crs.create_from_database("EPSG", "4267", :PJ_CATEGORY_CRS)
+    target = Proj::Crs.create_from_database("EPSG", "4258", :PJ_CATEGORY_CRS)
+
+    factory_context = Proj::OperationFactoryContext.new(context)
+    factory_context.spatial_criterion = :PROJ_SPATIAL_CRITERION_PARTIAL_INTERSECTION
+    factory_context.grid_availability = :PROJ_GRID_AVAILABILITY_IGNORED
+
+    # Allowed implicitly
+    operations = factory_context.create_operations(source, target)
+    assert_equal(1, operations.count)
+
+    # Allow explicitly
+    factory_context.ballpark_transformations = true
+    operations = factory_context.create_operations(source, target)
+    assert_equal(1, operations.count)
+
+    # Disallow
+    factory_context.ballpark_transformations = false
+    operations = factory_context.create_operations(source, target)
+    assert_equal(0, operations.count)
+  end
+
+  def test_desired_accuracy
+    context = Proj::Context.new
+    factory_context = Proj::OperationFactoryContext.new(context)
+    factory_context.desired_accuracy = 5
+  end
+
+  def test_set_area_of_interest
+    context = Proj::Context.new
+    factory_context = Proj::OperationFactoryContext.new(context)
+    factory_context.set_area_of_interest(10, 10, 10, 10)
+  end
+
+  def test_crs_extent_use
+    context = Proj::Context.new
+    factory_context = Proj::OperationFactoryContext.new(context)
+    factory_context.crs_extent_use = :PJ_CRS_EXTENT_SMALLEST
+  end
+
+  def test_spatial_criterion
+    context = Proj::Context.new
+    factory_context = Proj::OperationFactoryContext.new(context)
+    factory_context.spatial_criterion = :PROJ_SPATIAL_CRITERION_STRICT_CONTAINMENT
+  end
+
+  def test_grid_availability
+    context = Proj::Context.new
+    factory_context = Proj::OperationFactoryContext.new(context)
+    factory_context.grid_availability = :PROJ_GRID_AVAILABILITY_USE
+  end
+
+  def test_use_proj_alternative_grid_names
+    context = Proj::Context.new
+    factory_context = Proj::OperationFactoryContext.new(context)
+    factory_context.use_proj_alternative_grid_names = true
+  end
+
+  def test_allow_use_intermediate_crs
+    context = Proj::Context.new
+    # There is no direct transformations between both
+    source = Proj::Crs.create_from_database("EPSG", "4230", :PJ_CATEGORY_CRS)
+    target = Proj::Crs.create_from_database("EPSG", "4171", :PJ_CATEGORY_CRS)
+
+    # Default behavior: allow any pivot
+    factory_context = Proj::OperationFactoryContext.new(context)
+    operations = factory_context.create_operations(source, target)
+    assert_equal(1, operations.count)
+
+    operation = operations[0]
+    assert_equal("ED50 to ETRS89 (10) + Inverse of RGF93 v1 to ETRS89 (1)", operation.name)
+    refute(operation.ballpark_transformation?)
+
+    # Disallow pivots
+    factory_context.allow_use_intermediate_crs = :PROJ_INTERMEDIATE_CRS_USE_NEVER
+    operations = factory_context.create_operations(source, target)
+    assert_equal(1, operations.count)
+
+    operation = operations[0]
+    assert_equal("Ballpark geographic offset from ED50 to RGF93 v1", operation.name)
+    assert(operation.ballpark_transformation?)
+  end
+
+  def test_allowed_intermediate_crs
+    context = Proj::Context.new
+
+    # There is no direct transformations between both
+    source = Proj::Crs.create_from_database("EPSG", "4230", :PJ_CATEGORY_CRS)
+    target = Proj::Crs.create_from_database("EPSG", "4171", :PJ_CATEGORY_CRS)
+
+    # Restrict pivot to ETRS89
+    factory_context = Proj::OperationFactoryContext.new(context, authority: "EPSG")
+    factory_context.allowed_intermediate_crs = ["EPSG", "4258"]
+
+    operations = factory_context.create_operations(source, target)
+    assert_equal(1, operations.count)
+
+    operation = operations[0]
+    assert_equal("ED50 to ETRS89 (10) + Inverse of RGF93 v1 to ETRS89 (1)", operation.name)
+  end
+
+  def test_discard_superseded
+    context = Proj::Context.new
+    source = Proj::Crs.create_from_database("EPSG", "4203", :PJ_CATEGORY_CRS)
+    target = Proj::Crs.create_from_database("EPSG", "4326", :PJ_CATEGORY_CRS)
+
+    factory_context = Proj::OperationFactoryContext.new(context)
+    factory_context.spatial_criterion = :PROJ_SPATIAL_CRITERION_PARTIAL_INTERSECTION
+    factory_context.grid_availability = :PROJ_GRID_AVAILABILITY_IGNORED
+
+    factory_context.discard_superseded = true
+    operations = factory_context.create_operations(source, target)
+    assert_equal(4, operations.count)
+
+    factory_context.discard_superseded = false
+    operations = factory_context.create_operations(source, target)
+    assert_equal(5, operations.count)
+  end
+
+  if proj9?
+    def test_set_area_of_interest_name
+      context = Proj::Context.new
+      factory_context = Proj::OperationFactoryContext.new(context)
+      factory_context.area_of_interest_name = 'test'
+    end
+  end
+end

data/test/parameters_test.rb

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class ParametersTest < AbstractTest
+  def test_types_nil
+    params = Proj::Parameters.new
+    assert(params.types.empty?)
+  end
+
+  def test_types_one
+    types = [:PJ_TYPE_GEODETIC_CRS]
+    params = Proj::Parameters.new
+    params.types = types
+    assert_equal(types, params.types)
+  end
+
+  def test_types_many
+    types = [:PJ_TYPE_GEODETIC_CRS, :PJ_TYPE_GEOCENTRIC_CRS, :PJ_TYPE_GEOGRAPHIC_CRS]
+    params = Proj::Parameters.new
+    params.types = types
+    assert_equal(types, params.types)
+  end
+
+  def test_bbox_valid
+    params = Proj::Parameters.new
+    refute(params.bbox_valid)
+
+    params.bbox_valid = true
+    assert(params.bbox_valid)
+  end
+
+  def test_allow_deprecated
+    params = Proj::Parameters.new
+    refute(params.allow_deprecated)
+
+    params.allow_deprecated = true
+    assert(params.allow_deprecated)
+  end
+end

data/test/pj_object_test.rb

@@ -0,0 +1,179 @@
+# encoding: UTF-8
+
+require_relative './abstract_test'
+class PjObjectTest < AbstractTest
+  def test_clone
+    object = Proj::PjObject.create("+proj=longlat")
+    clone = object.clone
+    assert(object.equivalent_to?(clone, :PJ_COMP_STRICT))
+    assert(object.context.equal?(clone.context))
+  end
+
+  def test_dup
+    object = Proj::PjObject.create("+proj=longlat")
+    clone = object.dup
+    assert(object.equivalent_to?(clone, :PJ_COMP_STRICT))
+    assert(object.context.equal?(clone.context))
+  end
+  
+  def test_equivalent
+    from_epsg = Proj::PjObject.create_from_database("EPSG", "7844", :PJ_CATEGORY_CRS)
+    from_wkt = Proj::PjObject.create_from_wkt(<<~EOS)
+                    GEOGCRS["GDA2020",
+                      DATUM["GDA2020",
+                          ELLIPSOID["GRS_1980",6378137,298.257222101,
+                              LENGTHUNIT["metre",1]]],
+                      PRIMEM["Greenwich",0,
+                          ANGLEUNIT["Degree",0.0174532925199433]],
+                      CS[ellipsoidal,2],
+                          AXIS["geodetic latitude (Lat)",north,
+                              ORDER[1],
+                              ANGLEUNIT["degree",0.0174532925199433]],
+                          AXIS["geodetic longitude (Lon)",east,
+                              ORDER[2],
+                              ANGLEUNIT["degree",0.0174532925199433]]]"
+                  EOS
+
+    assert(from_epsg.equivalent_to?(from_wkt, :PJ_COMP_EQUIVALENT))
+  end
+
+  def test_accuracy_crs
+    object = Proj::PjObject.create_from_database("EPSG", "4326", :PJ_CATEGORY_CRS)
+    assert_equal(-1, object.accuracy)
+  end
+
+  def test_accuracy_coordinate_operation
+    object = Proj::PjObject.create_from_database("EPSG", "1170", :PJ_CATEGORY_COORDINATE_OPERATION)
+    assert_equal(16.0, object.accuracy)
+  end
+
+  def test_accuracy_projection
+    object = Proj::Conversion.new("+proj=helmert")
+    assert_equal(-1.0, object.accuracy)
+  end
+
+  def test_id_code
+    crs = Proj::Crs.new('EPSG:4326')
+    assert_equal("4326", crs.id_code)
+    refute(crs.id_code(1))
+  end
+
+  def test_remarks_transformation
+    transformation = Proj::PjObject.create_from_database("EPSG", "8048", :PJ_CATEGORY_COORDINATE_OPERATION)
+
+    expected = "Scale difference in ppb where 1/billion = 1E-9. See CT codes 8444-46 for NTv2 method giving equivalent results for Christmas Island, Cocos Islands and Australia respectively. See CT code 8447 for alternative including distortion model for Australia only."
+    assert_equal(expected, transformation.remarks)
+  end
+
+  def test_remarks_conversion
+    operation = Proj::PjObject.create_from_database("EPSG", "3811", :PJ_CATEGORY_COORDINATE_OPERATION)
+
+    expected = "Replaces Lambert 2005."
+    assert_equal(expected, operation.remarks)
+  end
+
+  def test_scope_transformation
+    transformation = Proj::PjObject.create_from_database("EPSG", "8048", :PJ_CATEGORY_COORDINATE_OPERATION)
+
+    expected = "Transformation of GDA94 coordinates that have been derived through GNSS CORS."
+    assert_equal(expected, transformation.scope)
+  end
+
+  def test_scope_conversion
+    operation = Proj::PjObject.create_from_database("EPSG", "3811", :PJ_CATEGORY_COORDINATE_OPERATION)
+
+    expected = "Engineering survey, topographic mapping."
+    assert_equal(expected, operation.scope)
+  end
+
+  def test_scope_invalid
+    operation = Proj::Conversion.new("+proj=noop")
+    refute(operation.scope)
+  end
+
+  def test_factors
+    conversion = Proj::Conversion.new("+proj=merc +ellps=WGS84")
+    coord = Proj::Coordinate.new(lon: Proj.degrees_to_radians(12), lat: Proj.degrees_to_radians(55))
+    factors = conversion.factors(coord)
+
+    assert_in_delta(1.739526610076288, factors[:meridional_scale], 1e-7)
+    assert_in_delta(1.739526609938368, factors[:parallel_scale], 1e-7)
+    assert_in_delta(3.0259528269235867, factors[:areal_scale], 1e-7)
+
+    assert_in_delta(0.0, factors[:angular_distortion], 1e-7)
+    assert_in_delta(1.5707963267948966, factors[:meridian_parallel_angle], 1e-7)
+    assert_in_delta(0.0, factors[:meridian_convergence], 1e-7)
+
+    assert_in_delta(1.7395266100073281, factors[:tissot_semimajor], 1e-7)
+    assert_in_delta(1.7395266100073281, factors[:tissot_semiminor], 1e-7)
+
+    assert_in_delta(0.9999999999996122, factors[:dx_dlam], 1e-7)
+    assert_in_delta(0.0, factors[:dx_dphi], 1e-7)
+    assert_in_delta(0.0, factors[:dy_dlam], 1e-7)
+    assert_in_delta(1.7395897312200146, factors[:dy_dphi], 1e-7)
+  end
+
+  def test_create_from_name
+    context = Proj::Context.new
+    objects = Proj::PjObject.create_from_name("WGS 84", context)
+    assert_equal(5, objects.size)
+  end
+
+  def test_create_from_name_with_auth_name
+    context = Proj::Context.new
+    objects = Proj::PjObject.create_from_name("WGS 84", context, auth_name: "xx")
+    assert_equal(0, objects.size)
+  end
+
+  def test_create_from_name_with_types
+    context = Proj::Context.new
+    objects = Proj::PjObject.create_from_name("WGS 84", context, types: [:PJ_TYPE_GEODETIC_CRS, :PJ_TYPE_PROJECTED_CRS])
+    assert_equal(3, objects.size)
+  end
+
+  def test_create_from_name_with_types_and_approximate_match
+    context = Proj::Context.new
+    objects = Proj::PjObject.create_from_name("WGS 84", context, approximate_match: true,
+                                              types: [:PJ_TYPE_GEODETIC_CRS, :PJ_TYPE_PROJECTED_CRS])
+
+    expected = proj9? ? 442 : 440
+    assert_equal(expected, objects.size)
+  end
+
+  def test_create_from_name_with_types_and_approximate_match_and_limit
+    context = Proj::Context.new
+    objects = Proj::PjObject.create_from_name("WGS 84", context, approximate_match: true, limit: 25,
+                                              types: [:PJ_TYPE_GEODETIC_CRS, :PJ_TYPE_PROJECTED_CRS])
+    assert_equal(25, objects.size)
+  end
+
+  def test_deprecated_true
+    wkt = <<~EOS
+          GEOGCRS["SAD69 (deprecated)",
+              DATUM["South_American_Datum_1969",
+                  ELLIPSOID["GRS 1967",6378160,298.247167427,
+                      LENGTHUNIT["metre",1,
+                          ID["EPSG",9001]]]],
+              PRIMEM["Greenwich",0,
+                  ANGLEUNIT["degree",0.0174532925199433,
+                      ID["EPSG",9122]]],
+              CS[ellipsoidal,2],
+                  AXIS["latitude",north,
+                      ORDER[1],
+                      ANGLEUNIT["degree",0.0174532925199433,
+                          ID["EPSG",9122]]],
+                  AXIS["longitude",east,
+                      ORDER[2],
+                      ANGLEUNIT["degree",0.0174532925199433,
+                          ID["EPSG",9122]]]]
+    EOS
+
+    crs = Proj::Crs.create(wkt)
+    assert(crs.deprecated?)
+  end
+
+  def test_deprecated_false
+    crs = Proj::Crs.create_from_database("EPSG", "4326", :PJ_CATEGORY_CRS)
+    refute(crs.deprecated?)
+  end
+end