opengl 0.8.0 → 0.9.0

data/ext/opengl/opengl.c

@@ -1,13 +1,7 @@
 #include "common.h"
 
 void Init_gl(void);
-void Init_glu(void);
-void Init_glut(void);
-void Init_glut_callbacks(void);
 
 DLLEXPORT void Init_opengl() {
-  Init_gl();
-  Init_glu();
-  Init_glut();
-  Init_glut_callbacks();
+	Init_gl();
 }

data/lib/opengl.rb

@@ -21,69 +21,33 @@
 # and to Bill Kelly for a version before that one.
 
 module OpenGL
-
-  VERSION = '0.8.0'
-
+  VERSION = '0.9.0'
 end
 
-require 'opengl/opengl'
-
-include Gl,Glu,Glut
+begin
+  RUBY_VERSION =~ /(\d+.\d+)/
+  require "opengl/#{$1}/opengl"
+rescue LoadError
+  require 'opengl/opengl'
+end
 
 # (Gl.)glVertex -> GL.Vertex
 # (Gl::)GL_TRUE -> GL::TRUE
 module GL
-	extend self
-	include Gl
-
-	Gl.constants.each do |cn|
-		n = cn.to_s.sub(/^GL_/,'')
-		# due to ruby naming scheme, we can't export constants with leading decimal,
-		# e.g. (Gl::)GL_2D would under old syntax become (GL::)2D which is illegal
-		next if n =~ /^[0-9]/
-		const_set( n, Gl.const_get( cn ) )
-	end
-
-	Gl.methods( false ).each do |mn|
-		n = mn.to_s.sub(/^gl/,'')
-		alias_method( n, mn )
-		public( n )
-	end
-end
-
-# (Glu.)gluSphere -> GLU.Sphere
-# (Glu::)GLU_INSIDE -> GLU::INSIDE
-module GLU
-	extend self
-	include Glu
-
-	Glu.constants.each do |cn|
-		n = cn.to_s.sub(/^GLU_/,'')
-		const_set( n, Glu.const_get( cn ) )
-	end
-
-	Glu.methods( false ).each do |mn|
-		n = mn.to_s.sub(/^glu/,'')
-		alias_method( n, mn )
-		public( n )
-	end
-end
-
-# (Glut.)glutInit -> GLUT.Init
-# (Glut::)GLUT_RGBA -> GLUT::RGBA
-module GLUT
-	extend self
-	include Glut
-
-	Glut.constants.each do |cn|
-		n = cn.to_s.sub(/^GLUT_/,'')
-		next if n =~ /^[0-9]/
-		const_set( n, Glut.const_get( cn ) )
-	end
-
-	Glut.methods( false ).each do |mn|
-		n = mn.to_s.sub(/^glut/,'')
-		alias_method( n, mn )
-		public( n )
-	end
+  extend self
+  include Gl
+
+  Gl.constants.each do |cn|
+    n = cn.to_s.sub(/^GL_/,'')
+    # due to ruby naming scheme, we can't export constants with leading decimal,
+    # e.g. (Gl::)GL_2D would under old syntax become (GL::)2D which is illegal
+    next if n =~ /^[0-9]/
+    const_set( n, Gl.const_get( cn ) )
+  end
+
+  Gl.methods( false ).each do |mn|
+    n = mn.to_s.sub(/^gl/,'')
+    alias_method( n, mn )
+    public( n )
+  end
 end

data/lib/opengl/test_case.rb

@@ -64,7 +64,7 @@ class OpenGL::TestCase < MiniTest::Unit::TestCase
 
     # in case there is an GL error that escaped error checking routines ...
     error = glGetError
-    assert_equal error, 0, gluErrorString(error)
+    assert_equal 0, error, gluErrorString(error)
 
     glutDestroyWindow @window
   end
@@ -84,4 +84,3 @@ class OpenGL::TestCase < MiniTest::Unit::TestCase
   end
 
 end
-

data/test/dummy.xorg.conf

@@ -0,0 +1,140 @@
+# This file is used to setup a dummy X server for testing on http://travis-ci.org
+# See config file ".travis.yml"
+
+##Xdummy:##
+Section "ServerFlags"
+  Option "DontVTSwitch" "true"
+  Option "AllowMouseOpenFail" "true"
+  Option "PciForceNone" "true"
+  Option "AutoEnableDevices" "false"
+  Option "AutoAddDevices" "false"
+EndSection
+
+Section "Module"
+  Load "/usr/lib/xorg/modules/extensions/libglx.so"
+EndSection
+
+Section "Extensions"
+  Option "GLX" "Enable"
+  Option "NV-GLX" "Disable"
+EndSection
+
+
+##Xdummy:##
+Section "InputDevice"
+  Identifier "NoMouse"
+  Option "CorePointer" "true"
+  Driver "void"
+EndSection
+
+Section "InputDevice"
+  Identifier "NoKeyboard"
+  Option "CoreKeyboard" "true"
+  Driver "void"
+EndSection
+
+##Xdummy:##
+Section "Device"
+  Identifier "Videocard0"
+  Driver "dummy"
+  #VideoRam 4096000
+  VideoRam 256000
+EndSection
+
+##Xdummy:##
+Section "Monitor"
+  Identifier "Monitor0"
+  HorizSync   10.0 - 300.0
+  VertRefresh 10.0 - 200.0
+  DisplaySize 4335 1084
+  #The following modeline is invalid (calculator overflowed):
+  #Modeline "32000x32000@0" -38917.43 32000 32032 -115848 -115816 32000 32775 32826 33601
+  Modeline "16384x8192@10" 2101.93 16384 16416 24400 24432 8192 8390 8403 8602
+  Modeline "8192x4096@10" 424.46 8192 8224 9832 9864 4096 4195 4202 4301
+  Modeline "5120x3200@10" 199.75 5120 5152 5904 5936 3200 3277 3283 3361
+  Modeline "3840x2880@10" 133.43 3840 3872 4376 4408 2880 2950 2955 3025
+  Modeline "3840x2560@10" 116.93 3840 3872 4312 4344 2560 2622 2627 2689
+  Modeline "3840x2048@10" 91.45 3840 3872 4216 4248 2048 2097 2101 2151
+  Modeline "2048x2048@10" 49.47 2048 2080 2264 2296 2048 2097 2101 2151
+  Modeline "2560x1600@10" 47.12 2560 2592 2768 2800 1600 1639 1642 1681
+  Modeline "1920x1200@10" 26.28 1920 1952 2048 2080 1200 1229 1231 1261
+  Modeline "1920x1080@10" 23.53 1920 1952 2040 2072 1080 1106 1108 1135
+  Modeline "1680x1050@10" 20.08 1680 1712 1784 1816 1050 1075 1077 1103
+  Modeline "1600x900@20" 33.92 1600 1632 1760 1792 900 921 924 946
+  Modeline "1440x900@20" 30.66 1440 1472 1584 1616 900 921 924 946
+  Modeline "1360x768@20" 24.49 1360 1392 1480 1512 768 786 789 807
+  #common resolutions for android devices (both orientations):
+  Modeline "800x1280@20" 25.89 800 832 928 960 1280 1310 1315 1345
+  Modeline "1280x800@20" 24.15 1280 1312 1400 1432 800 819 822 841
+  Modeline "720x1280@25" 30.22 720 752 864 896 1280 1309 1315 1345
+  Modeline "1280x720@25" 27.41 1280 1312 1416 1448 720 737 740 757
+  Modeline "768x1024@25" 24.93 768 800 888 920 1024 1047 1052 1076
+  Modeline "1024x768@25" 23.77 1024 1056 1144 1176 768 785 789 807
+  Modeline "600x1024@25" 19.90 600 632 704 736 1024 1047 1052 1076
+  Modeline "1024x600@25" 18.26 1024 1056 1120 1152 600 614 617 631
+  Modeline "536x960@25" 16.74 536 568 624 656 960 982 986 1009
+  Modeline "960x536@25" 15.23 960 992 1048 1080 536 548 551 563
+  Modeline "600x800@25" 15.17 600 632 688 720 800 818 822 841
+  Modeline "800x600@25" 14.50 800 832 880 912 600 614 617 631
+  Modeline "480x854@25" 13.34 480 512 560 592 854 873 877 897
+  Modeline "848x480@25" 12.09 848 880 920 952 480 491 493 505
+  Modeline "480x800@25" 12.43 480 512 552 584 800 818 822 841
+  Modeline "800x480@25" 11.46 800 832 872 904 480 491 493 505
+  Modeline "320x480@50" 10.73 320 352 392 424 480 490 494 505
+  Modeline "480x320@50" 9.79 480 512 544 576 320 327 330 337
+  Modeline "240x400@50" 6.96 240 272 296 328 400 408 412 421
+  Modeline "400x240@50" 6.17 400 432 448 480 240 245 247 253
+  Modeline "240x320@50" 5.47 240 272 288 320 320 327 330 337
+  Modeline "320x240@50" 5.10 320 352 368 400 240 245 247 253
+  #resolutions for android devices (both orientations)
+  #minus the status bar
+  #38px status bar (and width rounded up)
+  Modeline "800x1242@20" 25.03 800 832 920 952 1242 1271 1275 1305
+  Modeline "1280x762@20" 22.93 1280 1312 1392 1424 762 780 783 801
+  Modeline "720x1242@25" 29.20 720 752 856 888 1242 1271 1276 1305
+  Modeline "1280x682@25" 25.85 1280 1312 1408 1440 682 698 701 717
+  Modeline "768x986@25" 23.90 768 800 888 920 986 1009 1013 1036
+  Modeline "1024x730@25" 22.50 1024 1056 1136 1168 730 747 750 767
+  Modeline "600x986@25" 19.07 600 632 704 736 986 1009 1013 1036
+  Modeline "1024x562@25" 17.03 1024 1056 1120 1152 562 575 578 591
+  Modeline "536x922@25" 16.01 536 568 624 656 922 943 947 969
+  Modeline "960x498@25" 14.09 960 992 1040 1072 498 509 511 523
+  Modeline "600x762@25" 14.39 600 632 680 712 762 779 783 801
+  Modeline "800x562@25" 13.52 800 832 880 912 562 575 578 591
+  Modeline "480x810@25" 12.59 480 512 552 584 810 828 832 851
+  Modeline "848x442@25" 11.09 848 880 920 952 442 452 454 465
+  Modeline "480x762@25" 11.79 480 512 552 584 762 779 783 801
+  Modeline "800x442@25" 10.51 800 832 864 896 442 452 454 465
+  #32px status bar (no need for rounding):
+  Modeline "320x448@50" 9.93 320 352 384 416 448 457 461 471
+  Modeline "480x288@50" 8.75 480 512 544 576 288 294 297 303
+  #24px status bar:
+  Modeline "240x376@50" 6.49 240 272 296 328 376 384 387 395
+  Modeline "400x216@50" 5.50 400 432 448 480 216 220 222 227
+  Modeline "240x296@50" 5.02 240 272 288 320 296 302 305 311
+  Modeline "320x216@50" 4.55 320 352 368 400 216 220 222 227
+EndSection
+
+##Xdummy:##
+Section "Screen"
+  Identifier "Screen0"
+  Device "Videocard0"
+  Monitor "Monitor0"
+  DefaultDepth 24
+  SubSection "Display"
+    Viewport 0 0
+    Depth 24
+    Modes "32000x32000" "16384x8192" "8192x4096" "5120x3200" "3840x2880" "3840x2560" "3840x2048" "2048x2048" "2560x1600" "1920x1440" "1920x1200" "1920x1080" "1600x1200" "1680x1050" "1600x900" "1400x1050" "1440x900" "1280x1024" "1366x768" "1280x800" "1024x768" "1024x600" "800x600" "320x200"
+    #Virtual 32000 32000
+    #Virtual 16384 8192
+    #Virtual 8192 4096
+    Virtual 1920 1440
+  EndSubSection
+EndSection
+
+Section "ServerLayout"
+  Identifier   "dummy_layout"
+  Screen       "screen0"
+  InputDevice  "NoMouse"
+  InputDevice  "NoKeyboard"
+EndSection

data/test/test_gl.rb

@@ -14,29 +14,25 @@
 #
 
 require 'opengl/test_case'
-require 'gl'
-require 'glut'
-include Gl
-include Glut
 
 class TestGl < OpenGL::TestCase
-	def test_isavailable
-		assert_equal(is_available?(1.1),true)
-		assert_equal(is_available?("GL_ARB_multitexture"),true)
-		assert_equal(is_available?("GL_NON_EXISTENT"),false)
-	end
+  def test_isavailable
+    assert_equal(true, is_available?(1.1))
+    assert_equal(true, is_available?("GL_ARB_multitexture"))
+    assert_equal(false, is_available?("GL_NON_EXISTENT"))
+  end
 
-	def test_errorchecking
-		Gl.disable_error_checking
-		assert_equal(Gl.is_error_checking_enabled?,false)
-		Gl.enable_error_checking
-		assert_equal(Gl.is_error_checking_enabled?,true)
-		begin
-			glEnable(0)	
-		rescue Gl::Error => err
-		  assert_equal(err.id,GL_INVALID_ENUM)
-		else
-			assert(false) # error not detected
-		end
-	end
+  def test_errorchecking
+    Gl.disable_error_checking
+    assert_equal(false, Gl.is_error_checking_enabled?)
+    Gl.enable_error_checking
+    assert_equal(true, Gl.is_error_checking_enabled?)
+    begin
+      glEnable(0)
+    rescue Gl::Error => err
+      assert_equal(err.id, GL_INVALID_ENUM)
+    else
+      assert(false) # error not detected
+    end
+  end
 end

data/test/test_gl_10_11.rb

@@ -25,60 +25,60 @@ class TestGl10_11 < OpenGL::TestCase
 
   def test_glindex
     glIndexd(2.0)
-    assert_in_delta(glGetDoublev(GL_CURRENT_INDEX),2.0,0.001)
+    assert_in_delta(2.0, glGetDoublev(GL_CURRENT_INDEX), 0.001)
     glIndexdv([3.0])
-    assert_in_delta(glGetDoublev(GL_CURRENT_INDEX),3.0,0.001)
+    assert_in_delta(3.0, glGetDoublev(GL_CURRENT_INDEX), 0.001)
 
     glIndexf(4.0)
-    assert_in_delta(glGetFloatv(GL_CURRENT_INDEX),4.0,0.001)
+    assert_in_delta(4.0, glGetFloatv(GL_CURRENT_INDEX), 0.001)
     glIndexfv([5.0])
-    assert_in_delta(glGetFloatv(GL_CURRENT_INDEX),5.0,0.001)
+    assert_in_delta(5.0, glGetFloatv(GL_CURRENT_INDEX), 0.001)
 
     glIndexi(6)
-    assert_in_delta(glGetIntegerv(GL_CURRENT_INDEX),6,0.001)
+    assert_in_delta(6, glGetIntegerv(GL_CURRENT_INDEX), 0.001)
     glIndexiv([7])
-    assert_in_delta(glGetIntegerv(GL_CURRENT_INDEX),7,0.001)
+    assert_in_delta(7, glGetIntegerv(GL_CURRENT_INDEX), 0.001)
 
     glIndexs(8)
-    assert_in_delta(glGetIntegerv(GL_CURRENT_INDEX),8,0.001)
+    assert_in_delta(8, glGetIntegerv(GL_CURRENT_INDEX), 0.001)
     glIndexsv([9])
-    assert_in_delta(glGetIntegerv(GL_CURRENT_INDEX),9,0.001)
+    assert_in_delta(9, glGetIntegerv(GL_CURRENT_INDEX), 0.001)
 
     glIndexub(10)
-    assert_in_delta(glGetIntegerv(GL_CURRENT_INDEX),10,0.001)
+    assert_in_delta(10, glGetIntegerv(GL_CURRENT_INDEX), 0.001)
     glIndexubv([11])
-    assert_in_delta(glGetIntegerv(GL_CURRENT_INDEX),11,0.001)
+    assert_in_delta(11, glGetIntegerv(GL_CURRENT_INDEX), 0.001)
 
     # index pointer
-    glIndexPointer(GL_INT,2,"")
-    assert_equal(glGetIntegerv(GL_INDEX_ARRAY_STRIDE),2)
-    assert_equal(glGetIntegerv(GL_INDEX_ARRAY_TYPE),GL_INT)
+    glIndexPointer(GL_INT, 2, "")
+    assert_equal(2, glGetIntegerv(GL_INDEX_ARRAY_STRIDE))
+    assert_equal(GL_INT, glGetIntegerv(GL_INDEX_ARRAY_TYPE))
   end
 
   def test_glclear
     glClearColor(1,0,1,0)
-    assert_equal(glGetDoublev(GL_COLOR_CLEAR_VALUE),[1,0,1,0])
+    assert_equal([1,0,1,0], glGetDoublev(GL_COLOR_CLEAR_VALUE))
 
     glClearIndex(2)
-    assert_equal(glGetDoublev(GL_INDEX_CLEAR_VALUE),2)
+    assert_equal(2, glGetDoublev(GL_INDEX_CLEAR_VALUE))
 
     glClearAccum(0.5,0.5,0.5,0.5)
-    assert_equal(glGetDoublev(GL_ACCUM_CLEAR_VALUE),[0.5,0.5,0.5,0.5])
+    assert_equal([0.5,0.5,0.5,0.5], glGetDoublev(GL_ACCUM_CLEAR_VALUE))
 
     glClearStencil(1)
-    assert_equal(glGetIntegerv(GL_STENCIL_CLEAR_VALUE),1)
+    assert_equal(1, glGetIntegerv(GL_STENCIL_CLEAR_VALUE))
 
     glClearDepth(0.5)
-    assert_equal(glGetDoublev(GL_DEPTH_CLEAR_VALUE),0.5)
+    assert_equal(0.5, glGetDoublev(GL_DEPTH_CLEAR_VALUE))
   end
 
   def test_glclientattrib
     glPixelStorei(GL_PACK_ALIGNMENT,2)
     glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT)
     glPixelStorei(GL_PACK_ALIGNMENT,4)
-    assert_equal(glGetIntegerv(GL_PACK_ALIGNMENT),4)
+    assert_equal(4, glGetIntegerv(GL_PACK_ALIGNMENT))
     glPopClientAttrib()
-    assert_equal(glGetIntegerv(GL_PACK_ALIGNMENT),2)
+    assert_equal(2, glGetIntegerv(GL_PACK_ALIGNMENT))
   end
 
   def test_matrix
@@ -97,21 +97,21 @@ class TestGl10_11 < OpenGL::TestCase
       [0.0,0.0,1.0,0.0],
       [0.0,0.0,0.0,1.0]]
 
-    # 1	 
+    # 1
     glMatrixMode(GL_MODELVIEW)
     glLoadMatrixf(m_a)
-    assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m_a)
+    assert_equal(m_a, glGetDoublev(GL_MODELVIEW_MATRIX))
     glLoadMatrixd(m_b)
-    assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m_b)
+    assert_equal(m_b, glGetDoublev(GL_MODELVIEW_MATRIX))
 
     glLoadIdentity()
-    assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m_ident)
+    assert_equal( m_ident, glGetDoublev(GL_MODELVIEW_MATRIX))
 
     glMultMatrixf(m_a)
-    assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m_a)
+    assert_equal(m_a, glGetDoublev(GL_MODELVIEW_MATRIX))
     glLoadIdentity()
     glMultMatrixd(m_b)
-    assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m_b)
+    assert_equal(m_b, glGetDoublev(GL_MODELVIEW_MATRIX))
 
     # 2
     glMatrixMode(GL_MODELVIEW)
@@ -119,31 +119,31 @@ class TestGl10_11 < OpenGL::TestCase
     glMatrixMode(GL_PROJECTION)
     glLoadMatrixf(m_b)
 
-    assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m_a)
-    assert_equal(glGetDoublev(GL_PROJECTION_MATRIX), m_b)
+    assert_equal(m_a, glGetDoublev(GL_MODELVIEW_MATRIX))
+    assert_equal(m_b, glGetDoublev(GL_PROJECTION_MATRIX))
 
     glMatrixMode(GL_MODELVIEW)
     glLoadMatrixf(m_a)
     glPushMatrix()
     glLoadMatrixf(m_b)
-    assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m_b)
+    assert_equal(m_b, glGetDoublev(GL_MODELVIEW_MATRIX))
     glPopMatrix()
-    assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m_a)
+    assert_equal(m_a, glGetDoublev(GL_MODELVIEW_MATRIX))
 
     # 3
     m = Matrix.rows([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])
     glMatrixMode(GL_MODELVIEW)
     glLoadMatrixf(m)
-    assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m.to_a)
+    assert_equal(m.to_a, glGetDoublev(GL_MODELVIEW_MATRIX))
     glLoadIdentity()
     glLoadMatrixd(m)
-    assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m.to_a)
+    assert_equal(m.to_a, glGetDoublev(GL_MODELVIEW_MATRIX))
     glLoadIdentity()
     glMultMatrixf(m)
-    assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m.to_a)
+    assert_equal(m.to_a, glGetDoublev(GL_MODELVIEW_MATRIX))
     glLoadIdentity()
     glMultMatrixd(m)
-    assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m.to_a)
+    assert_equal(m.to_a, glGetDoublev(GL_MODELVIEW_MATRIX))
 
     assert_raises ArgumentError do glLoadMatrixf([1,2,3,4]) end
     assert_raises ArgumentError do glLoadMatrixd([1,2,3,4]) end
@@ -153,63 +153,63 @@ class TestGl10_11 < OpenGL::TestCase
 
   def test_gledge
     glEdgeFlag(GL_FALSE)
-    assert_equal(glGetBooleanv(GL_EDGE_FLAG),false)
+    assert_equal(false, glGetBooleanv(GL_EDGE_FLAG))
 
     glEdgeFlag(GL_TRUE)
-    assert_equal(glGetBooleanv(GL_EDGE_FLAG),true)
+    assert_equal(true, glGetBooleanv(GL_EDGE_FLAG))
 
     glEdgeFlagv([GL_FALSE])
-    assert_equal(glGetBooleanv(GL_EDGE_FLAG),false)
+    assert_equal(false, glGetBooleanv(GL_EDGE_FLAG))
   end
 
   def test_clientstate
     glEnableClientState(GL_COLOR_ARRAY)
-    assert_equal(glIsEnabled(GL_COLOR_ARRAY),true)
+    assert_equal(true, glIsEnabled(GL_COLOR_ARRAY))
     glDisableClientState(GL_COLOR_ARRAY)
-    assert_equal(glIsEnabled(GL_COLOR_ARRAY),false)
+    assert_equal(false, glIsEnabled(GL_COLOR_ARRAY))
   end
 
   def test_glshademodel
     glShadeModel(GL_FLAT)
-    assert_equal(glGetIntegerv(GL_SHADE_MODEL),GL_FLAT)
+    assert_equal(GL_FLAT, glGetIntegerv(GL_SHADE_MODEL))
     glShadeModel(GL_SMOOTH)
-    assert_equal(glGetIntegerv(GL_SHADE_MODEL),GL_SMOOTH)
+    assert_equal(GL_SMOOTH, glGetIntegerv(GL_SHADE_MODEL))
   end
 
   def test_glclipplane
     glClipPlane(GL_CLIP_PLANE0,[1,2,3,4])
-    assert_equal(glGetClipPlane(GL_CLIP_PLANE0),[1,2,3,4])
+    assert_equal([1,2,3,4], glGetClipPlane(GL_CLIP_PLANE0))
   end
 
   def test_polygonoffset
     glPolygonOffset(2.0,3.0)
-    assert_equal(glGetDoublev(GL_POLYGON_OFFSET_FACTOR),2.0)
-    assert_equal(glGetDoublev(GL_POLYGON_OFFSET_UNITS),3.0)
+    assert_equal(2.0, glGetDoublev(GL_POLYGON_OFFSET_FACTOR))
+    assert_equal(3.0, glGetDoublev(GL_POLYGON_OFFSET_UNITS))
   end
 
   def test_glviewport
     glViewport(1,2,3,4)
-    assert_equal(glGetIntegerv(GL_VIEWPORT), [1,2,3,4])
+    assert_equal([1,2,3,4], glGetIntegerv(GL_VIEWPORT))
   end
 
   def test_mask
     glStencilMask(2)
-    assert_equal(glGetIntegerv(GL_STENCIL_WRITEMASK), 2)
+    assert_equal( 2, glGetIntegerv(GL_STENCIL_WRITEMASK))
     glStencilMask(1)
-    assert_equal(glGetIntegerv(GL_STENCIL_BACK_WRITEMASK), 1)
+    assert_equal( 1, glGetIntegerv(GL_STENCIL_BACK_WRITEMASK))
 
     glColorMask(GL_TRUE,GL_FALSE,GL_TRUE,GL_FALSE)
-    assert_equal(glGetBooleanv(GL_COLOR_WRITEMASK),[true,false,true,false])
+    assert_equal([true,false,true,false], glGetBooleanv(GL_COLOR_WRITEMASK))
 
     glDepthMask(GL_TRUE)
-    assert_equal(glGetBooleanv(GL_DEPTH_WRITEMASK),true)
+    assert_equal(true, glGetBooleanv(GL_DEPTH_WRITEMASK))
     glDepthMask(GL_FALSE)
-    assert_equal(glGetBooleanv(GL_DEPTH_WRITEMASK),false)
+    assert_equal(false, glGetBooleanv(GL_DEPTH_WRITEMASK))
 
     glIndexMask(2)
-    assert_equal(glGetIntegerv(GL_INDEX_WRITEMASK), 2)
+    assert_equal(2, glGetIntegerv(GL_INDEX_WRITEMASK))
     glIndexMask(1)
-    assert_equal(glGetIntegerv(GL_INDEX_WRITEMASK), 1)
+    assert_equal(1, glGetIntegerv(GL_INDEX_WRITEMASK))
   end
 
   def test_glflush
@@ -219,7 +219,7 @@ class TestGl10_11 < OpenGL::TestCase
       glEnd
     rescue Gl::Error => err
       assert(err.id == GL_INVALID_OPERATION)
-    end	
+    end
   end
 
   def test_glfinish
@@ -229,7 +229,7 @@ class TestGl10_11 < OpenGL::TestCase
       glEnd
     rescue Gl::Error => err
       assert(err.id == GL_INVALID_OPERATION)
-    end	
+    end
   end
 
   def test_glgetstring
@@ -238,26 +238,26 @@ class TestGl10_11 < OpenGL::TestCase
 
   def test_glscissor
     glScissor(1,2,3,4)
-    assert_equal(glGetIntegerv(GL_SCISSOR_BOX),[1,2,3,4])
+    assert_equal([1,2,3,4], glGetIntegerv(GL_SCISSOR_BOX))
   end
 
   def test_glstencilfunc
     glStencilFunc(GL_LEQUAL,2,3)
-    assert_equal(glGetIntegerv(GL_STENCIL_FUNC),GL_LEQUAL)
-    assert_equal(glGetIntegerv(GL_STENCIL_REF),2)
-    assert_equal(glGetIntegerv(GL_STENCIL_VALUE_MASK),3)
+    assert_equal(GL_LEQUAL, glGetIntegerv(GL_STENCIL_FUNC))
+    assert_equal(2, glGetIntegerv(GL_STENCIL_REF))
+    assert_equal(3, glGetIntegerv(GL_STENCIL_VALUE_MASK))
   end
 
   def test_glstencilop
     glStencilOp(GL_ZERO,GL_REPLACE,GL_INCR)
-    assert_equal(glGetIntegerv(GL_STENCIL_FAIL),GL_ZERO)
-    assert_equal(glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL),GL_REPLACE)
-    assert_equal(glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS),GL_INCR)
+    assert_equal(GL_ZERO, glGetIntegerv(GL_STENCIL_FAIL))
+    assert_equal(GL_REPLACE, glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL))
+    assert_equal(GL_INCR, glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS))
   end
 
   def test_gllogicop
     glLogicOp(GL_NAND)
-    assert_equal(glGetIntegerv(GL_LOGIC_OP_MODE),GL_NAND)
+    assert_equal(GL_NAND, glGetIntegerv(GL_LOGIC_OP_MODE))
   end
 
   def test_glfrustum
@@ -265,68 +265,68 @@ class TestGl10_11 < OpenGL::TestCase
     glLoadIdentity()
 
     glFrustum(1,2,3,4,5,6)
-    assert_equal(glGetDoublev(GL_PROJECTION_MATRIX),[[10.0, 0.0, 0.0, 0.0], [0.0, 10.0, 0.0, 0.0], [3.0, 7.0, -11.0, -1.0], [0.0, 0.0, -60.0, 0.0]])
+    assert_equal([[10.0, 0.0, 0.0, 0.0], [0.0, 10.0, 0.0, 0.0], [3.0, 7.0, -11.0, -1.0], [0.0, 0.0, -60.0, 0.0]], glGetDoublev(GL_PROJECTION_MATRIX))
   end
 
   def test_gldepthrange
     glDepthRange(0.5,0.5)
-    assert_equal(glGetDoublev(GL_DEPTH_RANGE),[0.5,0.5])
+    assert_equal([0.5,0.5], glGetDoublev(GL_DEPTH_RANGE))
   end
 
   def test_func
-    glAlphaFunc(GL_GREATER,0.5)
-    assert_equal(glGetIntegerv(GL_ALPHA_TEST_FUNC),GL_GREATER)
-    assert_equal(glGetDoublev(GL_ALPHA_TEST_REF),0.5)
+    glAlphaFunc(GL_GREATER, 0.5)
+    assert_equal(GL_GREATER, glGetIntegerv(GL_ALPHA_TEST_FUNC))
+    assert_equal(0.5, glGetDoublev(GL_ALPHA_TEST_REF))
 
     glBlendFunc(GL_CONSTANT_ALPHA, GL_ONE_MINUS_DST_COLOR)
-    assert_equal(glGetIntegerv(GL_BLEND_SRC),GL_CONSTANT_ALPHA)
-    assert_equal(glGetIntegerv(GL_BLEND_DST),GL_ONE_MINUS_DST_COLOR)
+    assert_equal(GL_CONSTANT_ALPHA, glGetIntegerv(GL_BLEND_SRC))
+    assert_equal(GL_ONE_MINUS_DST_COLOR, glGetIntegerv(GL_BLEND_DST))
 
     glDepthFunc(GL_LEQUAL)
-    assert_equal(glGetIntegerv(GL_DEPTH_FUNC),GL_LEQUAL)
+    assert_equal(GL_LEQUAL, glGetIntegerv(GL_DEPTH_FUNC))
   end
 
   def test_glpixelzoom
     glPixelZoom(0.5,0.5)
-    assert_equal(glGetDoublev(GL_ZOOM_X),0.5)
-    assert_equal(glGetDoublev(GL_ZOOM_Y),0.5)
+    assert_equal(0.5, glGetDoublev(GL_ZOOM_X))
+    assert_equal(0.5, glGetDoublev(GL_ZOOM_Y))
   end
 
   def test_glpixelstore
     glPixelStoref(GL_PACK_IMAGE_HEIGHT,5)
-    assert_equal(glGetIntegerv(GL_PACK_IMAGE_HEIGHT),5)
+    assert_equal(5, glGetIntegerv(GL_PACK_IMAGE_HEIGHT))
     glPixelStorei(GL_PACK_IMAGE_HEIGHT,6)
-    assert_equal(glGetIntegerv(GL_PACK_IMAGE_HEIGHT),6)
+    assert_equal(6, glGetIntegerv(GL_PACK_IMAGE_HEIGHT))
   end
 
   def test_glpixeltransfer
     glPixelTransferf(GL_RED_SCALE,2)
-    assert_equal(glGetIntegerv(GL_RED_SCALE),2)
+    assert_equal(2, glGetIntegerv(GL_RED_SCALE))
     glPixelTransferi(GL_RED_SCALE,3)
-    assert_equal(glGetIntegerv(GL_RED_SCALE),3)
+    assert_equal(3, glGetIntegerv(GL_RED_SCALE))
   end
 
   def test_pixelmap
     glPixelMapfv(GL_PIXEL_MAP_I_TO_I,[1,2,3,4])
-    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,[5,6,7,8])
-    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,[9,10,11,12])
-    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))
   end
 
   def test_buffers
     glDrawBuffer(GL_FRONT)
-    assert_equal(glGetIntegerv(GL_DRAW_BUFFER),GL_FRONT)
+    assert_equal(GL_FRONT, glGetIntegerv(GL_DRAW_BUFFER))
     glDrawBuffer(GL_BACK)
-    assert_equal(glGetIntegerv(GL_DRAW_BUFFER),GL_BACK)
+    assert_equal(GL_BACK, glGetIntegerv(GL_DRAW_BUFFER))
 
     glReadBuffer(GL_FRONT)
-    assert_equal(glGetIntegerv(GL_READ_BUFFER),GL_FRONT)
+    assert_equal(GL_FRONT, glGetIntegerv(GL_READ_BUFFER))
     glReadBuffer(GL_BACK)
-    assert_equal(glGetIntegerv(GL_READ_BUFFER),GL_BACK)
+    assert_equal(GL_BACK, glGetIntegerv(GL_READ_BUFFER))
   end
 
   def test__selection_buffer
@@ -350,8 +350,8 @@ class TestGl10_11 < OpenGL::TestCase
     data = buf.unpack("i*")
     assert(count==1) # number of records
     assert(data[0]==1) # number of hits in this record
-    #		assert(data[1]>0) # zbuffer near
-    #		assert(data[2]>0) # zbuffer far
+    #    assert(data[1]>0) # zbuffer near
+    #    assert(data[2]>0) # zbuffer far
     assert(data[3]==6) # name of hit
   end
 
@@ -370,12 +370,12 @@ class TestGl10_11 < OpenGL::TestCase
 
     count = glRenderMode(GL_RENDER)
     data = buf.unpack("f*")
-    assert_equal(count,10) # (1 + 1 + 3x2) + (1 + 1)
-    assert_equal(data[0],GL_POLYGON_TOKEN)
-    assert_equal(data[1],3) # 3 vertices
+    assert_equal(10, count) # (1 + 1 + 3x2) + (1 + 1)
+    assert_equal(GL_POLYGON_TOKEN, data[0])
+    assert_equal(3, data[1]) # 3 vertices
     # skip rasterized vertex data
-    assert_equal(data[8],GL_PASS_THROUGH_TOKEN)
-    assert_equal(data[9],2.0)
+    assert_equal(GL_PASS_THROUGH_TOKEN, data[8])
+    assert_equal(2.0, data[9])
   end
 
   def test_glrasterposv
@@ -390,69 +390,69 @@ class TestGl10_11 < OpenGL::TestCase
     glOrtho 0, WINDOW_SIZE, 0, WINDOW_SIZE, 0, -1
 
     glRasterPos2d(1.0,2.0)
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1.0,2.0,0.0,1.0])
+    assert_equal([1.0,2.0,0.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glRasterPos2dv([3.0,4.0])
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[3.0,4.0,0.0,1.0])
+    assert_equal([3.0,4.0,0.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
 
     glRasterPos2f(1.0,2.0)
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1.0,2.0,0.0,1.0])
+    assert_equal([1.0,2.0,0.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glRasterPos2fv([3.0,4.0])
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[3.0,4.0,0.0,1.0])
+    assert_equal([3.0,4.0,0.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
 
     glRasterPos2i(1,2)
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1.0,2.0,0.0,1.0])
+    assert_equal([1.0,2.0,0.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glRasterPos2iv([3,4])
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[3.0,4.0,0.0,1.0])
+    assert_equal([3.0,4.0,0.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
 
     glRasterPos2s(1,2)
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1.0,2.0,0.0,1.0])
+    assert_equal([1.0,2.0,0.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glRasterPos2sv([3,4])
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[3.0,4.0,0.0,1.0])
+    assert_equal([3.0,4.0,0.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
   end
 
   def test_glrasterpos_3
     glOrtho 0, WINDOW_SIZE, 0, WINDOW_SIZE, 0, -1
 
     glRasterPos3d(1.0,2.0,1.0)
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1.0,2.0,1.0,1.0])
+    assert_equal([1.0,2.0,1.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glRasterPos3dv([3.0,4.0,0.0])
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[3.0,4.0,0.0,1.0])
+    assert_equal([3.0,4.0,0.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
 
     glRasterPos3f(1.0,2.0,1.0)
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1.0,2.0,1.0,1.0])
+    assert_equal([1.0,2.0,1.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glRasterPos3fv([3.0,4.0,0.0])
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[3.0,4.0,0.0,1.0])
+    assert_equal([3.0,4.0,0.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
 
     glRasterPos3i(1,2,1)
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1.0,2.0,1.0,1.0])
+    assert_equal([1.0,2.0,1.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glRasterPos3iv([3,4,0])
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[3.0,4.0,0.0,1.0])
+    assert_equal([3.0,4.0,0.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
 
     glRasterPos3s(1,2,1)
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1.0,2.0,1.0,1.0])
+    assert_equal([1.0,2.0,1.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glRasterPos3sv([3,4,0])
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[3.0,4.0,0.0,1.0])
+    assert_equal([3.0,4.0,0.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
 
     # 4
     glRasterPos4d(1.0,2.0,1.0,1.0)
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1.0,2.0,1.0,1.0])
+    assert_equal([1.0,2.0,1.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glRasterPos4dv([3.0,4.0,0.0,1.0])
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[3.0,4.0,0.0,1.0])
+    assert_equal([3.0,4.0,0.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
 
     glRasterPos4f(1.0,2.0,1.0,1.0)
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1.0,2.0,1.0,1.0])
+    assert_equal([1.0,2.0,1.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glRasterPos4fv([3.0,4.0,0.0,1.0])
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[3.0,4.0,0.0,1.0])
+    assert_equal([3.0,4.0,0.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
 
     glRasterPos4i(1,2,1,1)
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1.0,2.0,1.0,1.0])
+    assert_equal([1.0,2.0,1.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glRasterPos4iv([3,4,0,1])
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[3.0,4.0,0.0,1.0])
+    assert_equal([3.0,4.0,0.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
 
     glRasterPos4s(1,2,1,1)
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[1.0,2.0,1.0,1.0])
+    assert_equal([1.0,2.0,1.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
     glRasterPos4sv([3,4,0,1])
-    assert_equal(glGetDoublev(GL_CURRENT_RASTER_POSITION),[3.0,4.0,0.0,1.0])
+    assert_equal([3.0,4.0,0.0,1.0], glGetDoublev(GL_CURRENT_RASTER_POSITION))
   end
 
   def test_glbitmap
@@ -465,7 +465,7 @@ class TestGl10_11 < OpenGL::TestCase
 
     glBitmap(8,8,0,0,0,0,bitmap.pack("c*"))
     data = glReadPixels(0,0,8,8,GL_RED,GL_UNSIGNED_BYTE)
-    assert_equal(data.unpack("C*"),[0,255] * 32)
+    assert_equal([0,255] * 32, data.unpack("C*"))
   end
 
   def test_glfog
@@ -478,7 +478,7 @@ class TestGl10_11 < OpenGL::TestCase
     glFogi(GL_FOG_MODE,GL_EXP)
     assert_equal(glGetIntegerv(GL_FOG_MODE),GL_EXP)
     glFogiv(GL_FOG_MODE,[GL_EXP2])
-    assert_equal(glGetIntegerv(GL_FOG_MODE),GL_EXP2)
+    assert_equal(GL_EXP2, glGetIntegerv(GL_FOG_MODE))
   end
 
   def test_glcolorv
@@ -593,7 +593,7 @@ class TestGl10_11 < OpenGL::TestCase
     glMatrixMode(GL_PROJECTION)
     glLoadIdentity()
     glOrtho(0,WINDOW_SIZE,0,WINDOW_SIZE,0,-1)
-    assert_equal(glGetDoublev(GL_PROJECTION_MATRIX),res)
+    assert_equal(res, glGetDoublev(GL_PROJECTION_MATRIX))
   end
 
   def test_glnormal
@@ -610,10 +610,10 @@ class TestGl10_11 < OpenGL::TestCase
     assert_equal([4.0, 5.0, 6.0], glGetDoublev(GL_CURRENT_NORMAL))
 
     glNormal3i(1, 2, 3)
-    assert_equal([0, 1, 2], glGetIntegerv(GL_CURRENT_NORMAL))
+    assert_equal([1, 2, 3], glGetIntegerv(GL_CURRENT_NORMAL))
 
     glNormal3iv([4, 5, 6])
-    assert_equal([3, 4, 5], glGetIntegerv(GL_CURRENT_NORMAL))
+    assert_equal([4, 5, 6], glGetIntegerv(GL_CURRENT_NORMAL))
 
     glNormal3b(2**7-1, 0, 2**7-1)
     assert_each_in_delta([1.0, 0.0, 1.0], glGetDoublev(GL_CURRENT_NORMAL))
@@ -630,13 +630,13 @@ class TestGl10_11 < OpenGL::TestCase
 
   def test_gllight
     glLightf(GL_LIGHT0,GL_SPOT_CUTOFF,80.0)
-    assert_equal(glGetLightfv(GL_LIGHT0,GL_SPOT_CUTOFF),80.0)
+    assert_equal(80.0, glGetLightfv(GL_LIGHT0,GL_SPOT_CUTOFF))
     glLighti(GL_LIGHT0,GL_SPOT_CUTOFF,75)
-    assert_equal(glGetLightiv(GL_LIGHT0,GL_SPOT_CUTOFF),75)
+    assert_equal(75, glGetLightiv(GL_LIGHT0,GL_SPOT_CUTOFF))
     glLightfv(GL_LIGHT0,GL_AMBIENT,[0.5,0.5,0.5,1.0])
-    assert_equal(glGetLightfv(GL_LIGHT0,GL_AMBIENT), [0.5,0.5,0.5,1.0])
+    assert_equal([0.5,0.5,0.5,1.0], glGetLightfv(GL_LIGHT0,GL_AMBIENT))
     glLightiv(GL_LIGHT0,GL_CONSTANT_ATTENUATION,[32])
-    assert_equal(glGetLightiv(GL_LIGHT0,GL_CONSTANT_ATTENUATION),32)
+    assert_equal(32, glGetLightiv(GL_LIGHT0,GL_CONSTANT_ATTENUATION))
   end
 
   def test_glmaterial
@@ -644,24 +644,24 @@ class TestGl10_11 < OpenGL::TestCase
     assert_equal([0.0,1.0,0.0,1.0], glGetMaterialfv(GL_FRONT,GL_AMBIENT))
 
     glMaterialiv(GL_FRONT,GL_SHININESS,[50])
-    assert_equal(glGetMaterialiv(GL_FRONT,GL_SHININESS),50)
+    assert_equal(50, glGetMaterialiv(GL_FRONT,GL_SHININESS))
 
     glMaterialf(GL_FRONT,GL_SHININESS,49.0)
-    assert_equal(glGetMaterialfv(GL_FRONT,GL_SHININESS),49.0)
+    assert_equal(49.0, glGetMaterialfv(GL_FRONT,GL_SHININESS))
 
     glMateriali(GL_FRONT,GL_SHININESS,48)
-    assert_equal(glGetMaterialiv(GL_FRONT,GL_SHININESS),48)
+    assert_equal(48, glGetMaterialiv(GL_FRONT,GL_SHININESS))
 
   end
 
   def test_glcolormaterial
     glColorMaterial(GL_FRONT,GL_EMISSION)
-    assert_equal(glGetIntegerv(GL_COLOR_MATERIAL_FACE),GL_FRONT)
-    assert_equal(glGetIntegerv(GL_COLOR_MATERIAL_PARAMETER),GL_EMISSION)
+    assert_equal(GL_FRONT, glGetIntegerv(GL_COLOR_MATERIAL_FACE))
+    assert_equal(GL_EMISSION, glGetIntegerv(GL_COLOR_MATERIAL_PARAMETER))
 
     glColorMaterial(GL_BACK,GL_SPECULAR)
-    assert_equal(glGetIntegerv(GL_COLOR_MATERIAL_FACE),GL_BACK)
-    assert_equal(glGetIntegerv(GL_COLOR_MATERIAL_PARAMETER),GL_SPECULAR)
+    assert_equal(GL_BACK, glGetIntegerv(GL_COLOR_MATERIAL_FACE))
+    assert_equal(GL_SPECULAR, glGetIntegerv(GL_COLOR_MATERIAL_PARAMETER))
   end
 
   def test_gllightmodel
@@ -675,7 +675,7 @@ class TestGl10_11 < OpenGL::TestCase
     assert_equal([0.5, 0.5, 0.5, 1.0], glGetDoublev(GL_LIGHT_MODEL_AMBIENT))
 
     glLightModeliv(GL_LIGHT_MODEL_AMBIENT, [2, 0, 2, 0])
-    assert_equal([1, 0, 1, 0], glGetIntegerv(GL_LIGHT_MODEL_AMBIENT))
+    assert_equal([2, 0, 2, 0], glGetIntegerv(GL_LIGHT_MODEL_AMBIENT))
   end
 
   def test_gltexcoordv
@@ -762,80 +762,80 @@ class TestGl10_11 < OpenGL::TestCase
 
   def test_glenable_disable
     glEnable(GL_FOG)
-    assert_equal(glIsEnabled(GL_FOG),true)
+    assert_equal(true, glIsEnabled(GL_FOG))
     glDisable(GL_FOG)
-    assert_equal(glIsEnabled(GL_FOG),false)
+    assert_equal(false, glIsEnabled(GL_FOG))
   end
 
   def test_gltexparameter
     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP)
-    assert_equal(glGetTexParameteriv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S),GL_CLAMP)
+    assert_equal(GL_CLAMP, glGetTexParameteriv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S))
 
     glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_MIRRORED_REPEAT)
-    assert_equal(glGetTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S),GL_MIRRORED_REPEAT)
+    assert_equal(GL_MIRRORED_REPEAT, glGetTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S))
 
     glTexParameteriv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,[GL_CLAMP])
-    assert_equal(glGetTexParameteriv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S),GL_CLAMP)
+    assert_equal(GL_CLAMP, glGetTexParameteriv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S))
 
     glTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,[GL_MIRRORED_REPEAT])
-    assert_equal(glGetTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S),GL_MIRRORED_REPEAT)
+    assert_equal(GL_MIRRORED_REPEAT, glGetTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S))
 
-    assert_equal(glGetTexLevelParameterfv(GL_TEXTURE_2D,0,GL_TEXTURE_WIDTH),0.0)
-    assert_equal(glGetTexLevelParameteriv(GL_TEXTURE_2D,0,GL_TEXTURE_WIDTH),0)
+    assert_equal(0.0, glGetTexLevelParameterfv(GL_TEXTURE_2D,0,GL_TEXTURE_WIDTH))
+    assert_equal(0, glGetTexLevelParameteriv(GL_TEXTURE_2D,0,GL_TEXTURE_WIDTH))
   end
 
   def test_glcullface
     glCullFace(GL_FRONT)
-    assert_equal(glGetIntegerv(GL_CULL_FACE_MODE),GL_FRONT)
+    assert_equal(GL_FRONT, glGetIntegerv(GL_CULL_FACE_MODE))
     glCullFace(GL_BACK)
-    assert_equal(glGetIntegerv(GL_CULL_FACE_MODE),GL_BACK)
+    assert_equal(GL_BACK, glGetIntegerv(GL_CULL_FACE_MODE))
   end
 
   def test_glfrontface
     glFrontFace(GL_CW)
-    assert_equal(glGetIntegerv(GL_FRONT_FACE),GL_CW)
+    assert_equal(GL_CW, glGetIntegerv(GL_FRONT_FACE))
     glFrontFace(GL_CCW)
-    assert_equal(glGetIntegerv(GL_FRONT_FACE),GL_CCW)
+    assert_equal(GL_CCW, glGetIntegerv(GL_FRONT_FACE))
   end
 
   def test_glpointsize
     glPointSize(2.0)
-    assert_equal(glGetDoublev(GL_POINT_SIZE),2.0)
+    assert_equal(2.0, glGetDoublev(GL_POINT_SIZE))
     glPointSize(3.0)
-    assert_equal(glGetDoublev(GL_POINT_SIZE),3.0)
+    assert_equal(3.0, glGetDoublev(GL_POINT_SIZE))
   end
 
   def test_glpolygonmode
     glPolygonMode(GL_FRONT_AND_BACK,GL_LINE)
-    assert_equal(glGetIntegerv(GL_POLYGON_MODE),[GL_LINE,GL_LINE])
+    assert_equal([GL_LINE,GL_LINE], glGetIntegerv(GL_POLYGON_MODE))
     glPolygonMode(GL_FRONT_AND_BACK,GL_FILL)
-    assert_equal(glGetIntegerv(GL_POLYGON_MODE),[GL_FILL,GL_FILL])
+    assert_equal([GL_FILL,GL_FILL], glGetIntegerv(GL_POLYGON_MODE))
   end
 
   def test_gllinewidth
     glLineWidth(2.0)
-    assert_equal(glGetDoublev(GL_LINE_WIDTH),2.0)
+    assert_equal(2.0, glGetDoublev(GL_LINE_WIDTH))
     glLineWidth(3.0)
-    assert_equal(glGetDoublev(GL_LINE_WIDTH),3.0)
+    assert_equal(3.0, glGetDoublev(GL_LINE_WIDTH))
   end
 
   def test_gllinestipple
     glLineStipple(3,0x1234)
-    assert_equal(glGetIntegerv(GL_LINE_STIPPLE_REPEAT),3)
-    assert_equal(glGetIntegerv(GL_LINE_STIPPLE_PATTERN),0x1234)
+    assert_equal(3, glGetIntegerv(GL_LINE_STIPPLE_REPEAT))
+    assert_equal(0x1234, glGetIntegerv(GL_LINE_STIPPLE_PATTERN))
   end
 
   def test_glpolygonstipple
     stipple = [0x12] * 128
     glPolygonStipple(stipple.pack("c*"))
-    assert_equal(glGetPolygonStipple(),stipple.pack("c*"))
+    assert_equal(stipple.pack("c*"), glGetPolygonStipple())
   end
 
   def parse_feedback_data(data,count)
     c = count / 11
     ret = []
     (0...c).each do |x|
-      i = x *11
+      i = x * 11
       type = data[0+i]
 
       v1 = [data[2+i], data[3+i], data[4+i]]
@@ -895,7 +895,7 @@ class TestGl10_11 < OpenGL::TestCase
 
     ref = [[GL_POLYGON_TOKEN,[[0,0,0],[1,0,0],[1,1,0]]]] * 8
 
-    assert_equal(parse_feedback_data(data,count),ref)
+    assert_equal(ref, parse_feedback_data(data,count))
   end
 
   def test_glrect
@@ -919,10 +919,10 @@ class TestGl10_11 < OpenGL::TestCase
     glRectsv([0, 0], [1, 1])
 
     count = glRenderMode GL_RENDER
-    data = buf.unpack("f*")
+    data = buf.unpack("f*")[0, count]
 
     # eight 3d polygons with four points
-    assert_equal 8 * (4 * 3 + 2), count
+    assert_equal 16 * (3 * 3 + 2), count
   end
 
   def test_glrectv
@@ -943,62 +943,62 @@ class TestGl10_11 < OpenGL::TestCase
     glClear(GL_COLOR_BUFFER_BIT)
 
     data = glReadPixels(0,0,1,1,GL_RGB,GL_FLOAT)
-    assert_equal(data.unpack("f*"),[1.0,1.0,1.0])
+    assert_equal([1.0,1.0, 1.0], data.unpack("f*"))
 
     glClearColor(0.0,0.0,0.0,0.0)
     glClear(GL_COLOR_BUFFER_BIT)
 
     data = glReadPixels(0,0,1,1,GL_RGB,GL_FLOAT)
-    assert_equal(data.unpack("f*"),[0.0,0.0,0.0])
+    assert_equal([0.0,0.0,0.0], data.unpack("f*"))
   end
 
   def test_gltexenv
     glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_ADD)
-    assert_equal(glGetTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE),GL_ADD)
+    assert_equal(GL_ADD, glGetTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE))
     glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE)
-    assert_equal(glGetTexEnviv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE),GL_MODULATE)
+    assert_equal(GL_MODULATE, glGetTexEnviv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE))
 
     glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,[GL_ADD])
-    assert_equal(glGetTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE),GL_ADD)
+    assert_equal(GL_ADD, glGetTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE))
     glTexEnviv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,[GL_MODULATE])
-    assert_equal(glGetTexEnviv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE),GL_MODULATE)
+    assert_equal(GL_MODULATE, glGetTexEnviv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE))
   end
 
   def test_gltexgen
     glTexGend(GL_S,GL_TEXTURE_GEN_MODE,GL_REFLECTION_MAP)
-    assert_equal(glGetTexGendv(GL_S,GL_TEXTURE_GEN_MODE),GL_REFLECTION_MAP)
+    assert_equal(GL_REFLECTION_MAP, glGetTexGendv(GL_S,GL_TEXTURE_GEN_MODE))
     glTexGenf(GL_S,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR)
-    assert_equal(glGetTexGenfv(GL_S,GL_TEXTURE_GEN_MODE),GL_EYE_LINEAR)
+    assert_equal(GL_EYE_LINEAR, glGetTexGenfv(GL_S,GL_TEXTURE_GEN_MODE))
     glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_SPHERE_MAP)
-    assert_equal(glGetTexGeniv(GL_S,GL_TEXTURE_GEN_MODE),GL_SPHERE_MAP)
+    assert_equal(GL_SPHERE_MAP, glGetTexGeniv(GL_S,GL_TEXTURE_GEN_MODE))
 
     glTexGendv(GL_S,GL_TEXTURE_GEN_MODE,[GL_REFLECTION_MAP])
-    assert_equal(glGetTexGendv(GL_S,GL_TEXTURE_GEN_MODE),GL_REFLECTION_MAP)
+    assert_equal(GL_REFLECTION_MAP, glGetTexGendv(GL_S,GL_TEXTURE_GEN_MODE))
     glTexGenfv(GL_S,GL_TEXTURE_GEN_MODE,[GL_EYE_LINEAR])
-    assert_equal(glGetTexGenfv(GL_S,GL_TEXTURE_GEN_MODE),GL_EYE_LINEAR)
+    assert_equal(GL_EYE_LINEAR, glGetTexGenfv(GL_S,GL_TEXTURE_GEN_MODE))
     glTexGeniv(GL_S,GL_TEXTURE_GEN_MODE,[GL_SPHERE_MAP])
-    assert_equal(glGetTexGeniv(GL_S,GL_TEXTURE_GEN_MODE),GL_SPHERE_MAP)
+    assert_equal(GL_SPHERE_MAP, glGetTexGeniv(GL_S,GL_TEXTURE_GEN_MODE))
   end
 
   def test_textures
     textures = glGenTextures(2)
-    assert_equal(textures.size, 2)
-    assert_equal(glIsTexture(textures[0]),false)
+    assert_equal(2, textures.size)
+    assert_equal(false, glIsTexture(textures[0]))
     glBindTexture(GL_TEXTURE_2D,textures[0])
-    assert_equal(glIsTexture(textures[0]),true)
+    assert_equal(true, glIsTexture(textures[0]))
 
     image = ([0,0,0,1,1,1] * 8).pack("f*") # 16 RGB pixels
 
     glTexImage2D(GL_TEXTURE_2D,0,GL_RGB8, 4, 4, 0, GL_RGB, GL_FLOAT, image)
-    assert_equal(glGetTexImage(GL_TEXTURE_2D,0,GL_RGB,GL_FLOAT), image)
+    assert_equal(image, glGetTexImage(GL_TEXTURE_2D,0,GL_RGB,GL_FLOAT))
 
     glBindTexture(GL_TEXTURE_1D,textures[1])
 
     glTexImage1D(GL_TEXTURE_1D,0,GL_RGB8, 16, 0, GL_RGB, GL_FLOAT, image)
-    assert_equal(glGetTexImage(GL_TEXTURE_1D,0,GL_RGB,GL_FLOAT), image)
+    assert_equal(image, glGetTexImage(GL_TEXTURE_1D,0,GL_RGB,GL_FLOAT))
 
     glDeleteTextures(textures)
-    assert_equal(glIsTexture(textures[0]),false)
+    assert_equal(false, glIsTexture(textures[0]))
   end
 
   def test_pixels
@@ -1006,13 +1006,13 @@ class TestGl10_11 < OpenGL::TestCase
     glClear(GL_COLOR_BUFFER_BIT)
 
     data = glReadPixels(0,0,4,4,GL_RGB,GL_FLOAT)
-    assert_equal(data.unpack("f*"), [0] * 3 * 16)
+    assert_equal([0] * 3 * 16, data.unpack("f*"))
 
     image = ([1.0] * 3 * 16).pack("f*")
     glDrawPixels(4,4,GL_RGB,GL_FLOAT,image)
 
     data = glReadPixels(0,0,4,4,GL_RGB,GL_FLOAT)
-    assert_equal(data,image)
+    assert_equal(image, data)
 
     #
     glClearColor(0,0,0,0)
@@ -1022,12 +1022,12 @@ class TestGl10_11 < OpenGL::TestCase
     glDrawPixels(4,4,GL_RGB,GL_FLOAT,image)
 
     data = glReadPixels(0,0,4,4,GL_RGB,GL_FLOAT)
-    assert_equal(data,image)
+    assert_equal(image, data)
 
     glCopyPixels(0,2,4,2,GL_COLOR)
 
     data = glReadPixels(0,0,4,4,GL_RGB,GL_FLOAT)
-    assert_equal(data,([1.0] * 3 * 16).pack("f*"))
+    assert_equal(([1.0] * 3 * 16).pack("f*"), data)
   end
 
   def test_gltranslate
@@ -1035,10 +1035,10 @@ class TestGl10_11 < OpenGL::TestCase
     glMatrixMode(GL_MODELVIEW)
     glLoadIdentity()
     glTranslated(1.0,2.0,3.0)
-    assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX),m)
+    assert_equal(m, glGetDoublev(GL_MODELVIEW_MATRIX))
     glLoadIdentity()
     glTranslatef(1.0,2.0,3.0)
-    assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX),m)
+    assert_equal(m, glGetDoublev(GL_MODELVIEW_MATRIX))
   end
 
   def test_glscale
@@ -1046,10 +1046,10 @@ class TestGl10_11 < OpenGL::TestCase
     glMatrixMode(GL_MODELVIEW)
     glLoadIdentity()
     glScaled(1.0,2.0,3.0)
-    assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX),m)
+    assert_equal(m, glGetDoublev(GL_MODELVIEW_MATRIX))
     glLoadIdentity()
     glScalef(1.0,2.0,3.0)
-    assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX),m)
+    assert_equal(m, glGetDoublev(GL_MODELVIEW_MATRIX))
   end
 
   def test_glrotate
@@ -1070,10 +1070,10 @@ class TestGl10_11 < OpenGL::TestCase
     textures = glGenTextures(2)
     glBindTexture(GL_TEXTURE_1D,textures[0])
     glBindTexture(GL_TEXTURE_2D,textures[1])
-    assert_equal(glAreTexturesResident(textures).size,2)
+    assert_equal(2, glAreTexturesResident(textures).size)
     glPrioritizeTextures(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))
 
     tex = ([0,0,0,1,1,1] * 2).pack("f*")
     tex2 = ([1] * 3 * 4).pack("f*")
@@ -1081,26 +1081,26 @@ class TestGl10_11 < OpenGL::TestCase
     # 1d
     glDrawPixels(4,1,GL_RGB,GL_FLOAT,tex)
     glCopyTexImage1D(GL_TEXTURE_1D,0,GL_RGB8,0,0,4,0)
-    assert_equal(glGetTexImage(GL_TEXTURE_1D,0,GL_RGB,GL_FLOAT),tex)
+    assert_equal(tex, glGetTexImage(GL_TEXTURE_1D,0,GL_RGB,GL_FLOAT))
 
     glDrawPixels(4,1,GL_RGB,GL_FLOAT,tex2)
     glCopyTexSubImage1D(GL_TEXTURE_1D,0,0,0,0,4)
-    assert_equal(glGetTexImage(GL_TEXTURE_1D,0,GL_RGB,GL_FLOAT),tex2)
+    assert_equal(tex2, glGetTexImage(GL_TEXTURE_1D,0,GL_RGB,GL_FLOAT))
 
     glTexSubImage1D(GL_TEXTURE_1D,0,0,4,GL_RGB,GL_FLOAT,tex)
-    assert_equal(glGetTexImage(GL_TEXTURE_1D,0,GL_RGB,GL_FLOAT),tex)
+    assert_equal(tex, glGetTexImage(GL_TEXTURE_1D,0,GL_RGB,GL_FLOAT))
 
     # 2d
     glDrawPixels(2,2,GL_RGB,GL_FLOAT,tex)
     glCopyTexImage2D(GL_TEXTURE_2D,0,GL_RGB8,0,0,2,2,0)
-    assert_equal(glGetTexImage(GL_TEXTURE_2D,0,GL_RGB,GL_FLOAT),tex)
+    assert_equal(tex, glGetTexImage(GL_TEXTURE_2D,0,GL_RGB,GL_FLOAT))
 
     glDrawPixels(2,2,GL_RGB,GL_FLOAT,tex2)
     glCopyTexSubImage2D(GL_TEXTURE_2D,0,0,0,0,0,2,2)
-    assert_equal(glGetTexImage(GL_TEXTURE_2D,0,GL_RGB,GL_FLOAT),tex2)
+    assert_equal(tex2, glGetTexImage(GL_TEXTURE_2D,0,GL_RGB,GL_FLOAT))
 
     glTexSubImage2D(GL_TEXTURE_2D,0,0,0,2,2,GL_RGB,GL_FLOAT,tex)
-    assert_equal(glGetTexImage(GL_TEXTURE_2D,0,GL_RGB,GL_FLOAT),tex)
+    assert_equal(tex, glGetTexImage(GL_TEXTURE_2D,0,GL_RGB,GL_FLOAT))
 
     glDeleteTextures(textures)
   end
@@ -1117,35 +1117,35 @@ class TestGl10_11 < OpenGL::TestCase
     ]
 
     glMap1f(GL_MAP1_VERTEX_3,0,100,3,2,control_points)
-    assert_equal(glGetMapfv(GL_MAP1_VERTEX_3,GL_COEFF),control_points)
+    assert_equal(control_points, glGetMapfv(GL_MAP1_VERTEX_3,GL_COEFF))
 
     glMap1d(GL_MAP1_VERTEX_3,0,100,3,2,control_points_2)
-    assert_equal(glGetMapdv(GL_MAP1_VERTEX_3,GL_COEFF),control_points_2)
+    assert_equal(control_points_2, glGetMapdv(GL_MAP1_VERTEX_3,GL_COEFF))
 
-    assert_equal(glGetMapiv(GL_MAP1_VERTEX_3,GL_ORDER),2)
+    assert_equal(2, glGetMapiv(GL_MAP1_VERTEX_3,GL_ORDER))
 
     glMap2f(GL_MAP2_VERTEX_3,0,100,3,1,0,100,3,2,control_points)
-    assert_equal(glGetMapfv(GL_MAP2_VERTEX_3,GL_COEFF),control_points)
+    assert_equal(control_points,glGetMapfv(GL_MAP2_VERTEX_3,GL_COEFF))
 
     glMap2d(GL_MAP2_VERTEX_3,0,100,3,1,0,100,3,2,control_points_2)
-    assert_equal(glGetMapdv(GL_MAP2_VERTEX_3,GL_COEFF),control_points_2)
+    assert_equal(control_points_2, glGetMapdv(GL_MAP2_VERTEX_3,GL_COEFF))
   end
 
   def test_glmapgrid
     glMapGrid1d(2,1,100)
-    assert_equal(glGetIntegerv(GL_MAP1_GRID_SEGMENTS),2)
-    assert_equal(glGetIntegerv(GL_MAP1_GRID_DOMAIN),[1,100])
+    assert_equal(2, glGetIntegerv(GL_MAP1_GRID_SEGMENTS))
+    assert_equal([1,100], glGetIntegerv(GL_MAP1_GRID_DOMAIN))
     glMapGrid1f(3,2,99)
-    assert_equal(glGetIntegerv(GL_MAP1_GRID_SEGMENTS),3)
-    assert_equal(glGetIntegerv(GL_MAP1_GRID_DOMAIN),[2,99])
+    assert_equal(3, glGetIntegerv(GL_MAP1_GRID_SEGMENTS))
+    assert_equal([2,99], glGetIntegerv(GL_MAP1_GRID_DOMAIN))
     #
     glMapGrid2d(2,1,100,3,2,99)
-    assert_equal(glGetIntegerv(GL_MAP2_GRID_SEGMENTS),[2,3])
-    assert_equal(glGetIntegerv(GL_MAP2_GRID_DOMAIN),[1,100,2,99])
+    assert_equal([2,3], glGetIntegerv(GL_MAP2_GRID_SEGMENTS))
+    assert_equal([1,100,2,99], glGetIntegerv(GL_MAP2_GRID_DOMAIN))
 
     glMapGrid2f(3,2,99,4,3,98)
-    assert_equal(glGetIntegerv(GL_MAP2_GRID_SEGMENTS),[3,4])
-    assert_equal(glGetIntegerv(GL_MAP2_GRID_DOMAIN),[2,99,3,98])
+    assert_equal([3,4], glGetIntegerv(GL_MAP2_GRID_SEGMENTS))
+    assert_equal([2,99,3,98], glGetIntegerv(GL_MAP2_GRID_DOMAIN))
   end
 
   def test_gleval
@@ -1219,7 +1219,7 @@ class TestGl10_11 < OpenGL::TestCase
     i2 = ([1.0] * 3 + [0.0] * 3 ).pack("f*")
 
     # init
-    glClearColor(0,0,0,0)	
+    glClearColor(0,0,0,0)
     glClear(GL_ACCUM_BUFFER_BIT | GL_COLOR_BUFFER_BIT)
     # left
     glDrawPixels(2,1,GL_RGB,GL_FLOAT,i1)
@@ -1239,9 +1239,9 @@ class TestGl10_11 < OpenGL::TestCase
     base = glGenLists(2)
     assert(base>0)
     glListBase(1)
-    assert_equal(glGetIntegerv(GL_LIST_BASE),1)
+    assert_equal(1, glGetIntegerv(GL_LIST_BASE))
     glListBase(0)
-    assert_equal(glGetIntegerv(GL_LIST_BASE),0)
+    assert_equal(0, glGetIntegerv(GL_LIST_BASE))
 
     glNewList(base+0, GL_COMPILE)
     glBegin(GL_TRIANGLES)
@@ -1259,11 +1259,11 @@ class TestGl10_11 < OpenGL::TestCase
     glEnd()
     glEndList()
 
-    assert_equal(glIsList(base+0),true)
-    assert_equal(glIsList(base+1),true)
-    assert_equal(glIsList(base+2),false)
+    assert_equal(true, glIsList(base+0))
+    assert_equal(true, glIsList(base+1))
+    assert_equal(false, glIsList(base+2))
 
-    #		
+    #
     buf = glFeedbackBuffer(256,GL_3D)
     glRenderMode(GL_FEEDBACK)
 
@@ -1271,13 +1271,13 @@ class TestGl10_11 < OpenGL::TestCase
     glCallLists(GL_INT,[base+0,base+1])
 
     count = glRenderMode(GL_RENDER)
-    assert_equal(count,(3*3+2) * 3) # 3 triangles
+    assert_equal((3*3+2) * 3, count) # 3 triangles
     #
 
     glDeleteLists(base,2)
 
-    assert_equal(glIsList(base+0),false)
-    assert_equal(glIsList(base+1),false)
+    assert_equal(false, glIsList(base+0))
+    assert_equal(false, glIsList(base+1))
   end
 
   def test_arrays
@@ -1285,7 +1285,7 @@ class TestGl10_11 < OpenGL::TestCase
 
     va = [0, 0, 0, 1, 1, 1].pack("f*")
 
-    glVertexPointer 2, GL_FLOAT, 0, va
+    glVertexPointer 2, GL_FLOAT, 8, va
     assert_equal va,       glGetPointerv(GL_VERTEX_ARRAY_POINTER)
     assert_equal 2,        glGetIntegerv(GL_VERTEX_ARRAY_SIZE)
     assert_equal GL_FLOAT, glGetIntegerv(GL_VERTEX_ARRAY_TYPE)
@@ -1309,7 +1309,7 @@ class TestGl10_11 < OpenGL::TestCase
     glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_BYTE, [0, 1, 2].pack("C*"))
 
     count = glRenderMode(GL_RENDER)
-    assert_equal(count, 44)
+    assert_equal(44, count)
 
     glDisableClientState(GL_VERTEX_ARRAY)
   end
@@ -1320,22 +1320,22 @@ class TestGl10_11 < OpenGL::TestCase
     ea = [0].pack("C*")
     ca = [1, 0, 1, 0].pack("f*")
 
-    glNormalPointer(GL_FLOAT, 0, na)
+    glNormalPointer(GL_FLOAT, 12, na)
     assert_equal(GL_FLOAT, glGetIntegerv(GL_NORMAL_ARRAY_TYPE))
     assert_equal(12, glGetIntegerv(GL_NORMAL_ARRAY_STRIDE))
     assert_equal(na, glGetPointerv(GL_NORMAL_ARRAY_POINTER))
 
-    glTexCoordPointer(4, GL_FLOAT, 0, ta)
+    glTexCoordPointer(4, GL_FLOAT, 16, ta)
     assert_equal(4, glGetIntegerv(GL_TEXTURE_COORD_ARRAY_SIZE))
     assert_equal(GL_FLOAT, glGetIntegerv(GL_TEXTURE_COORD_ARRAY_TYPE))
     assert_equal(16, glGetIntegerv(GL_TEXTURE_COORD_ARRAY_STRIDE))
     assert_equal(ta, glGetPointerv(GL_TEXTURE_COORD_ARRAY_POINTER))
 
-    glEdgeFlagPointer(0, ea)
+    glEdgeFlagPointer(1, ea)
     assert_equal(1, glGetIntegerv(GL_EDGE_FLAG_ARRAY_STRIDE))
     assert_equal(ea, glGetPointerv(GL_EDGE_FLAG_ARRAY_POINTER))
 
-    glColorPointer(4, GL_FLOAT, 0, ca)
+    glColorPointer(4, GL_FLOAT, 16, ca)
     assert_equal(4, glGetIntegerv(GL_COLOR_ARRAY_SIZE))
     assert_equal(GL_FLOAT, glGetIntegerv(GL_COLOR_ARRAY_TYPE))
     assert_equal(16, glGetIntegerv(GL_COLOR_ARRAY_STRIDE))