proj4rb 4.1.1 → 5.0.0

data/test/datum_ensemble_test.rb

@@ -1,65 +1,65 @@
-# encoding: UTF-8
-
-require_relative './abstract_test'
-
-class DatumEnsembleTest < AbstractTest
-  def get_datum_ensemble
-    wkt = <<~EOS
-           GEOGCRS["ETRS89",
-             ENSEMBLE["European Terrestrial Reference System 1989 ensemble",
-                 MEMBER["European Terrestrial Reference Frame 1989"],
-                 MEMBER["European Terrestrial Reference Frame 1990"],
-                 MEMBER["European Terrestrial Reference Frame 1991"],
-                 MEMBER["European Terrestrial Reference Frame 1992"],
-                 MEMBER["European Terrestrial Reference Frame 1993"],
-                 MEMBER["European Terrestrial Reference Frame 1994"],
-                 MEMBER["European Terrestrial Reference Frame 1996"],
-                 MEMBER["European Terrestrial Reference Frame 1997"],
-                 MEMBER["European Terrestrial Reference Frame 2000"],
-                 MEMBER["European Terrestrial Reference Frame 2005"],
-                 MEMBER["European Terrestrial Reference Frame 2014"],
-                 ELLIPSOID["GRS 1980",6378137,298.257222101,
-                     LENGTHUNIT["metre",1]],
-                 ENSEMBLEACCURACY[0.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
-
-    crs = Proj::Crs.create(wkt)
-    crs.datum_ensemble
-  end
-
-  def test_count
-    ensemble = get_datum_ensemble
-    assert_equal(11, ensemble.count)
-  end
-
-  def test_member
-    ensemble = get_datum_ensemble
-
-    member = ensemble[0]
-    assert_equal(:PJ_TYPE_GEODETIC_REFERENCE_FRAME, member.proj_type)
-    assert_equal("European Terrestrial Reference Frame 1989", member.name)
-  end
-
-  def test_member_invalid
-    ensemble = get_datum_ensemble
-    member = ensemble[-1]
-    refute(member)
-
-    member = ensemble[100]
-    refute(member)
-  end
-
-  def test_accuracy
-    ensemble = get_datum_ensemble
-    assert_equal(0.1, ensemble.accuracy)
-  end
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class DatumEnsembleTest < AbstractTest
+  def get_datum_ensemble
+    wkt = <<~EOS
+           GEOGCRS["ETRS89",
+             ENSEMBLE["European Terrestrial Reference System 1989 ensemble",
+                 MEMBER["European Terrestrial Reference Frame 1989"],
+                 MEMBER["European Terrestrial Reference Frame 1990"],
+                 MEMBER["European Terrestrial Reference Frame 1991"],
+                 MEMBER["European Terrestrial Reference Frame 1992"],
+                 MEMBER["European Terrestrial Reference Frame 1993"],
+                 MEMBER["European Terrestrial Reference Frame 1994"],
+                 MEMBER["European Terrestrial Reference Frame 1996"],
+                 MEMBER["European Terrestrial Reference Frame 1997"],
+                 MEMBER["European Terrestrial Reference Frame 2000"],
+                 MEMBER["European Terrestrial Reference Frame 2005"],
+                 MEMBER["European Terrestrial Reference Frame 2014"],
+                 ELLIPSOID["GRS 1980",6378137,298.257222101,
+                     LENGTHUNIT["metre",1]],
+                 ENSEMBLEACCURACY[0.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
+
+    crs = Proj::Crs.create(wkt)
+    crs.datum_ensemble
+  end
+
+  def test_count
+    ensemble = get_datum_ensemble
+    assert_equal(11, ensemble.count)
+  end
+
+  def test_member
+    ensemble = get_datum_ensemble
+
+    member = ensemble[0]
+    assert_equal(:PJ_TYPE_GEODETIC_REFERENCE_FRAME, member.proj_type)
+    assert_equal("European Terrestrial Reference Frame 1989", member.name)
+  end
+
+  def test_member_invalid
+    ensemble = get_datum_ensemble
+    member = ensemble[-1]
+    refute(member)
+
+    member = ensemble[100]
+    refute(member)
+  end
+
+  def test_accuracy
+    ensemble = get_datum_ensemble
+    assert_equal(0.1, ensemble.accuracy)
+  end
 end

data/test/datum_test.rb

@@ -1,55 +1,62 @@
-# encoding: UTF-8
-
-require_relative './abstract_test'
-
-class DatumTest < AbstractTest
-  def test_datum
-    datum = Proj::PjObject.create_from_database("EPSG", "1061", :PJ_CATEGORY_DATUM)
-    assert_equal(:PJ_TYPE_DYNAMIC_GEODETIC_REFERENCE_FRAME, datum.proj_type)
-    assert_equal("International Terrestrial Reference Frame 2008", datum.name)
-  end
-
-  def test_frame_reference_epoch
-    datum = Proj::PjObject.create_from_database("EPSG", "1061", :PJ_CATEGORY_DATUM)
-    epoch = datum.frame_reference_epoch
-    assert_equal(2005.0, epoch)
-  end
-
-  def test_ellipsoid
-    wkt = <<~EOS
-        PROJCS["WGS 84 / UTM zone 31N",
-               GEOGCS["WGS 84",
-                      DATUM["WGS_1984",
-                            SPHEROID["WGS 84",6378137,298.257223563,
-                                     AUTHORITY["EPSG","7030"]],
-                            AUTHORITY["EPSG","6326"]],
-                      PRIMEM["Greenwich",0,
-                             AUTHORITY["EPSG","8901"]],
-                      UNIT["degree",0.0174532925199433,
-                           AUTHORITY["EPSG","9122"]],
-                      AUTHORITY["EPSG","4326"]],
-               PROJECTION["Transverse_Mercator"],
-               PARAMETER["latitude_of_origin",0],
-               PARAMETER["central_meridian",3],
-               PARAMETER["scale_factor",0.9996],
-               PARAMETER["false_easting",500000],
-               PARAMETER["false_northing",0],
-               UNIT["metre",1,
-                    AUTHORITY["EPSG","9001"]],
-               AXIS["Easting",EAST],
-               AXIS["Northing",NORTH],
-               AUTHORITY["EPSG","32631"]]
-      EOS
-
-    crs = Proj::Crs.new(wkt)
-    ellipsoid = crs.ellipsoid
-    assert_equal("WGS 84", ellipsoid.name)
-    assert_equal(:PJ_TYPE_ELLIPSOID, ellipsoid.proj_type)
-
-    ellipsoid_from_datum = crs.datum.ellipsoid
-    assert_equal("WGS 84", ellipsoid_from_datum.name)
-    assert_equal(:PJ_TYPE_ELLIPSOID, ellipsoid_from_datum.proj_type)
-
-    assert(ellipsoid_from_datum.equivalent_to?(ellipsoid, :PJ_COMP_STRICT))
-  end
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class DatumTest < AbstractTest
+  def test_datum
+    datum = Proj::PjObject.create_from_database("EPSG", "1061", :PJ_CATEGORY_DATUM)
+    assert_equal(:PJ_TYPE_DYNAMIC_GEODETIC_REFERENCE_FRAME, datum.proj_type)
+    assert_equal("International Terrestrial Reference Frame 2008", datum.name)
+  end
+
+  def test_frame_reference_epoch
+    datum = Proj::PjObject.create_from_database("EPSG", "1061", :PJ_CATEGORY_DATUM)
+    epoch = datum.frame_reference_epoch
+    assert_equal(2005.0, epoch)
+  end
+
+  def test_ellipsoid
+    wkt = <<~EOS
+        PROJCS["WGS 84 / UTM zone 31N",
+               GEOGCS["WGS 84",
+                      DATUM["WGS_1984",
+                            SPHEROID["WGS 84",6378137,298.257223563,
+                                     AUTHORITY["EPSG","7030"]],
+                            AUTHORITY["EPSG","6326"]],
+                      PRIMEM["Greenwich",0,
+                             AUTHORITY["EPSG","8901"]],
+                      UNIT["degree",0.0174532925199433,
+                           AUTHORITY["EPSG","9122"]],
+                      AUTHORITY["EPSG","4326"]],
+               PROJECTION["Transverse_Mercator"],
+               PARAMETER["latitude_of_origin",0],
+               PARAMETER["central_meridian",3],
+               PARAMETER["scale_factor",0.9996],
+               PARAMETER["false_easting",500000],
+               PARAMETER["false_northing",0],
+               UNIT["metre",1,
+                    AUTHORITY["EPSG","9001"]],
+               AXIS["Easting",EAST],
+               AXIS["Northing",NORTH],
+               AUTHORITY["EPSG","32631"]]
+      EOS
+
+    crs = Proj::Crs.new(wkt)
+    ellipsoid = crs.ellipsoid
+    assert_equal("WGS 84", ellipsoid.name)
+    assert_equal(:PJ_TYPE_ELLIPSOID, ellipsoid.proj_type)
+
+    ellipsoid_from_datum = crs.datum.ellipsoid
+    assert_equal("WGS 84", ellipsoid_from_datum.name)
+    assert_equal(:PJ_TYPE_ELLIPSOID, ellipsoid_from_datum.proj_type)
+
+    assert(ellipsoid_from_datum.equivalent_to?(ellipsoid, :PJ_COMP_STRICT))
+  end
+
+  def test_prime_meridian
+    datum = Proj::PjObject.create_from_database("EPSG", "6326", :PJ_CATEGORY_DATUM)
+    pm = datum.prime_meridian
+    assert_equal("Greenwich", pm.name)
+    assert_equal(:PJ_TYPE_PRIME_MERIDIAN, pm.proj_type)
+  end
 end

data/test/domain_test.rb

@@ -0,0 +1,72 @@
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class DomainTest < AbstractTest
+  def test_domain_count
+    crs = Proj::Crs.new('EPSG:4326')
+    count = Proj::Domain.count(crs)
+    assert_kind_of(Integer, count)
+    assert_operator(count, :>=, 1)
+  end
+
+  def test_domains
+    crs = Proj::Crs.new('EPSG:4326')
+    domains = Proj::Domain.domains(crs)
+    assert_kind_of(Array, domains)
+    refute_empty(domains)
+
+    domain = domains.first
+    assert_kind_of(Proj::Domain, domain)
+    assert_kind_of(String, domain.scope)
+    assert_kind_of(Proj::Area, domain.area_of_use)
+  end
+
+  def test_domain_scope
+    crs = Proj::Crs.new('EPSG:4326')
+    domain = Proj::Domain.domains(crs).first
+    assert_equal("Horizontal component of 3D system.", domain.scope)
+  end
+
+  def test_domain_area_of_use
+    crs = Proj::Crs.new('EPSG:4326')
+    domain = Proj::Domain.domains(crs).first
+    area = domain.area_of_use
+    assert_equal('World.', area.name)
+    assert_in_delta(-180.0, area.west_lon_degree, 0.1)
+    assert_in_delta(-90.0, area.south_lat_degree, 0.1)
+    assert_in_delta(180.0, area.east_lon_degree, 0.1)
+    assert_in_delta(90.0, area.north_lat_degree, 0.1)
+  end
+
+  def test_domains_matches_area_of_use
+    crs = Proj::Crs.new('EPSG:4326')
+    domain = Proj::Domain.domains(crs).first
+    area = crs.area_of_use
+    assert_equal(area.name, domain.area_of_use.name)
+    assert_in_delta(area.west_lon_degree, domain.area_of_use.west_lon_degree, 0.001)
+    assert_in_delta(area.south_lat_degree, domain.area_of_use.south_lat_degree, 0.001)
+    assert_in_delta(area.east_lon_degree, domain.area_of_use.east_lon_degree, 0.001)
+    assert_in_delta(area.north_lat_degree, domain.area_of_use.north_lat_degree, 0.001)
+  end
+
+  def test_domains_matches_scope
+    crs = Proj::Crs.new('EPSG:4326')
+    domain = Proj::Domain.domains(crs).first
+    assert_equal(crs.scope, domain.scope)
+  end
+
+  def test_pj_object_domains
+    crs = Proj::Crs.new('EPSG:4326')
+    domains = crs.domains
+    assert_kind_of(Array, domains)
+    refute_empty(domains)
+    assert_kind_of(Proj::Domain, domains.first)
+  end
+
+  def test_domains_noop
+    conversion = Proj::Conversion.new("+proj=noop")
+    domains = Proj::Domain.domains(conversion)
+    assert_empty(domains)
+  end
+end

data/test/ellipsoid_test.rb

@@ -1,80 +1,80 @@
-# encoding: UTF-8
-
-require_relative './abstract_test'
-
-class EllipsoidTest < AbstractTest
-  def parameter_crs
-    wkt = <<~EOS
-      PROJCS["WGS 84 / UTM zone 31N",
-             GEOGCS["WGS 84",
-                    DATUM["WGS_1984",
-                          SPHEROID["WGS 84",6378137,298.257223563,
-                                   AUTHORITY["EPSG","7030"]],
-                          AUTHORITY["EPSG","6326"]],
-                    PRIMEM["Greenwich",0,
-                           AUTHORITY["EPSG","8901"]],
-                    UNIT["degree",0.0174532925199433,
-                         AUTHORITY["EPSG","9122"]],
-                    AUTHORITY["EPSG","4326"]],
-             PROJECTION["Transverse_Mercator"],
-             PARAMETER["latitude_of_origin",0],
-             PARAMETER["central_meridian",3],
-             PARAMETER["scale_factor",0.9996],
-             PARAMETER["false_easting",500000],
-             PARAMETER["false_northing",0],
-             UNIT["metre",1,
-                  AUTHORITY["EPSG","9001"]],
-             AXIS["Easting",EAST],
-             AXIS["Northing",NORTH],
-             AUTHORITY["EPSG","32631"]]
-    EOS
-    Proj::Crs.new(wkt)
-  end
-
-  def test_built_in
-    ellipsoids = Proj::Ellipsoid.built_in.map {|ellipsoid| ellipsoid[:id] }
-    assert(ellipsoids.include?('WGS84'))
-    assert(ellipsoids.include?('bessel'))
-    assert(ellipsoids.include?('lerch'))
-  end
-
-  def test_from_database
-    ellipsoid = Proj::Ellipsoid.create_from_database("EPSG", "7030", :PJ_CATEGORY_ELLIPSOID)
-    assert_instance_of(Proj::Ellipsoid, ellipsoid)
-    assert_equal(:PJ_TYPE_ELLIPSOID, ellipsoid.proj_type)
-    assert_equal("EPSG", ellipsoid.auth_name)
-    assert_equal("WGS 84", ellipsoid.name)
-    assert_equal("7030", ellipsoid.id_code)
-  end
-
-  def test_parameters
-    ellipsoid = parameter_crs.ellipsoid
-    params = ellipsoid.parameters
-
-    expected = {semi_major_axis: 6378137.0,
-                semi_minor_axis: 6356752.314245179,
-                semi_minor_axis_computed: true,
-                inverse_flattening: 298.257223563}
-    assert_equal(expected, params)
-  end
-
-  def test_semi_major_axis
-    meridian = parameter_crs.ellipsoid
-    assert_equal(6378137.0, meridian.semi_major_axis)
-  end
-
-  def test_semi_minor_axis
-    meridian = parameter_crs.ellipsoid
-    assert_equal(6356752.314245179, meridian.semi_minor_axis)
-  end
-
-  def test_semi_minor_axis_computed
-    meridian = parameter_crs.ellipsoid
-    assert(meridian.semi_minor_axis_computed)
-  end
-
-  def test_inverse_flattening
-    meridian = parameter_crs.ellipsoid
-    assert_equal(298.257223563, meridian.inverse_flattening)
-  end
-end
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class EllipsoidTest < AbstractTest
+  def parameter_crs
+    wkt = <<~EOS
+      PROJCS["WGS 84 / UTM zone 31N",
+             GEOGCS["WGS 84",
+                    DATUM["WGS_1984",
+                          SPHEROID["WGS 84",6378137,298.257223563,
+                                   AUTHORITY["EPSG","7030"]],
+                          AUTHORITY["EPSG","6326"]],
+                    PRIMEM["Greenwich",0,
+                           AUTHORITY["EPSG","8901"]],
+                    UNIT["degree",0.0174532925199433,
+                         AUTHORITY["EPSG","9122"]],
+                    AUTHORITY["EPSG","4326"]],
+             PROJECTION["Transverse_Mercator"],
+             PARAMETER["latitude_of_origin",0],
+             PARAMETER["central_meridian",3],
+             PARAMETER["scale_factor",0.9996],
+             PARAMETER["false_easting",500000],
+             PARAMETER["false_northing",0],
+             UNIT["metre",1,
+                  AUTHORITY["EPSG","9001"]],
+             AXIS["Easting",EAST],
+             AXIS["Northing",NORTH],
+             AUTHORITY["EPSG","32631"]]
+    EOS
+    Proj::Crs.new(wkt)
+  end
+
+  def test_built_in
+    ellipsoids = Proj::Ellipsoid.built_in.map {|ellipsoid| ellipsoid[:id] }
+    assert(ellipsoids.include?('WGS84'))
+    assert(ellipsoids.include?('bessel'))
+    assert(ellipsoids.include?('lerch'))
+  end
+
+  def test_from_database
+    ellipsoid = Proj::Ellipsoid.create_from_database("EPSG", "7030", :PJ_CATEGORY_ELLIPSOID)
+    assert_instance_of(Proj::Ellipsoid, ellipsoid)
+    assert_equal(:PJ_TYPE_ELLIPSOID, ellipsoid.proj_type)
+    assert_equal("EPSG", ellipsoid.auth_name)
+    assert_equal("WGS 84", ellipsoid.name)
+    assert_equal("7030", ellipsoid.id_code)
+  end
+
+  def test_parameters
+    ellipsoid = parameter_crs.ellipsoid
+    params = ellipsoid.parameters
+
+    expected = {semi_major_axis: 6378137.0,
+                semi_minor_axis: 6356752.314245179,
+                semi_minor_axis_computed: true,
+                inverse_flattening: 298.257223563}
+    assert_equal(expected, params)
+  end
+
+  def test_semi_major_axis
+    meridian = parameter_crs.ellipsoid
+    assert_equal(6378137.0, meridian.semi_major_axis)
+  end
+
+  def test_semi_minor_axis
+    meridian = parameter_crs.ellipsoid
+    assert_equal(6356752.314245179, meridian.semi_minor_axis)
+  end
+
+  def test_semi_minor_axis_computed
+    meridian = parameter_crs.ellipsoid
+    assert(meridian.semi_minor_axis_computed)
+  end
+
+  def test_inverse_flattening
+    meridian = parameter_crs.ellipsoid
+    assert_equal(298.257223563, meridian.inverse_flattening)
+  end
+end

data/test/examples_test.rb

@@ -0,0 +1,149 @@
+require_relative 'abstract_test'
+
+class ExamplesTest < AbstractTest
+  def test_geodetic_distance
+    crs = Proj::Crs.new('EPSG:4326')
+
+    paris  = Proj::Coordinate.new(x: Proj.degrees_to_radians(2.3522),
+                                   y: Proj.degrees_to_radians(48.8566))
+    berlin = Proj::Coordinate.new(x: Proj.degrees_to_radians(13.4050),
+                                   y: Proj.degrees_to_radians(52.5200))
+
+    distance = crs.lp_distance(paris, berlin)
+    assert_in_delta(879_700, distance, 5_000)
+  end
+
+  def test_geod_distance_with_azimuth
+    crs = Proj::Crs.new('EPSG:4326')
+
+    paris  = Proj::Coordinate.new(x: Proj.degrees_to_radians(2.3522),
+                                   y: Proj.degrees_to_radians(48.8566))
+    berlin = Proj::Coordinate.new(x: Proj.degrees_to_radians(13.4050),
+                                   y: Proj.degrees_to_radians(52.5200))
+
+    result = crs.geod_distance(paris, berlin)
+    assert_in_delta(879_700, result.x, 5_000)
+    # Forward azimuth: roughly northeast
+    assert_in_delta(58.24, result.y, 1.0)
+    # Reverse azimuth: roughly southwest
+    assert_in_delta(66.81, result.z, 1.0)
+  end
+
+  if Proj::Api::PROJ_VERSION >= Gem::Version.new('9.7.0')
+    def test_geod_direct
+      crs = Proj::Crs.new('EPSG:4326')
+
+      paris = Proj::Coordinate.new(x: Proj.degrees_to_radians(2.3522),
+                                    y: Proj.degrees_to_radians(48.8566))
+
+      # 100 km due north
+      endpoint = crs.geod_direct(paris, 0.0, 100_000)
+      assert(endpoint.x.finite?)
+      assert(endpoint.y.finite?)
+      # Longitude should be approximately the same
+      assert_in_delta(2.3522, Proj.radians_to_degrees(endpoint.x), 0.01)
+      # Latitude should be ~0.9 degrees further north
+      assert_in_delta(49.76, Proj.radians_to_degrees(endpoint.y), 0.1)
+    end
+  end
+
+  def test_transform_bounds
+    transform = Proj::Transformation.new('EPSG:4326',
+      '+proj=laea +lat_0=45 +lon_0=-100 +x_0=0 +y_0=0 +a=6370997 +b=6370997 +units=m +no_defs')
+
+    bounds = Proj::Bounds.new(40, -120, 64, -80)
+    result = transform.transform_bounds(bounds, :PJ_FWD, 21)
+
+    assert(result.xmin.finite?)
+    assert(result.ymin.finite?)
+    assert(result.xmax.finite?)
+    assert(result.ymax.finite?)
+    assert_operator(result.xmin, :<, result.xmax)
+    assert_operator(result.ymin, :<, result.ymax)
+  end
+
+  def test_database_query_authorities
+    database = Proj::Database.new(Proj::Context.current)
+    authorities = database.authorities
+    assert_operator(authorities.count, :>, 0)
+    assert_includes(authorities.to_a, 'EPSG')
+  end
+
+  def test_database_query_codes
+    database = Proj::Database.new(Proj::Context.current)
+    codes = database.codes('EPSG', :PJ_TYPE_GEOGRAPHIC_2D_CRS)
+    assert_operator(codes.count, :>, 0)
+  end
+
+  def test_database_query_crs_info
+    database = Proj::Database.new(Proj::Context.current)
+    crs_infos = database.crs_info('EPSG')
+    assert_operator(crs_infos.count, :>, 0)
+
+    info = crs_infos.first
+    assert_equal('EPSG', info.auth_name)
+    refute_nil(info.name)
+    refute_nil(info.crs_type)
+  end
+
+  def test_crs_identification
+    crs = Proj::Crs.new('OGC:CRS84')
+    objects, confidences = crs.identify('OGC')
+
+    assert_equal(1, objects.count)
+    assert_equal(100, confidences[0])
+  end
+
+  def test_promote_to_3d
+    crs_2d = Proj::Crs.new('EPSG:4326')
+    assert_equal(:PJ_TYPE_GEOGRAPHIC_2D_CRS, crs_2d.proj_type)
+
+    crs_3d = crs_2d.promote_to_3d
+    assert_equal(:PJ_TYPE_GEOGRAPHIC_3D_CRS, crs_3d.proj_type)
+  end
+
+  def test_demote_to_2d
+    crs_2d = Proj::Crs.new('EPSG:4326')
+    crs_3d = crs_2d.promote_to_3d
+    crs_back = crs_3d.demote_to_2d
+    assert_equal(:PJ_TYPE_GEOGRAPHIC_2D_CRS, crs_back.proj_type)
+  end
+
+  def test_batch_transformation
+    conversion = Proj::Conversion.new('+proj=utm +zone=32 +ellps=GRS80')
+
+    coordinates = [
+      Proj::Coordinate.new(lon: Proj.degrees_to_radians(12), lat: Proj.degrees_to_radians(55), z: 45),
+      Proj::Coordinate.new(lon: Proj.degrees_to_radians(12), lat: Proj.degrees_to_radians(56), z: 50),
+      Proj::Coordinate.new(lon: Proj.degrees_to_radians(13), lat: Proj.degrees_to_radians(55), z: 30)
+    ]
+
+    results = conversion.transform_array(coordinates, :PJ_FWD)
+
+    assert_equal(3, results.size)
+    results.each do |coord|
+      assert(coord.x.finite?)
+      assert(coord.y.finite?)
+    end
+
+    assert_in_delta(691875.63, results[0].x, 1)
+    assert_in_delta(6098907.83, results[0].y, 1)
+  end
+
+  def test_context_logging
+    context = Proj::Context.new
+    messages = []
+
+    context.set_log_function do |_pointer, level, message|
+      messages << { level: level, message: message }
+    end
+
+    begin
+      context.database.path = '/nonexistent'
+    rescue Proj::Error
+    end
+
+    refute_empty(messages)
+    assert(messages.any? { |m| m[:message].include?('/nonexistent') })
+  end
+end