DirectPython 11 Code

import pickle
import random
import unittest

import d3d11

class Test(unittest.TestCase):

    def equal(self, a, b, epsilon=0.0):
        for i in range(3):
            if abs(a[i] - b[i]) > epsilon:
                return False
        return True

    def randomVector(self):
        v = d3d11.Vector(*[random.random() * 142.325 for x in range(3)])
        self.assert_(v.x == v[0] and v.y == v[1] and v.z == v[2])
        self.assert_(len(v) == 3)
        self.assert_(self.equal(v, v))
        t = tuple(v) 
        return v
        
    def test_ctor(self):
        v = d3d11.Vector()
        self.assert_(v.x == 0.0 and v.y == 0.0 and v.z == 0.0 and v.w == 0.0)
        self.assert_(self.equal(v, d3d11.Vector()))
        
        v = d3d11.Vector(1, 2, 3)
        v2 = d3d11.Vector(v)
        self.assert_(self.equal(v, v2))
        self.assert_(self.equal(v, d3d11.Vector((1,2,3))))
        
    def test_indexing(self):
        v = self.randomVector()
        self.assert_(v.x == v[0] and v.y == v[1] and v.z == v[2])
        
        self.failUnlessRaises(IndexError, v.__getitem__, 3)
             
    def test_mul(self):
        C = 5.34
        a = self.randomVector()
        b = a * C
        
        v = d3d11.Vector(a)
        v *= C
        self.assert_(self.equal(b, v))
        
    def test_str(self):
        s = str(self.randomVector())
        self.assert_(type(s) is str)
        
    def test_numeric(self):
        v = self.randomVector()
        
        v + self.randomVector()
        v += self.randomVector()
        
        v * 5.526
        v *= 3.23
        
        v / 6.34
        v /= 4.543
        
        v - self.randomVector()
        v -= self.randomVector()
  
        self.failUnlessRaises(ZeroDivisionError, v.__div__, 0.0)
        self.failUnlessRaises(ZeroDivisionError, v.__truediv__, 0.0)
        self.failUnlessRaises(ZeroDivisionError, v.__itruediv__, 0.0) 
  
    def test_pickle(self):
        v = self.randomVector()
        p = pickle.dumps(v)
        restored = pickle.loads(p)
        self.assert_(self.equal(v, restored))
        
    def test_methods(self):
        a = self.randomVector()
        b = self.randomVector()
        
        self.assert_(type(a.angle(self.randomVector())) is float)
        self.assert_(type(a.length()) is float)
        self.assert_(type(a.dot(b)) is float)
        self.assert_(type(a.cross(b)) is d3d11.Vector)
        self.assert_(type(a.lerp(b, 0.24534)) is d3d11.Vector)
        b = a.normalize()
        self.assert_(b.x <= 1.0 and b.y <= 1.0 and b.z <= 1.0 and b.w == 0.0)

        b.x = 4.0
        self.assert_(b.x == 4.0)
        b.y = 5.0 
        self.assert_(b.y == 5.0)
        b.z = 6.0
        self.assert_(b.z == 6.0)
        b.w = 7.0
        self.assert_(b.w == 7.0)