def test_output(self):
"""
Make sure the output is correct
"""
# Build matrix to rotate
m = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
for a in [
0, 30, 45, 60, 90, 135, 180, 210, 225, 240, 270, 315, 360, -30,
-45, -60, -90, -135, -180, -210, -225, -240, -270, -315, -360
]:
# Convert matrices into 1d-lists and check every element
for program, tester in zip(
SetupDecoder.rotateMatrix(a, m).ravel().tolist(),
self.rotate(a, m).ravel().tolist()):
self.assertAlmostEqual(program, tester)
# Check sizes
self.assertEqual(
SetupDecoder.rotateMatrix(a, m).shape,
self.rotate(a, m).shape)
# Check type
self.assertTrue(
type(SetupDecoder.rotateMatrix(a, m)) is np.ndarray)
def test_output(self):
"""
Check if the output is correct
"""
self.assertEqual(
SetupDecoder.unitMatrix().tolist(),
np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0,
1]]).tolist())
self.assertTrue(type(SetupDecoder.unitMatrix()) is np.ndarray)
def test_output(self):
"""
Make sure output is correct
"""
for t in [0, 0.1, 0.2, 0.5, 0.7, 1]:
self.assertEqual(
SetupDecoder.attenuatingFilter(t).tolist(),
self.flr(t).tolist())
self.assertTrue(
type(SetupDecoder.attenuatingFilter(t)) is np.ndarray)
def test_values(self):
"""
Make sure value error are raised if necessary
"""
self.assertRaises(ValueError, SetupDecoder.decode, "")
self.assertRaises(ValueError, SetupDecoder.decode, " ")
for line in self.valueErrorInput:
with self.assertRaises(
ValueError,
msg="No error while testing SetupDecoder.decode('" + line +
"')"):
SetupDecoder.decode(line)
def test_output(self):
"""
Check if the output is correct
"""
# Check if function returns correct answer for various inputs in degrees
for t in [0, 30, 45, 60, 90, 135, 180, 210, 225, 240, 270, 315, 360]:
for d in [
0, 30, 45, 60, 90, 135, 180, 210, 225, 240, 270, 315, 360
]:
self.assertEqual(
SetupDecoder.generalLinearRetarder(t, d).tolist(),
self.glr(t, d).tolist())
self.assertTrue(
type(SetupDecoder.generalLinearRetarder(t, d)) is
np.ndarray)
def test_types(self):
"""
Make sure type error are raised if necessary
"""
self.assertRaises(TypeError, SetupDecoder.decode, 1)
self.assertRaises(TypeError, SetupDecoder.decode, 1.0)
self.assertRaises(TypeError, SetupDecoder.decode, True)
self.assertRaises(TypeError, SetupDecoder.decode, False)
self.assertRaises(TypeError, SetupDecoder.decode, 1 + 1j)
self.assertRaises(TypeError, SetupDecoder.decode, ["str", "str"])
self.assertRaises(TypeError, SetupDecoder.decode, [1, 1])
for line in self.typeErrorInput:
with self.assertRaises(
TypeError,
msg="No error while testing SetupDecoder.decode('" + line +
"')"):
SetupDecoder.decode(line)
def test_output(self):
"""
Make sure output is correct
"""
for t in [0, 30, 45, 60, 90, 135, 180, 210, 225, 240, 270, 315, 360]:
# Convert matrices into 1d-lists and check every element
for program, tester in zip(
SetupDecoder.halfWavePlate(t).ravel().tolist(),
self.hwp(t).ravel().tolist()):
self.assertAlmostEqual(program, tester)
# Check sizes
self.assertEqual(
SetupDecoder.halfWavePlate(t).shape,
self.hwp(t).shape)
# Check type
self.assertTrue(type(SetupDecoder.halfWavePlate(t)) is np.ndarray)
def test_output(self):
"""
Check if output is correct
"""
# Check if function returns correct answer for various inputs in degrees
for t in [0, 30, 45, 60, 90, 135, 180, 210, 225, 240, 270, 315, 360]:
# Convert matrices into 1d-lists and check every element
for program, tester in zip(
SetupDecoder.linearVerticalPolariser(t).ravel().tolist(),
self.lvp(t).ravel().tolist()):
self.assertAlmostEqual(program, tester)
# Check sizes
self.assertEqual(
SetupDecoder.linearVerticalPolariser(t).shape,
self.lvp(t).shape)
# Check type
self.assertTrue(
type(SetupDecoder.linearVerticalPolariser(t)) is np.ndarray)
def test_output(self):
"""
Make sure the function returns the right values
"""
correct_matrix = lambda polarisedPart: np.diag(
[1, polarisedPart, polarisedPart, polarisedPart])
# Check for different input values
for value in [0, 0.1, 0.25, 0.5, 0.6, 0.9, 1]:
# Convert matrices into 1d-lists and check every element
for program, tester in zip(
SetupDecoder.depolariser(value).ravel().tolist(),
correct_matrix(value).ravel().tolist()):
self.assertAlmostEqual(program, tester)
# Check sizes
self.assertEqual(
SetupDecoder.depolariser(value).shape,
correct_matrix(value).shape)
# Check type
self.assertTrue(
type(SetupDecoder.depolariser(value)) is np.ndarray)
#
# UNITTESTS
#
import unittest
# Import class that shall be tested and create an instance of it
from SetupDecoder import SetupDecoder
SetupDecoder = SetupDecoder()
#
# EXTERNAL LIBARIES
#
import numpy as np
import math
class TestSetupDecoder_UnitMatrix(unittest.TestCase):
"""
Test the unitMatrix method in SetupDecoder
"""
def test_output(self):
"""
Check if the output is correct
"""
self.assertEqual(
SetupDecoder.unitMatrix().tolist(),
np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0,
1]]).tolist())
self.assertTrue(type(SetupDecoder.unitMatrix()) is np.ndarray)