diff --git a/MPChartLib/src/test/java/com/github/mikephil/charting/test/ApproximationTest.kt b/MPChartLib/src/test/java/com/github/mikephil/charting/test/ApproximationTest.kt new file mode 100644 index 0000000000..5c21429f42 --- /dev/null +++ b/MPChartLib/src/test/java/com/github/mikephil/charting/test/ApproximationTest.kt @@ -0,0 +1,20 @@ +package com.github.mikephil.charting.test + +import com.github.mikephil.charting.data.filter.Approximator +import org.junit.Assert +import org.junit.Test + +class ApproximationTest { + @Test + fun testApproximation() { + val points = floatArrayOf(10f, 20f, 20f, 30f, 25f, 25f, 30f, 28f, 31f, 31f, 33f, 33f, 40f, 40f, 44f, 40f, 48f, 23f, 50f, 20f, 55f, 20f, 60f, 25f) + + Assert.assertEquals(24, points.size) + + val a = Approximator() + + val reduced = a.reduceWithDouglasPeucker(points, 2f) + + Assert.assertEquals(18, reduced.size) + } +} diff --git a/MPChartLib/src/test/java/com/github/mikephil/charting/test/ApproximatorTest.java b/MPChartLib/src/test/java/com/github/mikephil/charting/test/ApproximatorTest.java deleted file mode 100644 index 955e782d4f..0000000000 --- a/MPChartLib/src/test/java/com/github/mikephil/charting/test/ApproximatorTest.java +++ /dev/null @@ -1,27 +0,0 @@ -package com.github.mikephil.charting.test; - -import static junit.framework.Assert.assertEquals; - -import com.github.mikephil.charting.data.filter.Approximator; - -import org.junit.Test; - -/** - * Created by philipp on 07/06/16. - */ -public class ApproximatorTest { - - @Test - public void testApproximation() { - - float[] points = new float[]{10, 20, 20, 30, 25, 25, 30, 28, 31, 31, 33, 33, 40, 40, 44, 40, 48, 23, 50, 20, 55, 20, 60, 25}; - - assertEquals(24, points.length); - - Approximator a = new Approximator(); - - float[] reduced = a.reduceWithDouglasPeucker(points, 2); - - assertEquals(18, reduced.length); - } -} diff --git a/MPChartLib/src/test/java/com/github/mikephil/charting/test/AxisRendererTest.java b/MPChartLib/src/test/java/com/github/mikephil/charting/test/AxisRendererTest.java deleted file mode 100644 index 05cb2f3592..0000000000 --- a/MPChartLib/src/test/java/com/github/mikephil/charting/test/AxisRendererTest.java +++ /dev/null @@ -1,105 +0,0 @@ -package com.github.mikephil.charting.test; - -import com.github.mikephil.charting.components.YAxis; -import com.github.mikephil.charting.renderer.AxisRenderer; -import com.github.mikephil.charting.renderer.YAxisRenderer; - -import org.junit.Test; - -import static junit.framework.Assert.assertEquals; - -/** - * Created by philipp on 31/05/16. - */ -public class AxisRendererTest { - - - @Test - public void testComputeAxisValues() { - - YAxis yAxis = new YAxis(); - yAxis.setLabelCount(6); - AxisRenderer renderer = new YAxisRenderer(null, yAxis, null); - - renderer.computeAxis(0, 100, false); - float[] entries = yAxis.mEntries; - - assertEquals(6, entries.length); - assertEquals(20, entries[1] - entries[0], 0.01); // interval 20 - assertEquals(0, entries[0], 0.01); - assertEquals(100, entries[entries.length - 1], 0.01); - - yAxis = new YAxis(); - yAxis.setLabelCount(6); - yAxis.setGranularity(50f); - renderer = new YAxisRenderer(null, yAxis, null); - - renderer.computeAxis(0, 100, false); - entries = yAxis.mEntries; - - assertEquals(3, entries.length); - assertEquals(50, entries[1] - entries[0], 0.01); // interval 50 - assertEquals(0, entries[0], 0.01); - assertEquals(100, entries[entries.length - 1], 0.01); - - yAxis = new YAxis(); - yAxis.setLabelCount(5, true); - renderer = new YAxisRenderer(null, yAxis, null); - - renderer.computeAxis(0, 100, false); - entries = yAxis.mEntries; - - assertEquals(5, entries.length); - assertEquals(25, entries[1] - entries[0], 0.01); // interval 25 - assertEquals(0, entries[0], 0.01); - assertEquals(100, entries[entries.length - 1], 0.01); - - yAxis = new YAxis(); - yAxis.setLabelCount(5, true); - renderer = new YAxisRenderer(null, yAxis, null); - - renderer.computeAxis(0, 0.01f, false); - entries = yAxis.mEntries; - - assertEquals(5, entries.length); - assertEquals(0.0025, entries[1] - entries[0], 0.0001); - assertEquals(0, entries[0], 0.0001); - assertEquals(0.01, entries[entries.length - 1], 0.0001); - - yAxis = new YAxis(); - yAxis.setLabelCount(5, false); - renderer = new YAxisRenderer(null, yAxis, null); - - renderer.computeAxis(0, 0.01f, false); - entries = yAxis.mEntries; - - assertEquals(5, entries.length); - assertEquals(0.0020, entries[1] - entries[0], 0.0001); - assertEquals(0, entries[0], 0.0001); - assertEquals(0.0080, entries[entries.length - 1], 0.0001); - - yAxis = new YAxis(); - yAxis.setLabelCount(6); - renderer = new YAxisRenderer(null, yAxis, null); - - renderer.computeAxis(-50, 50, false); - entries = yAxis.mEntries; - - assertEquals(5, entries.length); - assertEquals(-40, entries[0], 0.0001); - assertEquals(0, entries[2], 0.0001); - assertEquals(40, entries[entries.length - 1], 0.0001); - - yAxis = new YAxis(); - yAxis.setLabelCount(6); - renderer = new YAxisRenderer(null, yAxis, null); - - renderer.computeAxis(-50, 100, false); - entries = yAxis.mEntries; - - assertEquals(5, entries.length); - assertEquals(-30, entries[0], 0.0001); - assertEquals(30, entries[2], 0.0001); - assertEquals(90, entries[entries.length - 1], 0.0001); - } -} diff --git a/MPChartLib/src/test/java/com/github/mikephil/charting/test/AxisRendererTest.kt b/MPChartLib/src/test/java/com/github/mikephil/charting/test/AxisRendererTest.kt new file mode 100644 index 0000000000..913562cdd6 --- /dev/null +++ b/MPChartLib/src/test/java/com/github/mikephil/charting/test/AxisRendererTest.kt @@ -0,0 +1,97 @@ +package com.github.mikephil.charting.test + +import com.github.mikephil.charting.components.YAxis +import com.github.mikephil.charting.renderer.AxisRenderer +import com.github.mikephil.charting.renderer.YAxisRenderer +import org.junit.Assert +import org.junit.Test + +class AxisRendererTest { + @Test + fun testComputeAxisValues() { + var yAxis = YAxis() + yAxis.labelCount = 6 + var renderer: AxisRenderer = YAxisRenderer(null, yAxis, null) + + renderer.computeAxis(0f, 100f, false) + var entries = yAxis.mEntries + + Assert.assertEquals(6, entries.size) + Assert.assertEquals(20.0, (entries[1] - entries[0]).toDouble(), 0.01) // interval 20 + Assert.assertEquals(0.0, entries[0].toDouble(), 0.01) + Assert.assertEquals(100.0, entries[entries.size - 1].toDouble(), 0.01) + + yAxis = YAxis() + yAxis.labelCount = 6 + yAxis.granularity = 50f + renderer = YAxisRenderer(null, yAxis, null) + + renderer.computeAxis(0f, 100f, false) + entries = yAxis.mEntries + + Assert.assertEquals(3, entries.size) + Assert.assertEquals(50.0, (entries[1] - entries[0]).toDouble(), 0.01) // interval 50 + Assert.assertEquals(0.0, entries[0].toDouble(), 0.01) + Assert.assertEquals(100.0, entries[entries.size - 1].toDouble(), 0.01) + + yAxis = YAxis() + yAxis.setLabelCount(5, true) + renderer = YAxisRenderer(null, yAxis, null) + + renderer.computeAxis(0f, 100f, false) + entries = yAxis.mEntries + + Assert.assertEquals(5, entries.size) + Assert.assertEquals(25.0, (entries[1] - entries[0]).toDouble(), 0.01) // interval 25 + Assert.assertEquals(0.0, entries[0].toDouble(), 0.01) + Assert.assertEquals(100.0, entries[entries.size - 1].toDouble(), 0.01) + + yAxis = YAxis() + yAxis.setLabelCount(5, true) + renderer = YAxisRenderer(null, yAxis, null) + + renderer.computeAxis(0f, 0.01f, false) + entries = yAxis.mEntries + + Assert.assertEquals(5, entries.size) + Assert.assertEquals(0.0025, (entries[1] - entries[0]).toDouble(), 0.0001) + Assert.assertEquals(0.0, entries[0].toDouble(), 0.0001) + Assert.assertEquals(0.01, entries[entries.size - 1].toDouble(), 0.0001) + + yAxis = YAxis() + yAxis.setLabelCount(5, false) + renderer = YAxisRenderer(null, yAxis, null) + + renderer.computeAxis(0f, 0.01f, false) + entries = yAxis.mEntries + + Assert.assertEquals(5, entries.size) + Assert.assertEquals(0.0020, (entries[1] - entries[0]).toDouble(), 0.0001) + Assert.assertEquals(0.0, entries[0].toDouble(), 0.0001) + Assert.assertEquals(0.0080, entries[entries.size - 1].toDouble(), 0.0001) + + yAxis = YAxis() + yAxis.labelCount = 6 + renderer = YAxisRenderer(null, yAxis, null) + + renderer.computeAxis(-50f, 50f, false) + entries = yAxis.mEntries + + Assert.assertEquals(5, entries.size) + Assert.assertEquals(-40.0, entries[0].toDouble(), 0.0001) + Assert.assertEquals(0.0, entries[2].toDouble(), 0.0001) + Assert.assertEquals(40.0, entries[entries.size - 1].toDouble(), 0.0001) + + yAxis = YAxis() + yAxis.labelCount = 6 + renderer = YAxisRenderer(null, yAxis, null) + + renderer.computeAxis(-50f, 100f, false) + entries = yAxis.mEntries + + Assert.assertEquals(5, entries.size) + Assert.assertEquals(-30.0, entries[0].toDouble(), 0.0001) + Assert.assertEquals(30.0, entries[2].toDouble(), 0.0001) + Assert.assertEquals(90.0, entries[entries.size - 1].toDouble(), 0.0001) + } +} diff --git a/MPChartLib/src/test/java/com/github/mikephil/charting/test/BarDataTest.java b/MPChartLib/src/test/java/com/github/mikephil/charting/test/BarDataTest.java deleted file mode 100644 index ce360ce3f8..0000000000 --- a/MPChartLib/src/test/java/com/github/mikephil/charting/test/BarDataTest.java +++ /dev/null @@ -1,72 +0,0 @@ -package com.github.mikephil.charting.test; - -import com.github.mikephil.charting.data.BarData; -import com.github.mikephil.charting.data.BarDataSet; -import com.github.mikephil.charting.data.BarEntry; - -import org.junit.Test; - -import java.util.ArrayList; -import java.util.List; - -import static junit.framework.Assert.assertEquals; - -/** - * Created by philipp on 06/06/16. - */ -public class BarDataTest { - - @Test - public void testGroupBars() { - - float groupSpace = 5f; - float barSpace = 1f; - - List values1 = new ArrayList<>(); - List values2 = new ArrayList<>(); - - for (int i = 0; i < 5; i++) { - values1.add(new BarEntry(i, 50)); - values2.add(new BarEntry(i, 60)); - } - - BarDataSet barDataSet1 = new BarDataSet(values1, "Set1"); - BarDataSet barDataSet2 = new BarDataSet(values2, "Set2"); - - BarData data = new BarData(barDataSet1, barDataSet2); - data.setBarWidth(10f); - - float groupWidth = data.getGroupWidth(groupSpace, barSpace); - assertEquals(27f, groupWidth, 0.01f); - - assertEquals(0f, values1.get(0).getX(), 0.01f); - assertEquals(1f, values1.get(1).getX(), 0.01f); - - data.groupBars(1000, groupSpace, barSpace); - - // 1000 + 2.5 + 0.5 + 5 - assertEquals(1008f, values1.get(0).getX(), 0.01f); - assertEquals(1019f, values2.get(0).getX(), 0.01f); - assertEquals(1035f, values1.get(1).getX(), 0.01f); - assertEquals(1046f, values2.get(1).getX(), 0.01f); - - data.groupBars(-1000, groupSpace, barSpace); - - assertEquals(-992f, values1.get(0).getX(), 0.01f); - assertEquals(-981f, values2.get(0).getX(), 0.01f); - assertEquals(-965f, values1.get(1).getX(), 0.01f); - assertEquals(-954f, values2.get(1).getX(), 0.01f); - - data.setBarWidth(20f); - groupWidth = data.getGroupWidth(groupSpace, barSpace); - assertEquals(47f, groupWidth, 0.01f); - - data.setBarWidth(10f); - data.groupBars(-20, groupSpace, barSpace); - - assertEquals(-12f, values1.get(0).getX(), 0.01f); - assertEquals(-1f, values2.get(0).getX(), 0.01f); - assertEquals(15f, values1.get(1).getX(), 0.01f); - assertEquals(26f, values2.get(1).getX(), 0.01f); - } -} diff --git a/MPChartLib/src/test/java/com/github/mikephil/charting/test/BarDataTest.kt b/MPChartLib/src/test/java/com/github/mikephil/charting/test/BarDataTest.kt new file mode 100644 index 0000000000..67d2194dbc --- /dev/null +++ b/MPChartLib/src/test/java/com/github/mikephil/charting/test/BarDataTest.kt @@ -0,0 +1,62 @@ +package com.github.mikephil.charting.test + +import com.github.mikephil.charting.data.BarData +import com.github.mikephil.charting.data.BarDataSet +import com.github.mikephil.charting.data.BarEntry +import org.junit.Assert +import org.junit.Test + +class BarDataTest { + @Test + fun testGroupBars() { + val groupSpace = 5f + val barSpace = 1f + + val values1: MutableList = ArrayList() + val values2: MutableList = ArrayList() + + for (i in 0..4) { + values1.add(BarEntry(i.toFloat(), 50f)) + values2.add(BarEntry(i.toFloat(), 60f)) + } + + val barDataSet1 = BarDataSet(values1, "Set1") + val barDataSet2 = BarDataSet(values2, "Set2") + + val data = BarData(barDataSet1, barDataSet2) + data.barWidth = 10f + + var groupWidth = data.getGroupWidth(groupSpace, barSpace) + Assert.assertEquals(27f, groupWidth, 0.01f) + + Assert.assertEquals(0f, values1[0].x, 0.01f) + Assert.assertEquals(1f, values1[1].x, 0.01f) + + data.groupBars(1000f, groupSpace, barSpace) + + // 1000 + 2.5 + 0.5 + 5 + Assert.assertEquals(1008f, values1[0].x, 0.01f) + Assert.assertEquals(1019f, values2[0].x, 0.01f) + Assert.assertEquals(1035f, values1[1].x, 0.01f) + Assert.assertEquals(1046f, values2[1].x, 0.01f) + + data.groupBars(-1000f, groupSpace, barSpace) + + Assert.assertEquals(-992f, values1[0].x, 0.01f) + Assert.assertEquals(-981f, values2[0].x, 0.01f) + Assert.assertEquals(-965f, values1[1].x, 0.01f) + Assert.assertEquals(-954f, values2[1].x, 0.01f) + + data.barWidth = 20f + groupWidth = data.getGroupWidth(groupSpace, barSpace) + Assert.assertEquals(47f, groupWidth, 0.01f) + + data.barWidth = 10f + data.groupBars(-20f, groupSpace, barSpace) + + Assert.assertEquals(-12f, values1[0].x, 0.01f) + Assert.assertEquals(-1f, values2[0].x, 0.01f) + Assert.assertEquals(15f, values1[1].x, 0.01f) + Assert.assertEquals(26f, values2[1].x, 0.01f) + } +} diff --git a/MPChartLib/src/test/java/com/github/mikephil/charting/test/ChartDataTest.java b/MPChartLib/src/test/java/com/github/mikephil/charting/test/ChartDataTest.java deleted file mode 100644 index 6d276091e7..0000000000 --- a/MPChartLib/src/test/java/com/github/mikephil/charting/test/ChartDataTest.java +++ /dev/null @@ -1,211 +0,0 @@ -package com.github.mikephil.charting.test; - -import com.github.mikephil.charting.components.YAxis; -import com.github.mikephil.charting.data.Entry; -import com.github.mikephil.charting.data.LineData; -import com.github.mikephil.charting.data.LineDataSet; -import com.github.mikephil.charting.data.ScatterData; -import com.github.mikephil.charting.data.ScatterDataSet; - -import org.junit.Test; - -import java.util.ArrayList; -import java.util.List; - -import static junit.framework.Assert.assertEquals; -import static junit.framework.Assert.assertFalse; -import static junit.framework.Assert.assertTrue; - -/** - * Created by philipp on 06/06/16. - */ -public class ChartDataTest { - - @Test - public void testDynamicChartData() { - - List entries1 = new ArrayList<>(); - entries1.add(new Entry(10, 10)); - entries1.add(new Entry(15, -2)); - entries1.add(new Entry(21, 50)); - - ScatterDataSet set1 = new ScatterDataSet(entries1, ""); - - List entries2 = new ArrayList<>(); - entries2.add(new Entry(-1, 10)); - entries2.add(new Entry(10, 2)); - entries2.add(new Entry(20, 5)); - - ScatterDataSet set2 = new ScatterDataSet(entries2, ""); - - ScatterData data = new ScatterData(set1, set2); - - assertEquals(-2, data.getYMin(YAxis.AxisDependency.LEFT), 0.01f); - assertEquals(50f, data.getYMax(YAxis.AxisDependency.LEFT), 0.01f); - - assertEquals(6, data.getEntryCount()); - - assertEquals(-1f, data.getXMin(), 0.01f); - assertEquals(21f, data.getXMax(), 0.01f); - - assertEquals(-2f, data.getYMin(), 0.01f); - assertEquals(50f, data.getYMax(), 0.01f); - - assertEquals(3, data.getMaxEntryCountSet().getEntryCount()); - - // now add and remove values - data.addEntry(new Entry(-10, -10), 0); - - assertEquals(set1, data.getMaxEntryCountSet()); - assertEquals(4, data.getMaxEntryCountSet().getEntryCount()); - - assertEquals(-10f, data.getYMin(YAxis.AxisDependency.LEFT), 0.01f); - assertEquals(50f, data.getYMax(YAxis.AxisDependency.LEFT), 0.01f); - - assertEquals(-10f, data.getXMin(), 0.01f); - assertEquals(21f, data.getXMax(), 0.01f); - - assertEquals(-10f, data.getYMin(), 0.01f); - assertEquals(50f, data.getYMax(), 0.01f); - - data.addEntry(new Entry(-100, 100), 0); - data.addEntry(new Entry(0, -100), 0); - - assertEquals(-100f, data.getYMin(YAxis.AxisDependency.LEFT), 0.01f); - assertEquals(100f, data.getYMax(YAxis.AxisDependency.LEFT), 0.01f); - - // right axis will adapt left axis values if no right axis values are present - assertEquals(-100, data.getYMin(YAxis.AxisDependency.RIGHT), 0.01f); - assertEquals(100f, data.getYMax(YAxis.AxisDependency.RIGHT), 0.01f); - - List entries3 = new ArrayList<>(); - entries3.add(new Entry(0, 200)); - entries3.add(new Entry(0, -50)); - - ScatterDataSet set3 = new ScatterDataSet(entries3, ""); - set3.setAxisDependency(YAxis.AxisDependency.RIGHT); - - data.addDataSet(set3); - - assertEquals(3, data.getDataSetCount()); - - assertEquals(-100f, data.getYMin(YAxis.AxisDependency.LEFT), 0.01f); - assertEquals(100f, data.getYMax(YAxis.AxisDependency.LEFT), 0.01f); - - assertEquals(-50f, data.getYMin(YAxis.AxisDependency.RIGHT), 0.01f); - assertEquals(200f, data.getYMax(YAxis.AxisDependency.RIGHT), 0.01f); - - LineData lineData = new LineData(); - - assertEquals(Float.MAX_VALUE, lineData.getYMin(), 0.01f); - assertEquals(-Float.MAX_VALUE, lineData.getYMax(), 0.01f); - - assertEquals(Float.MAX_VALUE, lineData.getYMin(YAxis.AxisDependency.LEFT), 0.01f); - assertEquals(-Float.MAX_VALUE, lineData.getYMax(YAxis.AxisDependency.LEFT), 0.01f); - - assertEquals(Float.MAX_VALUE, lineData.getYMin(YAxis.AxisDependency.RIGHT), 0.01f); - assertEquals(-Float.MAX_VALUE, lineData.getYMax(YAxis.AxisDependency.RIGHT), 0.01f); - - assertEquals(0, lineData.getDataSetCount()); - - List lineEntries1 = new ArrayList<>(); - lineEntries1.add(new Entry(10, 90)); - lineEntries1.add(new Entry(1000, 1000)); - - LineDataSet lineSet1 = new LineDataSet(lineEntries1, ""); - - lineData.addDataSet(lineSet1); - - assertEquals(1, lineData.getDataSetCount()); - assertEquals(2, lineSet1.getEntryCount()); - assertEquals(2, lineData.getEntryCount()); - - assertEquals(10, lineData.getXMin(), 0.01f); - assertEquals(1000f, lineData.getXMax(), 0.01f); - - assertEquals(90, lineData.getYMin(), 0.01f); - assertEquals(1000, lineData.getYMax(), 0.01f); - - assertEquals(90, lineData.getYMin(YAxis.AxisDependency.LEFT), 0.01f); - assertEquals(1000f, lineData.getYMax(YAxis.AxisDependency.LEFT), 0.01f); - - assertEquals(90, lineData.getYMin(YAxis.AxisDependency.RIGHT), 0.01f); - assertEquals(1000, lineData.getYMax(YAxis.AxisDependency.RIGHT), 0.01f); - - List lineEntries2 = new ArrayList<>(); - lineEntries2.add(new Entry(-1000, 2000)); - lineEntries2.add(new Entry(2000, -3000)); - - Entry e = new Entry(-1000, 2500); - lineEntries2.add(e); - - LineDataSet lineSet2 = new LineDataSet(lineEntries2, ""); - lineSet2.setAxisDependency(YAxis.AxisDependency.RIGHT); - - lineData.addDataSet(lineSet2); - - assertEquals(2, lineData.getDataSetCount()); - assertEquals(3, lineSet2.getEntryCount()); - assertEquals(5, lineData.getEntryCount()); - - assertEquals(-1000, lineData.getXMin(), 0.01f); - assertEquals(2000, lineData.getXMax(), 0.01f); - - assertEquals(-3000, lineData.getYMin(), 0.01f); - assertEquals(2500, lineData.getYMax(), 0.01f); - - assertEquals(90, lineData.getYMin(YAxis.AxisDependency.LEFT), 0.01f); - assertEquals(1000f, lineData.getYMax(YAxis.AxisDependency.LEFT), 0.01f); - - assertEquals(-3000, lineData.getYMin(YAxis.AxisDependency.RIGHT), 0.01f); - assertEquals(2500, lineData.getYMax(YAxis.AxisDependency.RIGHT), 0.01f); - - assertTrue(lineData.removeEntry(e, 1)); - - assertEquals(-1000, lineData.getXMin(), 0.01f); - assertEquals(2000, lineData.getXMax(), 0.01f); - - assertEquals(-3000, lineData.getYMin(), 0.01f); - assertEquals(2000, lineData.getYMax(), 0.01f); - - assertEquals(90, lineData.getYMin(YAxis.AxisDependency.LEFT), 0.01f); - assertEquals(1000f, lineData.getYMax(YAxis.AxisDependency.LEFT), 0.01f); - - assertEquals(-3000, lineData.getYMin(YAxis.AxisDependency.RIGHT), 0.01f); - assertEquals(2000, lineData.getYMax(YAxis.AxisDependency.RIGHT), 0.01f); - - assertEquals(2, lineData.getDataSetCount()); - assertTrue(lineData.removeDataSet(lineSet2)); - assertEquals(1, lineData.getDataSetCount()); - - assertEquals(10, lineData.getXMin(), 0.01f); - assertEquals(1000, lineData.getXMax(), 0.01f); - - assertEquals(90, lineData.getYMin(), 0.01f); - assertEquals(1000, lineData.getYMax(), 0.01f); - - assertEquals(90, lineData.getYMin(YAxis.AxisDependency.LEFT), 0.01f); - assertEquals(1000f, lineData.getYMax(YAxis.AxisDependency.LEFT), 0.01f); - - assertEquals(90, lineData.getYMin(YAxis.AxisDependency.RIGHT), 0.01f); - assertEquals(1000, lineData.getYMax(YAxis.AxisDependency.RIGHT), 0.01f); - - assertTrue(lineData.removeDataSet(lineSet1)); - assertEquals(0, lineData.getDataSetCount()); - - assertEquals(Float.MAX_VALUE, lineData.getXMin(), 0.01f); - assertEquals(-Float.MAX_VALUE, lineData.getXMax(), 0.01f); - - assertEquals(Float.MAX_VALUE, lineData.getYMin(), 0.01f); - assertEquals(-Float.MAX_VALUE, lineData.getYMax(), 0.01f); - - assertEquals(Float.MAX_VALUE, lineData.getYMin(YAxis.AxisDependency.LEFT), 0.01f); - assertEquals(-Float.MAX_VALUE, lineData.getYMax(YAxis.AxisDependency.LEFT), 0.01f); - - assertEquals(Float.MAX_VALUE, lineData.getYMin(YAxis.AxisDependency.RIGHT), 0.01f); - assertEquals(-Float.MAX_VALUE, lineData.getYMax(YAxis.AxisDependency.RIGHT), 0.01f); - - assertFalse(lineData.removeDataSet(lineSet1)); - assertFalse(lineData.removeDataSet(lineSet2)); - } -} diff --git a/MPChartLib/src/test/java/com/github/mikephil/charting/test/ChartDataTest.kt b/MPChartLib/src/test/java/com/github/mikephil/charting/test/ChartDataTest.kt new file mode 100644 index 0000000000..2658ee6a14 --- /dev/null +++ b/MPChartLib/src/test/java/com/github/mikephil/charting/test/ChartDataTest.kt @@ -0,0 +1,199 @@ +package com.github.mikephil.charting.test + +import com.github.mikephil.charting.components.YAxis +import com.github.mikephil.charting.data.Entry +import com.github.mikephil.charting.data.LineData +import com.github.mikephil.charting.data.LineDataSet +import com.github.mikephil.charting.data.ScatterData +import com.github.mikephil.charting.data.ScatterDataSet +import org.junit.Assert +import org.junit.Test + +class ChartDataTest { + @Test + fun testDynamicChartData() { + val entries1: MutableList = ArrayList() + entries1.add(Entry(10f, 10f)) + entries1.add(Entry(15f, -2f)) + entries1.add(Entry(21f, 50f)) + + val set1 = ScatterDataSet(entries1, "") + + val entries2: MutableList = ArrayList() + entries2.add(Entry(-1f, 10f)) + entries2.add(Entry(10f, 2f)) + entries2.add(Entry(20f, 5f)) + + val set2 = ScatterDataSet(entries2, "") + + val data = ScatterData(set1, set2) + + Assert.assertEquals(-2f, data.getYMin(YAxis.AxisDependency.LEFT), 0.01f) + Assert.assertEquals(50f, data.getYMax(YAxis.AxisDependency.LEFT), 0.01f) + + Assert.assertEquals(6, data.entryCount) + + Assert.assertEquals(-1f, data.xMin, 0.01f) + Assert.assertEquals(21f, data.xMax, 0.01f) + + Assert.assertEquals(-2f, data.yMin, 0.01f) + Assert.assertEquals(50f, data.yMax, 0.01f) + + Assert.assertEquals(3, data.maxEntryCountSet.entryCount) + + // now add and remove values + data.addEntry(Entry(-10f, -10f), 0) + + Assert.assertEquals(set1, data.maxEntryCountSet) + Assert.assertEquals(4, data.maxEntryCountSet.entryCount) + + Assert.assertEquals(-10f, data.getYMin(YAxis.AxisDependency.LEFT), 0.01f) + Assert.assertEquals(50f, data.getYMax(YAxis.AxisDependency.LEFT), 0.01f) + + Assert.assertEquals(-10f, data.xMin, 0.01f) + Assert.assertEquals(21f, data.xMax, 0.01f) + + Assert.assertEquals(-10f, data.yMin, 0.01f) + Assert.assertEquals(50f, data.yMax, 0.01f) + + data.addEntry(Entry(-100f, 100f), 0) + data.addEntry(Entry(0f, -100f), 0) + + Assert.assertEquals(-100f, data.getYMin(YAxis.AxisDependency.LEFT), 0.01f) + Assert.assertEquals(100f, data.getYMax(YAxis.AxisDependency.LEFT), 0.01f) + + // right axis will adapt left axis values if no right axis values are present + Assert.assertEquals(-100f, data.getYMin(YAxis.AxisDependency.RIGHT), 0.01f) + Assert.assertEquals(100f, data.getYMax(YAxis.AxisDependency.RIGHT), 0.01f) + + val entries3: MutableList = ArrayList() + entries3.add(Entry(0f, 200f)) + entries3.add(Entry(0f, -50f)) + + val set3 = ScatterDataSet(entries3, "") + set3.axisDependency = YAxis.AxisDependency.RIGHT + + data.addDataSet(set3) + + Assert.assertEquals(3, data.dataSetCount) + + Assert.assertEquals(-100f, data.getYMin(YAxis.AxisDependency.LEFT), 0.01f) + Assert.assertEquals(100f, data.getYMax(YAxis.AxisDependency.LEFT), 0.01f) + + Assert.assertEquals(-50f, data.getYMin(YAxis.AxisDependency.RIGHT), 0.01f) + Assert.assertEquals(200f, data.getYMax(YAxis.AxisDependency.RIGHT), 0.01f) + + val lineData = LineData() + + Assert.assertEquals(Float.MAX_VALUE, lineData.yMin, 0.01f) + Assert.assertEquals(-Float.MAX_VALUE, lineData.yMax, 0.01f) + + Assert.assertEquals(Float.MAX_VALUE, lineData.getYMin(YAxis.AxisDependency.LEFT), 0.01f) + Assert.assertEquals(-Float.MAX_VALUE, lineData.getYMax(YAxis.AxisDependency.LEFT), 0.01f) + + Assert.assertEquals(Float.MAX_VALUE, lineData.getYMin(YAxis.AxisDependency.RIGHT), 0.01f) + Assert.assertEquals(-Float.MAX_VALUE, lineData.getYMax(YAxis.AxisDependency.RIGHT), 0.01f) + + Assert.assertEquals(0, lineData.dataSetCount) + + val lineEntries1: MutableList = ArrayList() + lineEntries1.add(Entry(10f, 90f)) + lineEntries1.add(Entry(1000f, 1000f)) + + val lineSet1 = LineDataSet(lineEntries1, "") + + lineData.addDataSet(lineSet1) + + Assert.assertEquals(1, lineData.dataSetCount) + Assert.assertEquals(2, lineSet1.entryCount) + Assert.assertEquals(2, lineData.entryCount) + + Assert.assertEquals(10f, lineData.xMin, 0.01f) + Assert.assertEquals(1000f, lineData.xMax, 0.01f) + + Assert.assertEquals(90f, lineData.yMin, 0.01f) + Assert.assertEquals(1000f, lineData.yMax, 0.01f) + + Assert.assertEquals(90f, lineData.getYMin(YAxis.AxisDependency.LEFT), 0.01f) + Assert.assertEquals(1000f, lineData.getYMax(YAxis.AxisDependency.LEFT), 0.01f) + + Assert.assertEquals(90f, lineData.getYMin(YAxis.AxisDependency.RIGHT), 0.01f) + Assert.assertEquals(1000f, lineData.getYMax(YAxis.AxisDependency.RIGHT), 0.01f) + + val lineEntries2: MutableList = ArrayList() + lineEntries2.add(Entry(-1000f, 2000f)) + lineEntries2.add(Entry(2000f, -3000f)) + + val e = Entry(-1000f, 2500f) + lineEntries2.add(e) + + val lineSet2 = LineDataSet(lineEntries2, "") + lineSet2.axisDependency = YAxis.AxisDependency.RIGHT + + lineData.addDataSet(lineSet2) + + Assert.assertEquals(2, lineData.dataSetCount) + Assert.assertEquals(3, lineSet2.entryCount) + Assert.assertEquals(5, lineData.entryCount) + + Assert.assertEquals(-1000f, lineData.xMin, 0.01f) + Assert.assertEquals(2000f, lineData.xMax, 0.01f) + + Assert.assertEquals(-3000f, lineData.yMin, 0.01f) + Assert.assertEquals(2500f, lineData.yMax, 0.01f) + + Assert.assertEquals(90f, lineData.getYMin(YAxis.AxisDependency.LEFT), 0.01f) + Assert.assertEquals(1000f, lineData.getYMax(YAxis.AxisDependency.LEFT), 0.01f) + + Assert.assertEquals(-3000f, lineData.getYMin(YAxis.AxisDependency.RIGHT), 0.01f) + Assert.assertEquals(2500f, lineData.getYMax(YAxis.AxisDependency.RIGHT), 0.01f) + + Assert.assertTrue(lineData.removeEntry(e, 1)) + + Assert.assertEquals(-1000f, lineData.xMin, 0.01f) + Assert.assertEquals(2000f, lineData.xMax, 0.01f) + + Assert.assertEquals(-3000f, lineData.yMin, 0.01f) + Assert.assertEquals(2000f, lineData.yMax, 0.01f) + + Assert.assertEquals(90f, lineData.getYMin(YAxis.AxisDependency.LEFT), 0.01f) + Assert.assertEquals(1000f, lineData.getYMax(YAxis.AxisDependency.LEFT), 0.01f) + + Assert.assertEquals(-3000f, lineData.getYMin(YAxis.AxisDependency.RIGHT), 0.01f) + Assert.assertEquals(2000f, lineData.getYMax(YAxis.AxisDependency.RIGHT), 0.01f) + + Assert.assertEquals(2, lineData.dataSetCount) + Assert.assertTrue(lineData.removeDataSet(lineSet2)) + Assert.assertEquals(1, lineData.dataSetCount) + + Assert.assertEquals(10f, lineData.xMin, 0.01f) + Assert.assertEquals(1000f, lineData.xMax, 0.01f) + + Assert.assertEquals(90f, lineData.yMin, 0.01f) + Assert.assertEquals(1000f, lineData.yMax, 0.01f) + + Assert.assertEquals(90f, lineData.getYMin(YAxis.AxisDependency.LEFT), 0.01f) + Assert.assertEquals(1000f, lineData.getYMax(YAxis.AxisDependency.LEFT), 0.01f) + + Assert.assertEquals(90f, lineData.getYMin(YAxis.AxisDependency.RIGHT), 0.01f) + Assert.assertEquals(1000f, lineData.getYMax(YAxis.AxisDependency.RIGHT), 0.01f) + + Assert.assertTrue(lineData.removeDataSet(lineSet1)) + Assert.assertEquals(0, lineData.dataSetCount) + + Assert.assertEquals(Float.MAX_VALUE, lineData.xMin, 0.01f) + Assert.assertEquals(-Float.MAX_VALUE, lineData.xMax, 0.01f) + + Assert.assertEquals(Float.MAX_VALUE, lineData.yMin, 0.01f) + Assert.assertEquals(-Float.MAX_VALUE, lineData.yMax, 0.01f) + + Assert.assertEquals(Float.MAX_VALUE, lineData.getYMin(YAxis.AxisDependency.LEFT), 0.01f) + Assert.assertEquals(-Float.MAX_VALUE, lineData.getYMax(YAxis.AxisDependency.LEFT), 0.01f) + + Assert.assertEquals(Float.MAX_VALUE, lineData.getYMin(YAxis.AxisDependency.RIGHT), 0.01f) + Assert.assertEquals(-Float.MAX_VALUE, lineData.getYMax(YAxis.AxisDependency.RIGHT), 0.01f) + + Assert.assertFalse(lineData.removeDataSet(lineSet1)) + Assert.assertFalse(lineData.removeDataSet(lineSet2)) + } +} diff --git a/MPChartLib/src/test/java/com/github/mikephil/charting/test/DataSetTest.java b/MPChartLib/src/test/java/com/github/mikephil/charting/test/DataSetTest.java deleted file mode 100644 index 054db7f47c..0000000000 --- a/MPChartLib/src/test/java/com/github/mikephil/charting/test/DataSetTest.java +++ /dev/null @@ -1,238 +0,0 @@ -package com.github.mikephil.charting.test; - -import com.github.mikephil.charting.data.DataSet; -import com.github.mikephil.charting.data.Entry; -import com.github.mikephil.charting.data.ScatterDataSet; - -import org.junit.Test; - -import java.util.ArrayList; -import java.util.List; - -import static junit.framework.Assert.assertEquals; -import static junit.framework.Assert.assertFalse; -import static junit.framework.Assert.assertTrue; - -/** - * Created by philipp on 31/05/16. - */ -public class DataSetTest { - - @Test - public void testCalcMinMax() { - - List entries = new ArrayList<>(); - entries.add(new Entry(10, 10)); - entries.add(new Entry(15, 2)); - entries.add(new Entry(21, 5)); - - ScatterDataSet set = new ScatterDataSet(entries, ""); - - assertEquals(10f, set.getXMin(), 0.01f); - assertEquals(21f, set.getXMax(), 0.01f); - - assertEquals(2f, set.getYMin(), 0.01f); - assertEquals(10f, set.getYMax(), 0.01f); - - assertEquals(3, set.getEntryCount()); - - set.addEntry(new Entry(25, 1)); - - assertEquals(10f, set.getXMin(), 0.01f); - assertEquals(25f, set.getXMax(), 0.01f); - - assertEquals(1f, set.getYMin(), 0.01f); - assertEquals(10f, set.getYMax(), 0.01f); - - assertEquals(4, set.getEntryCount()); - - set.removeEntry(3); - - assertEquals(10f, set.getXMin(), 0.01f); - assertEquals(21, set.getXMax(), 0.01f); - - assertEquals(2f, set.getYMin(), 0.01f); - assertEquals(10f, set.getYMax(), 0.01f); - } - - @Test - public void testAddRemoveEntry() { - - List entries = new ArrayList<>(); - entries.add(new Entry(10, 10)); - entries.add(new Entry(15, 2)); - entries.add(new Entry(21, 5)); - - ScatterDataSet set = new ScatterDataSet(entries, ""); - - assertEquals(3, set.getEntryCount()); - - set.addEntryOrdered(new Entry(5, 1)); - - assertEquals(4, set.getEntryCount()); - - assertEquals(5, set.getXMin(), 0.01f); - assertEquals(21, set.getXMax(), 0.01f); - - assertEquals(1f, set.getYMin(), 0.01f); - assertEquals(10f, set.getYMax(), 0.01f); - - assertEquals(5, set.getEntryForIndex(0).getX(), 0.01f); - assertEquals(1, set.getEntryForIndex(0).getY(), 0.01f); - - set.addEntryOrdered(new Entry(20, 50)); - - assertEquals(5, set.getEntryCount()); - - assertEquals(20, set.getEntryForIndex(3).getX(), 0.01f); - assertEquals(50, set.getEntryForIndex(3).getY(), 0.01f); - - assertTrue(set.removeEntry(3)); - - assertEquals(4, set.getEntryCount()); - - assertEquals(21, set.getEntryForIndex(3).getX(), 0.01f); - assertEquals(5, set.getEntryForIndex(3).getY(), 0.01f); - - assertEquals(5, set.getEntryForIndex(0).getX(), 0.01f); - assertEquals(1, set.getEntryForIndex(0).getY(), 0.01f); - - assertTrue(set.removeFirst()); - - assertEquals(3, set.getEntryCount()); - - assertEquals(10, set.getEntryForIndex(0).getX(), 0.01f); - assertEquals(10, set.getEntryForIndex(0).getY(), 0.01f); - - set.addEntryOrdered(new Entry(15, 3)); - - assertEquals(4, set.getEntryCount()); - - assertEquals(15, set.getEntryForIndex(1).getX(), 0.01f); - assertEquals(3, set.getEntryForIndex(1).getY(), 0.01f); - - assertEquals(21, set.getEntryForIndex(3).getX(), 0.01f); - assertEquals(5, set.getEntryForIndex(3).getY(), 0.01f); - - assertTrue(set.removeLast()); - - assertEquals(3, set.getEntryCount()); - - assertEquals(15, set.getEntryForIndex(2).getX(), 0.01f); - assertEquals(2, set.getEntryForIndex(2).getY(), 0.01f); - - assertTrue(set.removeLast()); - - assertEquals(2, set.getEntryCount()); - - assertTrue(set.removeLast()); - - assertEquals(1, set.getEntryCount()); - - assertEquals(10, set.getEntryForIndex(0).getX(), 0.01f); - assertEquals(10, set.getEntryForIndex(0).getY(), 0.01f); - - assertTrue(set.removeLast()); - - assertEquals(0, set.getEntryCount()); - - assertFalse(set.removeLast()); - assertFalse(set.removeFirst()); - } - - @Test - public void testGetEntryForXValue() { - - List entries = new ArrayList<>(); - entries.add(new Entry(10, 10)); - entries.add(new Entry(15, 5)); - entries.add(new Entry(21, 5)); - - ScatterDataSet set = new ScatterDataSet(entries, ""); - - Entry closest = set.getEntryForXValue(17, Float.NaN, DataSet.Rounding.CLOSEST); - assertEquals(15, closest.getX(), 0.01f); - assertEquals(5, closest.getY(), 0.01f); - - closest = set.getEntryForXValue(17, Float.NaN, DataSet.Rounding.DOWN); - assertEquals(15, closest.getX(), 0.01f); - assertEquals(5, closest.getY(), 0.01f); - - closest = set.getEntryForXValue(15, Float.NaN, DataSet.Rounding.DOWN); - assertEquals(15, closest.getX(), 0.01f); - assertEquals(5, closest.getY(), 0.01f); - - closest = set.getEntryForXValue(14, Float.NaN, DataSet.Rounding.DOWN); - assertEquals(10, closest.getX(), 0.01f); - assertEquals(10, closest.getY(), 0.01f); - - closest = set.getEntryForXValue(17, Float.NaN, DataSet.Rounding.UP); - assertEquals(21, closest.getX(), 0.01f); - assertEquals(5, closest.getY(), 0.01f); - - closest = set.getEntryForXValue(21, Float.NaN, DataSet.Rounding.UP); - assertEquals(21, closest.getX(), 0.01f); - assertEquals(5, closest.getY(), 0.01f); - - closest = set.getEntryForXValue(21, Float.NaN, DataSet.Rounding.CLOSEST); - assertEquals(21, closest.getX(), 0.01f); - assertEquals(5, closest.getY(), 0.01f); - } - - @Test - public void testGetEntryForXValueWithDuplicates() { - - // sorted list of values (by x position) - List values = new ArrayList<>(); - values.add(new Entry(0, 10)); - values.add(new Entry(1, 20)); - values.add(new Entry(2, 30)); - values.add(new Entry(3, 40)); - values.add(new Entry(3, 50)); // duplicate - values.add(new Entry(4, 60)); - values.add(new Entry(4, 70)); // duplicate - values.add(new Entry(5, 80)); - values.add(new Entry(6, 90)); - values.add(new Entry(7, 100)); - values.add(new Entry(8, 110)); - values.add(new Entry(8, 120)); // duplicate - - ScatterDataSet set = new ScatterDataSet(values, ""); - - Entry closest = set.getEntryForXValue(0, Float.NaN, DataSet.Rounding.CLOSEST); - assertEquals(0, closest.getX(), 0.01f); - assertEquals(10, closest.getY(), 0.01f); - - closest = set.getEntryForXValue(5, Float.NaN, DataSet.Rounding.CLOSEST); - assertEquals(5, closest.getX(), 0.01f); - assertEquals(80, closest.getY(), 0.01f); - - closest = set.getEntryForXValue(5.4f, Float.NaN, DataSet.Rounding.CLOSEST); - assertEquals(5, closest.getX(), 0.01f); - assertEquals(80, closest.getY(), 0.01f); - - closest = set.getEntryForXValue(4.6f, Float.NaN, DataSet.Rounding.CLOSEST); - assertEquals(5, closest.getX(), 0.01f); - assertEquals(80, closest.getY(), 0.01f); - - closest = set.getEntryForXValue(7, Float.NaN, DataSet.Rounding.CLOSEST); - assertEquals(7, closest.getX(), 0.01f); - assertEquals(100, closest.getY(), 0.01f); - - closest = set.getEntryForXValue(4f, Float.NaN, DataSet.Rounding.CLOSEST); - assertEquals(4, closest.getX(), 0.01f); - assertEquals(60, closest.getY(), 0.01f); - - List entries = set.getEntriesForXValue(4f); - assertEquals(2, entries.size()); - assertEquals(60, entries.get(0).getY(), 0.01f); - assertEquals(70, entries.get(1).getY(), 0.01f); - - entries = set.getEntriesForXValue(3.5f); - assertEquals(0, entries.size()); - - entries = set.getEntriesForXValue(2f); - assertEquals(1, entries.size()); - assertEquals(30, entries.get(0).getY(), 0.01f); - } -} diff --git a/MPChartLib/src/test/java/com/github/mikephil/charting/test/DataSetTest.kt b/MPChartLib/src/test/java/com/github/mikephil/charting/test/DataSetTest.kt new file mode 100644 index 0000000000..b5db37fc29 --- /dev/null +++ b/MPChartLib/src/test/java/com/github/mikephil/charting/test/DataSetTest.kt @@ -0,0 +1,224 @@ +package com.github.mikephil.charting.test + +import com.github.mikephil.charting.data.DataSet +import com.github.mikephil.charting.data.Entry +import com.github.mikephil.charting.data.ScatterDataSet +import org.junit.Assert +import org.junit.Test + +class DataSetTest { + @Test + fun testCalcMinMax() { + val entries: MutableList = ArrayList() + entries.add(Entry(10f, 10f)) + entries.add(Entry(15f, 2f)) + entries.add(Entry(21f, 5f)) + + val set = ScatterDataSet(entries, "") + + Assert.assertEquals(10f, set.xMin, 0.01f) + Assert.assertEquals(21f, set.xMax, 0.01f) + + Assert.assertEquals(2f, set.yMin, 0.01f) + Assert.assertEquals(10f, set.yMax, 0.01f) + + Assert.assertEquals(3, set.entryCount) + + set.addEntry(Entry(25f, 1f)) + + Assert.assertEquals(10f, set.xMin, 0.01f) + Assert.assertEquals(25f, set.xMax, 0.01f) + + Assert.assertEquals(1f, set.yMin, 0.01f) + Assert.assertEquals(10f, set.yMax, 0.01f) + + Assert.assertEquals(4, set.entryCount) + + set.removeEntry(3) + + Assert.assertEquals(10f, set.xMin, 0.01f) + Assert.assertEquals(21f, set.xMax, 0.01f) + + Assert.assertEquals(2f, set.yMin, 0.01f) + Assert.assertEquals(10f, set.yMax, 0.01f) + } + + @Test + fun testAddRemoveEntry() { + val entries: MutableList = ArrayList() + entries.add(Entry(10f, 10f)) + entries.add(Entry(15f, 2f)) + entries.add(Entry(21f, 5f)) + + val set = ScatterDataSet(entries, "") + + Assert.assertEquals(3, set.entryCount) + + set.addEntryOrdered(Entry(5f, 1f)) + + Assert.assertEquals(4, set.entryCount) + + Assert.assertEquals(5f, set.xMin, 0.01f) + Assert.assertEquals(21f, set.xMax, 0.01f) + + Assert.assertEquals(1f, set.yMin, 0.01f) + Assert.assertEquals(10f, set.yMax, 0.01f) + + Assert.assertEquals(5f, set.getEntryForIndex(0).x, 0.01f) + Assert.assertEquals(1f, set.getEntryForIndex(0).y, 0.01f) + + set.addEntryOrdered(Entry(20f, 50f)) + + Assert.assertEquals(5, set.entryCount) + + Assert.assertEquals(20f, set.getEntryForIndex(3).x, 0.01f) + Assert.assertEquals(50f, set.getEntryForIndex(3).y, 0.01f) + + Assert.assertTrue(set.removeEntry(3)) + + Assert.assertEquals(4, set.entryCount) + + Assert.assertEquals(21f, set.getEntryForIndex(3).x, 0.01f) + Assert.assertEquals(5f, set.getEntryForIndex(3).y, 0.01f) + + Assert.assertEquals(5f, set.getEntryForIndex(0).x, 0.01f) + Assert.assertEquals(1f, set.getEntryForIndex(0).y, 0.01f) + + Assert.assertTrue(set.removeFirst()) + + Assert.assertEquals(3, set.entryCount) + + Assert.assertEquals(10f, set.getEntryForIndex(0).x, 0.01f) + Assert.assertEquals(10f, set.getEntryForIndex(0).y, 0.01f) + + set.addEntryOrdered(Entry(15f, 3f)) + + Assert.assertEquals(4, set.entryCount) + + Assert.assertEquals(15f, set.getEntryForIndex(1).x, 0.01f) + Assert.assertEquals(3f, set.getEntryForIndex(1).y, 0.01f) + + Assert.assertEquals(21f, set.getEntryForIndex(3).x, 0.01f) + Assert.assertEquals(5f, set.getEntryForIndex(3).y, 0.01f) + + Assert.assertTrue(set.removeLast()) + + Assert.assertEquals(3, set.entryCount) + + Assert.assertEquals(15f, set.getEntryForIndex(2).x, 0.01f) + Assert.assertEquals(2f, set.getEntryForIndex(2).y, 0.01f) + + Assert.assertTrue(set.removeLast()) + + Assert.assertEquals(2, set.entryCount) + + Assert.assertTrue(set.removeLast()) + + Assert.assertEquals(1, set.entryCount) + + Assert.assertEquals(10f, set.getEntryForIndex(0).x, 0.01f) + Assert.assertEquals(10f, set.getEntryForIndex(0).y, 0.01f) + + Assert.assertTrue(set.removeLast()) + + Assert.assertEquals(0, set.entryCount) + + Assert.assertFalse(set.removeLast()) + Assert.assertFalse(set.removeFirst()) + } + + @Test + fun testGetEntryForXValue() { + val entries: MutableList = ArrayList() + entries.add(Entry(10f, 10f)) + entries.add(Entry(15f, 5f)) + entries.add(Entry(21f, 5f)) + + val set = ScatterDataSet(entries, "") + + var closest = set.getEntryForXValue(17f, Float.NaN, DataSet.Rounding.CLOSEST) + Assert.assertEquals(15f, closest.x, 0.01f) + Assert.assertEquals(5f, closest.y, 0.01f) + + closest = set.getEntryForXValue(17f, Float.NaN, DataSet.Rounding.DOWN) + Assert.assertEquals(15f, closest.x, 0.01f) + Assert.assertEquals(5f, closest.y, 0.01f) + + closest = set.getEntryForXValue(15f, Float.NaN, DataSet.Rounding.DOWN) + Assert.assertEquals(15f, closest.x, 0.01f) + Assert.assertEquals(5f, closest.y, 0.01f) + + closest = set.getEntryForXValue(14f, Float.NaN, DataSet.Rounding.DOWN) + Assert.assertEquals(10f, closest.x, 0.01f) + Assert.assertEquals(10f, closest.y, 0.01f) + + closest = set.getEntryForXValue(17f, Float.NaN, DataSet.Rounding.UP) + Assert.assertEquals(21f, closest.x, 0.01f) + Assert.assertEquals(5f, closest.y, 0.01f) + + closest = set.getEntryForXValue(21f, Float.NaN, DataSet.Rounding.UP) + Assert.assertEquals(21f, closest.x, 0.01f) + Assert.assertEquals(5f, closest.y, 0.01f) + + closest = set.getEntryForXValue(21f, Float.NaN, DataSet.Rounding.CLOSEST) + Assert.assertEquals(21f, closest.x, 0.01f) + Assert.assertEquals(5f, closest.y, 0.01f) + } + + @Test + fun testGetEntryForXValueWithDuplicates() { + // sorted list of values (by x position) + + val values: MutableList = ArrayList() + values.add(Entry(0f, 10f)) + values.add(Entry(1f, 20f)) + values.add(Entry(2f, 30f)) + values.add(Entry(3f, 40f)) + values.add(Entry(3f, 50f)) // duplicate + values.add(Entry(4f, 60f)) + values.add(Entry(4f, 70f)) // duplicate + values.add(Entry(5f, 80f)) + values.add(Entry(6f, 90f)) + values.add(Entry(7f, 100f)) + values.add(Entry(8f, 110f)) + values.add(Entry(8f, 120f)) // duplicate + + val set = ScatterDataSet(values, "") + + var closest = set.getEntryForXValue(0f, Float.NaN, DataSet.Rounding.CLOSEST) + Assert.assertEquals(0f, closest.x, 0.01f) + Assert.assertEquals(10f, closest.y, 0.01f) + + closest = set.getEntryForXValue(5f, Float.NaN, DataSet.Rounding.CLOSEST) + Assert.assertEquals(5f, closest.x, 0.01f) + Assert.assertEquals(80f, closest.y, 0.01f) + + closest = set.getEntryForXValue(5.4f, Float.NaN, DataSet.Rounding.CLOSEST) + Assert.assertEquals(5f, closest.x, 0.01f) + Assert.assertEquals(80f, closest.y, 0.01f) + + closest = set.getEntryForXValue(4.6f, Float.NaN, DataSet.Rounding.CLOSEST) + Assert.assertEquals(5f, closest.x, 0.01f) + Assert.assertEquals(80f, closest.y, 0.01f) + + closest = set.getEntryForXValue(7f, Float.NaN, DataSet.Rounding.CLOSEST) + Assert.assertEquals(7f, closest.x, 0.01f) + Assert.assertEquals(100f, closest.y, 0.01f) + + closest = set.getEntryForXValue(4f, Float.NaN, DataSet.Rounding.CLOSEST) + Assert.assertEquals(4f, closest.x, 0.01f) + Assert.assertEquals(60f, closest.y, 0.01f) + + var entries = set.getEntriesForXValue(4f) + Assert.assertEquals(2, entries.size) + Assert.assertEquals(60f, entries[0].y, 0.01f) + Assert.assertEquals(70f, entries[1].y, 0.01f) + + entries = set.getEntriesForXValue(3.5f) + Assert.assertEquals(0, entries.size) + + entries = set.getEntriesForXValue(2f) + Assert.assertEquals(1, entries.size) + Assert.assertEquals(30f, entries[0].y, 0.01f) + } +} diff --git a/MPChartLib/src/test/java/com/github/mikephil/charting/test/LargeValueFormatterTest.java b/MPChartLib/src/test/java/com/github/mikephil/charting/test/LargeValueFormatterTest.java deleted file mode 100644 index f1e1e0279e..0000000000 --- a/MPChartLib/src/test/java/com/github/mikephil/charting/test/LargeValueFormatterTest.java +++ /dev/null @@ -1,95 +0,0 @@ -package com.github.mikephil.charting.test; - -import com.github.mikephil.charting.formatter.LargeValueFormatter; - -import org.junit.Test; - -import static junit.framework.Assert.assertEquals; - -/** - * Created by philipp on 06/06/16. - */ -public class LargeValueFormatterTest { - - @Test - public void test() { - - LargeValueFormatter formatter = new LargeValueFormatter(); - - String result = formatter.getFormattedValue(5f, null); - assertEquals("5", result); - - result = formatter.getFormattedValue(5.5f, null); - assertEquals("5.5", result); - - result = formatter.getFormattedValue(50f, null); - assertEquals("50", result); - - result = formatter.getFormattedValue(50.5f, null); - assertEquals("50.5", result); - - result = formatter.getFormattedValue(500f, null); - assertEquals("500", result); - - result = formatter.getFormattedValue(1100f, null); - assertEquals("1.1k", result); - - result = formatter.getFormattedValue(10000f, null); - assertEquals("10k", result); - - result = formatter.getFormattedValue(10500f, null); - assertEquals("10.5k", result); - - result = formatter.getFormattedValue(100000f, null); - assertEquals("100k", result); - - result = formatter.getFormattedValue(1000000f, null); - assertEquals("1m", result); - - result = formatter.getFormattedValue(1500000f, null); - assertEquals("1.5m", result); - - result = formatter.getFormattedValue(9500000f, null); - assertEquals("9.5m", result); - - result = formatter.getFormattedValue(22200000f, null); - assertEquals("22.2m", result); - - result = formatter.getFormattedValue(222000000f, null); - assertEquals("222m", result); - - result = formatter.getFormattedValue(1000000000f, null); - assertEquals("1b", result); - - result = formatter.getFormattedValue(9900000000f, null); - assertEquals("9.9b", result); - - result = formatter.getFormattedValue(99000000000f, null); - assertEquals("99b", result); - - result = formatter.getFormattedValue(99500000000f, null); - assertEquals("99.5b", result); - - result = formatter.getFormattedValue(999000000000f, null); - assertEquals("999b", result); - - result = formatter.getFormattedValue(1000000000000f, null); - assertEquals("1t", result); - - formatter.setSuffix(new String[]{"", "k", "m", "b", "t", "q"}); // quadrillion support - result = formatter.getFormattedValue(1000000000000000f, null); - assertEquals("1q", result); - - result = formatter.getFormattedValue(1100000000000000f, null); - assertEquals("1.1q", result); - - result = formatter.getFormattedValue(10000000000000000f, null); - assertEquals("10q", result); - - result = formatter.getFormattedValue(13300000000000000f, null); - assertEquals("13.3q", result); - - result = formatter.getFormattedValue(100000000000000000f, null); - assertEquals("100q", result); - } -} diff --git a/MPChartLib/src/test/java/com/github/mikephil/charting/test/LargeValueFormatterTest.kt b/MPChartLib/src/test/java/com/github/mikephil/charting/test/LargeValueFormatterTest.kt new file mode 100644 index 0000000000..1bdd1f272a --- /dev/null +++ b/MPChartLib/src/test/java/com/github/mikephil/charting/test/LargeValueFormatterTest.kt @@ -0,0 +1,88 @@ +package com.github.mikephil.charting.test + +import com.github.mikephil.charting.formatter.LargeValueFormatter +import org.junit.Assert +import org.junit.Test + +class LargeValueFormatterTest { + @Test + fun test() { + val formatter = LargeValueFormatter() + + var result = formatter.getFormattedValue(5f, null) + Assert.assertEquals("5", result) + + result = formatter.getFormattedValue(5.5f, null) + Assert.assertEquals("5.5", result) + + result = formatter.getFormattedValue(50f, null) + Assert.assertEquals("50", result) + + result = formatter.getFormattedValue(50.5f, null) + Assert.assertEquals("50.5", result) + + result = formatter.getFormattedValue(500f, null) + Assert.assertEquals("500", result) + + result = formatter.getFormattedValue(1100f, null) + Assert.assertEquals("1.1k", result) + + result = formatter.getFormattedValue(10000f, null) + Assert.assertEquals("10k", result) + + result = formatter.getFormattedValue(10500f, null) + Assert.assertEquals("10.5k", result) + + result = formatter.getFormattedValue(100000f, null) + Assert.assertEquals("100k", result) + + result = formatter.getFormattedValue(1000000f, null) + Assert.assertEquals("1m", result) + + result = formatter.getFormattedValue(1500000f, null) + Assert.assertEquals("1.5m", result) + + result = formatter.getFormattedValue(9500000f, null) + Assert.assertEquals("9.5m", result) + + result = formatter.getFormattedValue(22200000f, null) + Assert.assertEquals("22.2m", result) + + result = formatter.getFormattedValue(222000000f, null) + Assert.assertEquals("222m", result) + + result = formatter.getFormattedValue(1000000000f, null) + Assert.assertEquals("1b", result) + + result = formatter.getFormattedValue(9900000000f, null) + Assert.assertEquals("9.9b", result) + + result = formatter.getFormattedValue(99000000000f, null) + Assert.assertEquals("99b", result) + + result = formatter.getFormattedValue(99500000000f, null) + Assert.assertEquals("99.5b", result) + + result = formatter.getFormattedValue(999000000000f, null) + Assert.assertEquals("999b", result) + + result = formatter.getFormattedValue(1000000000000f, null) + Assert.assertEquals("1t", result) + + formatter.setSuffix(arrayOf("", "k", "m", "b", "t", "q")) // quadrillion support + result = formatter.getFormattedValue(1000000000000000f, null) + Assert.assertEquals("1q", result) + + result = formatter.getFormattedValue(1100000000000000f, null) + Assert.assertEquals("1.1q", result) + + result = formatter.getFormattedValue(10000000000000000f, null) + Assert.assertEquals("10q", result) + + result = formatter.getFormattedValue(13300000000000000f, null) + Assert.assertEquals("13.3q", result) + + result = formatter.getFormattedValue(100000000000000000f, null) + Assert.assertEquals("100q", result) + } +} diff --git a/MPChartLib/src/test/java/com/github/mikephil/charting/test/ObjectPoolTest.java b/MPChartLib/src/test/java/com/github/mikephil/charting/test/ObjectPoolTest.java deleted file mode 100644 index 7b6777ef21..0000000000 --- a/MPChartLib/src/test/java/com/github/mikephil/charting/test/ObjectPoolTest.java +++ /dev/null @@ -1,240 +0,0 @@ -package com.github.mikephil.charting.test; - -import com.github.mikephil.charting.utils.ObjectPool; - -import junit.framework.Assert; - -import org.junit.Test; - -import java.util.ArrayList; -import java.util.List; - -/** - * Created by otheruser on 6/28/16. - */ -public class ObjectPoolTest { - - static class TestPoolable extends ObjectPool.Poolable { - - private static final ObjectPool pool; - - static { - pool = ObjectPool.create(4, new TestPoolable(0, 0)); - } - - public int foo; - public int bar; - - protected ObjectPool.Poolable instantiate() { - return new TestPoolable(0, 0); - } - - private TestPoolable(int foo, int bar) { - this.foo = foo; - this.bar = bar; - } - - public static TestPoolable getInstance(int foo, int bar) { - TestPoolable result = pool.get(); - result.foo = foo; - result.bar = bar; - return result; - } - - public static void recycleInstance(TestPoolable instance) { - pool.recycle(instance); - } - - public static void recycleInstances(List instances) { - pool.recycle(instances); - } - - public static ObjectPool getPool() { - return pool; - } - - } - - @Test - public void testObjectPool() { - - int poolCapacity = TestPoolable.getPool().getPoolCapacity(); - int poolCount = TestPoolable.getPool().getPoolCount(); - TestPoolable testPoolable; - ArrayList testPoolables = new ArrayList<>(); - - Assert.assertEquals(4, poolCapacity); - Assert.assertEquals(4, poolCount); - - testPoolable = TestPoolable.getInstance(6, 7); - Assert.assertEquals(6, testPoolable.foo); - Assert.assertEquals(7, testPoolable.bar); - - poolCapacity = TestPoolable.getPool().getPoolCapacity(); - poolCount = TestPoolable.getPool().getPoolCount(); - - Assert.assertEquals(4, poolCapacity); - Assert.assertEquals(3, poolCount); - - TestPoolable.recycleInstance(testPoolable); - - poolCapacity = TestPoolable.getPool().getPoolCapacity(); - poolCount = TestPoolable.getPool().getPoolCount(); - Assert.assertEquals(4, poolCapacity); - Assert.assertEquals(4, poolCount); - - - testPoolable = TestPoolable.getInstance(20, 30); - Assert.assertEquals(20, testPoolable.foo); - Assert.assertEquals(30, testPoolable.bar); - - TestPoolable.recycleInstance(testPoolable); - - poolCapacity = TestPoolable.getPool().getPoolCapacity(); - poolCount = TestPoolable.getPool().getPoolCount(); - Assert.assertEquals(4, poolCapacity); - Assert.assertEquals(4, poolCount); - - testPoolables.add(TestPoolable.getInstance(12, 24)); - testPoolables.add(TestPoolable.getInstance(1, 2)); - testPoolables.add(TestPoolable.getInstance(3, 5)); - testPoolables.add(TestPoolable.getInstance(6, 8)); - - poolCapacity = TestPoolable.getPool().getPoolCapacity(); - poolCount = TestPoolable.getPool().getPoolCount(); - Assert.assertEquals(4, poolCapacity); - Assert.assertEquals(0, poolCount); - - - TestPoolable.recycleInstances(testPoolables); - poolCapacity = TestPoolable.getPool().getPoolCapacity(); - poolCount = TestPoolable.getPool().getPoolCount(); - Assert.assertEquals(4, poolCapacity); - Assert.assertEquals(4, poolCount); - - testPoolables.clear(); - - - testPoolables.add(TestPoolable.getInstance(12, 24)); - testPoolables.add(TestPoolable.getInstance(1, 2)); - testPoolables.add(TestPoolable.getInstance(3, 5)); - testPoolables.add(TestPoolable.getInstance(6, 8)); - testPoolables.add(TestPoolable.getInstance(8, 9)); - Assert.assertEquals(12, testPoolables.get(0).foo); - Assert.assertEquals(24, testPoolables.get(0).bar); - Assert.assertEquals(1, testPoolables.get(1).foo); - Assert.assertEquals(2, testPoolables.get(1).bar); - Assert.assertEquals(3, testPoolables.get(2).foo); - Assert.assertEquals(5, testPoolables.get(2).bar); - Assert.assertEquals(6, testPoolables.get(3).foo); - Assert.assertEquals(8, testPoolables.get(3).bar); - Assert.assertEquals(8, testPoolables.get(4).foo); - Assert.assertEquals(9, testPoolables.get(4).bar); - - - poolCapacity = TestPoolable.getPool().getPoolCapacity(); - poolCount = TestPoolable.getPool().getPoolCount(); - Assert.assertEquals(4, poolCapacity); - Assert.assertEquals(3, poolCount); - - TestPoolable.recycleInstances(testPoolables); - poolCapacity = TestPoolable.getPool().getPoolCapacity(); - poolCount = TestPoolable.getPool().getPoolCount(); - Assert.assertEquals(8, poolCapacity); - Assert.assertEquals(8, poolCount); - - testPoolables.clear(); - - - testPoolables.add(TestPoolable.getInstance(0, 0)); - testPoolables.add(TestPoolable.getInstance(6, 8)); - testPoolables.add(TestPoolable.getInstance(1, 2)); - testPoolables.add(TestPoolable.getInstance(3, 5)); - testPoolables.add(TestPoolable.getInstance(8, 9)); - testPoolables.add(TestPoolable.getInstance(12, 24)); - testPoolables.add(TestPoolable.getInstance(12, 24)); - testPoolables.add(TestPoolable.getInstance(12, 24)); - testPoolables.add(TestPoolable.getInstance(6, 8)); - testPoolables.add(TestPoolable.getInstance(6, 8)); - Assert.assertEquals(0, testPoolables.get(0).foo); - Assert.assertEquals(0, testPoolables.get(0).bar); - Assert.assertEquals(6, testPoolables.get(1).foo); - Assert.assertEquals(8, testPoolables.get(1).bar); - Assert.assertEquals(1, testPoolables.get(2).foo); - Assert.assertEquals(2, testPoolables.get(2).bar); - Assert.assertEquals(3, testPoolables.get(3).foo); - Assert.assertEquals(5, testPoolables.get(3).bar); - Assert.assertEquals(8, testPoolables.get(4).foo); - Assert.assertEquals(9, testPoolables.get(4).bar); - Assert.assertEquals(12, testPoolables.get(5).foo); - Assert.assertEquals(24, testPoolables.get(5).bar); - Assert.assertEquals(12, testPoolables.get(6).foo); - Assert.assertEquals(24, testPoolables.get(6).bar); - Assert.assertEquals(12, testPoolables.get(7).foo); - Assert.assertEquals(24, testPoolables.get(7).bar); - Assert.assertEquals(6, testPoolables.get(8).foo); - Assert.assertEquals(8, testPoolables.get(8).bar); - Assert.assertEquals(6, testPoolables.get(9).foo); - Assert.assertEquals(8, testPoolables.get(9).bar); - - for (TestPoolable p : testPoolables) { - TestPoolable.recycleInstance(p); - } - - poolCapacity = TestPoolable.getPool().getPoolCapacity(); - poolCount = TestPoolable.getPool().getPoolCount(); - Assert.assertEquals(16, poolCapacity); - Assert.assertEquals(16, poolCount); - - testPoolable = TestPoolable.getInstance(9001, 9001); - Assert.assertEquals(9001, testPoolable.foo); - Assert.assertEquals(9001, testPoolable.bar); - - poolCapacity = TestPoolable.getPool().getPoolCapacity(); - poolCount = TestPoolable.getPool().getPoolCount(); - Assert.assertEquals(16, poolCapacity); - Assert.assertEquals(15, poolCount); - - - TestPoolable.recycleInstance(testPoolable); - - poolCapacity = TestPoolable.getPool().getPoolCapacity(); - poolCount = TestPoolable.getPool().getPoolCount(); - Assert.assertEquals(16, poolCapacity); - Assert.assertEquals(16, poolCount); - - Exception e = null; - try { - // expect an exception. - TestPoolable.recycleInstance(testPoolable); - } catch (Exception ex) { - e = ex; - } finally { - Assert.assertEquals(e.getMessage(), true, e != null); - } - - testPoolables.clear(); - - TestPoolable.getPool().setReplenishPercentage(0.5f); - int i = 16; - while (i > 0) { - testPoolables.add(TestPoolable.getInstance(0, 0)); - i--; - } - - poolCapacity = TestPoolable.getPool().getPoolCapacity(); - poolCount = TestPoolable.getPool().getPoolCount(); - Assert.assertEquals(16, poolCapacity); - Assert.assertEquals(0, poolCount); - - testPoolables.add(TestPoolable.getInstance(0, 0)); - - poolCapacity = TestPoolable.getPool().getPoolCapacity(); - poolCount = TestPoolable.getPool().getPoolCount(); - Assert.assertEquals(16, poolCapacity); - Assert.assertEquals(7, poolCount); - - - } - -} diff --git a/MPChartLib/src/test/java/com/github/mikephil/charting/test/ObjectPoolTest.kt b/MPChartLib/src/test/java/com/github/mikephil/charting/test/ObjectPoolTest.kt new file mode 100644 index 0000000000..bb390d30ef --- /dev/null +++ b/MPChartLib/src/test/java/com/github/mikephil/charting/test/ObjectPoolTest.kt @@ -0,0 +1,215 @@ +package com.github.mikephil.charting.test + +import com.github.mikephil.charting.utils.ObjectPool +import com.github.mikephil.charting.utils.ObjectPool.Poolable +import org.junit.Assert +import org.junit.Test + +class ObjectPoolTest { + internal class TestPoolable private constructor(var foo: Int, var bar: Int) : Poolable() { + override fun instantiate(): Poolable { + return TestPoolable(0, 0) + } + + companion object { + private val pool: ObjectPool = ObjectPool.create(4, TestPoolable(0, 0)) as ObjectPool + + fun getInstance(foo: Int, bar: Int): TestPoolable { + val result = pool.get() + result.foo = foo + result.bar = bar + return result + } + + fun recycleInstance(instance: TestPoolable) { + pool.recycle(instance) + } + + fun recycleInstances(instances: List?) { + pool.recycle(instances) + } + + fun getPool(): ObjectPool<*> { + return pool + } + } + } + + @Test + fun testObjectPool() { + var poolCapacity = TestPoolable.getPool().poolCapacity + var poolCount = TestPoolable.getPool().poolCount + val testPoolables = ArrayList() + + Assert.assertEquals(4, poolCapacity) + Assert.assertEquals(4, poolCount) + + var testPoolable = TestPoolable.getInstance(6, 7) + Assert.assertEquals(6, testPoolable.foo) + Assert.assertEquals(7, testPoolable.bar) + + poolCapacity = TestPoolable.getPool().poolCapacity + poolCount = TestPoolable.getPool().poolCount + + Assert.assertEquals(4, poolCapacity) + Assert.assertEquals(3, poolCount) + + TestPoolable.recycleInstance(testPoolable) + + poolCapacity = TestPoolable.getPool().poolCapacity + poolCount = TestPoolable.getPool().poolCount + Assert.assertEquals(4, poolCapacity) + Assert.assertEquals(4, poolCount) + + + testPoolable = TestPoolable.getInstance(20, 30) + Assert.assertEquals(20, testPoolable.foo) + Assert.assertEquals(30, testPoolable.bar) + + TestPoolable.recycleInstance(testPoolable) + + poolCapacity = TestPoolable.getPool().poolCapacity + poolCount = TestPoolable.getPool().poolCount + Assert.assertEquals(4, poolCapacity) + Assert.assertEquals(4, poolCount) + + testPoolables.add(TestPoolable.getInstance(12, 24)) + testPoolables.add(TestPoolable.getInstance(1, 2)) + testPoolables.add(TestPoolable.getInstance(3, 5)) + testPoolables.add(TestPoolable.getInstance(6, 8)) + + poolCapacity = TestPoolable.getPool().poolCapacity + poolCount = TestPoolable.getPool().poolCount + Assert.assertEquals(4, poolCapacity) + Assert.assertEquals(0, poolCount) + + + TestPoolable.recycleInstances(testPoolables) + poolCapacity = TestPoolable.getPool().poolCapacity + poolCount = TestPoolable.getPool().poolCount + Assert.assertEquals(4, poolCapacity) + Assert.assertEquals(4, poolCount) + + testPoolables.clear() + + + testPoolables.add(TestPoolable.getInstance(12, 24)) + testPoolables.add(TestPoolable.getInstance(1, 2)) + testPoolables.add(TestPoolable.getInstance(3, 5)) + testPoolables.add(TestPoolable.getInstance(6, 8)) + testPoolables.add(TestPoolable.getInstance(8, 9)) + Assert.assertEquals(12, testPoolables[0].foo) + Assert.assertEquals(24, testPoolables[0].bar) + Assert.assertEquals(1, testPoolables[1].foo) + Assert.assertEquals(2, testPoolables[1].bar) + Assert.assertEquals(3, testPoolables[2].foo) + Assert.assertEquals(5, testPoolables[2].bar) + Assert.assertEquals(6, testPoolables[3].foo) + Assert.assertEquals(8, testPoolables[3].bar) + Assert.assertEquals(8, testPoolables[4].foo) + Assert.assertEquals(9, testPoolables[4].bar) + + + poolCapacity = TestPoolable.getPool().poolCapacity + poolCount = TestPoolable.getPool().poolCount + Assert.assertEquals(4, poolCapacity) + Assert.assertEquals(3, poolCount) + + TestPoolable.recycleInstances(testPoolables) + poolCapacity = TestPoolable.getPool().poolCapacity + poolCount = TestPoolable.getPool().poolCount + Assert.assertEquals(8, poolCapacity) + Assert.assertEquals(8, poolCount) + + testPoolables.clear() + + + testPoolables.add(TestPoolable.getInstance(0, 0)) + testPoolables.add(TestPoolable.getInstance(6, 8)) + testPoolables.add(TestPoolable.getInstance(1, 2)) + testPoolables.add(TestPoolable.getInstance(3, 5)) + testPoolables.add(TestPoolable.getInstance(8, 9)) + testPoolables.add(TestPoolable.getInstance(12, 24)) + testPoolables.add(TestPoolable.getInstance(12, 24)) + testPoolables.add(TestPoolable.getInstance(12, 24)) + testPoolables.add(TestPoolable.getInstance(6, 8)) + testPoolables.add(TestPoolable.getInstance(6, 8)) + Assert.assertEquals(0, testPoolables[0].foo) + Assert.assertEquals(0, testPoolables[0].bar) + Assert.assertEquals(6, testPoolables[1].foo) + Assert.assertEquals(8, testPoolables[1].bar) + Assert.assertEquals(1, testPoolables[2].foo) + Assert.assertEquals(2, testPoolables[2].bar) + Assert.assertEquals(3, testPoolables[3].foo) + Assert.assertEquals(5, testPoolables[3].bar) + Assert.assertEquals(8, testPoolables[4].foo) + Assert.assertEquals(9, testPoolables[4].bar) + Assert.assertEquals(12, testPoolables[5].foo) + Assert.assertEquals(24, testPoolables[5].bar) + Assert.assertEquals(12, testPoolables[6].foo) + Assert.assertEquals(24, testPoolables[6].bar) + Assert.assertEquals(12, testPoolables[7].foo) + Assert.assertEquals(24, testPoolables[7].bar) + Assert.assertEquals(6, testPoolables[8].foo) + Assert.assertEquals(8, testPoolables[8].bar) + Assert.assertEquals(6, testPoolables[9].foo) + Assert.assertEquals(8, testPoolables[9].bar) + + for (p in testPoolables) { + TestPoolable.recycleInstance(p) + } + + poolCapacity = TestPoolable.getPool().poolCapacity + poolCount = TestPoolable.getPool().poolCount + Assert.assertEquals(16, poolCapacity) + Assert.assertEquals(16, poolCount) + + testPoolable = TestPoolable.getInstance(9001, 9001) + Assert.assertEquals(9001, testPoolable.foo) + Assert.assertEquals(9001, testPoolable.bar) + + poolCapacity = TestPoolable.getPool().poolCapacity + poolCount = TestPoolable.getPool().poolCount + Assert.assertEquals(16, poolCapacity) + Assert.assertEquals(15, poolCount) + + + TestPoolable.recycleInstance(testPoolable) + + poolCapacity = TestPoolable.getPool().poolCapacity + poolCount = TestPoolable.getPool().poolCount + Assert.assertEquals(16, poolCapacity) + Assert.assertEquals(16, poolCount) + + var e: Exception? = null + try { + // expect an exception. + TestPoolable.recycleInstance(testPoolable) + } catch (ex: Exception) { + e = ex + } finally { + Assert.assertEquals(e!!.message, true, true) + } + + testPoolables.clear() + + TestPoolable.getPool().replenishPercentage = 0.5f + var i = 16 + while (i > 0) { + testPoolables.add(TestPoolable.getInstance(0, 0)) + i-- + } + + poolCapacity = TestPoolable.getPool().poolCapacity + poolCount = TestPoolable.getPool().poolCount + Assert.assertEquals(16, poolCapacity) + Assert.assertEquals(0, poolCount) + + testPoolables.add(TestPoolable.getInstance(0, 0)) + + poolCapacity = TestPoolable.getPool().poolCapacity + poolCount = TestPoolable.getPool().poolCount + Assert.assertEquals(16, poolCapacity) + Assert.assertEquals(7, poolCount) + } +}