proj4rb 4.1.0 → 5.0.0

data/test/session_test.rb

@@ -1,78 +1,79 @@
-# encoding: UTF-8
-
-require_relative './abstract_test'
-
-class SessionTest < AbstractTest
-  def teardown
-    GC.start
-  end
-
-  def create_crs
-    Proj::Crs.new(<<~EOS, Proj::Context.new)
-      GEOGCRS["myGDA2020",
-        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
-  end
-
-  def test_create_session
-    session = Proj::Session.new
-    assert(session)
-  end
-
-  def test_finalize
-    100.times do
-      crs = Proj::Session.new(Proj::Context.new)
-      assert(crs.to_ptr)
-      GC.start
-    end
-    assert(true)
-  end
-
-  def test_insert_statements
-    crs = create_crs
-    session = Proj::Session.new(crs.context)
-    statements = session.get_insert_statements(crs, "HOBU", "XXXX")
-    assert_equal(4, statements.count)
-
-    expected = "INSERT INTO geodetic_datum VALUES('HOBU','GEODETIC_DATUM_XXXX','GDA2020','','EPSG','7019','EPSG','8901',NULL,NULL,NULL,NULL,0);"
-    assert_equal(expected, statements[0])
-  end
-
-  def test_insert_statements_empty_authorities
-    crs = create_crs
-
-    session = Proj::Session.new(crs.context)
-    statements = session.get_insert_statements(crs, "HOBU", "XXXX", false, [])
-    assert_equal(6, statements.count)
-  end
-
-  def test_insert_statements_authorities_proj
-    crs = create_crs
-
-    session = Proj::Session.new(crs.context)
-    statements = session.get_insert_statements(crs, "HOBU", "XXXX", false, ['EPSG'])
-    assert_equal(4, statements.count)
-  end
-
-  def test_insert_twice
-    crs = create_crs
-
-    session = Proj::Session.new(crs.context)
-    statements = session.get_insert_statements(crs, "HOBU", "XXXX")
-    assert_equal(4, statements.count)
-
-    statements = session.get_insert_statements(crs, "HOBU", "XXXX")
-    assert_equal(0, statements.count)
-  end
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class SessionTest < AbstractTest
+  def teardown
+    GC.start
+  end
+
+  def create_crs
+    Proj::Crs.new(<<~EOS, Proj::Context.new)
+      GEOGCRS["myGDA2020",
+        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
+  end
+
+  def test_create_session
+    session = Proj::Session.new
+    assert(session)
+  end
+
+  def test_finalize
+    100.times do
+      crs = Proj::Session.new(Proj::Context.new)
+      assert(crs.to_ptr)
+      GC.start
+    end
+    assert(true)
+  end
+
+  def test_insert_statements
+    crs = create_crs
+    session = Proj::Session.new(crs.context)
+    statements = session.get_insert_statements(crs, "HOBU", "XXXX")
+    assert_operator(statements.count, :>=, 4)
+
+    insert = statements.find { |s| s.include?("INSERT INTO geodetic_datum") }
+    assert(insert, "Expected an INSERT INTO geodetic_datum statement")
+    assert_includes(insert, "'HOBU','GEODETIC_DATUM_XXXX','GDA2020'")
+  end
+
+  def test_insert_statements_empty_authorities
+    crs = create_crs
+
+    session = Proj::Session.new(crs.context)
+    statements = session.get_insert_statements(crs, "HOBU", "XXXX", false, [])
+    assert_equal(6, statements.count)
+  end
+
+  def test_insert_statements_authorities_proj
+    crs = create_crs
+
+    session = Proj::Session.new(crs.context)
+    statements = session.get_insert_statements(crs, "HOBU", "XXXX", false, ['EPSG'])
+    assert_equal(4, statements.count)
+  end
+
+  def test_insert_twice
+    crs = create_crs
+
+    session = Proj::Session.new(crs.context)
+    statements = session.get_insert_statements(crs, "HOBU", "XXXX")
+    assert_equal(4, statements.count)
+
+    statements = session.get_insert_statements(crs, "HOBU", "XXXX")
+    assert_equal(0, statements.count)
+  end
 end

data/test/transformation_test.rb

@@ -1,210 +1,238 @@
-# encoding: UTF-8
-
-require_relative './abstract_test'
-
-class TransformationTest < AbstractTest
-  PRECISION = 1.5
-
-  def setup
-    @crs_wgs84 = Proj::Crs.new('EPSG:4326')
-    @crs_gk = Proj::Crs.new('EPSG:31467')
-  end
-
-  def test_create_from_strings
-    transform = Proj::Transformation.new('EPSG:31467', 'EPSG:4326')
-    assert(transform.info)
-  end
-
-  def test_create_from_crs
-    transform = Proj::Transformation.new(@crs_wgs84, @crs_gk)
-    assert(transform.info)
-  end
-
-  def test_create
-    context = Proj::Context.new
-    coordinate_system = Proj::CoordinateSystem.create_ellipsoidal_2d(:PJ_ELLPS2D_LONGITUDE_LATITUDE, context)
-    source_crs = Proj::Crs.create_geographic(context,
-                                             name: "Source CRS",
-                                             datum_name: "World Geodetic System 1984",
-                                             ellipsoid_name: "WGS 84",
-                                             semi_major_meter: 6378137,
-                                             inv_flattening: 298.257223563,
-                                             prime_meridian_name: "Greenwich",
-                                             prime_meridian_offset: 0.0,
-                                             pm_angular_units: "Degree",
-                                             pm_angular_units_conv: 0.0174532925199433,
-                                             coordinate_system: coordinate_system)
-
-    target_crs = Proj::Crs.create_geographic(context,
-                                             name: "WGS 84",
-                                             datum_name: "World Geodetic System 1984",
-                                             ellipsoid_name: "WGS 84",
-                                             semi_major_meter: 6378137,
-                                             inv_flattening: 298.257223563,
-                                             prime_meridian_name: "Greenwich",
-                                             prime_meridian_offset: 0.0,
-                                             pm_angular_units: "Degree",
-                                             pm_angular_units_conv: 0.0174532925199433,
-                                             coordinate_system: coordinate_system)
-
-    interp_crs = Proj::Crs.create_geographic(context,
-                                             name: "Interpolation CRS",
-                                             datum_name: "World Geodetic System 1984",
-                                             ellipsoid_name: "WGS 84",
-                                             semi_major_meter: 6378137,
-                                             inv_flattening: 298.257223563,
-                                             prime_meridian_name: "Greenwich",
-                                             prime_meridian_offset: 0.0,
-                                             pm_angular_units: "Degree",
-                                             pm_angular_units_conv: 0.0174532925199433,
-                                             coordinate_system: coordinate_system)
-
-    param = Proj::Parameter.new(name: "param name", value: 0.99,
-                                unit_conv_factor: 1.0, unit_type: :PJ_UT_SCALE)
-
-    transformation = Proj::Transformation.create(context, name: "transf", auth_name: "transf auth", code: "transf code",
-                                                 source_crs: source_crs, target_crs: target_crs, interpolation_crs: interp_crs,
-                                                 method_name: "method", method_auth_name: "method_auth", method_code: "1",
-                                                 params: [param], accuracy: 0)
-
-    assert_equal(1, transformation.param_count)
-
-    assert(source_crs.equivalent_to?(transformation.source_crs, :PJ_COMP_STRICT))
-    assert(target_crs.equivalent_to?(transformation.target_crs, :PJ_COMP_STRICT))
-  end
-
-  # echo "3458305 5428192" | cs2cs -f '%.10f' +init=epsg:31467 +to +init=epsg:4326 -
-  def test_gk_to_wgs84_forward
-    transform = Proj::Transformation.new(@crs_gk, @crs_wgs84)
-    from = Proj::Coordinate.new(x: 5428192.0, y: 3458305.0, z: -5.1790915237)
-    to = transform.forward(from)
-
-    assert_in_delta(48.98963932450735, to.x, PRECISION)
-    assert_in_delta(8.429263044355544, to.y, PRECISION)
-    assert_in_delta(-5.1790915237, to.z, PRECISION)
-    assert_in_delta(0, to.t, PRECISION)
-  end
-
-  def test_gk_to_wgs84_inverse
-    transform = Proj::Transformation.new(@crs_gk, @crs_wgs84)
-    from = Proj::Coordinate.new(lam: 48.9906726079, phi: 8.4302123334)
-    to = transform.inverse(from)
-
-    assert_in_delta(5428306, to.x, PRECISION)
-    assert_in_delta(3458375, to.y, PRECISION)
-    assert_in_delta(0, to.z, PRECISION)
-    assert_in_delta(0, to.t, PRECISION)
-  end
-
-  # echo "8.4293092923 48.9896114523" | cs2cs -f '%.10f' +init=epsg:4326 +to +init=epsg:31467 -
-  def test_wgs84_to_gk_forward
-    transform = Proj::Transformation.new(@crs_wgs84, @crs_gk)
-    from = Proj::Coordinate.new(lam: 48.9906726079, phi: 8.4302123334)
-    to = transform.forward(from)
-
-    assert_in_delta(5428306, to.x, PRECISION)
-    assert_in_delta(3458375, to.y, PRECISION)
-    assert_in_delta(0, to.z, PRECISION)
-    assert_in_delta(0, to.t, PRECISION)
-  end
-
-  def test_wgs84_to_gk_forward_inverse
-    transform = Proj::Transformation.new(@crs_wgs84, @crs_gk)
-    from = Proj::Coordinate.new(x: 5428192.0, y: 3458305.0, z: -5.1790915237)
-    to = transform.inverse(from)
-
-    assert_in_delta(48.98963932450735, to.x, PRECISION)
-    assert_in_delta(8.429263044355544, to.y, PRECISION)
-    assert_in_delta(-5.1790915237, to.z, PRECISION)
-    assert_in_delta(0, to.t, PRECISION)
-  end
-
-  def test_with_area
-    area = Proj::Area.new(west_lon_degree: -114.1324, south_lat_degree: 49.5614,
-                          east_lon_degree: 3.76488, north_lat_degree: 62.1463)
-    transformation = Proj::Transformation.new("EPSG:4277", "EPSG:4326", area: area)
-
-    coordinate1 = Proj::Coordinate.new(x: 50, y: -2, z: 0, t: Float::INFINITY)
-    coordinate2 = transformation.forward(coordinate1)
-
-    assert_in_delta(50.00065628, coordinate2.x, 1e-4)
-    assert_in_delta(-2.00133989, coordinate2.y, 1e-4)
-  end
-
-  def test_accuracy_filter
-    src = Proj::Crs.new("EPSG:4326")
-    dst = Proj::Crs.new("EPSG:4258")
-
-    error = assert_raises(Proj::Error) do
-      Proj::Transformation.new(src, dst, accuracy: 0.05)
-    end
-    assert_equal("No operation found matching criteria", error.to_s)
-  end
-
-  def test_ballpark_filter
-    src = Proj::Crs.new("EPSG:4267")
-    dst = Proj::Crs.new("EPSG:4258")
-
-    error = assert_raises(Proj::Error) do
-      Proj::Transformation.new(src, dst, allow_ballpark: false)
-    end
-    assert_equal("No operation found matching criteria", error.to_s)
-  end
-
-  if proj8?
-    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")
-
-      start_bounds = Proj::Bounds.new(40, -120, 64, -80)
-      end_bounds = transform.transform_bounds(start_bounds, :PJ_FWD, 0)
-
-      assert_equal(-1684649.4133828662, end_bounds.xmin)
-      assert_equal(-350356.8137658477, end_bounds.ymin)
-      assert_equal(1684649.4133828674, end_bounds.xmax)
-      assert_equal(2234551.1855909275, end_bounds.ymax)
-    end
-
-    def test_transform_bounds_normalized
-      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")
-
-      normalized = transform.normalize_for_visualization
-
-      start_bounds = Proj::Bounds.new(-120, 40, -80, 64)
-      end_bounds = normalized.transform_bounds(start_bounds, :PJ_FWD, 100)
-
-      assert_equal(-1684649.4133828662, end_bounds.xmin)
-      assert_equal(-555777.7923351025, end_bounds.ymin)
-      assert_equal(1684649.4133828674, end_bounds.xmax)
-      assert_equal(2234551.1855909275, end_bounds.ymax)
-    end
-
-    def test_transform_bounds_densify
-      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")
-
-      start_bounds = Proj::Bounds.new(40, -120, 64, -80)
-      end_bounds = transform.transform_bounds(start_bounds, :PJ_FWD, 100)
-
-      assert_equal(-1684649.4133828662, end_bounds.xmin)
-      assert_equal(-555777.7923351025, end_bounds.ymin)
-      assert_equal(1684649.4133828674, end_bounds.xmax)
-      assert_equal(2234551.1855909275, end_bounds.ymax)
-    end
-
-    def test_instantiable
-      operation = Proj::Conversion.create_from_database("EPSG", "1671", :PJ_CATEGORY_COORDINATE_OPERATION)
-      assert(operation.instantiable?)
-    end
-
-    def test_steps_not_concatenated
-      operation = Proj::Conversion.create_from_database("EPSG", "8048", :PJ_CATEGORY_COORDINATE_OPERATION)
-      assert_instance_of(Proj::Transformation, operation)
-      assert_equal(:PJ_TYPE_TRANSFORMATION, operation.proj_type)
-
-      assert_equal(0, operation.step_count)
-      refute(operation.step(0))
-    end
-  end
-end
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class TransformationTest < AbstractTest
+  PRECISION = 1.5
+
+  def setup
+    @crs_wgs84 = Proj::Crs.new('EPSG:4326')
+    @crs_gk = Proj::Crs.new('EPSG:31467')
+  end
+
+  def test_create_from_strings
+    transform = Proj::Transformation.new('EPSG:31467', 'EPSG:4326')
+    assert(transform.info)
+  end
+
+  def test_create_from_crs
+    transform = Proj::Transformation.new(@crs_wgs84, @crs_gk)
+    assert(transform.info)
+  end
+
+  def test_create
+    context = Proj::Context.new
+    coordinate_system = Proj::CoordinateSystem.create_ellipsoidal_2d(:PJ_ELLPS2D_LONGITUDE_LATITUDE, context)
+    source_crs = Proj::Crs.create_geographic(context,
+                                             name: "Source CRS",
+                                             datum_name: "World Geodetic System 1984",
+                                             ellipsoid_name: "WGS 84",
+                                             semi_major_meter: 6378137,
+                                             inv_flattening: 298.257223563,
+                                             prime_meridian_name: "Greenwich",
+                                             prime_meridian_offset: 0.0,
+                                             pm_angular_units: "Degree",
+                                             pm_angular_units_conv: 0.0174532925199433,
+                                             coordinate_system: coordinate_system)
+
+    target_crs = Proj::Crs.create_geographic(context,
+                                             name: "WGS 84",
+                                             datum_name: "World Geodetic System 1984",
+                                             ellipsoid_name: "WGS 84",
+                                             semi_major_meter: 6378137,
+                                             inv_flattening: 298.257223563,
+                                             prime_meridian_name: "Greenwich",
+                                             prime_meridian_offset: 0.0,
+                                             pm_angular_units: "Degree",
+                                             pm_angular_units_conv: 0.0174532925199433,
+                                             coordinate_system: coordinate_system)
+
+    interp_crs = Proj::Crs.create_geographic(context,
+                                             name: "Interpolation CRS",
+                                             datum_name: "World Geodetic System 1984",
+                                             ellipsoid_name: "WGS 84",
+                                             semi_major_meter: 6378137,
+                                             inv_flattening: 298.257223563,
+                                             prime_meridian_name: "Greenwich",
+                                             prime_meridian_offset: 0.0,
+                                             pm_angular_units: "Degree",
+                                             pm_angular_units_conv: 0.0174532925199433,
+                                             coordinate_system: coordinate_system)
+
+    param = Proj::Parameter.new(name: "param name", value: 0.99,
+                                unit_conv_factor: 1.0, unit_type: :PJ_UT_SCALE)
+
+    transformation = Proj::Transformation.create(context, name: "transf", auth_name: "transf auth", code: "transf code",
+                                                 source_crs: source_crs, target_crs: target_crs, interpolation_crs: interp_crs,
+                                                 method_name: "method", method_auth_name: "method_auth", method_code: "1",
+                                                 params: [param], accuracy: 0)
+
+    assert_equal(1, transformation.param_count)
+
+    assert(source_crs.equivalent_to?(transformation.source_crs, :PJ_COMP_STRICT))
+    assert(target_crs.equivalent_to?(transformation.target_crs, :PJ_COMP_STRICT))
+  end
+
+  # echo "3458305 5428192" | cs2cs -f '%.10f' +init=epsg:31467 +to +init=epsg:4326 -
+  def test_gk_to_wgs84_forward
+    transform = Proj::Transformation.new(@crs_gk, @crs_wgs84)
+    from = Proj::Coordinate.new(x: 5428192.0, y: 3458305.0, z: -5.1790915237)
+    to = transform.forward(from)
+
+    assert_in_delta(48.98963932450735, to.x, PRECISION)
+    assert_in_delta(8.429263044355544, to.y, PRECISION)
+    assert_in_delta(-5.1790915237, to.z, PRECISION)
+    assert_in_delta(0, to.t, PRECISION)
+  end
+
+  def test_gk_to_wgs84_inverse
+    transform = Proj::Transformation.new(@crs_gk, @crs_wgs84)
+    from = Proj::Coordinate.new(lam: 48.9906726079, phi: 8.4302123334)
+    to = transform.inverse(from)
+
+    assert_in_delta(5428306, to.x, PRECISION)
+    assert_in_delta(3458375, to.y, PRECISION)
+    assert_in_delta(0, to.z, PRECISION)
+    assert_in_delta(0, to.t, PRECISION)
+  end
+
+  # echo "8.4293092923 48.9896114523" | cs2cs -f '%.10f' +init=epsg:4326 +to +init=epsg:31467 -
+  def test_wgs84_to_gk_forward
+    transform = Proj::Transformation.new(@crs_wgs84, @crs_gk)
+    from = Proj::Coordinate.new(lam: 48.9906726079, phi: 8.4302123334)
+    to = transform.forward(from)
+
+    assert_in_delta(5428306, to.x, PRECISION)
+    assert_in_delta(3458375, to.y, PRECISION)
+    assert_in_delta(0, to.z, PRECISION)
+    assert_in_delta(0, to.t, PRECISION)
+  end
+
+  def test_wgs84_to_gk_forward_inverse
+    transform = Proj::Transformation.new(@crs_wgs84, @crs_gk)
+    from = Proj::Coordinate.new(x: 5428192.0, y: 3458305.0, z: -5.1790915237)
+    to = transform.inverse(from)
+
+    assert_in_delta(48.98963932450735, to.x, PRECISION)
+    assert_in_delta(8.429263044355544, to.y, PRECISION)
+    assert_in_delta(-5.1790915237, to.z, PRECISION)
+    assert_in_delta(0, to.t, PRECISION)
+  end
+
+  def test_with_area
+    area = Proj::Area.new(west_lon_degree: -114.1324, south_lat_degree: 49.5614,
+                          east_lon_degree: 3.76488, north_lat_degree: 62.1463)
+    transformation = Proj::Transformation.new("EPSG:4277", "EPSG:4326", area: area)
+
+    coordinate1 = Proj::Coordinate.new(x: 50, y: -2, z: 0, t: Float::INFINITY)
+    coordinate2 = transformation.forward(coordinate1)
+
+    assert_in_delta(50.00065628, coordinate2.x, 1e-4)
+    assert_in_delta(-2.00133989, coordinate2.y, 1e-4)
+  end
+
+  def test_accuracy_filter
+    src = Proj::Crs.new("EPSG:4326")
+    dst = Proj::Crs.new("EPSG:4258")
+
+    error = assert_raises(Proj::Error) do
+      Proj::Transformation.new(src, dst, accuracy: 0.05)
+    end
+    assert_includes(["No operation found matching criteria", "Unknown error (code 4096)"], error.to_s)
+  end
+
+  def test_ballpark_filter
+    src = Proj::Crs.new("EPSG:4267")
+    dst = Proj::Crs.new("EPSG:4258")
+
+    error = assert_raises(Proj::Error) do
+      Proj::Transformation.new(src, dst, allow_ballpark: false)
+    end
+    assert_includes(["No operation found matching criteria", "Unknown error (code 4096)"], error.to_s)
+  end
+
+  if Proj::Api::PROJ_VERSION >= '8.0.0'
+    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")
+
+      start_bounds = Proj::Bounds.new(40, -120, 64, -80)
+      end_bounds = transform.transform_bounds(start_bounds, :PJ_FWD, 0)
+
+      assert_in_delta(-1684649.4133828662, end_bounds.xmin, 1e-3)
+      assert_in_delta(-350356.8137658477, end_bounds.ymin, 1e-3)
+      assert_in_delta(1684649.4133828674, end_bounds.xmax, 1e-3)
+      assert_in_delta(2234551.1855909275, end_bounds.ymax, 1e-3)
+    end
+
+    def test_transform_bounds_normalized
+      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")
+
+      normalized = transform.normalize_for_visualization
+
+      start_bounds = Proj::Bounds.new(-120, 40, -80, 64)
+      end_bounds = normalized.transform_bounds(start_bounds, :PJ_FWD, 100)
+
+      assert_in_delta(-1684649.4133828662, end_bounds.xmin, 1e-3)
+      assert_in_delta(-555777.7923351025, end_bounds.ymin, 1e-3)
+      assert_in_delta(1684649.4133828674, end_bounds.xmax, 1e-3)
+      assert_in_delta(2234551.1855909275, end_bounds.ymax, 1e-3)
+    end
+
+    def test_transform_bounds_densify
+      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")
+
+      start_bounds = Proj::Bounds.new(40, -120, 64, -80)
+      end_bounds = transform.transform_bounds(start_bounds, :PJ_FWD, 100)
+
+      assert_in_delta(-1684649.4133828662, end_bounds.xmin, 1e-3)
+      assert_in_delta(-555777.7923351025, end_bounds.ymin, 1e-3)
+      assert_in_delta(1684649.4133828674, end_bounds.xmax, 1e-3)
+      assert_in_delta(2234551.1855909275, end_bounds.ymax, 1e-3)
+    end
+
+    def test_instantiable
+      operation = Proj::Conversion.create_from_database("EPSG", "1671", :PJ_CATEGORY_COORDINATE_OPERATION)
+      assert(operation.instantiable?)
+    end
+
+    def test_steps_not_concatenated
+      operation = Proj::Conversion.create_from_database("EPSG", "8048", :PJ_CATEGORY_COORDINATE_OPERATION)
+      assert_instance_of(Proj::Transformation, operation)
+      assert_equal(:PJ_TYPE_TRANSFORMATION, operation.proj_type)
+
+      assert_equal(0, operation.step_count)
+      refute(operation.step(0))
+    end
+  end
+
+  if Proj::Api::PROJ_VERSION >= Gem::Version.new('9.6.0')
+    def test_transform_bounds_3d
+      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")
+
+      start_bounds = Proj::Bounds3d.new(40, -120, 100, 64, -80, 500)
+      end_bounds = transform.transform_bounds_3d(start_bounds, :PJ_FWD, 21)
+
+      assert_in_delta(-1684649.4133828662, end_bounds.xmin, 1e-3)
+      assert_in_delta(-555797.9720927872, end_bounds.ymin, 1e-3)
+      assert_in_delta(100.0, end_bounds.zmin, 1e-3)
+      assert_in_delta(1684649.4133828674, end_bounds.xmax, 1e-3)
+      assert_in_delta(2234551.1855909275, end_bounds.ymax, 1e-3)
+      assert_in_delta(500.0, end_bounds.zmax, 1e-3)
+    end
+
+    def test_transform_bounds_3d_error
+      context = Proj::Context.new
+      conv = Proj::Conversion.new("+proj=cart +ellps=GRS80", context)
+      bounds = Proj::Bounds3d.new(40, -120, 100, 64, -80, 500)
+
+      error = assert_raises(Proj::Error) do
+        conv.transform_bounds_3d(bounds, :PJ_FWD, 0)
+      end
+      assert_equal("Invalid coordinate", error.message)
+    end
+  end
+end