opengl 0.8.0-x86-mingw32 → 0.9.0-x86-mingw32

data/test/test_gl_ext_arb.rb

@@ -31,33 +31,33 @@ class TestGlExtArb < OpenGL::TestCase
 
     glMatrixMode(GL_MODELVIEW)
     glLoadTransposeMatrixfARB(m_a)
-    assert_equal m_a, glGetDoublev(GL_TRANSPOSE_MODELVIEW_MATRIX_ARB)
+    assert_each_in_delta m_a, glGetDoublev(GL_TRANSPOSE_MODELVIEW_MATRIX_ARB)
 
     glLoadTransposeMatrixdARB(m_b)
-    assert_equal m_b, glGetDoublev(GL_TRANSPOSE_MODELVIEW_MATRIX_ARB)
+    assert_each_in_delta m_b, glGetDoublev(GL_TRANSPOSE_MODELVIEW_MATRIX_ARB)
 
     glLoadIdentity()
     glMultTransposeMatrixfARB(m_a)
-    assert_equal m_a, glGetDoublev(GL_TRANSPOSE_MODELVIEW_MATRIX_ARB)
+    assert_each_in_delta m_a, glGetDoublev(GL_TRANSPOSE_MODELVIEW_MATRIX_ARB)
 
     glLoadIdentity()
     glMultTransposeMatrixdARB(m_b)
-    assert_equal m_b, glGetDoublev(GL_TRANSPOSE_MODELVIEW_MATRIX_ARB)
+    assert_each_in_delta m_b, glGetDoublev(GL_TRANSPOSE_MODELVIEW_MATRIX_ARB)
 
     # 2
     m = Matrix.rows([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
     glMatrixMode(GL_MODELVIEW)
     glLoadTransposeMatrixfARB(m)
-    assert_equal m.to_a.transpose, glGetDoublev(GL_MODELVIEW_MATRIX)
+    assert_each_in_delta m.to_a.transpose, glGetDoublev(GL_MODELVIEW_MATRIX)
     glLoadIdentity()
     glLoadTransposeMatrixdARB(m)
-    assert_equal m.to_a.transpose, glGetDoublev(GL_MODELVIEW_MATRIX)
+    assert_each_in_delta m.to_a.transpose, glGetDoublev(GL_MODELVIEW_MATRIX)
     glLoadIdentity()
     glMultTransposeMatrixfARB(m)
-    assert_equal m.to_a.transpose, glGetDoublev(GL_MODELVIEW_MATRIX)
+    assert_each_in_delta m.to_a.transpose, glGetDoublev(GL_MODELVIEW_MATRIX)
     glLoadIdentity()
     glMultTransposeMatrixdARB(m)
-    assert_equal m.to_a.transpose, glGetDoublev(GL_MODELVIEW_MATRIX)
+    assert_each_in_delta m.to_a.transpose, glGetDoublev(GL_MODELVIEW_MATRIX)
 
     assert_raises ArgumentError do glLoadTransposeMatrixfARB([1, 2, 3, 4]) end
     assert_raises ArgumentError do glLoadTransposeMatrixdARB([1, 2, 3, 4]) end
@@ -87,16 +87,16 @@ class TestGlExtArb < OpenGL::TestCase
   def test_gl_arb_vertex_program
     supported? "GL_ARB_vertex_program"
 
-    assert_equal(glIsProgramARB(0), false)
+    assert_equal(false, glIsProgramARB(0))
     programs = glGenProgramsARB(1)
-    assert_equal(programs.size, 1)
+    assert_equal(1, programs.size)
 
     program = "!!ARBvp1.0\nTEMP vv;\nEND"
 
     glBindProgramARB(GL_VERTEX_PROGRAM_ARB, programs[0])
     glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, program)
     assert_equal program, glGetProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_STRING_ARB)
-    assert_equal(glIsProgramARB(programs[0]), true)	
+    assert_equal(glIsProgramARB(programs[0]), true)
 
     assert_equal program.size, glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_LENGTH_ARB)
     assert_equal programs[0], glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_BINDING_ARB)
@@ -128,17 +128,17 @@ class TestGlExtArb < OpenGL::TestCase
     assert_equal([5, 6, 7, 8], glGetProgramLocalParameterfvARB(GL_VERTEX_PROGRAM_ARB, 1))
 
     glVertexAttrib1dARB(1, 1)
-    assert_equal(glGetVertexAttribdvARB(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0], 1)
+    assert_equal(1, glGetVertexAttribdvARB(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0])
     glVertexAttrib1fARB(1, 2)
-    assert_equal(glGetVertexAttribfvARB(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0], 2)
+    assert_equal(2, glGetVertexAttribfvARB(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0])
     glVertexAttrib1sARB(1, 3)
-    assert_equal(glGetVertexAttribivARB(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0], 3)
+    assert_equal(3, glGetVertexAttribivARB(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0])
     glVertexAttrib1dvARB(1, [1])
-    assert_equal(glGetVertexAttribdvARB(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0], 1)
+    assert_equal(1, glGetVertexAttribdvARB(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0])
     glVertexAttrib1fvARB(1, [2])
-    assert_equal(glGetVertexAttribfvARB(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0], 2)
+    assert_equal(2, glGetVertexAttribfvARB(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0])
     glVertexAttrib1svARB(1, [3])
-    assert_equal(glGetVertexAttribivARB(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0], 3)
+    assert_equal(3, glGetVertexAttribivARB(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0])
 
     glVertexAttrib2dARB(1, 1, 2)
     assert_equal([1, 2], glGetVertexAttribdvARB(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 2])
@@ -215,58 +215,58 @@ class TestGlExtArb < OpenGL::TestCase
     supported? "GL_ARB_window_pos"
     # 2
     glWindowPos2dARB(1.0, 2.0)
-    assert_equal([1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
+    assert_each_in_delta([1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glWindowPos2dvARB([2.0, 1.0])
-    assert_equal([2, 1, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
+    assert_each_in_delta([2, 1, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glWindowPos2fARB(1.0, 2.0)
-    assert_equal([1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
+    assert_each_in_delta([1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glWindowPos2fvARB([2.0, 1.0])
-    assert_equal([2, 1, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
+    assert_each_in_delta([2, 1, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glWindowPos2iARB(1, 2)
-    assert_equal([1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
+    assert_each_in_delta([1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glWindowPos2ivARB([2, 1])
-    assert_equal([2, 1, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
+    assert_each_in_delta([2, 1, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glWindowPos2sARB(1, 2)
-    assert_equal([1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
+    assert_each_in_delta([1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glWindowPos2svARB([2, 1])
-    assert_equal([2, 1, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
+    assert_each_in_delta([2, 1, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
 
     # 3
     glWindowPos3dARB(1.0, 2.0, 0.5)
-    assert_equal([1, 2, 0.5, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
+    assert_each_in_delta([1, 2, 0.5, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glWindowPos3dvARB([3.0, 2.0, 1.0])
-    assert_equal([3, 2, 1, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
+    assert_each_in_delta([3, 2, 1, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glWindowPos3fARB(1.0, 2.0, 0.5)
-    assert_equal([1, 2, 0.5, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
+    assert_each_in_delta([1, 2, 0.5, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glWindowPos3fvARB([3.0, 2.0, 1.0])
-    assert_equal([3, 2, 1, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
+    assert_each_in_delta([3, 2, 1, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glWindowPos3iARB(1, 2, 0)
-    assert_equal([1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
+    assert_each_in_delta([1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glWindowPos3ivARB([3, 2, 1])
-    assert_equal([3, 2, 1, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
+    assert_each_in_delta([3, 2, 1, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glWindowPos3sARB(1, 2, 0)
-    assert_equal([1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
+    assert_each_in_delta([1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glWindowPos3svARB([3, 2, 1])
-    assert_equal([3, 2, 1, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
+    assert_each_in_delta([3, 2, 1, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION))
   end
 
   def test_gl_arb_pointparameter
     supported? "GL_ARB_point_parameters"
     glPointParameterfARB(GL_POINT_SIZE_MIN, 1.0)
-    assert_equal 1.0, glGetDoublev(GL_POINT_SIZE_MIN)
+    assert_in_delta 1.0, glGetDoublev(GL_POINT_SIZE_MIN)
 
     glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION, [1, 0, 1])
-    assert_equal([1, 0, 1], glGetDoublev(GL_POINT_DISTANCE_ATTENUATION))
+    assert_each_in_delta([1, 0, 1], glGetDoublev(GL_POINT_DISTANCE_ATTENUATION))
   end
 
   def test_gl_arb_occlusion_query
     supported? "GL_ARB_occlusion_query"
 
     queries = glGenQueriesARB(2)
-    assert_equal(queries.size, 2)
+    assert_equal(2, queries.size)
 
     glBeginQueryARB(GL_SAMPLES_PASSED, queries[1])
-    assert_equal(glIsQueryARB(queries[1]), true)
+    assert_equal(true, glIsQueryARB(queries[1]))
 
     glEndQueryARB(GL_SAMPLES_PASSED)
     r = glGetQueryObjectivARB(queries[1], GL_QUERY_RESULT_AVAILABLE)
@@ -274,7 +274,7 @@ class TestGlExtArb < OpenGL::TestCase
     assert(glGetQueryObjectuivARB(queries[1], GL_QUERY_RESULT)>=0)
 
     glDeleteQueriesARB(queries)
-    assert_equal(glIsQueryARB(queries[1]), false)
+    assert_equal(false, glIsQueryARB(queries[1]))
   end
 
   def test_gl_arb_shader_objects
@@ -296,7 +296,7 @@ class TestGlExtArb < OpenGL::TestCase
     assert_equal GL_TRUE, glGetObjectParameterivARB(vs, GL_OBJECT_COMPILE_STATUS_ARB)
 
     vslog = glGetInfoLogARB(vs)
-    assert_equal(vslog.class, String)
+    assert_equal(String, vslog.class)
 
     glAttachObjectARB(program, vs)
     assert_equal vs, glGetAttachedObjectsARB(program)
@@ -333,18 +333,11 @@ uniform int testivec1;
 uniform ivec2 testivec2;
 uniform ivec3 testivec3;
 uniform ivec4 testivec4;
+
 void main() {
-  testvec1;
-  test;
-  testvec2.x;
-  testvec3.x;
-  testivec1;
-  testivec2.x;
-  testivec3.x;
-  testivec4.x;
-  testvec4;
-
-  gl_Position = ftransform();
+  gl_Position = ftransform() * test[0] *
+      testvec1 * testvec2.x * testvec3.x * testvec4.x *
+      float(testivec1) * float(testivec2.x) * float(testivec3.x) * float(testivec4.x);
 }
     SHADER
 
@@ -384,7 +377,7 @@ void main() {
     assert_equal([2.0, 2.0, 2.0], glGetUniformfvARB(program, tv3l))
     glUniform4fARB(tv4l, 2.0, 2.0, 2.0, 2.0)
     assert_equal([2.0, 2.0, 2.0, 2.0], glGetUniformfvARB(program, tv4l))
-    # i 
+    # i
     glUniform1iARB(tv1il, 3)
     assert_equal 3, glGetUniformivARB(program, tv1il)
     glUniform2iARB(tv2il, 3, 3)
@@ -448,19 +441,18 @@ void main() {
       uniforms[uniform.last] = i
     end
 
-    glUniformMatrix2fvARB(uniforms['testmat2'], GL_TRUE, [0, 1, 1, 0])
-    assert_each_in_delta([0, 1, 1, 0],
+    glUniformMatrix2fvARB(uniforms['testmat2'], GL_TRUE, [0, 1, 2, 3])
+    assert_each_in_delta([0, 2, 1, 3],
                          glGetUniformfvARB(program, uniforms['testmat2']))
 
-    skip "glUniformMatrix3fvARB complains but I don't know why"
     glUniformMatrix3fvARB(uniforms['testmat3'], GL_TRUE,
-                          [0, 1, 0, 1, 0, 1, 0, 1, 0])
-    assert_each_in_delta([0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+                          [0, 1, 2, 3, 4, 5, 6, 7, 8])
+    assert_each_in_delta([0, 3, 6, 1, 4, 7, 2, 5, 8],
                          glGetUniformfvARB(program, uniforms['testmat3']))
 
     glUniformMatrix4fvARB(uniforms['testmat4'], GL_TRUE,
-                          [0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0])
-    assert_each_in_delta([0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0],
+                          [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
+    assert_each_in_delta([0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15],
                          glGetUniformfvARB(program, uniforms['testmat4']))
 
     glDeleteObjectARB(vs)
@@ -484,17 +476,9 @@ uniform ivec3 testivec3;
 uniform ivec4 testivec4;
 
 void main() {
-  testvec1;
-  test;
-  testvec2.x;
-  testvec3.x;
-  testivec1;
-  testivec2.x;
-  testivec3.x;
-  testivec4.x;
-  testvec4;
-
-  gl_Position = ftransform();
+  gl_Position = ftransform() * test[0] *
+      testvec1 * testvec2.x * testvec3.x * testvec4.x *
+      float(testivec1) * float(testivec2.x) * float(testivec3.x) * float(testivec4.x);
 }
     SHADER
 
@@ -516,11 +500,9 @@ void main() {
     glUseProgramObjectARB(program)
 
     assert_equal 2, glGetAttribLocationARB(program, "test")
-    assert_equal [1, GL_FLOAT_VEC4, "gl_Vertex"], glGetActiveAttribARB(program, 0)
+    assert_equal [1, GL_FLOAT_VEC4, "gl_Vertex"], glGetActiveAttribARB(program, 1)
 
     glDeleteObjectARB(vs)
     glDeleteObjectARB(program)
   end
-
 end
-

data/test/test_gl_ext_ati.rb

@@ -25,6 +25,4 @@ class TestGlExtAti < OpenGL::TestCase
     assert_equal GL_BACK_LEFT, glGetIntegerv(GL_DRAW_BUFFER0)
     assert_equal GL_FRONT_LEFT, glGetIntegerv(GL_DRAW_BUFFER1)
   end
-
 end
-

data/test/test_gl_ext_ext.rb

@@ -30,8 +30,8 @@ class TestGlExtExt < OpenGL::TestCase
     supported?("GL_EXT_polygon_offset")
 
     glPolygonOffsetEXT(1.0, 2.0)
-    assert_equal(glGetIntegerv(GL_POLYGON_OFFSET_FACTOR_EXT), 1.0)
-    assert_equal(glGetIntegerv(GL_POLYGON_OFFSET_BIAS_EXT), 2.0)
+    assert_equal(1.0, glGetIntegerv(GL_POLYGON_OFFSET_FACTOR_EXT))
+    assert_equal(2.0, glGetIntegerv(GL_POLYGON_OFFSET_BIAS_EXT))
   end
 
   def test_gl_ext_framebuffer_object
@@ -49,14 +49,14 @@ class TestGlExtExt < OpenGL::TestCase
     fb = glGenFramebuffersEXT(1)
     assert(fb.size==1)
     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb[0])
-    assert_equal(glIsFramebufferEXT(fb[0]), true)
+    assert_equal(true, glIsFramebufferEXT(fb[0]))
 
     rb = glGenRenderbuffersEXT(1)
     assert(rb.size==1)
     glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rb[0])
-    assert_equal(glIsRenderbufferEXT(rb[0]), true)
+    assert_equal(true, glIsRenderbufferEXT(rb[0]))
 
-    glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, WINDOW_SIZE, WINDOW_SIZE)
+    glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, WINDOW_SIZE, WINDOW_SIZE)
 
     assert_equal WINDOW_SIZE, glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_WIDTH_EXT)
     assert_equal WINDOW_SIZE, glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_HEIGHT_EXT)
@@ -81,12 +81,12 @@ class TestGlExtExt < OpenGL::TestCase
     glDeleteTextures(t)
   end
 
-  def test_gl_ext_gpu_program_parameters		
+  def test_gl_ext_gpu_program_parameters
     supported?("GL_EXT_gpu_program_parameters")
 
     glProgramEnvParameters4fvEXT(GL_VERTEX_PROGRAM_ARB, 1, [1, 2, 3, 4, 5, 6, 7, 8])
-    assert_equal(glGetProgramEnvParameterdvARB(GL_VERTEX_PROGRAM_ARB, 1), [1, 2, 3, 4])
-    assert_equal(glGetProgramEnvParameterdvARB(GL_VERTEX_PROGRAM_ARB, 2), [5, 6, 7, 8])
+    assert_equal([1, 2, 3, 4], glGetProgramEnvParameterdvARB(GL_VERTEX_PROGRAM_ARB, 1))
+    assert_equal([5, 6, 7, 8], glGetProgramEnvParameterdvARB(GL_VERTEX_PROGRAM_ARB, 2))
   end
 
   def test_gl_ext_framebuffer_blit
@@ -110,9 +110,9 @@ class TestGlExtExt < OpenGL::TestCase
     glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texture[1], 0)
 
     status = glCheckFramebufferStatusEXT(GL_READ_FRAMEBUFFER_EXT)
-    assert_equal(status, GL_FRAMEBUFFER_COMPLETE_EXT)
+    assert_equal(GL_FRAMEBUFFER_COMPLETE_EXT, status)
     status = glCheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT)
-    assert_equal(status, GL_FRAMEBUFFER_COMPLETE_EXT)
+    assert_equal(GL_FRAMEBUFFER_COMPLETE_EXT, status)
 
     glBlitFramebufferEXT(0, 0, 2, 2,
                          0, 0, 2, 2,
@@ -121,7 +121,7 @@ class TestGlExtExt < OpenGL::TestCase
 
     glBindTexture(GL_TEXTURE_2D, texture[1])
     tex = glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE).unpack("C*")
-    assert_equal(tex, data)
+    assert_equal(data, tex)
 
     glDeleteTextures(texture)
     glDeleteFramebuffersEXT(fbo)
@@ -134,7 +134,7 @@ class TestGlExtExt < OpenGL::TestCase
     glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rb)
     glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, 4, GL_RGBA, 2, 2)
     samples = glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_SAMPLES_EXT)
-    assert_equal(samples, 4)
+    assert_equal(4, samples)
 
     glDeleteRenderbuffersEXT(rb)
   end
@@ -142,25 +142,25 @@ class TestGlExtExt < OpenGL::TestCase
   def test_gl_ext_pointparameter
     supported?("GL_EXT_point_parameters")
     glPointParameterfEXT(GL_POINT_SIZE_MIN, 1.0)
-    assert_equal(glGetDoublev(GL_POINT_SIZE_MIN), 1.0)
+    assert_equal(1.0, glGetDoublev(GL_POINT_SIZE_MIN))
 
     glPointParameterfvEXT(GL_POINT_DISTANCE_ATTENUATION, [1, 0, 1])
-    assert_equal(glGetDoublev(GL_POINT_DISTANCE_ATTENUATION), [1, 0, 1])
+    assert_equal([1, 0, 1], glGetDoublev(GL_POINT_DISTANCE_ATTENUATION))
   end
 
   def test_gl_ext_stencil_two_side
     supported?("GL_EXT_stencil_two_side")
     glActiveStencilFaceEXT(GL_FRONT)
-    assert_equal(glGetIntegerv(GL_ACTIVE_STENCIL_FACE_EXT), GL_FRONT)
+    assert_equal(GL_FRONT, glGetIntegerv(GL_ACTIVE_STENCIL_FACE_EXT))
     glActiveStencilFaceEXT(GL_BACK)
-    assert_equal(glGetIntegerv(GL_ACTIVE_STENCIL_FACE_EXT), GL_BACK)
+    assert_equal(GL_BACK, glGetIntegerv(GL_ACTIVE_STENCIL_FACE_EXT))
   end
 
   def test_gl_ext_stencil_clear_tag
     supported?("GL_EXT_stencil_clear_tag")
     glStencilClearTagEXT(1, 2)
-    assert_equal(glGetIntegerv(GL_STENCIL_TAG_BITS_EXT), 1)
-    assert_equal(glGetIntegerv(GL_STENCIL_CLEAR_TAG_VALUE_EXT), 2)
+    assert_equal(1, glGetIntegerv(GL_STENCIL_TAG_BITS_EXT))
+    assert_equal(2, glGetIntegerv(GL_STENCIL_CLEAR_TAG_VALUE_EXT))
   end
 
   def test_gl_ext_secondary_color
@@ -216,7 +216,7 @@ class TestGlExtExt < OpenGL::TestCase
 
     sc = [0, 1, 0, 1, 0, 1].pack("f*")
 
-    glSecondaryColorPointerEXT(3, GL_FLOAT, 0, sc)
+    glSecondaryColorPointerEXT(3, GL_FLOAT, 12, sc)
     assert_equal 3,        glGetIntegerv(GL_SECONDARY_COLOR_ARRAY_SIZE)
     assert_equal GL_FLOAT, glGetIntegerv(GL_SECONDARY_COLOR_ARRAY_TYPE)
     assert_equal 12,       glGetIntegerv(GL_SECONDARY_COLOR_ARRAY_STRIDE)
@@ -249,33 +249,33 @@ class TestGlExtExt < OpenGL::TestCase
   def test_gl_ext_blend_minmax
     supported?("GL_EXT_blend_minmax")
     glBlendEquationEXT(GL_MIN_EXT)
-    assert_equal(glGetIntegerv(GL_BLEND_EQUATION_EXT), GL_MIN_EXT)
+    assert_equal(GL_MIN_EXT, glGetIntegerv(GL_BLEND_EQUATION_EXT))
     glBlendEquationEXT(GL_MAX_EXT)
-    assert_equal(glGetIntegerv(GL_BLEND_EQUATION_EXT), GL_MAX_EXT)
+    assert_equal(GL_MAX_EXT, glGetIntegerv(GL_BLEND_EQUATION_EXT))
   end
 
   def test_gl_ext_blend_func_separate
     supported?("GL_EXT_blend_func_separate")
     glBlendFuncSeparateEXT(GL_ZERO, GL_ONE, GL_ZERO, GL_ONE)
-    assert_equal(glGetIntegerv(GL_BLEND_SRC_RGB_EXT), GL_ZERO)
-    assert_equal(glGetIntegerv(GL_BLEND_DST_RGB_EXT), GL_ONE)
-    assert_equal(glGetIntegerv(GL_BLEND_SRC_ALPHA_EXT), GL_ZERO)
+    assert_equal(GL_ZERO, glGetIntegerv(GL_BLEND_SRC_RGB_EXT))
+    assert_equal(GL_ONE, glGetIntegerv(GL_BLEND_DST_RGB_EXT))
+    assert_equal(GL_ZERO, glGetIntegerv(GL_BLEND_SRC_ALPHA_EXT))
     assert_equal(glGetIntegerv(GL_BLEND_DST_ALPHA_EXT), GL_ONE)
     glBlendFuncSeparateEXT(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO)
-    assert_equal(glGetIntegerv(GL_BLEND_SRC_RGB_EXT), GL_ONE)
-    assert_equal(glGetIntegerv(GL_BLEND_DST_RGB_EXT), GL_ZERO)
-    assert_equal(glGetIntegerv(GL_BLEND_SRC_ALPHA_EXT), GL_ONE)
-    assert_equal(glGetIntegerv(GL_BLEND_DST_ALPHA_EXT), GL_ZERO)
+    assert_equal(GL_ONE, glGetIntegerv(GL_BLEND_SRC_RGB_EXT))
+    assert_equal(GL_ZERO, glGetIntegerv(GL_BLEND_DST_RGB_EXT))
+    assert_equal(GL_ONE, glGetIntegerv(GL_BLEND_SRC_ALPHA_EXT))
+    assert_equal(GL_ZERO, glGetIntegerv(GL_BLEND_DST_ALPHA_EXT))
   end
 
   def test_gl_ext_blend_equation_separate
     supported?("GL_EXT_blend_equation_separate")
     glBlendEquationSeparateEXT(GL_FUNC_ADD, GL_FUNC_SUBTRACT)
-    assert_equal(glGetIntegerv(GL_BLEND_EQUATION_RGB_EXT), GL_FUNC_ADD)
-    assert_equal(glGetIntegerv(GL_BLEND_EQUATION_ALPHA_EXT), GL_FUNC_SUBTRACT)
+    assert_equal(GL_FUNC_ADD, glGetIntegerv(GL_BLEND_EQUATION_RGB_EXT))
+    assert_equal(GL_FUNC_SUBTRACT, glGetIntegerv(GL_BLEND_EQUATION_ALPHA_EXT))
     glBlendEquationSeparateEXT(GL_FUNC_SUBTRACT, GL_FUNC_ADD)
-    assert_equal(glGetIntegerv(GL_BLEND_EQUATION_RGB_EXT), GL_FUNC_SUBTRACT)
-    assert_equal(glGetIntegerv(GL_BLEND_EQUATION_ALPHA_EXT), GL_FUNC_ADD)
+    assert_equal(GL_FUNC_SUBTRACT, glGetIntegerv(GL_BLEND_EQUATION_RGB_EXT))
+    assert_equal(GL_FUNC_ADD, glGetIntegerv(GL_BLEND_EQUATION_ALPHA_EXT))
   end
 
   def test_gl_ext_depth_bounds_test
@@ -310,22 +310,22 @@ class TestGlExtExt < OpenGL::TestCase
     textures = glGenTexturesEXT(2)
     glBindTextureEXT(GL_TEXTURE_1D, textures[0])
     glBindTextureEXT(GL_TEXTURE_2D, textures[1])
-    assert_equal(glIsTextureEXT(textures[0]), true)
-    assert_equal(glAreTexturesResidentEXT(textures).size, 2)
+    assert_equal(true, glIsTextureEXT(textures[0]))
+    assert_equal(2, glAreTexturesResidentEXT(textures).size)
 
     glPrioritizeTexturesEXT(textures, [0.5, 1.0])
-    assert_equal(glGetTexParameterfv(GL_TEXTURE_1D, GL_TEXTURE_PRIORITY), 0.5)
-    assert_equal(glGetTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_PRIORITY), 1.0)
+    assert_equal(0.5, glGetTexParameterfv(GL_TEXTURE_1D, GL_TEXTURE_PRIORITY))
+    assert_equal(1.0, glGetTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_PRIORITY))
 
     glDeleteTexturesEXT(textures)
-    assert_equal(glIsTextureEXT(textures[0]), false)
+    assert_equal(false, glIsTextureEXT(textures[0]))
   end
 
   def test_gl_ext_compiled_vertex_array
     supported?("GL_EXT_compiled_vertex_array")
     glLockArraysEXT(1, 2)
-    assert_equal(glGetIntegerv(GL_ARRAY_ELEMENT_LOCK_FIRST_EXT), 1)
-    assert_equal(glGetIntegerv(GL_ARRAY_ELEMENT_LOCK_COUNT_EXT), 2)
+    assert_equal(1, glGetIntegerv(GL_ARRAY_ELEMENT_LOCK_FIRST_EXT))
+    assert_equal(2, glGetIntegerv(GL_ARRAY_ELEMENT_LOCK_COUNT_EXT))
     glUnlockArraysEXT()
   end
 
@@ -343,7 +343,7 @@ class TestGlExtExt < OpenGL::TestCase
     assert_equal 3.0, glGetDoublev(GL_CURRENT_FOG_COORD)
 
     fc = [1, 0].pack("f*")
-    glFogCoordPointerEXT(GL_FLOAT, 0, fc)
+    glFogCoordPointerEXT(GL_FLOAT, 4, fc)
     assert_equal GL_FLOAT, glGetIntegerv(GL_FOG_COORD_ARRAY_TYPE)
     assert_equal 4, glGetIntegerv(GL_FOG_COORD_ARRAY_STRIDE)
     assert_equal fc, glGetPointerv(GL_FOG_COORD_ARRAY_POINTER)
@@ -398,7 +398,7 @@ class TestGlExtExt < OpenGL::TestCase
 
     glDrawRangeElementsEXT(GL_POINTS, 0, 2, 3, GL_UNSIGNED_BYTE, [0, 1, 2].pack("C*"))
     count = glRenderMode(GL_RENDER)
-    assert_equal(count, 12)
+    assert_equal(12, count)
 
     glDisableClientState(GL_VERTEX_ARRAY)
   end
@@ -408,7 +408,7 @@ class TestGlExtExt < OpenGL::TestCase
     program = glCreateProgramObjectARB()
 
     glProgramParameteriEXT(program, GL_GEOMETRY_INPUT_TYPE_EXT , GL_LINES_ADJACENCY_EXT)
-    assert_equal(glGetObjectParameterivARB(program, GL_GEOMETRY_INPUT_TYPE_EXT), GL_LINES_ADJACENCY_EXT)
+    assert_equal(GL_LINES_ADJACENCY_EXT, glGetObjectParameterivARB(program, GL_GEOMETRY_INPUT_TYPE_EXT))
 
     glDeleteObjectARB(program)
   end
@@ -423,31 +423,31 @@ class TestGlExtExt < OpenGL::TestCase
     glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, program)
 
     glVertexAttribI1iEXT(1, 1)
-    assert_equal(glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0], 1)
+    assert_equal(1, glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0])
     glVertexAttribI1uiEXT(1, 2)
-    assert_equal(glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0], 2)
+    assert_equal(2, glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0])
     glVertexAttribI1ivEXT(1, [3])
-    assert_equal(glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0], 3)
+    assert_equal(3, glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0])
     glVertexAttribI1uivEXT(1, [4])
-    assert_equal(glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0], 4)
+    assert_equal(4, glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0])
 
     glVertexAttribI2iEXT(1, 1, 2)
-    assert_equal(glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 2], [1, 2])
+    assert_equal([1, 2], glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 2])
     glVertexAttribI2uiEXT(1, 2, 3)
-    assert_equal(glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 2], [2, 3])
+    assert_equal([2, 3], glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 2])
     glVertexAttribI2ivEXT(1, [3, 4])
-    assert_equal(glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 2], [3, 4])
+    assert_equal([3, 4], glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 2])
     glVertexAttribI2uivEXT(1, [4, 5])
-    assert_equal(glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 2], [4, 5])
+    assert_equal([4, 5], glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 2])
 
     glVertexAttribI3iEXT(1, 1, 2, 3)
-    assert_equal(glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 3], [1, 2, 3])
+    assert_equal([1, 2, 3], glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 3])
     glVertexAttribI3uiEXT(1, 2, 3, 4)
-    assert_equal(glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 3], [2, 3, 4])
+    assert_equal([2, 3, 4], glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 3])
     glVertexAttribI3ivEXT(1, [3, 4, 5])
-    assert_equal(glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 3], [3, 4, 5])
+    assert_equal([3, 4, 5], glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 3])
     glVertexAttribI3uivEXT(1, [4, 5, 6])
-    assert_equal(glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 3], [4, 5, 6])
+    assert_equal([4, 5, 6], glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)[0, 3])
 
     glVertexAttribI4iEXT(1, 1, 2, 3, 4)
     assert_equal [1, 2, 3, 4], glGetVertexAttribIivEXT(1, GL_CURRENT_VERTEX_ATTRIB_ARB)
@@ -505,16 +505,16 @@ void main() {
     glUseProgramObjectARB(program)
 
     tv1il = glGetUniformLocation program, "testivec1"
-    refute_equal -1, tv1il, "testivec1 missing!"
+    refute_equal(-1, tv1il, "testivec1 missing!")
 
     tv2il = glGetUniformLocation program, "testivec2"
-    refute_equal -1, tv2il, "testivec2 missing!"
+    refute_equal(-1, tv2il, "testivec2 missing!")
 
     tv3il = glGetUniformLocation program, "testivec3"
-    refute_equal -1, tv3il, "testivec3 missing!"
+    refute_equal(-1, tv3il, "testivec3 missing!")
 
     tv4il = glGetUniformLocation program, "testivec4"
-    refute_equal -1, tv4il, "testivec4 missing!"
+    refute_equal(-1, tv4il, "testivec4 missing!")
 
     skip "glGetUniformLocation is broken" if
       glGetActiveUniform(program, tv1il).last != "testivec1"
@@ -554,7 +554,7 @@ void main() {
     assert_equal [3, 4, 5, 6], glGetUniformuivEXT(program, tv4il)
 
     glBindFragDataLocationEXT(program, 1, "test")
-    assert_equal -1, glGetFragDataLocationEXT(program, "test")
+    assert_equal(-1, glGetFragDataLocationEXT(program, "test"))
   end
 
   def test_gl_ext_draw_instanced
@@ -572,7 +572,7 @@ void main() {
 
     glDrawElementsInstancedEXT(GL_TRIANGLES, 3, GL_UNSIGNED_BYTE, [0, 1, 2].pack("C*"), 2)
     count = glRenderMode(GL_RENDER)
-    assert_equal(count, 2*2*11)
+    assert_equal(2*2*11, count)
 
     glDisableClientState(GL_VERTEX_ARRAY)
   end
@@ -587,8 +587,8 @@ void main() {
     glBindTexture(GL_TEXTURE_BUFFER_EXT, tex)
     glTexBufferEXT(GL_TEXTURE_BUFFER_EXT, GL_RGBA32F_ARB, buf)
 
-    assert_equal(glGetIntegerv(GL_TEXTURE_BINDING_BUFFER_EXT), tex)
-    assert_equal(glGetIntegerv(GL_TEXTURE_BUFFER_FORMAT_EXT), GL_RGBA32F_ARB)
+    assert_equal(tex, glGetIntegerv(GL_TEXTURE_BINDING_BUFFER_EXT))
+    assert_equal(GL_RGBA32F_ARB, glGetIntegerv(GL_TEXTURE_BUFFER_FORMAT_EXT))
 
     glDeleteBuffers(buf)
     glDeleteTextures(tex)
@@ -597,12 +597,12 @@ void main() {
   def test_gl_ext_texture_integer
     supported?("GL_EXT_texture_integer")
 
-    glClearColorIiEXT(1, 2, 3, 4)	
-    glClearColorIuiEXT(1, 2, 3, 4)	
+    glClearColorIiEXT(1, 2, 3, 4)
+    glClearColorIuiEXT(1, 2, 3, 4)
 
     glTexParameterIivEXT(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, [1, 2, 3, 4])
-    assert_equal(glGetTexParameterIivEXT(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR), [1, 2, 3, 4])
+    assert_equal([1, 2, 3, 4], glGetTexParameterIivEXT(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR))
     glTexParameterIuivEXT(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, [5, 6, 7, 8])
-    assert_equal(glGetTexParameterIuivEXT(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR), [5, 6, 7, 8])
+    assert_equal([5, 6, 7, 8], glGetTexParameterIuivEXT(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR))
   end
 end