picrate 1.3.0-java → 2.0.0.pre-java

data/src/main/java/processing/opengl/PGraphicsOpenGL.java

@@ -3651,7 +3651,7 @@ public class PGraphicsOpenGL extends PGraphics {
    * Ported from the implementation of textCharShapeImpl() in 1.5.1
    *
    * <EM>No attempt has been made to optimize this code</EM>
-   *
+   * 
    * TODO: Implement a FontShape class where each glyph is tessellated and
    * stored inside a larger PShapeOpenGL object (which needs to be expanded as
    * new glyphs are added and exceed the initial capacity in a similar way as
@@ -3659,18 +3659,18 @@ public class PGraphicsOpenGL extends PGraphics {
    * in shape mode, then the correct sequences of vertex indices are computed
    * (akin to the texcoords in the texture case) and used to draw only those
    * parts of the PShape object that are required for the text.
-   *
+   * 
    *
    * Some issues of the original implementation probably remain, so they are
    * reproduced below:
-   *
+   * 
    * Also a problem where some fonts seem to be a bit slight, as if the
    * control points aren't being mapped quite correctly. Probably doing
    * something dumb that the control points don't map to P5's control
    * points. Perhaps it's returning b-spline data from the TrueType font?
    * Though it seems like that would make a lot of garbage rather than
    * just a little flattening.
-   *
+   * 
    * There also seems to be a bug that is causing a line (but not a filled
    * triangle) back to the origin on some letters (i.e. a capital L when
    * tested with Akzidenz Grotesk Light). But this won't be visible
@@ -5352,7 +5352,7 @@ public class PGraphicsOpenGL extends PGraphics {
   // showWarning() and showException() available from PGraphics.
 
   /**
-   * Report on anything from glError().Don't use this inside glBegin/glEnd
+   * Report on anything from glError().Don't use this inside glBegin/glEnd 
    * otherwise it'll throw an GL_INVALID_OPERATION error.
    * @param where
    */
@@ -6366,11 +6366,11 @@ public class PGraphicsOpenGL extends PGraphics {
 
 
   /**
-   * Not an approved function, this will change or be removed in the future.This
-   * utility method returns the texture associated to the renderer's. drawing
-   * surface, making sure is updated to reflect the current contents off the
+   * Not an approved function, this will change or be removed in the future.This 
+   * utility method returns the texture associated to the renderer's. drawing 
+   * surface, making sure is updated to reflect the current contents off the 
    * screen (or offscreen drawing surface).
-   * @return
+   * @return 
    */
   public Texture getTexture() {
     return getTexture(true);
@@ -6380,7 +6380,7 @@ public class PGraphicsOpenGL extends PGraphics {
   /**
    * Not an approved function either, don't use it.
    * @param load
-   * @return
+   * @return 
    */
   public Texture getTexture(boolean load) {
     if (load) loadTexture();
@@ -6393,7 +6393,7 @@ public class PGraphicsOpenGL extends PGraphics {
    * creating and/or updating it if needed.
    *
    * @param img the image to have a texture metadata associated to it
-   * @return
+   * @return 
    */
   public Texture getTexture(PImage img) {
     Texture tex = (Texture)initCache(img);
@@ -6419,7 +6419,7 @@ public class PGraphicsOpenGL extends PGraphics {
   /**
    * Not an approved function, test its use in libraries to grab the FB objects
    * for offscreen PGraphics.
-   * @return
+   * @return 
    */
   public FrameBuffer getFrameBuffer() {
     return getFrameBuffer(false);
@@ -6478,7 +6478,7 @@ public class PGraphicsOpenGL extends PGraphics {
    * This utility method creates a texture for the provided image, and adds it
    * to the metadata cache of the image.
    * @param img the image to have a texture metadata associated to it
-   * @return
+   * @return 
    */
   protected Texture addTexture(PImage img) {
     Texture.Parameters params =
@@ -6892,6 +6892,7 @@ public class PGraphicsOpenGL extends PGraphics {
     OPENGL_VERSION    = pgl.getString(PGL.VERSION);
     OPENGL_EXTENSIONS = pgl.getString(PGL.EXTENSIONS);
     GLSL_VERSION      = pgl.getString(PGL.SHADING_LANGUAGE_VERSION);
+
     npotTexSupported = pgl.hasNpotTexSupport();
     autoMipmapGenSupported = pgl.hasAutoMipmapGenSupport();
     fboMultisampleSupported = pgl.hasFboMultisampleSupport();
@@ -6899,28 +6900,45 @@ public class PGraphicsOpenGL extends PGraphics {
     anisoSamplingSupported = pgl.hasAnisoSamplingSupport();
     readBufferSupported = pgl.hasReadBuffer();
     drawBufferSupported = pgl.hasDrawBuffer();
+
     try {
       pgl.blendEquation(PGL.FUNC_ADD);
       blendEqSupported = true;
     } catch (Exception e) {
       blendEqSupported = false;
     }
+
     depthBits = pgl.getDepthBits();
     stencilBits = pgl.getStencilBits();
+
     pgl.getIntegerv(PGL.MAX_TEXTURE_SIZE, intBuffer);
     maxTextureSize = intBuffer.get(0);
-    pgl.getIntegerv(PGL.MAX_SAMPLES, intBuffer);
-    maxSamples = intBuffer.get(0);
+
+    // work around runtime exceptions in Broadcom's VC IV driver
+    if (false == OPENGL_RENDERER.equals("VideoCore IV HW")) {
+      pgl.getIntegerv(PGL.MAX_SAMPLES, intBuffer);
+      maxSamples = intBuffer.get(0);
+    }
+
     if (anisoSamplingSupported) {
       pgl.getFloatv(PGL.MAX_TEXTURE_MAX_ANISOTROPY, floatBuffer);
       maxAnisoAmount = floatBuffer.get(0);
     }
-    // Broadcom's binary drivers for Raspberry Pi don't work with PiCrate in Buster
-    if (OPENGL_RENDERER.equals("VideoCore IV HW")) {
-      pgl.dispose();
-      System.out.println("Use FakeKMS or FullKMS video driver for P2D and P3D sketches");
-      super.dispose();
+
+    // overwrite the default shaders with vendor specific versions
+    // if needed
+    if (OPENGL_RENDERER.equals("VideoCore IV HW")) {  // Broadcom's binary driver for Raspberry Pi
+        defLightShaderVertURL =
+          PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/LightVert-brcm.glsl");
+        defTexlightShaderVertURL =
+          PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/TexLightVert-brcm.glsl");
+    } else if (OPENGL_RENDERER.contains("VC4")) {     // Mesa driver for same hardware
+        defLightShaderVertURL =
+          PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/LightVert-vc4.glsl");
+        defTexlightShaderVertURL =
+          PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/TexLightVert-vc4.glsl");
     }
+
     glParamsRead = true;
   }
 
@@ -13142,7 +13160,6 @@ public class PGraphicsOpenGL extends PGraphics {
         else if (type == PGL.TRIANGLES) primitive = TRIANGLES;
       }
 
-      @Override
       public void end() {
         if (PGL.MAX_VERTEX_INDEX1 <= vertFirst + vertCount) {
           // We need a new index block for the new batch of

data/src/main/java/processing/opengl/PSurfaceJOGL.java

@@ -438,21 +438,6 @@ public class PSurfaceJOGL implements PSurface {
      *
      */
     protected void initAnimator() {
-        if (PApplet.platform == PConstants.WINDOWS) {
-            // Force Windows to keep timer resolution high by
-            // sleeping for time which is not a multiple of 10 ms.
-            // See section "Clocks and Timers on Windows":
-            //   https://blogs.oracle.com/dholmes/entry/inside_the_hotspot_vm_clocks
-            Thread highResTimerThread = new Thread(() -> {
-                try {
-                    Thread.sleep(Long.MAX_VALUE);
-                } catch (InterruptedException ignore) {
-                }
-            }, "HighResTimerThread");
-            highResTimerThread.setDaemon(true);
-            highResTimerThread.start();
-        }
-
         animator = new FPSAnimator(window, 60);
         drawException = null;
         animator.setUncaughtExceptionHandler((final GLAnimatorControl animator1, final GLAutoDrawable drawable, final Throwable cause) -> {
@@ -462,34 +447,31 @@ public class PSurfaceJOGL implements PSurface {
             }
         });
 
-        drawExceptionHandler = new Thread(new Runnable() {
-            @Override
-            public void run() {
-                synchronized (drawExceptionMutex) {
-                    try {
-                        while (drawException == null) {
-                            drawExceptionMutex.wait();
-                        }
-                        // System.err.println("Caught exception: " + drawException.getMessage());
-                        if (drawException != null) {
-                            Throwable cause = drawException.getCause();
-                            if (cause instanceof ThreadDeath) {
-                                // System.out.println("caught ThreadDeath");
-                                // throw (ThreadDeath)cause;
-                            } else if (cause instanceof RuntimeException) {
-                                throw (RuntimeException) cause;
-                            } else if (cause instanceof UnsatisfiedLinkError) {
-                                throw new UnsatisfiedLinkError(cause.getMessage());
-                            } else if (cause == null) {
-                                throw new RuntimeException(drawException.getMessage());
-                            } else {
-                                throw new RuntimeException(cause);
-                            }
-                        }
-                    } catch (InterruptedException e) {
-                    }
+        drawExceptionHandler = new Thread(() -> {
+          synchronized (drawExceptionMutex) {
+            try {
+              while (drawException == null) {
+                drawExceptionMutex.wait();
+              }
+              // System.err.println("Caught exception: " + drawException.getMessage());
+              if (drawException != null) {
+                Throwable cause = drawException.getCause();
+                if (cause instanceof ThreadDeath) {
+                  // System.out.println("caught ThreadDeath");
+                  // throw (ThreadDeath)cause;
+                } else if (cause instanceof RuntimeException) {
+                  throw (RuntimeException) cause;
+                } else if (cause instanceof UnsatisfiedLinkError) {
+                  throw new UnsatisfiedLinkError(cause.getMessage());
+                } else if (cause == null) {
+                  throw new RuntimeException(drawException.getMessage());
+                } else {
+                  throw new RuntimeException(cause);
                 }
+              }
+            } catch (InterruptedException e) {
             }
+          }
         });
         drawExceptionHandler.start();
     }
@@ -532,7 +514,7 @@ public class PSurfaceJOGL implements PSurface {
      *
      */
     protected void initIcons() {
-        IOUtil.ClassResources res = null;
+        IOUtil.ClassResources res;
         if (PJOGL.icons == null || PJOGL.icons.length == 0) {
             // Default Processing icons
             final int[] sizes = {16, 32, 48, 64, 128, 256, 512};
@@ -560,7 +542,7 @@ public class PSurfaceJOGL implements PSurface {
     @SuppressWarnings("resource")
     private String resourceFilename(String filename) {
         // The code below comes from PApplet.createInputRaw() with a few adaptations
-        InputStream stream = null;
+        InputStream stream;
         try {
             // First see if it's in a data folder. This may fail by throwing
             // a SecurityException. If so, this whole block will be skipped.
@@ -592,10 +574,10 @@ public class PSurfaceJOGL implements PSurface {
             }
 
             stream = new FileInputStream(file);
-            if (stream != null) {
+           // if (stream != null) {
                 stream.close();
                 return file.getCanonicalPath();
-            }
+          //  }
 
             // have to break these out because a general Exception might
             // catch the RuntimeException being thrown above
@@ -641,29 +623,29 @@ public class PSurfaceJOGL implements PSurface {
                 try {
                     String path = sketch.dataPath(filename);
                     stream = new FileInputStream(path);
-                    if (stream != null) {
+                   // if (stream != null) {
                         stream.close();
                         return path;
-                    }
+                   // }
                 } catch (IOException e2) {
                 }
 
                 try {
                     String path = sketch.sketchPath(filename);
                     stream = new FileInputStream(path);
-                    if (stream != null) {
+                    //if (stream != null) {
                         stream.close();
                         return path;
-                    }
+                  //  }
                 } catch (IOException e) {
                 }  // ignored
 
                 try {
                     stream = new FileInputStream(filename);
-                    if (stream != null) {
+                   // if (stream != null) {
                         stream.close();
                         return filename;
-                    }
+                   // }
                 } catch (IOException e1) {
                 }
 
@@ -1389,16 +1371,15 @@ public class PSurfaceJOGL implements PSurface {
     }
 
     static Map<Integer, CursorInfo> cursors = new HashMap<>();
-    static Map<Integer, String> cursorNames = new HashMap<>();
-
-    static {
-        cursorNames.put(PConstants.ARROW, "arrow");
-        cursorNames.put(PConstants.CROSS, "cross");
-        cursorNames.put(PConstants.WAIT, "wait");
-        cursorNames.put(PConstants.MOVE, "move");
-        cursorNames.put(PConstants.HAND, "hand");
-        cursorNames.put(PConstants.TEXT, "text");
-    }
+    static Map<Integer, String> cursorNames = Map.of(
+          PConstants.ARROW, "arrow",
+          PConstants.CROSS, "cross",
+          PConstants.WAIT, "wait",
+          PConstants.MOVE, "move",
+          PConstants.HAND, "hand",
+          PConstants.TEXT, "text"
+  );
+
 
     @Override
     public void setCursor(int kind) {

data/test/color_group_test.rb

@@ -9,21 +9,21 @@ java_import Java::Monkstone::ColorUtil
 Dir.chdir(File.dirname(__FILE__))
 
 PALETTE = %w[#FFFFFF #FF0000 #0000FF].freeze
-COLORS = [16777215, 16711680, 255].to_java(:int)
+COLORS = [16_777_215, 16_711_680, 255].to_java(:int)
 
 class ColorGroupTest < Minitest::Test
   def test_new
     group = ColorGroup.new(COLORS)
-    assert group.kind_of? ColorGroup
+    assert group.is_a? ColorGroup
   end
 
   def test_web_array
     group = ColorGroup.from_web_array(PALETTE)
-    assert group.kind_of? ColorGroup
+    assert group.is_a? ColorGroup
   end
 
   def test_ruby_string
-    p5array = [16777215, 16711680, 255]
+    p5array = [16_777_215, 16_711_680, 255]
     group = ColorGroup.new(COLORS)
     code_string = "%w[#FFFFFF #FF0000 #0000FF]\n"
     result = group.ruby_code

data/test/deglut_spec_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'test_helper'
 
 Dir.chdir(File.dirname(__FILE__))

data/test/helper_methods_test.rb

@@ -10,40 +10,68 @@ include MathTool
 Dir.chdir(File.dirname(__FILE__))
 
 class HelperMethodsTest < Minitest::Test
-
- ARRAY = %w(albatross dog horse)
- def test_hex_color
+  ARRAY = %w[albatross dog horse].freeze
+  def test_hex_color
     col_double = 0.5
     hexcolor = 0xFFCC6600
     dodgy_hexstring = '*56666'
     hexstring = '#CC6600'
     assert hex_color(col_double) == 0.5, 'double as a color'
-    assert hex_color(hexcolor) == -3381760, 'hexadecimal fixnum color'
-    assert hex_color(hexstring) == -3381760, 'hexadecimal string color'
+    assert hex_color(hexcolor) == -3_381_760, 'hexadecimal fixnum color'
+    assert hex_color(hexstring) == -3_381_760, 'hexadecimal string color'
     assert_raises(StandardError, 'Dodgy Hexstring') do
       hex_color(dodgy_hexstring)
     end
     assert_raises(StandardError, 'Dodgy Color Conversion') do
       hex_color([])
     end
-  end
+   end
 
   def test_dist
-    ax, ay, bx, by = 0, 0, 1.0, 1.0
+    ax = 0
+    ay = 0
+    bx = 1.0
+    by = 1.0
     assert_in_epsilon(dist(ax, ay, bx, by), Math.sqrt(2), epsilon = 0.0001, msg = '2D distance')
     by = 0.0
     assert_in_epsilon(dist(ax, ay, bx, by), 1.0, epsilon = 0.0001, msg = 'when y dimension is zero')
-    ax, ay, bx, by = 0, 0, 0.0, 0.0
+    ax = 0
+    ay = 0
+    bx = 0.0
+    by = 0.0
     assert_in_epsilon(dist(ax, ay, bx, by), 0.0, epsilon = 0.0001, msg = 'when x and y dimension are zero')
-    ax, ay, bx, by = 1, 1, -2.0, -3.0
+    ax = 1
+    ay = 1
+    bx = -2.0
+    by = -3.0
     assert_in_epsilon(dist(ax, ay, bx, by), 5.0, epsilon = 0.0001, msg = 'classic triangle dimensions')
-    ax, ay, bx, by, cx, cy = -1, -1, 100, 2.0, 3.0, 100
+    ax = -1
+    ay = -1
+    bx = 100
+    by = 2.0
+    cx = 3.0
+    cy = 100
     assert_in_epsilon(dist(ax, ay, bx, by, cx, cy), 5.0, epsilon = 0.0001, msg = 'classic triangle dimensions')
-    ax, ay, bx, by, cx, cy = 0, 0, -1.0, -1.0, 0, 0
+    ax = 0
+    ay = 0
+    bx = -1.0
+    by = -1.0
+    cx = 0
+    cy = 0
     assert_in_epsilon(dist(ax, ay, bx, by, cx, cy), Math.sqrt(2), epsilon = 0.0001, msg = '2D distance')
-    ax, ay, bx, by, cx, cy = 0, 0, 0.0, 0.0, 0, 0
+    ax = 0
+    ay = 0
+    bx = 0.0
+    by = 0.0
+    cx = 0
+    cy = 0
     assert_in_epsilon(dist(ax, ay, bx, by, cx, cy), 0.0)
-    ax, ay, bx, by, cx, cy = 0, 0, 1.0, 0.0, 0, 0
+    ax = 0
+    ay = 0
+    bx = 1.0
+    by = 0.0
+    cx = 0
+    cy = 0
     assert_in_epsilon(dist(ax, ay, bx, by, cx, cy), 1.0, epsilon = 0.0001, msg = 'when x and z dimension are zero')
   end
 

data/test/math_tool_test.rb

@@ -1,73 +1,82 @@
+# frozen_string_literal: true
+
 require_relative 'test_helper'
 
 Java::Monkstone::PicrateLibrary.new.load(JRuby.runtime, false)
 
 # include Processing::HelperMethods
 
-
 Dir.chdir(File.dirname(__FILE__))
-
-class MathToolTest < Minitest::Test
- include MathTool
- def test_map1d
+# Test processing map functions
+class ProcessingMapTest < Minitest::Test
+  include MathTool
+  def test_map1d
     x = [0, 5, 7.5, 10]
     range1 = (0..10)
     range2 = (100..1)
     range3 = (0..10)
     range4 = (5..105)
-    assert_in_delta(map1d(x[0], range1, range2), 100, delta = 0.00001, msg = 'map to first')
-    assert_in_delta(map1d(x[1], range1, range2), 50.5, delta = 0.00001, msg = 'map to reversed intermediate')
-    assert_in_delta(map1d(x[2], range3, range4), 80.0, delta = 0.00001, msg = 'map to intermediate')
-    assert_in_delta(map1d(x[3], range1, range2), 1, delta = 0.00001, msg = 'map to last')
-  end
+    assert_in_delta(map1d(x[0], range1, range2), 100, 0.00001, 'map to first')
+    assert_in_delta(map1d(x[1], range1, range2), 50.5, 0.00001, 'map to reversed intermediate')
+    assert_in_delta(map1d(x[2], range3, range4), 80.0, 0.00001, 'map to intermediate')
+    assert_in_delta(map1d(x[3], range1, range2), 1, 0.00001, 'map to last')
+   end
 
-  def test_p5map # as map1d except not using range input
+  # as map1d except not using range input
+  def test_p5map
     x = [0, 5, 7.5, 10]
     range1 = (0..10)
     range2 = (100..1)
     range3 = (0..10)
     range4 = (5..105)
-    assert_in_delta(p5map(x[0], range1.first, range1.last, range2.first, range2.last), 100, delta = 0.00001)
-    assert_in_delta(p5map(x[1], range1.first, range1.last, range2.first, range2.last), 50.5, delta = 0.00001)
-    assert_in_delta(p5map(x[2], range3.first, range3.last, range4.first, range4.last), 80.0, delta = 0.00001)
-    assert_in_delta(p5map(x[3], range1.first, range1.last, range2.first, range2.last), 1, delta = 0.00001)
+    assert_in_delta(p5map(x[0], range1.first, range1.last, range2.first, range2.last), 100, 0.00001)
+    assert_in_delta(p5map(x[1], range1.first, range1.last, range2.first, range2.last), 50.5, 0.00001)
+    assert_in_delta(p5map(x[2], range3.first, range3.last, range4.first, range4.last), 80.0, 0.00001)
+    assert_in_delta(p5map(x[3], range1.first, range1.last, range2.first, range2.last), 1, 0.00001)
   end
 
   def test_norm
     x = [10, 140, 210]
-    start0, last0 = 30, 200
-    start_int, last_int = 0, 200
-    assert_in_delta(norm(x[0], start0, last0), -0.11764705882352941, delta = 0.00001, msg = 'unclamped map')
-    assert_in_delta(norm(x[1], start_int, last_int), 0.7, delta = 0.00001, msg = 'map to intermediate')
-    assert_in_delta(norm(x[2], start_int, last_int), 1.05, delta = 0.00001, msg = 'unclamped map')
+    start0 = 30
+    last0 = 200
+    start_int = 0
+    last_int = 200
+    assert_in_delta(norm(x[0], start0, last0), -0.11764705882352941, 0.00001, 'unclamped map')
+    assert_in_delta(norm(x[1], start_int, last_int), 0.7, 0.00001, 'map to intermediate')
+    assert_in_delta(norm(x[2], start_int, last_int), 1.05, 0.00001, 'unclamped map')
   end
 
   def test_norm_strict
     x = [10, 140, 210]
-    assert_in_delta(norm_strict(x[2], x[0], x[1]), 1.0, delta = 0.00001, msg = 'clamped map to 0..1.0')
-    assert_in_delta(norm_strict(x[2], x[1], x[0]), 0.0, delta = 0.00001, msg = 'clamped map to 0..1.0')
-    assert_in_delta(norm_strict(x[1], x[0], x[2]), 0.65, delta = 0.00001, msg = 'clamped map to 0..1.0')
+    assert_in_delta(norm_strict(x[2], x[0], x[1]), 1.0, 0.00001, 'clamped map to 0..1.0')
+    assert_in_delta(norm_strict(x[2], x[1], x[0]), 0.0, 0.00001, 'clamped map to 0..1.0')
+    assert_in_delta(norm_strict(x[1], x[0], x[2]), 0.65, 0.00001, 'clamped map to 0..1.0')
   end
 
-  def test_lerp # behaviour is deliberately different to processing which is unclamped
+  # behaviour is deliberately different to processing which is unclamped
+  def test_lerp
     x = [0.5, 0.8, 2.0]
-    start0, last0 = 300, 200
-    start_int, last_int = 0, 200
-    assert_in_delta(lerp(start0, last0, x[0]), 250, delta = 0.00001, msg = 'produces a intermediate value of a reversed range')
-    assert_in_delta(lerp(start_int, last_int, x[1]), 160, delta = 0.00001, msg = 'lerps to an intermediate value')
-    assert_in_delta(lerp(start_int, last_int, x[2]), 200, delta = 0.00001, msg = 'lerps to the last value of a range')
+    start0 = 300
+    last0 = 200
+    start_int = 0
+    last_int = 200
+    assert_in_delta(lerp(start0, last0, x[0]), 250, 0.00001, 'produces a intermediate value of a reversed range')
+    assert_in_delta(lerp(start_int, last_int, x[1]), 160, 0.00001, 'lerps to an intermediate value')
+    assert_in_delta(lerp(start_int, last_int, x[2]), 200, 0.00001, 'lerps to the last value of a range')
   end
 
   def test_constrain
     x_int = [15, 2_500, -2_500]
-    start_int, last_int = 0, 200
-    assert_in_delta(constrain(x_int[0], start_int, last_int), 15, delta = 0.00001)
-    assert_in_delta(constrain(x_int[1], start_int, last_int), 200, delta = 0.00001)
-    assert_in_delta(constrain(x_int[2], start_int, last_int), 0, delta = 0.00001)
+    start_int = 0
+    last_int = 200
+    assert_in_delta(constrain(x_int[0], start_int, last_int), 15, 0.00001)
+    assert_in_delta(constrain(x_int[1], start_int, last_int), 200, 0.00001)
+    assert_in_delta(constrain(x_int[2], start_int, last_int), 0, 0.00001)
     xf = [15.0, 2_500.0, -2_500.0]
-    startf, lastf = 0, 200.0
-    assert_in_delta(constrain(xf[0], startf, lastf), 15.0, delta = 0.00001, msg = 'constrain to 0..200')
-    assert_in_delta(constrain(xf[1], startf, lastf), 200.0, delta = 0.00001, msg = 'constrain to 0..200')
-    assert_in_delta(constrain(xf[2], startf, lastf), 0.0, delta = 0.00001, msg = 'constrain to 0..200')
+    startf = 0
+    lastf = 200.0
+    assert_in_delta(constrain(xf[0], startf, lastf), 15.0, 0.00001, 'constrain to 0..200')
+    assert_in_delta(constrain(xf[1], startf, lastf), 200.0, 0.00001, 'constrain to 0..200')
+    assert_in_delta(constrain(xf[2], startf, lastf), 0.0, 0.00001, 'constrain to 0..200')
   end
 end