Merge branch 'feat/printable_data-8' into 'master'

Feat/printable data 8

See merge request !6

build.gradle

@@ -34,6 +34,10 @@ dependencies {
     // Logging
     compile group: 'org.slf4j', name: 'slf4j-api', version: '1.7.26'
     compile group: 'ch.qos.logback', name: 'logback-classic', version: '1.2.3'
+
+    // Units
+    compile group: 'javax.measure', name: 'unit-api', version: '2.0-PRD'
+    compile group: 'tec.units', name: 'unit-ri', version: '1.0.3'
 }
 
 test {

config/checkstyle/checkstyle.xml

@@ -79,6 +79,7 @@
     <!--   <property name="fileExtensions" value="java"/> -->
     <!-- </module> -->
 
+    <module name="SuppressWarningsFilter" />
     <module name="TreeWalker">
 
         <!-- Checks for Javadoc comments.                     -->
@@ -183,6 +184,8 @@
         <module name="TodoComment"/>
 -->
         <module name="UpperEll"/>
+        <!-- Add support for SuppressWarnings Annotations -->
+        <module name="SuppressWarningsHolder" />
 
     </module>
 

src/main/java/de/tudresden/inf/mci/brailleplot/printabledata/AbstractPrintableData.java

+package de.tudresden.inf.mci.brailleplot.printabledata;
+
+import de.tudresden.inf.mci.brailleplot.configparser.Printer;
+import de.tudresden.inf.mci.brailleplot.configparser.Format;
+
+/**
+ * Abstract parent class for all {@link PrintableData} implementations.
+ * @author Georg Graßnick
+ * @version 2019.06.26
+ */
+abstract class AbstractPrintableData implements PrintableData {
+
+    private final Printer mPrinter;
+    private final Format mFormat;
+
+    AbstractPrintableData(final Printer printer, final Format format) {
+        if (printer == null || format == null) {
+            throw new NullPointerException();
+        }
+        mPrinter = printer;
+        mFormat = format;
+    }
+
+    @Override
+    public Printer getPrinterConfig() {
+        return mPrinter;
+    }
+
+    @Override
+    public Format getFormatConfig() {
+        return mFormat;
+    }
+}

src/main/java/de/tudresden/inf/mci/brailleplot/printabledata/BrailleCell6.java

+package de.tudresden.inf.mci.brailleplot.printabledata;
+
+/**
+ * Simple container class encapsulating 6 dots to form a representation of a Braille cell.
+ * The ordering of the positions follows the following convention:
+ * Top to bottom, then left to right; indices start at 0:
+ *
+ * 0  3
+ * 1  4
+ * 2  5
+ *
+ * @param <T> The type used for representing the intensity. Could be set to {@link Boolean} for basic Braille support,
+ *           but could also by set to {@link Short} if different embossing strengths are required.
+ * @author Georg Graßnick
+ * @version 2019.06.28
+ */
+public final class BrailleCell6<T> {
+
+    static final int DOT_COUNT = 6;
+    static final int ROW_COUNT = 3;
+    static final int COLUMN_COUNT = 2;
+
+    private T[] mDots;
+
+    /**
+     * Constructor.
+     * The values are not checked for null!
+     * @param first Value of the first dot.
+     * @param second Value of the second dot.
+     * @param third Value of the third dot.
+     * @param fourth Value of the fourth dot.
+     * @param fifth Value of the fifth dot.
+     * @param sixth  Value of the sixth dot.
+     */
+    @SuppressWarnings({"unchecked", "checkstyle:MagicNumber"})
+    public BrailleCell6(final T first, final T second, final T third, final T fourth, final T fifth, final T sixth) {
+        mDots = (T[]) new Object[DOT_COUNT];
+        mDots[0] = first;
+        mDots[1] = second;
+        mDots[2] = third;
+        mDots[3] = fourth;
+        mDots[4] = fifth;
+        mDots[5] = sixth;
+    }
+
+    /**
+     * Constructor.
+     * The values are not checked for null!
+     * @param vals An array of values to obtain the values from.
+     * @throws IllegalArgumentException If the length is not equal to 6.
+     */
+    BrailleCell6(final T[] vals) {
+        if (vals.length != DOT_COUNT) {
+            throw new IllegalArgumentException("Input Array must be of length " + DOT_COUNT);
+        }
+        mDots = vals.clone();
+    }
+
+    /**
+     * Get the value at the specified position.
+     * @param index The index of the position,
+     * @return The according value.
+     * @throws ArrayIndexOutOfBoundsException If the index is out of bounds (not in 0-5).
+     */
+    public T get(final int index) {
+        if (index < 0 || index >= DOT_COUNT) {
+            throw new ArrayIndexOutOfBoundsException("Index not valid");
+        }
+        return mDots[index];
+    }
+
+    /**
+     * Set the value at the specified position.
+     * @param index The index of the position.
+     * @param value The value to set.
+     * @throws ArrayIndexOutOfBoundsException If the index is out of bounds (not in 0-5).
+     */
+    public void set(final int index, final T value) {
+        if (index < 0 || index >= DOT_COUNT) {
+            throw new ArrayIndexOutOfBoundsException("Index not valid");
+        }
+        mDots[index] = value;
+    }
+
+    /**
+     * Get the internal data array.
+     * @return The internal data array of length 6.
+     */
+    public T[] data() {
+        return mDots;
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < ROW_COUNT; i++) {
+            for (int j = 0; j < COLUMN_COUNT; j++) {
+                sb.append(mDots[i * COLUMN_COUNT + j]);
+                sb.append(" ");
+            }
+            sb.append("\n");
+        }
+        return sb.toString();
+    }
+}

src/main/java/de/tudresden/inf/mci/brailleplot/printabledata/FloatingPointData.java

+package de.tudresden.inf.mci.brailleplot.printabledata;
+
+import java.util.Iterator;
+
+/**
+ * This data is used to describe the data for the "Floating Dot Area" print mode.
+ * For each dot to emboss, there is one {@link Point2D} object which encapsulates both the position in width and height,
+ * as well as the intensity of the point.
+ * @param <T> The type used for representing the intensity. Could be set to {@link Boolean} for basic Braille support,
+ *           but could also by set to {@link Short} if different embossing strengths are required.
+ * @author Georg Graßnick
+ * @version 2019.06.26
+ */
+public interface FloatingPointData<T> extends PrintableData {
+
+    /**
+     * Returns an iterator over all {@link Point2DValued}.
+     * @return An iterator over all points.
+     */
+    Iterator<Point2DValued<T>> getIterator();
+
+    /**
+     * Add a point to the data structure.
+     * @param point The point to be inserted.
+     */
+    void addPoint(Point2DValued<T> point);
+}

src/main/java/de/tudresden/inf/mci/brailleplot/printabledata/MatrixData.java

+package de.tudresden.inf.mci.brailleplot.printabledata;
+
+import java.util.Iterator;
+
+/**
+ * This data is used to describe the data for the "Braille" and "Graphics" print modes.
+ * The data is organized in a matrix structure, which can be queried for its values on integer x (row) and y (column) indices.
+ * @param <T> The type used for representing the intensity. Could be set to {@link Boolean} for basic Braille support,
+ *           but could also by set to {@link Short} if different embossing strengths are required.
+ * @author Georg Graßnick
+ * @version 2019.06.26
+ */
+public interface MatrixData<T> extends PrintableData {
+
+    /**
+     * Get the value for a specific position in the matrix.
+     * Indices start at 0.
+     * @param row The row index of the position.
+     * @param column The column index of the position.
+     * @return The value at the requested position.
+     */
+    T getValue(int row, int column);
+
+    /**
+     * Get an iterator which iterates all dots of the matrix.
+     * Depending on the width and height parameters, the iterator will iterate the dots of Braille cells of the
+     * specified size from top to bottom and then from left to right
+     * Example: width = 2, height = 3; matrix size is 4x6:
+     *
+     * 01  04  07  10
+     * 02  05  08  11
+     * 03  06  09  12
+     * 13  16  19  22
+     * 14  17  20  23
+     * 15  18  21  24
+     *
+     * @param width The width of a Braille cell
+     * @param height The height of a Braille cell
+     * @return The according iterator.
+     */
+    Iterator<T> getDotIterator(int width, int height);
+
+
+    /**
+     * Get an iterator which iterates over Braille cells of the matrix.
+     * The cells have a width of 2 columns and a height of 3 rows to mach a standard 6 dot Braille cell.
+     * The matrix is traversed from left to right and then top to bottom.
+     * Example: matrix size is 4x6 - The ids specify the associated Braille cell.
+     *
+     * 01  01  02  02
+     * 01  01  02  02
+     * 01  01  02  02
+     * 03  03  04  04
+     * 03  03  04  04
+     * 03  03  04  04
+     *
+     * @return The according iterator.
+     */
+    Iterator<BrailleCell6<T>> getBrailleCell6Iterator();
+
+    /**
+     * Set the value at a specific position.
+     * Indices start at 0.
+     * @param row The row index of the position.
+     * @param column The column index of the position.
+     * @param value The value to set.
+     */
+    void setValue(int row, int column, T value);
+
+    /**
+     * Getter.
+     * @return The number of rows.
+     */
+    int getRowCount();
+
+    /**
+     * Getter.
+     * @return The number of columns.
+     */
+    int getColumnCount();
+}

src/main/java/de/tudresden/inf/mci/brailleplot/printabledata/Point2D.java

+package de.tudresden.inf.mci.brailleplot.printabledata;
+
+import javax.measure.Quantity;
+import javax.measure.quantity.Length;
+import java.util.Objects;
+
+/**
+ * Representation of a 2 dimensional point.
+ * Encapsulates a position on x and y axis.
+ * @author Georg Graßnick
+ * @version 2019.06.26
+ */
+public class Point2D {
+
+    private final Quantity<Length> mX;
+    private final Quantity<Length> mY;
+
+    /**
+     * Constructor.
+     * @param x Position on the x axis.
+     * @param y Position on the y axis.
+     */
+    public Point2D(final Quantity<Length> x, final Quantity<Length> y) {
+        if (x == null || y == null) {
+            throw new NullPointerException();
+        }
+        mX = x;
+        mY = y;
+    }
+
+    /**
+     * Getter.
+     * @return The position on the x axis.
+     */
+    public final Quantity<Length> getX() {
+        return mX;
+    }
+
+    /**
+     * Getter.
+     * @return The position on the y axis.
+     */
+    public final Quantity<Length> getY() {
+        return mY;
+    }
+
+    /**
+     * Check for Object equality.
+     * @param other The other to compare to.
+     * @return true, if X and Y positions of both points are equal; else false
+     */
+    @Override
+    public boolean equals(final Object other) {
+        if (this == other) {
+            return true;
+        }
+        if (!(other instanceof Point2D)) {
+            return false;
+        }
+        Point2D point = (Point2D) other;
+        return mX.equals(point.mX) && mY.equals(point.mY);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(mX, mY);
+    }
+
+    /**
+     * Create a human readable String to represent the point.
+     * @return A human readable String.
+     */
+    @Override
+    public String toString() {
+        return "(" + mX + ", " + mY + ")";
+    }
+}

src/main/java/de/tudresden/inf/mci/brailleplot/printabledata/Point2DValued.java

+package de.tudresden.inf.mci.brailleplot.printabledata;
+
+import javax.measure.Quantity;
+import javax.measure.quantity.Length;
+import java.util.Objects;
+
+/**
+ * Representation of a 2 dimensional point with an associated value.
+ * Encapsulates both the position on x and y axis, as well as a value (think of embossing intensity).
+ * @param <T> The type used for representing the intensity. Could be set to {@link Boolean} for basic Braille support,
+ *           but could also by set to {@link Short} if different embossing strengths are required.
+ * @author Georg Graßnick
+ * @version 2019.06.26
+ */
+public class Point2DValued<T> extends Point2D {
+
+    private final T mVal;
+
+    /**
+     * Constructor.
+     * @param x Position on the x axis.
+     * @param y Position on the y axis.
+     * @param val The value of the dot
+     */
+    public Point2DValued(final Quantity<Length> x, final Quantity<Length> y, final T val) {
+        super(x, y);
+        if (val == null) {
+            throw new NullPointerException();
+        }
+        mVal = val;
+    }
+
+    /**
+     * Getter.
+     * @return The value that is associated with this point.
+     */
+    public final T getVal() {
+        return mVal;
+    }
+
+    /**
+     * Check for Object equality.
+     * @param other The other to compare to.
+     * @return true, if X and Y positions and the values of both points are equal; else false
+     */
+    @Override
+    public boolean equals(final Object other) {
+        if (this == other) {
+            return true;
+        }
+        if (!(other instanceof Point2DValued)) {
+            return false;
+        }
+        Point2D point = (Point2DValued) other;
+        return super.equals(other) && mVal.equals(((Point2DValued) other).mVal);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(mVal, super.hashCode());
+    }
+
+    /**
+     * Create a human readable String to represent the point.
+     * @return A human readable String.
+     */
+    @Override
+    public String toString() {
+        return "(" + super.getX() + ", " + super.getY() + ": " + mVal + ")";
+    }
+}

src/main/java/de/tudresden/inf/mci/brailleplot/printabledata/PrintableData.java

+package de.tudresden.inf.mci.brailleplot.printabledata;
+
+import de.tudresden.inf.mci.brailleplot.configparser.Printer;
+import de.tudresden.inf.mci.brailleplot.configparser.Format;
+
+/**
+ * Top interface for all data types that describe data ready for printing.
+ * These data containers are generated by the rasterizer and later on processed by the printer backend.
+ * @author Georg Graßnick
+ * @version 2019.06.26
+ */
+public interface PrintableData {
+
+   /**
+    * Getter for the Printer Configuration, that was used to generate this data representation in the rasterizer.
+    * @return The associated Printer Configuration
+    */
+   Printer getPrinterConfig();
+
+   /**
+    * Getter for the Format Configuration, that was used to generate this data representation in the rasterizer.
+    * @return The associated Format Configuration
+    */
+   Format getFormatConfig();
+
+}

src/main/java/de/tudresden/inf/mci/brailleplot/printabledata/SimpleFloatingPointDataImpl.java

+package de.tudresden.inf.mci.brailleplot.printabledata;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+
+import de.tudresden.inf.mci.brailleplot.configparser.Printer;
+import de.tudresden.inf.mci.brailleplot.configparser.Format;
+
+/**
+ * A low effort implementation of the {@link FloatingPointData} interface.
+ * The underlying data is organized in a {@link LinkedList}, which makes insertions fast, but slows down random access.
+ * @param <T> The type used for representing the intensity. Could be set to {@link Boolean} for basic Braille support,
+ *           but could also by set to {@link Short} if different embossing strengths are required.
+ * @author Georg Graßnick
+ * @version 2019.06.26
+ */
+public class SimpleFloatingPointDataImpl<T> extends AbstractPrintableData implements FloatingPointData<T> {
+
+    private LinkedList<Point2DValued<T>> mPoints;
+
+    public SimpleFloatingPointDataImpl(final Printer printer, final Format format) {
+        super(printer, format);
+        mPoints = new LinkedList<>();
+    }
+
+    @Override
+    public Iterator<Point2DValued<T>> getIterator() {
+        return mPoints.iterator();
+    }
+
+    @Override
+    public void addPoint(final Point2DValued<T> point) {
+        if (point == null) {
+            throw new NullPointerException();
+        }
+        mPoints.addLast(point);
+    }
+}

src/main/java/de/tudresden/inf/mci/brailleplot/printabledata/SimpleMatrixDataImpl.java

+package de.tudresden.inf.mci.brailleplot.printabledata;
+
+import java.util.Iterator;
+import java.util.Vector;
+
+import de.tudresden.inf.mci.brailleplot.configparser.Printer;
+import de.tudresden.inf.mci.brailleplot.configparser.Format;
+
+/**
+ * A low effort implementation of the {@link MatrixData} interface.
+ * The underlying data is represented by a {@link Vector} which makes the lookup and insertion fast, but uses lots of memory.
+ * @param <T> The type used for representing the intensity. Could be set to {@link Boolean} for basic Braille support,
+ *  *           but could also by set to {@link Short} if different embossing strengths are required.
+ * @author Georg Graßnick
+ * @version 2019.06.26
+ */
+public class SimpleMatrixDataImpl<T> extends AbstractPrintableData implements MatrixData<T> {
+
+    private final int mRows;
+    private final int mColumns;
+    private final Vector<T> mData;
+
+    /**
+     * Constructor.
+     * @param printer The according {@link Printer} object.
+     * @param format The according {@link Format} object.
+     * @param rowCount The height of the matrix.
+     * @param columnCount The width of the matrix.
+     * @param defaultValue The default value each element will be assigned.
+     * @throws IllegalArgumentException if rowCount {@literal <} 0 or columnCount {@literal <} 0
+     */
+    public SimpleMatrixDataImpl(final Printer printer, final Format format, final int rowCount, final int columnCount, final T defaultValue) {
+        super(printer, format);
+        if (rowCount <= 0 || columnCount <= 0) {
+            throw new IllegalArgumentException("rowCount and columnCount must be a non zero positive integer");
+        }
+        mRows = rowCount;
+        mColumns = columnCount;
+        mData = new Vector<>(rowCount * columnCount);
+        mData.setSize(rowCount * columnCount);
+        for (int i = 0; i < mData.size(); i++) {
+            mData.setElementAt(defaultValue, i);
+        }
+    }
+
+    /**
+     * Calculate the index for the underlying {@link java.util.ArrayList}.
+     * @param row The row index of the requested index.
+     * @param column The column index of the requested index.
+     * @return The according index in the underlying {@link java.util.ArrayList}
+     * @throws IndexOutOfBoundsException If row or column are negative or larger than the size of the matrix.
+     */
+    private int calcIndex(final int row, final int column) {
+        if (row >= mRows || column > mColumns ||  row < 0 || column < 0) {
+            throw new IndexOutOfBoundsException("Index (" + row + "," + column + ") out of bounds");
+        }
+        return row * mColumns + column;
+    }
+
+    @Override
+    public T getValue(final int row, final int column) {
+        return mData.get(calcIndex(row, column));
+    }
+
+    @Override
+    public void setValue(final int row, final int column, final T value) {
+        if (value == null) {
+            throw new NullPointerException();
+        }
+        mData.set(calcIndex(row, column), value);
+    }
+
+    @Override
+    public Iterator<T> getDotIterator(final int width, final int height) {
+        return new ElementIter(width, height, this);
+    }
+
+    @Override
+    public Iterator<BrailleCell6<T>> getBrailleCell6Iterator() {
+        return new BrailleCell6Iterator(this);
+    }
+
+    @Override
+    public int getColumnCount() {
+        return mColumns;
+    }
+
+    @Override
+    public int getRowCount() {
+        return mRows;
+    }
+
+    public final String toString() {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < getRowCount(); i++) {
+            for (int j = 0; j < getColumnCount(); j++) {
+                sb.append(getValue(i, j));
+                sb.append(" ");
+            }
+            sb.append("\n");
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Iterator that iterates all elements of the matrix in a pattern that iterates Braille cells of specified height
+     * and width from left to right and top to bottom.
+     * See {@link MatrixData#getDotIterator(int, int)} for details.
+     */
+    class ElementIter implements Iterator<T> {
+
+        private final SimpleMatrixDataImpl<T> mMatrix;
+
+        private final int mCellWidth;
+        private final int mCellHeight;
+
+        // We use indices starting at 1, so that we do not have to check for the x-index to be 0 in the next() method call
+        private int mCurrentX = 1;
+        private int mCurrentY = 1;
+
+        private boolean mIsFirstElem = true;
+
+        ElementIter(final int cellWidth, final int cellHeight, final SimpleMatrixDataImpl<T> matrix) {
+            if (matrix.getColumnCount() % cellWidth != 0) {
+                throw new IllegalArgumentException("Cannot create requested iterator: matrix column count (" + matrix.getColumnCount() + ") is not a multiple of cell height (" + cellHeight + ")");
+            }
+            if (matrix.getRowCount() % cellHeight != 0) {
+                throw new IllegalArgumentException("Cannot create requested iterator: matrix row count (" + matrix.getRowCount() + ") is not a multiple of cell width (" + cellWidth + ")");
+            }
+            mMatrix = matrix;
+            mCellWidth = cellWidth;
+            mCellHeight = cellHeight;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return !(mCurrentY == mMatrix.getRowCount() && mCurrentX == mMatrix.getColumnCount());
+        }
+
+        @Override
+        public T next() {
+            if (mIsFirstElem) {
+                mIsFirstElem = false;
+            } else if (mCurrentY % mCellHeight != 0) {
+                // Staying in the current cell, move down
+                mCurrentY++;
+            } else if (mCurrentX % mCellWidth != 0) {
+                // Staying in current cell, move right, set y to the top most index of the current cell
+                mCurrentX++;
+                mCurrentY = (((mCurrentY / mCellHeight) - 1) * mCellHeight) + 1;
+            } else if (mCurrentX < mMatrix.getColumnCount()) { // Moving on to the next cell
+                // Right is possible
+                mCurrentX += 1;
+                mCurrentY = (((mCurrentY / mCellHeight) - 1) * mCellHeight) + 1;
+            } else {
+                // We need to go downwards
+                mCurrentY += 1;
+                mCurrentX = 1;
+            }
+            // Correct index to match the specifications of the MatrixData interface
+            return mMatrix.getValue(mCurrentY - 1, mCurrentX - 1);
+        }
+    }
+
+    /**
+     * Iterator that returns {@link BrailleCell6} objects rather than the dots themselves.
+     * See {@link MatrixData#getBrailleCell6Iterator()} for details.
+     */
+    class BrailleCell6Iterator implements Iterator<BrailleCell6<T>> {
+
+        private final Iterator<T> mElemIter;
+
+        BrailleCell6Iterator(final SimpleMatrixDataImpl<T> matrix) {
+            mElemIter = matrix.getDotIterator(BrailleCell6.COLUMN_COUNT, BrailleCell6.ROW_COUNT);
+        }
+
+        @Override
+        public boolean hasNext() {
+            return mElemIter.hasNext();
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public BrailleCell6<T> next() {
+            T[] vals = (T[]) new Object[BrailleCell6.DOT_COUNT];
+            for (int i = 0; i < BrailleCell6.DOT_COUNT; i++) {
+                vals[i] = mElemIter.next();
+            }
+            return new BrailleCell6<>(vals);
+        }
+    }
+}

src/main/java/de/tudresden/inf/mci/brailleplot/printabledata/package-info.java

+/**
+ * This package contains all the requiered classes and interfaces for data exchange between the rasterizer and
+ * the printer backend.
+ * @author Georg Graßnick
+ * @version 2019.06.26
+ */
+package de.tudresden.inf.mci.brailleplot.printabledata;

src/test/java/de/tudresden/inf/mci/brailleplot/printabledata/Point2DValuedTest.java

+package de.tudresden.inf.mci.brailleplot.printabledata;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import tec.units.ri.quantity.Quantities;
+import tec.units.ri.unit.MetricPrefix;
+
+import javax.measure.Quantity;
+import javax.measure.quantity.Length;
+
+import static tec.units.ri.unit.Units.METRE;
+
+class Point2DValuedTest {
+
+    private Quantity<Length> length() {
+        return Quantities.getQuantity(5, MetricPrefix.CENTI(METRE));
+    }
+
+    private Integer integer() {
+        return 42;
+    }
+
+    @Test
+    void testConstructorNull() {
+        Assertions.assertThrows(NullPointerException.class, () -> {
+            new Point2DValued<>(null, length(), 3);
+            new Point2DValued<>( length(), null, 3);
+            new Point2DValued<>( length(), length(), null);
+        });
+    }
+
+    @Test
+    void testSetGet() {
+        Point2DValued<Integer> point = new Point2DValued<>(length(), length(), integer());
+        Assertions.assertEquals(point.getVal(), integer());
+        Assertions.assertEquals(point.getX(), length());
+        Assertions.assertEquals(point.getY(), length());
+    }
+}
\ No newline at end of file

src/test/java/de/tudresden/inf/mci/brailleplot/printabledata/SimpleFloatingPointDataImplTest.java

+package de.tudresden.inf.mci.brailleplot.printabledata;
+
+import de.tudresden.inf.mci.brailleplot.configparser.Format;
+import de.tudresden.inf.mci.brailleplot.configparser.Printer;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import tec.units.ri.quantity.Quantities;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+
+import static tec.units.ri.unit.Units.METRE;
+
+class SimpleFloatingPointDataImplTest {
+
+    FloatingPointData<Integer> emptyIntFloatingPointData() {
+        return new SimpleFloatingPointDataImpl<>(new Printer(new ArrayList<>()), new Format(new ArrayList<>()));
+    }
+
+    Point2DValued<Integer> point2dInt(Integer one, Integer two, Integer val) {
+        return new Point2DValued<>(Quantities.getQuantity(one, METRE), Quantities.getQuantity(two, METRE), val);
+    }
+
+    @Test
+    void testAddPointNull() {
+        FloatingPointData<Integer> data = emptyIntFloatingPointData();
+        Assertions.assertThrows(NullPointerException.class, () -> {
+            data.addPoint(null);
+        });
+    }
+
+    @Test
+    void testAddPointAndIterator() {
+        FloatingPointData<Integer> data = emptyIntFloatingPointData();
+        for (int i = 0; i < 5; i++) {
+            data.addPoint(point2dInt(i, i, i));
+        }
+        Iterator<Point2DValued<Integer>> it = data.getIterator();
+        int i = 0;
+        while (it.hasNext()) {
+            Point2DValued<Integer> point = it.next();
+            Assertions.assertEquals(point, point2dInt(i, i, i));
+            i++;
+        }
+    }
+}

src/test/java/de/tudresden/inf/mci/brailleplot/printabledata/SimpleMatrixDataImplTest.java

+package de.tudresden.inf.mci.brailleplot.printabledata;
+
+import de.tudresden.inf.mci.brailleplot.configparser.Format;
+import de.tudresden.inf.mci.brailleplot.configparser.Printer;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+
+class SimpleMatrixDataImplTest {
+
+
+    private final Integer mTestInt = 42;
+    private final Integer mDefaultTestInt = 0;
+
+    private MatrixData<Integer> simpleIntMat() {
+        return new SimpleMatrixDataImpl<>(new Printer(new LinkedList<>()), new Format(new LinkedList<>()),3, 3, mDefaultTestInt);
+    }
+
+    private MatrixData<Integer> iteratorIntMat() {
+        SimpleMatrixDataImpl<Integer> matrix = new SimpleMatrixDataImpl<>(new Printer(new LinkedList<>()), new Format(new LinkedList<>()), 6, 4, 0);
+        matrix.setValue(0, 0, 1);
+        matrix.setValue(1, 0, 2);
+        matrix.setValue(2, 0, 3);
+        matrix.setValue(0, 1, 4);
+        matrix.setValue(1, 1, 5);
+        matrix.setValue(2, 1, 6);
+        matrix.setValue(0, 2, 7);
+        matrix.setValue(1, 2, 8);
+        matrix.setValue(2, 2, 9);
+        matrix.setValue(0, 3, 10);
+        matrix.setValue(1, 3, 11);
+        matrix.setValue(2, 3, 12);
+        matrix.setValue(3, 0, 13);
+        matrix.setValue(4, 0, 14);
+        matrix.setValue(5, 0, 15);
+        matrix.setValue(3, 1, 16);
+        matrix.setValue(4, 1, 17);
+        matrix.setValue(5, 1, 18);
+        matrix.setValue(3, 2, 19);
+        matrix.setValue(4, 2, 20);
+        matrix.setValue(5, 2, 21);
+        matrix.setValue(3, 3, 22);
+        matrix.setValue(4, 3, 23);
+        matrix.setValue(5, 3, 24);
+
+        return matrix;
+    }
+
+    @Test
+    void getSetValueTestPosZero() {
+        MatrixData<Integer> matrixData = simpleIntMat();
+        matrixData.setValue(0, 0, mTestInt);
+        Assertions.assertEquals(matrixData.getValue(0,0), mTestInt);
+    }
+
+    @Test
+    void getSetValueTestInner() {
+        MatrixData<Integer> matrixData = simpleIntMat();
+        matrixData.setValue(matrixData.getRowCount() - 1, matrixData.getColumnCount() - 1, mTestInt);
+        Assertions.assertEquals(matrixData.getValue(matrixData.getRowCount() - 1,matrixData.getColumnCount() - 1), mTestInt);
+    }
+
+    @Test
+    void getSetValueTestInvalidPos() {
+        MatrixData<Integer> matrixData = simpleIntMat();
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> {
+            matrixData.setValue(matrixData.getRowCount(), matrixData.getColumnCount(), mTestInt);
+        });
+    }
+
+    @Test
+    void defaultValueTest() {
+        MatrixData<Integer> matrixData = simpleIntMat();
+        Assertions.assertEquals(matrixData.getValue(0,0), mDefaultTestInt);
+    }
+
+    @Test
+    void getDotIteratorTest() {
+        MatrixData<Integer> matrixData = iteratorIntMat();
+        int referenceValue = 0;
+        Iterator<Integer> it = matrixData.getDotIterator(2, 3);
+
+        while (it.hasNext()) {
+            Integer current = it.next();
+            Assertions.assertEquals(current, ++referenceValue);
+        }
+    }
+
+    @Test
+    void getBrailleCelll6IteratorTest() {
+        MatrixData<Integer> matrixData = iteratorIntMat();
+        int referenceValue = 0;
+        Iterator<BrailleCell6<Integer>> cellIt = matrixData.getBrailleCell6Iterator();
+        while (cellIt.hasNext()) {
+            BrailleCell6<Integer> cell = cellIt.next();
+            for (int i = 0; i < BrailleCell6.DOT_COUNT; i++) {
+                Assertions.assertEquals(cell.get(i), ++referenceValue);
+            }
+        }
+
+    }
+
+    @Test
+    void getColumnCount() {
+        Assertions.assertEquals(simpleIntMat().getColumnCount(), 3);
+    }
+
+    @Test
+    void getRowCount() {
+        Assertions.assertEquals(simpleIntMat().getRowCount(), 3);
+    }
+}
\ No newline at end of file