Expand unit tests across charts, capture, and utilities

maven/core-unittests/src/test/java/com/codename1/capture/CapturePackageTest.java

@@ -0,0 +1,57 @@
+package com.codename1.capture;
+
+import com.codename1.junit.FormTest;
+import com.codename1.junit.UITestBase;
+import com.codename1.media.MediaRecorderBuilder;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.events.ActionListener;
+import com.codename1.capture.VideoCaptureConstraints;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class CapturePackageTest extends UITestBase {
+
+    @FormTest
+    void captureSynchronousMethodsReturnConfiguredPaths() {
+        implementation.setNextCapturePhotoPath("file://photo.jpg");
+        assertEquals("file://photo.jpg", Capture.capturePhoto());
+
+        implementation.setNextCaptureAudioPath("file://audio.wav");
+        assertEquals("file://audio.wav", Capture.captureAudio());
+
+        implementation.setNextCaptureVideoPath("file://video.mp4");
+        assertEquals("file://video.mp4", Capture.captureVideo());
+
+        VideoCaptureConstraints constraints = new VideoCaptureConstraints();
+        Capture.captureVideo(constraints);
+        assertSame(constraints, implementation.getLastVideoConstraints());
+
+        MediaRecorderBuilder builder = new MediaRecorderBuilder();
+        Capture.captureAudio(builder);
+        assertSame(builder, implementation.getLastMediaRecorderBuilder());
+    }
+
+    @FormTest
+    void asynchronousCaptureInvokesListenersImmediately() {
+        implementation.setNextCapturePhotoPath("file://async-photo.jpg");
+        RecordingListener listener = new RecordingListener();
+        Capture.capturePhoto(listener);
+        assertEquals("file://async-photo.jpg", listener.lastPath);
+
+        implementation.setNextCaptureAudioPath("file://async-audio.wav");
+        Capture.captureAudio(listener);
+        assertEquals("file://async-audio.wav", listener.lastPath);
+
+        implementation.setNextCaptureVideoPath("file://async-video.mp4");
+        Capture.captureVideo(listener);
+        assertEquals("file://async-video.mp4", listener.lastPath);
+    }
+
+    private static class RecordingListener implements ActionListener {
+        private String lastPath;
+
+        public void actionPerformed(ActionEvent evt) {
+            lastPath = (String) evt.getSource();
+        }
+    }
+}

maven/core-unittests/src/test/java/com/codename1/charts/ChartComponentInteractionTest.java

@@ -0,0 +1,127 @@
+package com.codename1.charts;
+
+import com.codename1.charts.compat.Canvas;
+import com.codename1.charts.compat.Paint;
+import com.codename1.charts.models.Point;
+import com.codename1.charts.models.SeriesSelection;
+import com.codename1.charts.models.XYMultipleSeriesDataset;
+import com.codename1.charts.models.XYSeries;
+import com.codename1.charts.renderers.SimpleSeriesRenderer;
+import com.codename1.charts.renderers.XYMultipleSeriesRenderer;
+import com.codename1.charts.renderers.XYSeriesRenderer;
+import com.codename1.charts.views.AbstractChart;
+import com.codename1.charts.views.LineChart;
+import com.codename1.junit.FormTest;
+import com.codename1.junit.UITestBase;
+import com.codename1.ui.Form;
+import com.codename1.ui.Graphics;
+import com.codename1.ui.Image;
+import com.codename1.ui.Transform;
+import com.codename1.ui.geom.Rectangle;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ChartComponentInteractionTest extends UITestBase {
+
+    @FormTest
+    void panAndZoomFlagsPropagateToRenderer() {
+        XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
+        XYSeries series = new XYSeries("Series");
+        series.add(0, 1);
+        series.add(1, 2);
+        dataset.addSeries(series);
+
+        XYMultipleSeriesRenderer renderer = new XYMultipleSeriesRenderer();
+        renderer.addSeriesRenderer(new XYSeriesRenderer());
+        ChartComponent component = new ChartComponent(new LineChart(dataset, renderer));
+
+        Form form = new Form();
+        form.add(component);
+        form.show();
+
+        assertEquals(renderer.isZoomEnabled(), component.isZoomEnabled());
+        assertEquals(renderer.isPanEnabled(), component.isPanEnabled());
+
+        component.setZoomEnabled(false);
+        assertFalse(component.isZoomEnabled());
+        assertFalse(renderer.isZoomEnabled());
+
+        component.setZoomEnabled(true);
+        assertTrue(component.isZoomEnabled());
+        assertTrue(renderer.isZoomEnabled());
+
+        component.setZoomEnabled(false, true);
+        assertTrue(component.isZoomEnabled());
+        assertFalse(renderer.isZoomXEnabled());
+        assertTrue(renderer.isZoomYEnabled());
+
+        component.setPanEnabled(false);
+        assertFalse(renderer.isPanEnabled());
+        component.setPanEnabled(false, true);
+        assertTrue(renderer.isPanYEnabled());
+        assertFalse(renderer.isPanXEnabled());
+    }
+
+    @FormTest
+    void chartUtilDelegatesToChartDraw() {
+        RecordingChart chart = new RecordingChart();
+        ChartUtil util = new ChartUtil();
+        Image buffer = Image.createImage(40, 30);
+        Graphics graphics = buffer.getGraphics();
+        Rectangle bounds = new Rectangle(5, 6, 20, 10);
+
+        util.paintChart(graphics, chart, bounds, 7, 9);
+
+        assertSame(graphics, chart.lastGraphics);
+        assertEquals(bounds, chart.lastBounds);
+        assertEquals(7, chart.lastAbsX);
+        assertEquals(9, chart.lastAbsY);
+    }
+
+    @FormTest
+    void transformSetterAndGetterPersistState() {
+        XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
+        dataset.addSeries(new XYSeries("Series"));
+        XYMultipleSeriesRenderer renderer = new XYMultipleSeriesRenderer();
+        renderer.addSeriesRenderer(new XYSeriesRenderer());
+        ChartComponent component = new ChartComponent(new LineChart(dataset, renderer));
+        Form form = new Form();
+        form.add(component);
+        form.show();
+
+        Transform transform = Transform.makeIdentity();
+        transform.translate(5, 7);
+        component.setTransform(transform);
+        assertSame(transform, component.getTransform());
+    }
+
+    private static class RecordingChart extends AbstractChart {
+        private Graphics lastGraphics;
+        private Rectangle lastBounds;
+        private int lastAbsX;
+        private int lastAbsY;
+
+        @Override
+        public void draw(Canvas canvas, int x, int y, int width, int height, Paint paint) {
+            lastGraphics = canvas.g;
+            lastBounds = canvas.bounds;
+            lastAbsX = canvas.absoluteX;
+            lastAbsY = canvas.absoluteY;
+        }
+
+        @Override
+        public void drawLegendShape(Canvas canvas, SimpleSeriesRenderer renderer, float x, float y, int seriesIndex, Paint paint) {
+        }
+
+        @Override
+        public int getLegendShapeWidth(int seriesIndex) {
+            return 0;
+        }
+
+        @Override
+        public SeriesSelection getSeriesAndPointForScreenCoordinate(Point point) {
+            return null;
+        }
+
+    }
+}

maven/core-unittests/src/test/java/com/codename1/charts/compat/CompatCanvasTest.java

@@ -0,0 +1,97 @@
+package com.codename1.charts.compat;
+
+import com.codename1.junit.FormTest;
+import com.codename1.junit.UITestBase;
+import com.codename1.testing.TestCodenameOneImplementation.FillOperation;
+import com.codename1.testing.TestCodenameOneImplementation.GradientOperation;
+import com.codename1.ui.Image;
+import com.codename1.ui.geom.Rectangle;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class CompatCanvasTest extends UITestBase {
+
+    @FormTest
+    void drawRectFillsOrStrokesBasedOnPaintStyle() {
+        Image image = Image.createImage(6, 6);
+        Canvas canvas = new Canvas();
+        canvas.g = image.getGraphics();
+        canvas.g.setAlpha(255);
+        canvas.bounds = new Rectangle(0, 0, 6, 6);
+
+        Paint fillPaint = new Paint();
+        fillPaint.setColor(0xFFFF0000);
+        fillPaint.setStyle(Paint.Style.FILL);
+        implementation.clearGraphicsOperations();
+        canvas.drawRect(0, 0, 6, 6, fillPaint);
+        FillOperation fill = latestFill();
+        assertNotNull(fill);
+        assertEquals(0, fill.getX());
+        assertEquals(0, fill.getY());
+        assertEquals(6, fill.getWidth());
+        assertEquals(6, fill.getHeight());
+        assertEquals(0xFFFF0000, fill.getColor());
+
+        Image strokeImage = Image.createImage(6, 6);
+        canvas.g = strokeImage.getGraphics();
+        canvas.g.setAlpha(255);
+        Paint strokePaint = new Paint();
+        strokePaint.setColor(0xFF00FF00);
+        strokePaint.setStyle(Paint.Style.STROKE);
+        implementation.clearGraphicsOperations();
+        canvas.drawRect(0, 0, 6, 6, strokePaint);
+        boolean hasHorizontalEdge = false;
+        boolean hasVerticalEdge = false;
+        for (FillOperation op : implementation.getFillOperationsSnapshot()) {
+            if (op.getColor() == 0xFF00FF00 && op.getY() == 0 && op.getHeight() == 1 && op.getWidth() == 6) {
+                hasHorizontalEdge = true;
+            }
+            if (op.getColor() == 0xFF00FF00 && op.getX() == 0 && op.getWidth() == 1 && op.getHeight() >= 4) {
+                hasVerticalEdge = true;
+            }
+        }
+        assertTrue(hasHorizontalEdge);
+        assertTrue(hasVerticalEdge);
+    }
+
+    @FormTest
+    void gradientDrawableDrawsUsingCanvasOrientation() {
+        Image image = Image.createImage(4, 4);
+        Canvas canvas = new Canvas();
+        canvas.g = image.getGraphics();
+        canvas.g.setAlpha(255);
+        canvas.bounds = new Rectangle(0, 0, 4, 4);
+
+        GradientDrawable horizontal = new GradientDrawable(GradientDrawable.Orientation.LEFT_RIGHT,
+                new int[]{0xFF0000FF, 0xFFFF0000});
+        horizontal.setBounds(0, 0, 4, 4);
+        implementation.clearGraphicsOperations();
+        horizontal.draw(canvas);
+        GradientOperation gradient = implementation.getLastGradientOperation();
+        assertNotNull(gradient);
+        assertTrue(gradient.isHorizontal());
+        assertEquals(0xFF0000FF, gradient.getStartColor());
+        assertEquals(0xFFFF0000, gradient.getEndColor());
+
+        Image fallbackImage = Image.createImage(4, 4);
+        canvas.g = fallbackImage.getGraphics();
+        canvas.g.setAlpha(255);
+        GradientDrawable fallback = new GradientDrawable(GradientDrawable.Orientation.TL_BR,
+                new int[]{0xFF00FF00, 0xFF000000});
+        fallback.setBounds(0, 0, 4, 4);
+        implementation.clearGraphicsOperations();
+        fallback.draw(canvas);
+        assertNull(implementation.getLastGradientOperation());
+        FillOperation fallbackFill = latestFill();
+        assertNotNull(fallbackFill);
+        assertEquals(0xFF00FF00, fallbackFill.getColor());
+    }
+
+    private FillOperation latestFill() {
+        FillOperation fill = null;
+        for (FillOperation op : implementation.getFillOperationsSnapshot()) {
+            fill = op;
+        }
+        return fill;
+    }
+}

maven/core-unittests/src/test/java/com/codename1/charts/transitions/XYTransitionsTest.java

@@ -0,0 +1,100 @@
+package com.codename1.charts.transitions;
+
+import com.codename1.charts.ChartComponent;
+import com.codename1.charts.models.XYMultipleSeriesDataset;
+import com.codename1.charts.models.XYSeries;
+import com.codename1.charts.models.XYValueSeries;
+import com.codename1.charts.renderers.XYMultipleSeriesRenderer;
+import com.codename1.charts.renderers.XYSeriesRenderer;
+import com.codename1.charts.views.LineChart;
+import com.codename1.junit.FormTest;
+import com.codename1.junit.UITestBase;
+import com.codename1.ui.Form;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class XYTransitionsTest extends UITestBase {
+
+    @FormTest
+    void xySeriesTransitionAnimatesBufferValues() throws Exception {
+        XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
+        XYSeries series = new XYSeries("Series");
+        series.add(0, 1);
+        series.add(1, 2);
+        dataset.addSeries(series);
+
+        ChartComponent chartComponent = createChartComponent(dataset);
+        Form form = new Form();
+        form.add(chartComponent);
+        form.show();
+
+        XYSeriesTransition transition = new XYSeriesTransition(chartComponent, series);
+        XYSeries buffer = new XYSeries(series.getTitle(), series.getScaleNumber());
+        buffer.add(0, 5);
+        buffer.add(1, 7);
+        transition.setBuffer(buffer);
+
+        transition.setDuration(5);
+        transition.animateChart();
+        while (transition.animate()) {
+            Thread.sleep(5);
+        }
+
+        assertEquals(2, series.getItemCount());
+        assertEquals(5.0, series.getY(0));
+        assertEquals(7.0, series.getY(1));
+        assertEquals(0, buffer.getItemCount());
+    }
+
+    @FormTest
+    void multiSeriesTransitionUpdatesAllSeries() throws Exception {
+        XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
+        XYSeries first = new XYSeries("First");
+        first.add(0, 1);
+        first.add(1, 2);
+        XYSeries second = new XYSeries("Second");
+        second.add(0, 4);
+        second.add(1, 5);
+        dataset.addSeries(first);
+        dataset.addSeries(second);
+
+        ChartComponent chartComponent = createChartComponent(dataset);
+        Form form = new Form();
+        form.add(chartComponent);
+        form.show();
+
+        XYMultiSeriesTransition transition = new XYMultiSeriesTransition(chartComponent, dataset);
+        XYMultipleSeriesDataset buffer = transition.getBuffer();
+        assertEquals(2, buffer.getSeriesCount());
+        buffer.getSeriesAt(0).add(0, 10);
+        buffer.getSeriesAt(0).add(1, 12);
+        buffer.getSeriesAt(1).add(0, 8);
+        buffer.getSeriesAt(1).add(1, 9);
+
+        transition.setDuration(5);
+        transition.animateChart();
+        while (transition.animate()) {
+            Thread.sleep(5);
+        }
+
+        assertEquals(10.0, first.getY(0));
+        assertEquals(12.0, first.getY(1));
+        assertEquals(8.0, second.getY(0));
+        assertEquals(9.0, second.getY(1));
+        assertEquals(0, buffer.getSeriesAt(0).getItemCount());
+        assertEquals(0, buffer.getSeriesAt(1).getItemCount());
+    }
+
+    private ChartComponent createChartComponent(XYMultipleSeriesDataset dataset) {
+        XYMultipleSeriesRenderer renderer = new XYMultipleSeriesRenderer();
+        for (int i = 0; i < dataset.getSeriesCount(); i++) {
+            renderer.addSeriesRenderer(new XYSeriesRenderer());
+        }
+        LineChart chart = new LineChart(dataset, renderer);
+        ChartComponent component = new ChartComponent(chart);
+        component.setWidth(100);
+        component.setHeight(100);
+        return component;
+    }
+
+}