StateAccelerationZ() {
        final AbsoluteOrientationSlamEstimator estimator =
                new AbsoluteOrientationSlamEstimator();

        final UniformRandomizer randomizer = new UniformRandomizer(new Random());

        // check initial values
        assertEquals(estimator.getStateAccelerationZ(), 0.0, 0.0);

        final double value = randomizer.nextDouble();
        estimator.mStateAccelerationZ = value;

        // check correctness
        assertEquals(estimator.getStateAccelerationZ(), value, 0.0);
    }

    @Test
    public void testGetStateAcceleration() {
        final AbsoluteOrientationSlamEstimator estimator =
                new AbsoluteOrientationSlamEstimator();

        final UniformRandomizer randomizer = new UniformRandomizer(new Random());

        final double valueX = randomizer.nextDouble();
        final double valueY = randomizer.nextDouble();
        final double valueZ = randomizer.nextDouble();
        estimator.mStateAccelerationX = valueX;
        estimator.mStateAccelerationY = valueY;
        estimator.mStateAccelerationZ = valueZ;

        // check correctness
        assertArrayEquals(estimator.getStateAcceleration(),
                new double[]{valueX, valueY, valueZ}, 0.0);

        final double[] acceleration = new double[3];
        estimator.getStateAcceleration(acceleration);

        // check correctness
        assertArrayEquals(acceleration, new double[]{valueX, valueY, valueZ},
                0.0);

        // Force IllegalArgumentException
        final double[] wrong = new double[4];
        try {
            estimator.getStateAcceleration(wrong);
            fail("IllegalArgumentException expected but not thrown");
        } catch (final IllegalArgumentException ignore) {
        }
    }

    @Test
    public void testGetStateQuaternionA() {
        final AbsoluteOrientationSlamEstimator estimator =
                new AbsoluteOrientationSlamEstimator();

        final UniformRandomizer randomizer = new UniformRandomizer(new Random());

        // check initial value
        assertEquals(estimator.getStateQuaternionA(), 1.0, 0.0);

        // set new value
        final double value = randomizer.nextDouble();
        estimator.mStateQuaternionA = value;

        // check correctness
        assertEquals(estimator.getStateQuaternionA(), value, 0.0);
    }

    @Test
    public void testGetStateQuaternionB() {
        final AbsoluteOrientationSlamEstimator estimator =
                new AbsoluteOrientationSlamEstimator();

        final UniformRandomizer randomizer = new UniformRandomizer(new Random());

        // check initial value
        assertEquals(estimator.getStateQuaternionB(), 0.0, 0.0);

        // set new value
        final double value = randomizer.nextDouble();
        estimator.mStateQuaternionB = value;

        // check correctness
        assertEquals(estimator.getStateQuaternionB(), value, 0.0);
    }

    @Test
    public void testGetStateQuaternionC() {
        final AbsoluteOrientationSlamEstimator estimator =
                new AbsoluteOrientationSlamEstimator();

        final UniformRandomizer randomizer = new UniformRandomizer(new Random());

        // check initial value
        assertEquals(estimator.getStateQuaternionC(), 0.0, 0.0);

        // set new value
        final double value = randomizer.nextDouble();
        estimator.mStateQuaternionC = value;

        // check correctness
        assertEquals(estimator.getStateQuaternionC(), value, 0.0);
    }

    @Test
    public void testGetStateQuaternionD() {
        final AbsoluteOrientationSlamEstimator estimator =
                new AbsoluteOrientationSlamEstimator();

        final UniformRandomizer randomizer = new UniformRandomizer(new Random());

        // check initial value
        assertEquals(estimator.getStateQuaternionD(), 0.0, 0.0);

        // set new value
        final double value = randomizer.nextDouble();
        estimator.mStateQuaternionD = value;

        // check correctness
        assertEquals(estimator.getStateQuaternionD(), value, 0.0);
    }

    @Test
    public void testGetStateQuaternionArray() {
        final AbsoluteOrientationSlamEstimator estimator =
                new AbsoluteOrientationSlamEstimator();

        final UniformRandomizer randomizer = new UniformRandomizer(new Random());

        // check initial value
        assertArrayEquals(estimator.getStateQuaternionArray(),
                new double[]{1.0, 0.0, 0.0, 0.0}, 0.0);

        // set new values
        final double valueA = randomizer.nextDouble();
        final double valueB = randomizer.nextDouble();
        final double valueC = randomizer.nextDouble();
        final double valueD = randomizer.nextDouble();
        estimator.mStateQuaternionA = valueA;
        estimator.mStateQuaternionB = valueB;
        estimator.mStateQuaternionC = valueC;
        estimator.mStateQuaternionD = valueD;

        // check correctness
        assertArrayEquals(estimator.getStateQuaternionArray(),
                new double[]{valueA, valueB, valueC, valueD}, 0.0);

        final double[] quaternion = new double[4];
        estimator.getStateQuaternionArray(quaternion);

        assertArrayEquals(quaternion,
                new double[]{valueA, valueB, valueC, valueD}, 0.0);

        // Force IllegalArgumentException
        final double[] wrong = new double[5];
        try {
            estimator.getStateQuaternionArray(wrong);
            fail("IllegalArgumentException expected but not thrown");
        } catch (final IllegalArgumentException ignore) {
        }
    }

    @Test
    public void testGetStateQuaternion() {
        final AbsoluteOrientationSlamEstimator estimator =
                new AbsoluteOrientationSlamEstimator();

        final UniformRandomizer randomizer = new UniformRandomizer(new Random());

        // check initial value
        Quaternion q = estimator.getStateQuaternion();

        assertEquals(q.getA(), 1.0, 0.0);
        assertEquals(q.getB(), 0.0, 0.0);
        assertEquals(q.getC(), 0.0, 0.0);
        assertEquals(q.getD(), 0.0, 0.0);

        // set new values
        final double valueA = randomizer.nextDouble();
        final double valueB = randomizer.nextDouble();
        final double valueC = randomizer.nextDouble();
        final double valueD = randomizer.nextDouble();
        estimator.mStateQuaternionA = valueA;
        estimator.mStateQuaternionB = valueB;
        estimator.mStateQuaternionC = valueC;
        estimator.mStateQuaternionD = valueD;

        // check correctness
        q = estimator.getStateQuaternion();

        assertEquals(q.getA(), valueA, 0.0);
        assertEquals(q.getB(), valueB, 0.0);
        assertEquals(q.getC(), valueC, 0.0);
        assertEquals(q.getD(), valueD, 0.0);

        q = new Quaternion();
        estimator.getStateQuaternion(q);

        assertEquals(q.getA(), valueA, 0.0);
        assertEquals(q.getB(), valueB, 0.0);
        assertEquals(q.getC(), valueC, 0.0);
        assertEquals(q.getD(), valueD, 0.0);
    }

    @Test
    public void testGetStateAngularSpeedX() {
        final AbsoluteOrientationSlamEstimator estimator =
                new AbsoluteOrientationSlamEstimator();

        final UniformRandomizer randomizer = new UniformRandomizer(new Random());

        // check initial value
        assertEquals(estimator.getStateAngularSpeedX(), 0.0, 0.0);

        // set new value
        final double value = randomizer.nextDouble();
        estimator.mStateAngularSpeedX = value;

        // check correctness
        assertEquals(estimator.getStateAngularSpeedX(), value, 0.0);
    }

    @Test
    public void testGetStateAngularSpeedY() {
        final AbsoluteOrientationSlamEstimator estimator =
                new AbsoluteOrientationSlamEstimator();

        final UniformRandomizer randomizer = new UniformRandomizer(new Random());

        // check initial value
        assertEquals(