opengl 0.8.0 → 0.9.0

data/test/test_gl_14.rb

@@ -19,7 +19,6 @@ class TestGl14 < OpenGL::TestCase
 
   def setup
     super
-
     supported? 1.4
   end
 
@@ -27,13 +26,13 @@ class TestGl14 < OpenGL::TestCase
     sc = [0, 1, 0, 1, 0, 1].pack("f*")
     fc = [1, 0].pack("f*")
 
-    glSecondaryColorPointer(3, GL_FLOAT, 0, sc)
+    glSecondaryColorPointer(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)
     assert_equal sc,       glGetPointerv(GL_SECONDARY_COLOR_ARRAY_POINTER)
 
-    glFogCoordPointer(GL_FLOAT, 0, fc)
+    glFogCoordPointer(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)
@@ -45,15 +44,15 @@ class TestGl14 < OpenGL::TestCase
     glArrayElement(0)
     glEnd()
 
-    assert_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR), [0, 1, 0, 1])
-    assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD), 1)
+    assert_equal([0, 1, 0, 1], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+    assert_equal(1, glGetDoublev(GL_CURRENT_FOG_COORD))
 
     glBegin(GL_TRIANGLES)
     glArrayElement(1)
     glEnd()
 
-    assert_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR), [1, 0, 1, 1])
-    assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD), 0)
+    assert_equal([1, 0, 1, 1], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+    assert_equal(0, glGetDoublev(GL_CURRENT_FOG_COORD))
 
     glDisableClientState(GL_SECONDARY_COLOR_ARRAY)
     glDisableClientState(GL_FOG_COORD_ARRAY)
@@ -81,21 +80,21 @@ class TestGl14 < OpenGL::TestCase
 
   def test_glblendfuncseparate
     glBlendFuncSeparate(GL_SRC_COLOR, GL_SRC_COLOR, GL_SRC_COLOR, GL_SRC_COLOR)
-    assert_equal(glGetIntegerv(GL_BLEND_SRC_RGB), GL_SRC_COLOR)
-    assert_equal(glGetIntegerv(GL_BLEND_SRC_ALPHA), GL_SRC_COLOR)
-    assert_equal(glGetIntegerv(GL_BLEND_DST_RGB), GL_SRC_COLOR)
-    assert_equal(glGetIntegerv(GL_BLEND_DST_ALPHA), GL_SRC_COLOR)
+    assert_equal(GL_SRC_COLOR, glGetIntegerv(GL_BLEND_SRC_RGB))
+    assert_equal(GL_SRC_COLOR, glGetIntegerv(GL_BLEND_SRC_ALPHA))
+    assert_equal(GL_SRC_COLOR, glGetIntegerv(GL_BLEND_DST_RGB))
+    assert_equal(GL_SRC_COLOR, glGetIntegerv(GL_BLEND_DST_ALPHA))
   end
 
   def test_glpointparameter
     glPointParameterf(GL_POINT_SIZE_MIN, 2.0)
-    assert_equal(glGetDoublev(GL_POINT_SIZE_MIN), 2.0)
+    assert_equal(2.0, glGetDoublev(GL_POINT_SIZE_MIN))
 
     glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION, [0, 1, 0])
     assert_equal([0, 1, 0], glGetDoublev(GL_POINT_DISTANCE_ATTENUATION))
 
     glPointParameteri(GL_POINT_SIZE_MAX, 4)
-    assert_equal(glGetDoublev(GL_POINT_SIZE_MAX), 4)
+    assert_equal(4, glGetDoublev(GL_POINT_SIZE_MAX))
 
     glPointParameteriv(GL_POINT_DISTANCE_ATTENUATION, [1, 0, 1])
     assert_equal([1, 0, 1], glGetDoublev(GL_POINT_DISTANCE_ATTENUATION))
@@ -103,14 +102,14 @@ class TestGl14 < OpenGL::TestCase
 
   def test_glfogcoord
     glFogCoordf(2.0)
-    assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD), 2.0)
+    assert_equal(2.0, glGetDoublev(GL_CURRENT_FOG_COORD))
     glFogCoordfv([3.0])
-    assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD), 3.0)
+    assert_equal(3.0, glGetDoublev(GL_CURRENT_FOG_COORD))
 
     glFogCoordd(2.0)
-    assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD), 2.0)
+    assert_equal(2.0, glGetDoublev(GL_CURRENT_FOG_COORD))
     glFogCoorddv([3.0])
-    assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD), 3.0)
+    assert_equal(3.0, glGetDoublev(GL_CURRENT_FOG_COORD))
   end
 
   def test_glsecondarycolor
@@ -216,6 +215,4 @@ class TestGl14 < OpenGL::TestCase
     glWindowPos3sv [3, 2, 1]
     assert_each_in_delta [3, 2, 1, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
   end
-
 end
-

data/test/test_gl_15.rb

@@ -19,7 +19,6 @@ class TestGl15 < OpenGL::TestCase
 
   def setup
     super
-
     supported? 1.5
   end
 
@@ -72,7 +71,7 @@ class TestGl15 < OpenGL::TestCase
     r = glUnmapBuffer(GL_ARRAY_BUFFER)
     assert(r == true || r == false)
 
-    glDeleteBuffers(buffers)		
+    glDeleteBuffers(buffers)
     refute glIsBuffer(buffers[0])
 
     # FIXME: GetBufferPointerv not yet implemented
@@ -251,10 +250,9 @@ class TestGl15 < OpenGL::TestCase
     glMultiDrawElements(GL_TRIANGLES, GL_UNSIGNED_BYTE, [3, 3], [0, 3])
 
     count = glRenderMode(GL_RENDER)
-    assert_equal 2 * (3 * 3 + 2), count
+    assert_equal count, 2 * (3 * 3 + 2)
 
     glDisableClientState(GL_VERTEX_ARRAY)
     glDeleteBuffers(buffers)
   end
-
 end

data/test/test_gl_20.rb

@@ -19,48 +19,47 @@ class TestGl20 < OpenGL::TestCase
 
   def setup
     super
-
     supported? 2.0
   end
 
   def test_glblendequationseparate
     glBlendEquationSeparate(GL_MIN, GL_MAX)
-    assert_equal(glGetIntegerv(GL_BLEND_EQUATION_RGB), GL_MIN)
-    assert_equal(glGetIntegerv(GL_BLEND_EQUATION_ALPHA), GL_MAX)
+    assert_equal(GL_MIN, glGetIntegerv(GL_BLEND_EQUATION_RGB))
+    assert_equal(GL_MAX, glGetIntegerv(GL_BLEND_EQUATION_ALPHA))
     glBlendEquationSeparate(GL_MAX, GL_MIN)
-    assert_equal(glGetIntegerv(GL_BLEND_EQUATION_RGB), GL_MAX)
-    assert_equal(glGetIntegerv(GL_BLEND_EQUATION_ALPHA), GL_MIN)
+    assert_equal(GL_MAX, glGetIntegerv(GL_BLEND_EQUATION_RGB))
+    assert_equal(GL_MIN, glGetIntegerv(GL_BLEND_EQUATION_ALPHA))
   end
 
   def test_stencilops
     glStencilOpSeparate(GL_FRONT, GL_ZERO, GL_INCR, GL_DECR)
-    assert_equal(glGetIntegerv(GL_STENCIL_FAIL), GL_ZERO)
-    assert_equal(glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL), GL_INCR)
-    assert_equal(glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS), GL_DECR)
+    assert_equal(GL_ZERO, glGetIntegerv(GL_STENCIL_FAIL))
+    assert_equal(GL_INCR, glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL))
+    assert_equal(GL_DECR, glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS))
     glStencilOpSeparate(GL_FRONT, GL_INCR, GL_DECR, GL_ZERO)
-    assert_equal(glGetIntegerv(GL_STENCIL_FAIL), GL_INCR)
-    assert_equal(glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL), GL_DECR)
-    assert_equal(glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS), GL_ZERO)
+    assert_equal(GL_INCR, glGetIntegerv(GL_STENCIL_FAIL))
+    assert_equal(GL_DECR, glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL))
+    assert_equal(GL_ZERO, glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS))
 
     glStencilFuncSeparate(GL_FRONT, GL_LEQUAL, 1, 0)
-    assert_equal(glGetIntegerv(GL_STENCIL_FUNC), GL_LEQUAL)
-    assert_equal(glGetIntegerv(GL_STENCIL_REF), 1)
-    assert_equal(glGetIntegerv(GL_STENCIL_VALUE_MASK), 0)
+    assert_equal(GL_LEQUAL, glGetIntegerv(GL_STENCIL_FUNC))
+    assert_equal(1, glGetIntegerv(GL_STENCIL_REF))
+    assert_equal(0, glGetIntegerv(GL_STENCIL_VALUE_MASK))
     glStencilFuncSeparate(GL_FRONT, GL_GEQUAL, 0, 1)
-    assert_equal(glGetIntegerv(GL_STENCIL_FUNC), GL_GEQUAL)
-    assert_equal(glGetIntegerv(GL_STENCIL_REF), 0)
-    assert_equal(glGetIntegerv(GL_STENCIL_VALUE_MASK), 1)
+    assert_equal(GL_GEQUAL, glGetIntegerv(GL_STENCIL_FUNC))
+    assert_equal(0, glGetIntegerv(GL_STENCIL_REF))
+    assert_equal(1, glGetIntegerv(GL_STENCIL_VALUE_MASK))
 
     glStencilMaskSeparate(GL_FRONT, 1)
-    assert_equal(glGetIntegerv( GL_STENCIL_WRITEMASK), 1)
+    assert_equal(1, glGetIntegerv( GL_STENCIL_WRITEMASK))
     glStencilMaskSeparate(GL_FRONT, 0)
-    assert_equal(glGetIntegerv(GL_STENCIL_WRITEMASK), 0)
+    assert_equal(0, glGetIntegerv(GL_STENCIL_WRITEMASK))
   end
 
   def test_gldrawbuf
     glDrawBuffers([GL_FRONT_LEFT, GL_BACK_LEFT])
-    assert_equal(glGetIntegerv(GL_DRAW_BUFFER0), GL_FRONT_LEFT)
-    assert_equal(glGetIntegerv(GL_DRAW_BUFFER1), GL_BACK_LEFT)
+    assert_equal(GL_FRONT_LEFT, glGetIntegerv(GL_DRAW_BUFFER0))
+    assert_equal(GL_BACK_LEFT, glGetIntegerv(GL_DRAW_BUFFER1))
   end
 
   def test_glvertexattrib
@@ -230,15 +229,9 @@ uniform ivec3 testivec3;
 uniform ivec4 testivec4;
 
 void main() {
-  testvec1;
-  testvec2;
-  testvec3;
-  testvec4;
-  testivec1;
-  testivec2;
-  testivec3;
-  testivec4;
-  gl_Position = ftransform();
+  gl_Position = ftransform() *
+    testvec1 * testvec2[0] * testvec3[0] * testvec4[0] *
+    float(testivec1) * float(testivec2[0]) * float(testivec3[0]) * float(testivec4[0]);
 }
     SHADER
 
@@ -265,47 +258,47 @@ void main() {
     glUseProgram program
 
     test = glGetAttribLocation program, "test"
-    assert_equal -1, test
+    assert_equal(-1, test)
 
     tv1l = glGetUniformLocation program, "testvec1"
-    refute_equal -1, tv1l, "testvec1 missing!"
+    refute_equal(-1, tv1l, "testvec1 missing!")
 
     tv2l = glGetUniformLocation program, "testvec2"
-    refute_equal -1, tv2l, "testvec2 missing!"
+    refute_equal(-1, tv2l, "testvec2 missing!")
 
     tv3l = glGetUniformLocation program, "testvec3"
-    refute_equal -1, tv3l, "testvec3 missing!"
+    refute_equal(-1, tv3l, "testvec3 missing!")
 
     tv4l = glGetUniformLocation program, "testvec4"
-    refute_equal -1, tv4l, "testvec4 missing!"
+    refute_equal(-1, tv4l, "testvec4 missing!")
 
     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!")
 
     assert_equal [1, GL_FLOAT_VEC4, "gl_Vertex"], glGetActiveAttrib(program, 0)
     assert_equal [1, GL_INT, "testivec1"], glGetActiveUniform(program, tv1il)
 
     # f
     glUniform1f(tv1l, 2.0)
-    assert_equal(glGetUniformfv(program, tv1l), 2.0)
+    assert_equal(2.0, glGetUniformfv(program, tv1l))
     glUniform2f(tv2l, 2.0, 2.0)
     assert_equal([2.0, 2.0], glGetUniformfv(program, tv2l))
     glUniform3f(tv3l, 2.0, 2.0, 2.0)
     assert_equal([2.0, 2.0, 2.0], glGetUniformfv(program, tv3l))
     glUniform4f(tv4l, 2.0, 2.0, 2.0, 2.0)
     assert_equal([2.0, 2.0, 2.0, 2.0], glGetUniformfv(program, tv4l))
-    # i 
+    # i
     glUniform1i(tv1il, 3)
-    assert_equal(glGetUniformiv(program, tv1il), 3)
+    assert_equal(3, glGetUniformiv(program, tv1il))
     glUniform2i(tv2il, 3, 3)
     assert_equal([3, 3], glGetUniformiv(program, tv2il))
     glUniform3i(tv3il, 3, 3, 3)
@@ -314,7 +307,7 @@ void main() {
     assert_equal([3, 3, 3, 3], glGetUniformiv(program, tv4il))
     # fv
     glUniform1fv(tv1l, [3.0])
-    assert_equal(glGetUniformfv(program, tv1l), 3.0)
+    assert_equal(3.0, glGetUniformfv(program, tv1l))
     glUniform2fv(tv2l, [3.0, 3.0])
     assert_equal([3.0, 3.0], glGetUniformfv(program, tv2l))
     glUniform3fv(tv3l, [3.0, 3.0, 3.0])
@@ -323,7 +316,7 @@ void main() {
     assert_equal([3.0, 3.0, 3.0, 3.0], glGetUniformfv(program, tv4l))
     # iv
     glUniform1iv(tv1il, [2])
-    assert_equal(glGetUniformiv(program, tv1il), 2)
+    assert_equal(2, glGetUniformiv(program, tv1il))
     glUniform2iv(tv2il, [2, 2])
     assert_equal([2, 2], glGetUniformiv(program, tv2il))
     glUniform3iv(tv3il, [2, 2, 2])
@@ -344,10 +337,7 @@ uniform mat3 testmat3;
 uniform mat4 testmat4;
 
 void main() {
-  testmat2;
-  testmat3;
-  testmat4;
-  gl_Position = ftransform();
+  gl_Position = ftransform() * testmat2[0][0] * testmat3[0][0] * testmat4[0][0];
 }
     SHADER
 
@@ -383,22 +373,21 @@ void main() {
       uniforms[uniform.last] = i
     end
 
-    glUniformMatrix2fv(uniforms['testmat2'], GL_TRUE, [0, 1, 1, 0])
+    glUniformMatrix2fv(uniforms['testmat2'], GL_TRUE, [0, 1, 2, 3])
 
-    assert_each_in_delta([0, 1, 1, 0],
+    assert_each_in_delta([0, 2, 1, 3],
                          glGetUniformfv(program, uniforms['testmat2']))
 
-    skip "glUniformMatrix3fv complains but I don't know why"
     glUniformMatrix3fv(uniforms['testmat3'], GL_TRUE,
-                       [1, 1, 1, 1, 1, 1, 1, 1, 1])
+                       [0, 1, 2, 3, 4, 5, 6, 7, 8])
 
-    assert_each_in_delta([1, 0, 0, 1, 0, 0, 0, 0, 0],
+    assert_each_in_delta([0, 3, 6, 1, 4, 7, 2, 5, 8],
                          glGetUniformfv(program, uniforms['testmat3']))
 
     glUniformMatrix4fv(uniforms['testmat4'], GL_TRUE,
-                       [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, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0],
+    assert_each_in_delta([0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15],
                          glGetUniformfv(program, uniforms['testmat4']))
   ensure
     glDeleteProgram program
@@ -413,7 +402,7 @@ void main() {
     glBufferData(GL_ARRAY_BUFFER, 8*4, vaa, GL_DYNAMIC_DRAW)
 
     glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, 0)
-    assert_equal(glGetVertexAttribPointerv(1), 0)
+    assert_equal(0, glGetVertexAttribPointerv(1))
 
     glEnableVertexAttribArray(1)
 
@@ -425,6 +414,4 @@ void main() {
     glDisableVertexAttribArray(1)
     glDeleteBuffers(buffers)
   end
-
 end
-

data/test/test_gl_21.rb

@@ -19,7 +19,6 @@ class TestGl21 < OpenGL::TestCase
 
   def setup
     super
-
     supported? 2.1
   end
 
@@ -48,25 +47,25 @@ void main() {
     glShaderSource(vs, vertex_shader_source)
     glCompileShader(vs)
 
-    assert_equal(glGetShaderiv(vs, GL_COMPILE_STATUS), GL_TRUE)
+    assert_equal(GL_TRUE, glGetShaderiv(vs, GL_COMPILE_STATUS))
     glAttachShader(program, vs)
 
-    glLinkProgram(program)	
-    assert_equal(glGetProgramiv(program, GL_LINK_STATUS), GL_TRUE)
+    glLinkProgram(program)
+    assert_equal(GL_TRUE, glGetProgramiv(program, GL_LINK_STATUS))
     glUseProgram(program)
 
     tm23l = glGetUniformLocation(program, "testmat23")
-    refute_equal -1, tm23l, "testmat23 missing!"
+    refute_equal(-1, tm23l, "testmat23 missing!")
     tm32l = glGetUniformLocation(program, "testmat32")
-    refute_equal -1, tm32l, "testmat32 missing!"
+    refute_equal(-1, tm32l, "testmat32 missing!")
     tm24l = glGetUniformLocation(program, "testmat24")
-    refute_equal -1, tm24l, "testmat24 missing!"
+    refute_equal(-1, tm24l, "testmat24 missing!")
     tm42l = glGetUniformLocation(program, "testmat42")
-    refute_equal -1, tm42l, "testmat42 missing!"
+    refute_equal(-1, tm42l, "testmat42 missing!")
     tm34l = glGetUniformLocation(program, "testmat34")
-    refute_equal -1, tm34l, "testmat34 missing!"
+    refute_equal(-1, tm34l, "testmat34 missing!")
     tm43l = glGetUniformLocation(program, "testmat43")
-    refute_equal -1, tm43l, "testmat43 missing!"
+    refute_equal(-1, tm43l, "testmat43 missing!")
 
     refute_equal(-1, glGetUniformLocation(program, "testmat23"),
                  "testmat23 missing!")
@@ -81,50 +80,49 @@ void main() {
     refute_equal(-1, glGetUniformLocation(program, "testmat43"),
                  "testmat43 missing!")
 
-    uniforms = Hash.new do |_, k| raise "invalid uniform #{k}" end
+    uniforms = Hash.new { |_, k| raise "invalid uniform #{k}" }
     (0...glGetProgramiv(program, GL_ACTIVE_UNIFORMS)).each do |i|
       uniform = glGetActiveUniform program, i
       uniforms[uniform.last] = i
     end
 
-    skip "glUniformMatrix2x3fv complains but I don't know why"
     glUniformMatrix2x3fv(uniforms["testmat23"], GL_FALSE, [0, 1, 1, 0, 0, 1])
-    assert_equal(glGetUniformfv(program, uniforms["testmat23"]), [0, 1, 1, 0, 0, 1])
+    assert_equal([0, 1, 1, 0, 0, 1], glGetUniformfv(program, uniforms["testmat23"]))
     glUniformMatrix3x2fv(uniforms["testmat32"], GL_FALSE, [1, 0, 0, 1, 1, 0])
-    assert_equal(glGetUniformfv(program, uniforms["testmat32"]), [1, 0, 0, 1, 1, 0])
+    assert_equal([1, 0, 0, 1, 1, 0], glGetUniformfv(program, uniforms["testmat32"]))
 
     glUniformMatrix2x4fv(uniforms["testmat24"], GL_FALSE, [0, 1, 1, 0, 0, 1, 1, 0])
-    assert_equal(glGetUniformfv(program, uniforms["testmat24"]), [0, 1, 1, 0, 0, 1, 1, 0])
+    assert_equal([0, 1, 1, 0, 0, 1, 1, 0], glGetUniformfv(program, uniforms["testmat24"]))
     glUniformMatrix4x2fv(uniforms["testmat42"], GL_FALSE, [1, 0, 0, 1, 1, 0, 0, 1])
-    assert_equal(glGetUniformfv(program, uniforms["testmat42"]), [1, 0, 0, 1, 1, 0, 0, 1])
+    assert_equal([1, 0, 0, 1, 1, 0, 0, 1], glGetUniformfv(program, uniforms["testmat42"]))
 
     glUniformMatrix3x4fv(uniforms["testmat34"], GL_FALSE, [0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1])
-    assert_equal(glGetUniformfv(program, uniforms["testmat34"]), [0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1])
+    assert_equal([0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1], glGetUniformfv(program, uniforms["testmat34"]))
     glUniformMatrix4x3fv(uniforms["testmat43"], GL_FALSE, [1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0])
-    assert_equal(glGetUniformfv(program, uniforms["testmat43"]), [1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0])
+    assert_equal([1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0], glGetUniformfv(program, uniforms["testmat43"]))
 
     # 2
     m = Matrix.rows([[0, 1], [1, 0], [0, 1]])
     glUniformMatrix2x3fv(uniforms["testmat23"], GL_FALSE, m)
-    assert_equal(glGetUniformfv(program, uniforms["testmat23"]), [0, 1, 1, 0, 0, 1])
+    assert_equal([0, 1, 1, 0, 0, 1], glGetUniformfv(program, uniforms["testmat23"]))
     m = Matrix.rows([[0, 1, 1], [0, 0, 1]])
     glUniformMatrix3x2fv(uniforms["testmat32"], GL_FALSE, m)
-    assert_equal(glGetUniformfv(program, uniforms["testmat32"]), [0, 1, 1, 0, 0, 1])
+    assert_equal([0, 1, 1, 0, 0, 1], glGetUniformfv(program, uniforms["testmat32"]))
 
     m = Matrix.rows([[0, 1], [1, 0], [0, 1], [1, 0]])
     glUniformMatrix2x4fv(uniforms["testmat24"], GL_FALSE, m)
-    assert_equal(glGetUniformfv(program, uniforms["testmat24"]), [0, 1, 1, 0, 0, 1, 1, 0])
+    assert_equal([0, 1, 1, 0, 0, 1, 1, 0], glGetUniformfv(program, uniforms["testmat24"]))
     m = Matrix.rows([[0, 1, 1, 1], [0, 0, 1, 1]])
     glUniformMatrix4x2fv(uniforms["testmat42"], GL_FALSE, m)
-    assert_equal(glGetUniformfv(program, uniforms["testmat42"]), [0, 1, 1, 1, 0, 0, 1, 1])
+    assert_equal([0, 1, 1, 1, 0, 0, 1, 1], glGetUniformfv(program, uniforms["testmat42"]))
 
     m = Matrix.rows([[0, 1, 0], [1, 0, 1], [0, 1, 0], [1, 0, 1]])
     glUniformMatrix3x4fv(uniforms["testmat34"], GL_FALSE, m)
-    assert_equal(glGetUniformfv(program, uniforms["testmat34"]), [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
+    assert_equal([0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1], glGetUniformfv(program, uniforms["testmat34"]))
 
     m = Matrix.rows([[0, 1, 1, 1], [0, 0, 1, 1], [1, 1, 0, 0]])
     glUniformMatrix4x3fv(uniforms["testmat43"], GL_FALSE, m)
-    assert_equal(glGetUniformfv(program, uniforms["testmat43"]), [0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0])
+    assert_equal([0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0], glGetUniformfv(program, uniforms["testmat43"]))
 
     # 3
     assert_raises ArgumentError do glUniformMatrix2x3fv(uniforms["testmat23"], GL_FALSE, [1, 2, 3, 4]) end
@@ -136,6 +134,7 @@ void main() {
   end
 
   def test_pixelunpack_bitmap
+    skip("Segfaults on Mesa until upstream fixes it")
     glOrtho(0, WINDOW_SIZE, 0, WINDOW_SIZE, 0, -1)
 
     bitmap = [ 0x55 ] * 8 # 64 bits (8x8 bitmap), stipple pattern
@@ -148,47 +147,7 @@ void main() {
 
     glBitmap(8, 8, 0, 0, 0, 0, 0)
     data = glReadPixels(0, 0, 8, 8, GL_RED, GL_UNSIGNED_BYTE)
-    assert_equal(data.unpack("C*"), [0, 255] * 32)
-
-    glDeleteBuffers(buffers)
-  end
-
-  def test_pixelunpack_color_convolution
-    ct = ([0]*3+[1]*3+[0]*3+[1]*3).pack("f*")
-    ct2 = ([1]*3+[0]*3+[1]*3+[0]*3).pack("f*")
-
-    buffers = glGenBuffers(2)
-    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[0])
-    glBufferData(GL_PIXEL_UNPACK_BUFFER, 4*3*4, ct, GL_DYNAMIC_DRAW)
-
-    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[1])
-    glBufferData(GL_PIXEL_UNPACK_BUFFER, 4*3*4, ct2, GL_DYNAMIC_DRAW)
-
-    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[0])
-    glColorTable(GL_COLOR_TABLE, GL_RGB8, 4, GL_RGB, GL_FLOAT, 0)
-    assert_equal(glGetColorTable(GL_COLOR_TABLE, GL_RGB, GL_FLOAT), ct)
-    glConvolutionFilter1D(GL_CONVOLUTION_1D, GL_RGB8, 4, GL_RGB, GL_FLOAT, 0)
-    assert_equal(glGetConvolutionFilter(GL_CONVOLUTION_1D, GL_RGB, GL_FLOAT), ct)
-
-    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[1])
-    glColorSubTable(GL_COLOR_TABLE, 0, 4, GL_RGB, GL_FLOAT, 0)
-    assert_equal(glGetColorTable(GL_COLOR_TABLE, GL_RGB, GL_FLOAT), ct2)
-    glConvolutionFilter2D(GL_CONVOLUTION_2D, GL_RGB8, 2, 2, GL_RGB, GL_FLOAT, 0)
-    assert_equal(glGetConvolutionFilter(GL_CONVOLUTION_2D, GL_RGB, GL_FLOAT), ct2)
-
-    glDeleteBuffers(buffers)
-  end
-
-  def test_pixelunpack_separable
-    sf_a = ([0]*3+[1]*3).pack("f*")
-    sf_b = ([1]*3+[0]*3).pack("f*")
-
-    buffers = glGenBuffers(1)
-    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[0])
-    glBufferData(GL_PIXEL_UNPACK_BUFFER, 2*3*4 *2, sf_a + sf_b, GL_DYNAMIC_DRAW)
-
-    glSeparableFilter2D(GL_SEPARABLE_2D, GL_RGB8, 2, 2, GL_RGB, GL_FLOAT, 0, 2*3*4)
-    assert_equal(glGetSeparableFilter(GL_SEPARABLE_2D, GL_RGB, GL_FLOAT), [sf_a, sf_b])
+    assert_equal([0, 255] * 32, data.unpack("C*"))
 
     glDeleteBuffers(buffers)
   end
@@ -206,7 +165,7 @@ void main() {
     glDrawPixels(4, 4, GL_RGB, GL_FLOAT, 0)
 
     data = glReadPixels(0, 0, 4, 4, GL_RGB, GL_FLOAT)
-    assert_equal(data, image)
+    assert_equal(image, data)
 
     glDeleteBuffers(buffers)
   end
@@ -218,7 +177,7 @@ void main() {
     glBufferData(GL_PIXEL_UNPACK_BUFFER, 128, stipple, GL_DYNAMIC_DRAW)
 
     glPolygonStipple(0)
-    assert_equal(glGetPolygonStipple(), stipple)
+    assert_equal(stipple, glGetPolygonStipple())
     glDeleteBuffers(buffers)
   end
 
@@ -247,7 +206,7 @@ void main() {
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[0])
     begin
       glCompressedTexImage1D(GL_TEXTURE_1D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 4, 0, 16, 0)
-      assert_equal(glGetCompressedTexImage(GL_TEXTURE_1D, 0), image_1)
+      assert_equal(image_1, glGetCompressedTexImage(GL_TEXTURE_1D, 0))
     rescue Gl::Error => err
       assert(err.id == GL_INVALID_ENUM || err.id == GL_INVALID_OPERATION)
     end
@@ -255,7 +214,7 @@ void main() {
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[1])
     begin
       glCompressedTexSubImage1D(GL_TEXTURE_1D, 0, 0, 4, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 16, 0)
-      assert_equal(glGetCompressedTexImage(GL_TEXTURE_1D, 0), image_2)
+      assert_equal(image_2, glGetCompressedTexImage(GL_TEXTURE_1D, 0))
     rescue Gl::Error => err
       assert(err.id == GL_INVALID_ENUM || err.id == GL_INVALID_OPERATION)
     end
@@ -263,17 +222,17 @@ void main() {
     # 2D
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[0])
     glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 2, 2, 0, 16, 0)
-    assert_equal(glGetCompressedTexImage(GL_TEXTURE_2D, 0), image_1)
+    assert_equal(image_1, glGetCompressedTexImage(GL_TEXTURE_2D, 0))
 
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[1])
     glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 2, 2, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 16, 0)
-    assert_equal(glGetCompressedTexImage(GL_TEXTURE_2D, 0), image_2)
+    assert_equal(image_2, glGetCompressedTexImage(GL_TEXTURE_2D, 0))
 
     # 3D
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[0])
     begin
       glCompressedTexImage3D(GL_TEXTURE_3D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 2, 2, 1, 0, 16, 0)
-      assert_equal(glGetCompressedTexImage(GL_TEXTURE_3D, 0), image_1)
+      assert_equal(image_1, glGetCompressedTexImage(GL_TEXTURE_3D, 0))
     rescue Gl::Error => err
       assert(err.id == GL_INVALID_ENUM || err.id == GL_INVALID_OPERATION)
     end
@@ -281,7 +240,7 @@ void main() {
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[1])
     begin
       glCompressedTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 2, 2, 1, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 16, 0)
-      assert_equal(glGetCompressedTexImage(GL_TEXTURE_3D, 0), image_2)
+      assert_equal(image_2, glGetCompressedTexImage(GL_TEXTURE_3D, 0))
     rescue Gl::Error => err
       assert(err.id == GL_INVALID_ENUM || err.id == GL_INVALID_OPERATION)
     end
@@ -306,22 +265,22 @@ void main() {
 
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[0])
     glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB8, 2, 2, 4, 0, GL_RGB, GL_FLOAT, 0)
-    assert_equal(glGetTexImage(GL_TEXTURE_3D, 0, GL_RGB, GL_FLOAT), image_1)
+    assert_equal(image_1, glGetTexImage(GL_TEXTURE_3D, 0, GL_RGB, GL_FLOAT))
 
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[1])
     glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 2, 2, 4, GL_RGB, GL_FLOAT, 0)
-    assert_equal(glGetTexImage(GL_TEXTURE_3D, 0, GL_RGB, GL_FLOAT), image_2)
+    assert_equal(image_2, glGetTexImage(GL_TEXTURE_3D, 0, GL_RGB, GL_FLOAT))
 
     # 2D
     glBindTexture(GL_TEXTURE_2D, textures[1])
 
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[0])
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, 4, 4, 0, GL_RGB, GL_FLOAT, 0)
-    assert_equal(glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_FLOAT), image_1)
+    assert_equal(image_1, glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_FLOAT))
 
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[1])
     glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGB, GL_FLOAT, 0)
-    assert_equal(glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_FLOAT), image_2)
+    assert_equal(image_2, glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_FLOAT))
 
     # 1D
     glBindTexture(GL_TEXTURE_1D, textures[2])
@@ -329,11 +288,11 @@ void main() {
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[0])
 
     glTexImage1D(GL_TEXTURE_1D, 0, GL_RGB8, 16, 0, GL_RGB, GL_FLOAT, 0)
-    assert_equal(glGetTexImage(GL_TEXTURE_1D, 0, GL_RGB, GL_FLOAT), image_1)
+    assert_equal(image_1, glGetTexImage(GL_TEXTURE_1D, 0, GL_RGB, GL_FLOAT))
 
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffers[1])
     glTexSubImage1D(GL_TEXTURE_1D, 0, 0, 16, GL_RGB, GL_FLOAT, 0)
-    assert_equal(glGetTexImage(GL_TEXTURE_1D, 0, GL_RGB, GL_FLOAT), image_2)
+    assert_equal(image_2, glGetTexImage(GL_TEXTURE_1D, 0, GL_RGB, GL_FLOAT))
 
     glDeleteBuffers(buffers)
     glDeleteTextures(textures)
@@ -349,13 +308,13 @@ void main() {
     glBufferData(GL_PIXEL_UNPACK_BUFFER, 4*4+4*4+4*2, data_1+data_2+data_3, GL_DYNAMIC_DRAW)
 
     glPixelMapfv(GL_PIXEL_MAP_I_TO_I, 4, 0)
-    assert_equal(glGetPixelMapfv(GL_PIXEL_MAP_I_TO_I), [1, 2, 3, 4])
+    assert_equal([1, 2, 3, 4], glGetPixelMapfv(GL_PIXEL_MAP_I_TO_I))
 
     glPixelMapuiv(GL_PIXEL_MAP_I_TO_I, 4, 4*4)
-    assert_equal(glGetPixelMapuiv(GL_PIXEL_MAP_I_TO_I), [5, 6, 7, 8])
+    assert_equal([5, 6, 7, 8], glGetPixelMapuiv(GL_PIXEL_MAP_I_TO_I))
 
     glPixelMapusv(GL_PIXEL_MAP_I_TO_I, 4, 4*4+4*4)
-    assert_equal(glGetPixelMapusv(GL_PIXEL_MAP_I_TO_I), [9, 10, 11, 12])
+    assert_equal([9, 10, 11, 12], glGetPixelMapusv(GL_PIXEL_MAP_I_TO_I))
 
     glDeleteBuffers(buffers)
   end
@@ -373,7 +332,7 @@ void main() {
     glReadPixels(0, 0, 4, 4, GL_RGB, GL_FLOAT, 0)
 
     data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
-    assert_equal(data, image)
+    assert_equal(image, data)
     glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
 
     glDeleteBuffers(buffers)
@@ -384,7 +343,7 @@ void main() {
     glBindBuffer(GL_PIXEL_PACK_BUFFER, buffers[0])
     glBufferData(GL_PIXEL_PACK_BUFFER_ARB, 4*4, nil, GL_STREAM_READ)
 
-    # fv	
+    # fv
     glPixelMapfv(GL_PIXEL_MAP_I_TO_I, [1, 2, 3, 4])
     glGetPixelMapfv(GL_PIXEL_MAP_I_TO_I, 0)
 
@@ -400,7 +359,7 @@ void main() {
     assert_equal([5, 6, 7, 8].pack("I*"), data)
     glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
 
-    # usv	
+    # usv
     glBufferData(GL_PIXEL_PACK_BUFFER_ARB, 4*2, nil, GL_STREAM_READ)
 
     glPixelMapusv(GL_PIXEL_MAP_I_TO_I, [9, 10, 11, 12])
@@ -430,80 +389,6 @@ void main() {
     glDeleteBuffers(buffers)
   end
 
-  def test_pixelpack_separablefilter
-    sf_a = ([0]*3+[1]*3).pack("f*")
-    sf_b = ([1]*3+[0]*3).pack("f*")
-
-    buffers = glGenBuffers(1)
-    glBindBuffer(GL_PIXEL_PACK_BUFFER, buffers[0])
-    glBufferData(GL_PIXEL_PACK_BUFFER_ARB, 6*4 + 6*4, nil, GL_STREAM_READ)
-
-    glSeparableFilter2D(GL_SEPARABLE_2D, GL_RGB8, 2, 2, GL_RGB, GL_FLOAT, sf_a, sf_b)
-    glGetSeparableFilter(GL_SEPARABLE_2D, GL_RGB, GL_FLOAT, 0, 6*4, 0)
-
-    data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
-    assert_equal(data, sf_a + sf_b)
-    glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
-
-    glDeleteBuffers(buffers)
-  end
-
-  def test_pixelpack_convolutionfilter
-    cf = ([0]*3+[1]*3+[0]*3+[1]*3).pack("f*")
-
-    buffers = glGenBuffers(1)
-    glBindBuffer(GL_PIXEL_PACK_BUFFER, buffers[0])
-    glBufferData(GL_PIXEL_PACK_BUFFER_ARB, 3*4*4, nil, GL_STREAM_READ)
-
-    glConvolutionFilter1D(GL_CONVOLUTION_1D, GL_RGB8, 4, GL_RGB, GL_FLOAT, cf)
-
-    glGetConvolutionFilter(GL_CONVOLUTION_1D, GL_RGB, GL_FLOAT, 0)
-    data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
-    assert_equal(data, cf)
-    glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
-
-    glDeleteBuffers(buffers)
-  end
-
-  def test_pixelpack_histogram
-    glEnable(GL_HISTOGRAM)
-
-    glHistogram(GL_HISTOGRAM, 1, GL_RGB8, GL_FALSE)
-
-    buffers = glGenBuffers(1)
-    glBindBuffer(GL_PIXEL_PACK_BUFFER, buffers[0])
-    glBufferData(GL_PIXEL_PACK_BUFFER_ARB, 3*4, nil, GL_STREAM_READ)
-
-    glDrawPixels(2, 1, GL_RGB, GL_FLOAT, [1, 1, 1, 1, 1, 1].pack("f*"))
-    glGetHistogram(GL_HISTOGRAM, GL_FALSE, GL_RGB, GL_FLOAT, 0)
-
-    data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
-    assert_equal(data.unpack("f*"), [2, 2, 2])
-    glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
-
-    glDeleteBuffers(buffers)
-    glDisable(GL_HISTOGRAM)
-  end
-
-  def test_pixelpack_minmax
-    glEnable(GL_MINMAX)		
-
-    glMinmax(GL_MINMAX, GL_RGB8, GL_FALSE)
-
-    buffers = glGenBuffers(1)
-    glBindBuffer(GL_PIXEL_PACK_BUFFER, buffers[0])
-    glBufferData(GL_PIXEL_PACK_BUFFER_ARB, 6*4, nil, GL_STREAM_READ)
-
-    glDrawPixels(2, 1, GL_RGB, GL_FLOAT, [0, 0, 0, 1, 1, 1].pack("f*"))
-    glGetMinmax(GL_MINMAX, GL_FALSE, GL_RGB, GL_FLOAT, 0)
-    data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
-    assert_equal(data.unpack("f*"), [0, 0, 0, 1, 1, 1])
-    glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
-
-    glDeleteBuffers(buffers)
-    glDisable(GL_MINMAX)
-  end
-
   def test_pixelpack_teximage
     textures = glGenTextures(1)
     glBindTexture(GL_TEXTURE_2D, textures[0])
@@ -518,7 +403,7 @@ void main() {
     glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_FLOAT, 0)
 
     data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
-    assert_equal(data, image)
+    assert_equal(image, data)
     glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
 
     glDeleteBuffers(buffers)
@@ -542,12 +427,10 @@ void main() {
     glGetCompressedTexImage(GL_TEXTURE_2D, 0, 0)
 
     data = glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY)
-    assert_equal(data, image)
+    assert_equal(image, data)
     glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB)
 
     glDeleteBuffers(buffers)
     glDeleteTextures(textures)
   end
-
 end
-