Author: ArcRiley
Date: 2008-02-17 09:25:30 -0500 (Sun, 17 Feb 2008)
New Revision: 923

Modified:
   trunk/pysoy/tests/Mesh.py
Log:
added license template and pydocs, fixed indentation


Modified: trunk/pysoy/tests/Mesh.py
===================================================================
--- trunk/pysoy/tests/Mesh.py   2008-02-17 14:04:04 UTC (rev 922)
+++ trunk/pysoy/tests/Mesh.py   2008-02-17 14:25:30 UTC (rev 923)
@@ -1,7 +1,39 @@
 #!/usr/bin/env python
+'''Tests for soy.meshes.Mesh
 
+    This currently tests the ability to create a mesh from Vertex and Face
+    objects and that the order of those objects remain predictable.
+
+    Additional tests for Mesh are required including material add/del,
+    Face removal when a Vertex it uses is removed, VertexList and FaceList 
+    slicing, merging two Mesh objects via add/sub, multiplying a Mesh to 
+    repeat a pattern such a mirroring, and other features we have not yet 
+    added but which will require a high degree of testing due to their complex 
+    and bug-prone nature.
+'''
+__credits__ = '''Copyright (C) 2006,2007,2008 PySoy Group
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, see http://www.gnu.org/licenses
+'''
+__author__  = 'PySoy Group'
+__date__    = 'Last change on '+ \
+              '$Date: 2008-02-15 03:16:28 -0500 (Fri, 15 Feb 2008) $'[7:-20]+ \
+              'by '+'$Author: ArcRiley $'[9:-2]
+__version__ = 'Trunk (r'+'$Rev: 898 $'[6:-2]+')'
+
+import soy
 import unittest
-import soy
 
 V = soy.atoms.Vertex
 F = soy.atoms.Face
@@ -31,131 +63,130 @@
         ]
 
 def copy_c_array(array):
-    arr = []
-    for i in range(len(array)):
-        arr.append(array[i])
-    return arr
+  arr = []
+  for i in range(len(array)):
+    arr.append(array[i])
+  return arr
 
+
 class TestMesh(unittest.TestCase):
-    def setUp(self):
-        self.mesh = soy.meshes.Mesh()
-        self.material = soy.materials.StainlessSteel()
+  def setUp(self):
+    self.mesh = soy.meshes.Mesh()
+    self.material = soy.materials.StainlessSteel()
 
-    def test_addition_mesh(self):
-        V1 = lambda x : V(self.mesh, position=x)
-        F1 = lambda x : F(self.mesh, verts=x, material=self.material)
+  def test_addition_mesh(self):
+    V1 = lambda x : V(self.mesh, position=x)
+    F1 = lambda x : F(self.mesh, verts=x, material=self.material)
 
-        verts = map(V1, quad_vertices)
-        verts_copy = copy_c_array(self.mesh.verts)
+    verts = map(V1, quad_vertices)
+    verts_copy = copy_c_array(self.mesh.verts)
 
-        face_vert = [ map(lambda x : verts[x], x) for x in quad_faces]
-        faces = map(F1, face_vert)
-        faces_copy = copy_c_array(self.mesh.faces)
+    face_vert = [ map(lambda x : verts[x], x) for x in quad_faces]
+    faces = map(F1, face_vert)
+    faces_copy = copy_c_array(self.mesh.faces)
 
-        self.assertEqual(len(self.mesh.verts),4)
-        self.assertEqual(len(self.mesh.faces),2)
+    self.assertEqual(len(self.mesh.verts),4)
+    self.assertEqual(len(self.mesh.faces),2)
         
-        for i in range(4):
-            self.assertEqual( self.mesh.verts[i], verts_copy[i])
-        for i in range(2):
-            self.assertEqual( self.mesh.faces[i], faces_copy[i])
+    for i in range(4):
+      self.assertEqual( self.mesh.verts[i], verts_copy[i])
+    for i in range(2):
+      self.assertEqual( self.mesh.faces[i], faces_copy[i])
 
-        verts2 = map(V1, quad2_vertices)
-        face_vert2 = [ map(lambda x : verts2[x], x) for x in quad_faces]
-        faces2 = map(F1, face_vert2)
+    verts2 = map(V1, quad2_vertices)
+    face_vert2 = [ map(lambda x : verts2[x], x) for x in quad_faces]
+    faces2 = map(F1, face_vert2)
 
-        self.assertEqual(len(self.mesh.verts),8)
-        self.assertEqual(len(self.mesh.faces),4)
+    self.assertEqual(len(self.mesh.verts),8)
+    self.assertEqual(len(self.mesh.faces),4)
 
-        for i in range(4):
-            self.assertEqual( self.mesh.verts[i], verts_copy[i])
-        for i in range(2):
-            self.assertEqual( self.mesh.faces[i], faces_copy[i])
+    for i in range(4):
+      self.assertEqual( self.mesh.verts[i], verts_copy[i])
+    for i in range(2):
+      self.assertEqual( self.mesh.faces[i], faces_copy[i])
 
-    def test_modification_mesh(self):
-        V1 = lambda x : V(self.mesh, position=x)
-        F1 = lambda x : F(self.mesh, verts=x, material=self.material)
+  def test_modification_mesh(self):
+    V1 = lambda x : V(self.mesh, position=x)
+    F1 = lambda x : F(self.mesh, verts=x, material=self.material)
 
-        verts = map(V1, quad_vertices)
-        face_vert = [ map(lambda x : verts[x], x) for x in quad_faces]
-        faces = map(F1, face_vert)
+    verts = map(V1, quad_vertices)
+    face_vert = [ map(lambda x : verts[x], x) for x in quad_faces]
+    faces = map(F1, face_vert)
         
-        verts2 = map(V1, quad2_vertices)
-        face_vert2 = [ map(lambda x : verts2[x], x) for x in quad_faces]
-        faces2 = map(F1, face_vert2)
+    verts2 = map(V1, quad2_vertices)
+    face_vert2 = [ map(lambda x : verts2[x], x) for x in quad_faces]
+    faces2 = map(F1, face_vert2)
 
-        self.assertEqual(len(self.mesh.verts),8)
-        self.assertEqual(len(self.mesh.faces),4)
+    self.assertEqual(len(self.mesh.verts),8)
+    self.assertEqual(len(self.mesh.faces),4)
 
-        verts_copy = copy_c_array(self.mesh.verts)
-        faces_copy = copy_c_array(self.mesh.faces)
+    verts_copy = copy_c_array(self.mesh.verts)
+    faces_copy = copy_c_array(self.mesh.faces)
 
-        face_vert3 = [ map(lambda x : verts[x], x) for x in 
quad_faces_alternate]
+    face_vert3 = [ map(lambda x : verts[x], x) for x in quad_faces_alternate]
 
-        for i in range(2,4):
-            self.mesh.faces[i].verts = face_vert3[i-2]
+    for i in range(2,4):
+      self.mesh.faces[i].verts = face_vert3[i-2]
 
-        for i in range(8):
-            self.assertEqual( self.mesh.verts[i], verts_copy[i])
-        for i in range(2):
-            self.assertEqual( self.mesh.faces[i], faces_copy[i])
+    for i in range(8):
+      self.assertEqual( self.mesh.verts[i], verts_copy[i])
+    for i in range(2):
+      self.assertEqual( self.mesh.faces[i], faces_copy[i])
 
+  def test_substraction_mesh(self):
+    V1 = lambda x : V(self.mesh, position=x)
+    F1 = lambda x : F(self.mesh, verts=x, material=self.material)
 
-    def test_substraction_mesh(self):
-        V1 = lambda x : V(self.mesh, position=x)
-        F1 = lambda x : F(self.mesh, verts=x, material=self.material)
+    verts = map(V1, quad_vertices)
+    face_vert = [ map(lambda x : verts[x], x) for x in quad_faces]
+    faces = map(F1, face_vert)
 
-        verts = map(V1, quad_vertices)
-        face_vert = [ map(lambda x : verts[x], x) for x in quad_faces]
-        faces = map(F1, face_vert)
+    self.assertEqual(len(self.mesh.verts),4)
+    self.assertEqual(len(self.mesh.faces),2)
 
-        self.assertEqual(len(self.mesh.verts),4)
-        self.assertEqual(len(self.mesh.faces),2)
+    verts2 = map(V1, quad2_vertices)
+    face_vert2 = [ map(lambda x : verts2[x], x) for x in quad_faces]
 
-        verts2 = map(V1, quad2_vertices)
-        face_vert2 = [ map(lambda x : verts2[x], x) for x in quad_faces]
+    for i in range(2):
+      self.mesh.faces[i].verts = face_vert2[i]
 
-        for i in range(2):
-            self.mesh.faces[i].verts = face_vert2[i]
+    self.assertEqual(len(self.mesh.verts),4) # THIS ONE FAILS
+    self.assertEqual(len(self.mesh.faces),2)
 
-        self.assertEqual(len(self.mesh.verts),4) # THIS ONE FAILS
-        self.assertEqual(len(self.mesh.faces),2)
+  def test_reuse_mesh(self):
+    V1 = lambda x : V(self.mesh, position=x)
+    F1 = lambda x : F(self.mesh, verts=x, material=self.material)
 
-    def test_reuse_mesh(self):
-        V1 = lambda x : V(self.mesh, position=x)
-        F1 = lambda x : F(self.mesh, verts=x, material=self.material)
+    verts = map(V1, quad_vertices)
+    face_vert = [ map(lambda x : verts[x], x) for x in quad_faces]
+    faces = map(F1, face_vert)
 
-        verts = map(V1, quad_vertices)
-        face_vert = [ map(lambda x : verts[x], x) for x in quad_faces]
-        faces = map(F1, face_vert)
+    self.assertEqual(len(self.mesh.verts),4)
+    self.assertEqual(len(self.mesh.faces),2)
 
-        self.assertEqual(len(self.mesh.verts),4)
-        self.assertEqual(len(self.mesh.faces),2)
+    verts2 = map(V1, quad_vertices)
+    face_vert2 = [ map(lambda x : verts2[x], x) for x in quad_faces_alternate]
+    faces2 = map(F1, face_vert2)
 
-        verts2 = map(V1, quad_vertices)
-        face_vert2 = [ map(lambda x : verts2[x], x) for x in 
quad_faces_alternate]
-        faces2 = map(F1, face_vert2)
+    self.assertEqual(len(self.mesh.verts),4) #THIS ONE FAILS
+    self.assertEqual(len(self.mesh.faces),4)
 
-        self.assertEqual(len(self.mesh.verts),4) #THIS ONE FAILS
-        self.assertEqual(len(self.mesh.faces),4)
-    def test_changed_order(self):
-        V1 = lambda x : V(self.mesh, position=x)
-        F1 = lambda x : F(self.mesh, verts=x, material=self.material)
+  def test_changed_order(self):
+    V1 = lambda x : V(self.mesh, position=x)
+    F1 = lambda x : F(self.mesh, verts=x, material=self.material)
 
-        verts = map(V1, quad_vertices)
-        face_vert = [ map(lambda x : verts[x], x) for x in quad_faces]
-        faces = map(F1, face_vert)
+    verts = map(V1, quad_vertices)
+    face_vert = [ map(lambda x : verts[x], x) for x in quad_faces]
+    faces = map(F1, face_vert)
 
-        faces_copy = copy_c_array(self.mesh.faces)
+    faces_copy = copy_c_array(self.mesh.faces)
 
-        for i in range(len(self.mesh.faces)):
-            self.mesh.faces[i].verts = faces_copy[2-i-1].verts
+    for i in range(len(self.mesh.faces)):
+      self.mesh.faces[i].verts = faces_copy[2-i-1].verts
 
-        for i  in range(len(self.mesh.faces)):
-            self.assertEqual(self.mesh.faces[i], faces[2-i-1]) #THIS ALSO FAILS
+    for i  in range(len(self.mesh.faces)):
+      self.assertEqual(self.mesh.faces[i], faces[2-i-1]) #THIS ALSO FAILS
 
 
-
 if __name__=='__main__':
     unittest.main()
-

_______________________________________________
PySoy-SVN mailing list
PySoy-SVN@pysoy.org
http://www.pysoy.org/mailman/listinfo/pysoy-svn

Reply via email to