DirectPython 11 Code

import pickle
import random
import unittest

import d3d11

identity = [
    (1, 0, 0, 0),
    (0, 1, 0, 0),
    (0, 0, 1, 0),
    (0, 0, 0, 1)
]

class Test(unittest.TestCase):

    def randomMatrix(self):
        m = d3d11.Matrix()
        for x in range(4):
            for y in range(4):  
                #Test both indexing styles.
                m[x][y] = random.random() * 103.1453
                self.assert_(m[x][y] == m[x,y])
        return m
        
    def equal(self, a, b, epsilon=0.0):
        for x in range(4):
            for y in range(4):
                if abs(a[x][y] - b[x][y]) > epsilon:
                    return False
        return True
        
    def test_ctor(self):
        a = self.randomMatrix() 
        b = d3d11.Matrix(a)
        self.assert_(self.equal(a, b))
        self.assert_(self.equal(d3d11.Matrix(), d3d11.Matrix()))
        
        i = d3d11.Matrix()
        i2 = d3d11.Matrix(identity)
        self.assert_(self.equal(i, i2))
        
        x = self.randomMatrix()
        self.assert_(self.equal(x, d3d11.Matrix(x.toList())))

    def test_indexing(self):
        m = d3d11.Matrix()
        for x in range(4):
            for y in range(4):
                self.assertEqual(m[x][y], identity[x][y])
                m[x][y] = 1.0
            
        for x in range(4):
            for y in range(4):
                self.assertEqual(m[x][y], 1.0)

    def test_multiply(self):
        a = d3d11.Matrix() 
        b = d3d11.Matrix() 
        self.assert_(self.equal(a, b))
        self.assert_(self.equal(a * b, b * a))
        
    def test_multiply2(self):
        a = self.randomMatrix() 
        b = d3d11.Matrix(a) 
        m = self.randomMatrix() 
        a *= m
        self.assert_(self.equal(a, b * m))
        
    def test_numeric(self):
        m = self.randomMatrix()
        m *= self.randomMatrix()
        m = m * self.randomMatrix()
        
    def test_convert(self):
        s = str(self.randomMatrix())
        self.assert_(type(s) is str)
        
        m = self.randomMatrix()
        data = m.toBytes()
        self.assert_(len(data) == (4*4*4))
        
        values = self.randomMatrix().toList()
        self.assert_(len(values) == 16)
        
    def test_pickle(self):
        m = self.randomMatrix()
        data = pickle.dumps(m)
        m2 = pickle.loads(data)
        self.assert_(self.equal(m, m2)) 
        
    def test_error(self):
        m = d3d11.Matrix()
        m[3][3] = 1
        m[3,3] = 1  
        
        self.failUnlessRaises(IndexError, m.__setitem__, (4, 3), 1)
        self.failUnlessRaises(IndexError, m.__setitem__, (3, 4), 1) 
        self.failUnlessRaises(IndexError, m.__getitem__, (4, 3))
        self.failUnlessRaises(IndexError, m.__getitem__, (3, 4)) 

        
if __name__ == '__main__':
    unittest.main()