@Test
  public void testScale() {
    final Scale trans =
        new Scale() {
          {
            setX(25);
            setY(52);
          }
        };
    final Rectangle n = new Rectangle();
    n.getTransforms().add(trans);

    assertTx(n, BaseTransform.getScaleInstance(25, 52));
    TransformHelper.assertMatrix(trans, 25, 0, 0, 0, 0, 52, 0, 0, 0, 0, 1, 0);

    trans.setX(34);
    Assert.assertEquals(34, trans.getX(), 1e-100);
    assertTx(n, BaseTransform.getScaleInstance(34, 52));
    TransformHelper.assertMatrix(trans, 34, 0, 0, 0, 0, 52, 0, 0, 0, 0, 1, 0);

    trans.setY(67);
    assertTx(n, BaseTransform.getScaleInstance(34, 67));
    TransformHelper.assertMatrix(trans, 34, 0, 0, 0, 0, 67, 0, 0, 0, 0, 1, 0);

    trans.setPivotX(66);

    Affine2D expTx = new Affine2D();
    expTx.setToTranslation(trans.getPivotX(), trans.getPivotY());
    expTx.scale(trans.getX(), trans.getY());
    expTx.translate(-trans.getPivotX(), -trans.getPivotY());
    assertTx(n, expTx);
    TransformHelper.assertMatrix(trans, 34, 0, 0, -2178, 0, 67, 0, 0, 0, 0, 1, 0);

    trans.setPivotY(77);

    expTx.setToTranslation(trans.getPivotX(), trans.getPivotY());
    expTx.scale(trans.getX(), trans.getY());
    expTx.translate(-trans.getPivotX(), -trans.getPivotY());
    assertTx(n, expTx);
    TransformHelper.assertMatrix(trans, 34, 0, 0, -2178, 0, 67, 0, -5082, 0, 0, 1, 0);

    trans.setZ(10);
    trans.setPivotZ(5);
    TransformHelper.assertMatrix(trans, 34, 0, 0, -2178, 0, 67, 0, -5082, 0, 0, 10, -45);
  }
  // This function is nearly identical to the one written for the
  // original port of the F3 graphics/UI library:
  // javafx.ui.canvas.ArcTo#addTo
  private void addArcTo(NGPath pgPath, Path2D path, final double x0, final double y0) {
    double localX = getX();
    double localY = getY();
    boolean localSweepFlag = isSweepFlag();
    boolean localLargeArcFlag = isLargeArcFlag();

    // Determine target "to" position
    final double xto = (isAbsolute()) ? localX : localX + x0;
    final double yto = (isAbsolute()) ? localY : localY + y0;
    // Compute the half distance between the current and the final point
    final double dx2 = (x0 - xto) / 2.0;
    final double dy2 = (y0 - yto) / 2.0;
    // Convert angle from degrees to radians
    final double xAxisRotationR = Math.toRadians(getXAxisRotation());
    final double cosAngle = Math.cos(xAxisRotationR);
    final double sinAngle = Math.sin(xAxisRotationR);

    //
    // Step 1 : Compute (x1, y1)
    //
    final double x1 = (cosAngle * dx2 + sinAngle * dy2);
    final double y1 = (-sinAngle * dx2 + cosAngle * dy2);
    // Ensure radii are large enough
    double rx = Math.abs(getRadiusX());
    double ry = Math.abs(getRadiusY());
    double Prx = rx * rx;
    double Pry = ry * ry;
    final double Px1 = x1 * x1;
    final double Py1 = y1 * y1;
    // check that radii are large enough
    final double radiiCheck = Px1 / Prx + Py1 / Pry;
    if (radiiCheck > 1.0) {
      rx = Math.sqrt(radiiCheck) * rx;
      ry = Math.sqrt(radiiCheck) * ry;
      if (rx == rx && ry == ry) {
        /* not NANs */
      } else {
        if (pgPath == null) {
          path.lineTo((float) xto, (float) yto);
        } else {
          pgPath.addLineTo((float) xto, (float) yto);
        }
        return;
      }
      Prx = rx * rx;
      Pry = ry * ry;
    }

    //
    // Step 2 : Compute (cx1, cy1)
    //
    double sign = ((localLargeArcFlag == localSweepFlag) ? -1.0 : 1.0);
    double sq = ((Prx * Pry) - (Prx * Py1) - (Pry * Px1)) / ((Prx * Py1) + (Pry * Px1));
    sq = (sq < 0.0) ? 0.0 : sq;
    final double coef = (sign * Math.sqrt(sq));
    final double cx1 = coef * ((rx * y1) / ry);
    final double cy1 = coef * -((ry * x1) / rx);

    //
    // Step 3 : Compute (cx, cy) from (cx1, cy1)
    //
    final double sx2 = (x0 + xto) / 2.0;
    final double sy2 = (y0 + yto) / 2.0;
    final double cx = sx2 + (cosAngle * cx1 - sinAngle * cy1);
    final double cy = sy2 + (sinAngle * cx1 + cosAngle * cy1);

    //
    // Step 4 : Compute the angleStart (angle1) and the angleExtent (dangle)
    //
    final double ux = (x1 - cx1) / rx;
    final double uy = (y1 - cy1) / ry;
    final double vx = (-x1 - cx1) / rx;
    final double vy = (-y1 - cy1) / ry;
    // Compute the angle start
    double n = Math.sqrt((ux * ux) + (uy * uy));
    double p = ux; // (1 * ux) + (0 * uy)
    sign = ((uy < 0.0) ? -1.0 : 1.0);
    double angleStart = Math.toDegrees(sign * Math.acos(p / n));

    // Compute the angle extent
    n = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy));
    p = ux * vx + uy * vy;
    sign = ((ux * vy - uy * vx < 0.0) ? -1.0 : 1.0);
    double angleExtent = Math.toDegrees(sign * Math.acos(p / n));
    if (!localSweepFlag && (angleExtent > 0)) {
      angleExtent -= 360.0;
    } else if (localSweepFlag && (angleExtent < 0)) {
      angleExtent += 360.0;
    }
    angleExtent = angleExtent % 360;
    angleStart = angleStart % 360;

    //
    // We can now build the resulting Arc2D
    //
    final float arcX = (float) (cx - rx);
    final float arcY = (float) (cy - ry);
    final float arcW = (float) (rx * 2.0);
    final float arcH = (float) (ry * 2.0);
    final float arcStart = (float) -angleStart;
    final float arcExtent = (float) -angleExtent;

    if (pgPath == null) {
      final Arc2D arc = new Arc2D(arcX, arcY, arcW, arcH, arcStart, arcExtent, Arc2D.OPEN);
      BaseTransform xform =
          (xAxisRotationR == 0) ? null : BaseTransform.getRotateInstance(xAxisRotationR, cx, cy);
      PathIterator pi = arc.getPathIterator(xform);
      // RT-8926, append(true) converts the initial moveTo into a
      // lineTo which can generate huge miter joins if the segment
      // is small enough.  So, we manually skip it here instead.
      pi.next();
      path.append(pi, true);
    } else {
      pgPath.addArcTo(arcX, arcY, arcW, arcH, arcStart, arcExtent, (float) xAxisRotationR);
    }
  }