ruby-opengl 0.50.0 → 0.60.0

data/test/tc_ext_gremedy.rb

@@ -0,0 +1,36 @@
+#
+# Copyright (C) 2007 Jan Dvorak <jan.dvorak@kraxnet.cz>
+#
+# This program is distributed under the terms of the MIT license.
+# See the included MIT-LICENSE file for the terms of this license.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+require 'test/unit'
+
+class Test_EXT_GREMEDY < Test::Unit::TestCase
+	def setup
+		common_setup()
+	end
+
+	def teardown
+		common_teardown()
+	end
+
+	def test_gl_gremedy_string_marker
+		return if not supported?("GL_GREMEDY_string_marker")
+		glStringMarkerGREMEDY("test")
+	end
+
+	def test_gl_gremedy_frame_terminator
+		return if not supported?("GL_GREMEDY_frame_terminator")
+		glFrameTerminatorGREMEDY()
+	end
+end

data/test/tc_ext_nv.rb

@@ -0,0 +1,357 @@
+
+# Copyright (C) 2007 Jan Dvorak <jan.dvorak@kraxnet.cz>
+#
+# This program is distributed under the terms of the MIT license.
+# See the included MIT-LICENSE file for the terms of this license.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+require 'test/unit'
+
+class Test_EXT_NV < Test::Unit::TestCase
+	def setup
+		common_setup()
+	end
+
+	def teardown
+		common_teardown()
+	end
+
+	def test_gl_nv_vertex_program
+		return if not supported?("GL_NV_vertex_program")
+	
+		assert_equal(glIsProgramNV(0),false)
+		programs = glGenProgramsNV(2)
+		assert_equal(programs.size,2)
+		
+		program = "!!VSP1.0\nEND"
+	
+	  glBindProgramNV(GL_VERTEX_PROGRAM_NV, programs[1])
+		glLoadProgramNV(GL_VERTEX_STATE_PROGRAM_NV, programs[0], program)
+		assert_equal(glGetProgramStringNV(programs[0], GL_PROGRAM_STRING_NV), program)
+		assert_equal(glIsProgramNV(programs[0]),true)	
+	
+		assert_equal(glGetProgramivNV(programs[0],GL_PROGRAM_LENGTH_NV),program.size)
+
+		glVertexAttribPointerNV(1,2,GL_FLOAT,0,[1,1].pack("f*"))
+		assert_equal(glGetVertexAttribPointervNV(1),[1,1].pack("f*"))
+
+		glExecuteProgramNV(GL_VERTEX_STATE_PROGRAM_NV,programs[0],[1,1,1,1])
+
+		glProgramParameter4dNV(GL_VERTEX_PROGRAM_NV,1, 1,2,3,4)
+		assert_equal(glGetProgramParameterdvNV(GL_VERTEX_PROGRAM_NV,1,GL_PROGRAM_PARAMETER_NV),[1,2,3,4])
+		glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV,1, 5,6,7,8)
+		assert_equal(glGetProgramParameterfvNV(GL_VERTEX_PROGRAM_NV,1,GL_PROGRAM_PARAMETER_NV),[5,6,7,8])
+		glProgramParameter4dvNV(GL_VERTEX_PROGRAM_NV,1, [1,2,3,4])
+		assert_equal(glGetProgramParameterdvNV(GL_VERTEX_PROGRAM_NV,1,GL_PROGRAM_PARAMETER_NV),[1,2,3,4])
+		glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV,1, [5,6,7,8])
+		assert_equal(glGetProgramParameterfvNV(GL_VERTEX_PROGRAM_NV,1,GL_PROGRAM_PARAMETER_NV),[5,6,7,8])
+
+		glProgramParameters4fvNV(GL_VERTEX_PROGRAM_NV,1, [1,2,3,4,5,6,7,8])
+		assert_equal(glGetProgramParameterfvNV(GL_VERTEX_PROGRAM_NV,1,GL_PROGRAM_PARAMETER_NV),[1,2,3,4])
+		assert_equal(glGetProgramParameterfvNV(GL_VERTEX_PROGRAM_NV,2,GL_PROGRAM_PARAMETER_NV),[5,6,7,8])
+
+		glProgramParameters4dvNV(GL_VERTEX_PROGRAM_NV,1, [8,7,6,5,4,3,2,1])
+		assert_equal(glGetProgramParameterdvNV(GL_VERTEX_PROGRAM_NV,1,GL_PROGRAM_PARAMETER_NV),[8,7,6,5])
+		assert_equal(glGetProgramParameterdvNV(GL_VERTEX_PROGRAM_NV,2,GL_PROGRAM_PARAMETER_NV),[4,3,2,1])
+
+
+		glVertexAttrib1dNV(1,1)
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0],1)
+		glVertexAttrib1fNV(1,2)
+		assert_equal(glGetVertexAttribfvNV(1,GL_CURRENT_ATTRIB_NV)[0],2)
+		glVertexAttrib1sNV(1,3)
+		assert_equal(glGetVertexAttribivNV(1,GL_CURRENT_ATTRIB_NV)[0],3)
+		glVertexAttrib1dvNV(1,[1])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0],1)
+		glVertexAttrib1fvNV(1,[2])
+		assert_equal(glGetVertexAttribfvNV(1,GL_CURRENT_ATTRIB_NV)[0],2)
+		glVertexAttrib1svNV(1,[3])
+		assert_equal(glGetVertexAttribivNV(1,GL_CURRENT_ATTRIB_NV)[0],3)
+	
+		glVertexAttrib2dNV(1,1,2)
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[1,2])
+		glVertexAttrib2fNV(1,2,3)
+		assert_equal(glGetVertexAttribfvNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[2,3])
+		glVertexAttrib2sNV(1,3,4)
+		assert_equal(glGetVertexAttribivNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[3,4])
+		glVertexAttrib2dvNV(1,[1,2])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[1,2])
+		glVertexAttrib2fvNV(1,[2,3])
+		assert_equal(glGetVertexAttribfvNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[2,3])
+		glVertexAttrib2svNV(1,[3,4])
+		assert_equal(glGetVertexAttribivNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[3,4])
+	
+		glVertexAttrib3dNV(1,1,2,3)
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[1,2,3])
+		glVertexAttrib3fNV(1,2,3,4)
+		assert_equal(glGetVertexAttribfvNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[2,3,4])
+		glVertexAttrib3sNV(1,3,4,5)
+		assert_equal(glGetVertexAttribivNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[3,4,5])
+		glVertexAttrib3dvNV(1,[1,2,3])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[1,2,3])
+		glVertexAttrib3fvNV(1,[2,3,4])
+		assert_equal(glGetVertexAttribfvNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[2,3,4])
+		glVertexAttrib3svNV(1,[3,4,5])
+		assert_equal(glGetVertexAttribivNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[3,4,5])
+	
+		glVertexAttrib4dNV(1,1,2,3,4)
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[1,2,3,4])
+		glVertexAttrib4fNV(1,2,3,4,5)
+		assert_equal(glGetVertexAttribfvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[2,3,4,5])
+		glVertexAttrib4sNV(1,3,4,5,6)
+		assert_equal(glGetVertexAttribivNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[3,4,5,6])
+		glVertexAttrib4dvNV(1,[1,2,3,4])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[1,2,3,4])
+		glVertexAttrib4fvNV(1,[2,3,4,5])
+		assert_equal(glGetVertexAttribfvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[2,3,4,5])
+		glVertexAttrib4svNV(1,[3,4,5,6])
+		assert_equal(glGetVertexAttribivNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[3,4,5,6])
+
+		glVertexAttrib4ubNV(1,2**8-1,0,2**8-1,0)
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[1,0,1,0])
+		glVertexAttrib4ubvNV(1,[0,2**8-1,0,2**8-1])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[0,1,0,1])
+
+		glVertexAttribs1dvNV(1,[1,2])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0],1)
+		assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0],2)
+		glVertexAttribs1fvNV(1,[3,4])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0],3)
+		assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0],4)
+		glVertexAttribs1svNV(1,[5,6])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0],5)
+		assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0],6)
+
+		glVertexAttribs2dvNV(1,[1,2,3,4])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[1,2])
+		assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,2],[3,4])
+		glVertexAttribs2fvNV(1,[3,4,5,6])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[3,4])
+		assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,2],[5,6])
+		glVertexAttribs2svNV(1,[5,6,7,8])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,2],[5,6])
+		assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,2],[7,8])
+
+		glVertexAttribs3dvNV(1,[1,2,3,4,5,6])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[1,2,3])
+		assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,3],[4,5,6])
+		glVertexAttribs3fvNV(1,[3,4,5,6,7,8])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[3,4,5])
+		assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,3],[6,7,8])
+		glVertexAttribs3svNV(1,[5,6,7,8,9,10])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,3],[5,6,7])
+		assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,3],[8,9,10])
+	
+		glVertexAttribs4dvNV(1,[1,2,3,4,5,6,7,8])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[1,2,3,4])
+		assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,4],[5,6,7,8])
+		glVertexAttribs4fvNV(1,[3,4,5,6,7,8,9,10])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[3,4,5,6])
+		assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,4],[7,8,9,10])
+		glVertexAttribs4svNV(1,[5,6,7,8,9,10,11,12])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[5,6,7,8])
+		assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,4],[9,10,11,12])
+		glVertexAttribs4ubvNV(1,[2**8-1,0,2**8-1,0,2**8-1,0,2**8-1,0])
+		assert_equal(glGetVertexAttribdvNV(1,GL_CURRENT_ATTRIB_NV)[0,4],[1,0,1,0])
+		assert_equal(glGetVertexAttribdvNV(2,GL_CURRENT_ATTRIB_NV)[0,4],[1,0,1,0])
+
+		glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 4, GL_MATRIX0_NV, GL_IDENTITY_NV);
+		assert_equal(glGetTrackMatrixivNV(GL_VERTEX_PROGRAM_NV, 4, GL_TRACK_MATRIX_NV),GL_MATRIX0_NV)
+
+		glRequestResidentProgramsNV(programs[0])
+		res = glAreProgramsResidentNV(programs[0])
+		assert_equal(res.size,1)
+	
+		glDeleteProgramsNV(programs)
+	end
+
+	def test_gl_nv_fragment_program
+		return if not supported?("GL_NV_fragment_program")
+		programs = glGenProgramsNV(1)
+		program = "!!FP1.0\nDECLARE test = {0,0,0,0};\nEND"
+	  glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, programs[0])
+		glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, programs[0], program)
+		
+		glProgramNamedParameter4fNV(programs[0],"test",1,2,3,4)
+		assert_equal(glGetProgramNamedParameterfvNV(programs[0],"test"),[1,2,3,4])
+		glProgramNamedParameter4dNV(programs[0],"test",5,6,7,8)
+		assert_equal(glGetProgramNamedParameterdvNV(programs[0],"test"),[5,6,7,8])
+		glProgramNamedParameter4fvNV(programs[0],"test",[1,2,3,4])
+		assert_equal(glGetProgramNamedParameterfvNV(programs[0],"test"),[1,2,3,4])
+		glProgramNamedParameter4dvNV(programs[0],"test",[5,6,7,8])
+		assert_equal(glGetProgramNamedParameterdvNV(programs[0],"test"),[5,6,7,8])
+
+		glDeleteProgramsNV(programs)
+	end
+
+	def test_gl_nv_framebuffer_multisample_coverage
+		return if not supported?("GL_NV_framebuffer_multisample_coverage")
+		rb = glGenRenderbuffersEXT(1)[0]
+
+		glBindRenderbufferEXT(GL_RENDERBUFFER_EXT,rb)
+		glRenderbufferStorageMultisampleCoverageNV(GL_RENDERBUFFER_EXT,4,4, GL_RGBA,2,2)
+		samples = glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT,GL_RENDERBUFFER_COVERAGE_SAMPLES_NV)
+		assert_equal(samples,4)
+		samples = glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT,GL_RENDERBUFFER_COLOR_SAMPLES_NV)
+		assert_equal(samples,4)
+
+		glDeleteRenderbuffersEXT(rb)
+	end
+
+	def test_gl_nv_fence
+		return if not supported?("GL_NV_fence")
+			fences = glGenFencesNV(2)
+			assert_equal(fences.size,2)
+			
+			glSetFenceNV(fences[0],GL_ALL_COMPLETED_NV)
+			assert_equal(glGetFenceivNV(fences[0],GL_FENCE_CONDITION_NV),GL_ALL_COMPLETED_NV)
+			assert_equal(glIsFenceNV(fences[0]),true)
+
+			glFinishFenceNV(fences[0])
+			assert_equal(glTestFenceNV(fences[0]),true)
+
+			glDeleteFencesNV(fences)
+	end
+
+	def test_gl_nv_depth_buffer_float
+		return if not supported?("GL_NV_depth_buffer_float")
+		glDepthRangedNV(0.1,0.2)
+		assert(approx_equal(glGetFloatv(GL_DEPTH_RANGE),[0.1,0.2]))
+		glDepthBoundsdNV(0.1,0.2)
+		assert(approx_equal(glGetFloatv(GL_DEPTH_BOUNDS_EXT),[0.1,0.2]))
+		glClearDepthdNV(0.3)
+		assert(approx_equal([glGetDoublev(GL_DEPTH_CLEAR_VALUE)],[0.3]))
+	end
+
+	def test_gl_nv_occlusion_query
+		return if not supported?("GL_NV_occlusion_query")
+
+		queries = glGenOcclusionQueriesNV(2)
+		assert_equal(queries.size,2)
+
+		glBeginOcclusionQueryNV(queries[0])
+		assert_equal(glIsOcclusionQueryNV(queries[0]),true)
+
+		glEndOcclusionQueryNV()
+		r = glGetOcclusionQueryivNV(queries[0],GL_PIXEL_COUNT_AVAILABLE_NV)
+		assert(r==GL_TRUE || r==GL_FALSE)
+		assert(glGetOcclusionQueryuivNV(queries[0],GL_PIXEL_COUNT_NV)>=0)
+
+		glDeleteOcclusionQueriesNV(queries)
+		assert_equal(glIsOcclusionQueryNV(queries[1]),false)
+	end
+
+	def test_gl_nv_gpu_program4
+		return if not supported?(["GL_NV_gpu_program4","GL_ARB_vertex_program"])
+
+		programs = glGenProgramsARB(1)
+		program = "!!ARBvp1.0\nTEMP vv;\nEND"
+	
+	  glBindProgramARB(GL_VERTEX_PROGRAM_ARB, programs[0])
+		glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, program)
+		
+		glProgramLocalParameterI4iNV(GL_VERTEX_PROGRAM_ARB,1, 1,2,3,4)
+		assert_equal(glGetProgramLocalParameterIivNV(GL_VERTEX_PROGRAM_ARB,1),[1,2,3,4])
+		glProgramLocalParameterI4uiNV(GL_VERTEX_PROGRAM_ARB,1, 5,6,7,8)
+		assert_equal(glGetProgramLocalParameterIuivNV(GL_VERTEX_PROGRAM_ARB,1),[5,6,7,8])
+		glProgramLocalParameterI4ivNV(GL_VERTEX_PROGRAM_ARB,1, [1,2,3,4])
+		assert_equal(glGetProgramLocalParameterIivNV(GL_VERTEX_PROGRAM_ARB,1),[1,2,3,4])
+		glProgramLocalParameterI4uivNV(GL_VERTEX_PROGRAM_ARB,1, [5,6,7,8])
+		assert_equal(glGetProgramLocalParameterIuivNV(GL_VERTEX_PROGRAM_ARB,1),[5,6,7,8])
+		glProgramLocalParametersI4ivNV(GL_VERTEX_PROGRAM_ARB,1, [1,2,3,4])
+		assert_equal(glGetProgramLocalParameterIivNV(GL_VERTEX_PROGRAM_ARB,1),[1,2,3,4])
+		glProgramLocalParametersI4uivNV(GL_VERTEX_PROGRAM_ARB,1, [5,6,7,8])
+		assert_equal(glGetProgramLocalParameterIuivNV(GL_VERTEX_PROGRAM_ARB,1),[5,6,7,8])
+
+		glProgramEnvParameterI4iNV(GL_VERTEX_PROGRAM_ARB,1, 1,2,3,4)
+		assert_equal(glGetProgramEnvParameterIivNV(GL_VERTEX_PROGRAM_ARB,1),[1,2,3,4])
+		glProgramEnvParameterI4uiNV(GL_VERTEX_PROGRAM_ARB,1, 5,6,7,8)
+		assert_equal(glGetProgramEnvParameterIuivNV(GL_VERTEX_PROGRAM_ARB,1),[5,6,7,8])
+		glProgramEnvParameterI4ivNV(GL_VERTEX_PROGRAM_ARB,1, [1,2,3,4])
+		assert_equal(glGetProgramEnvParameterIivNV(GL_VERTEX_PROGRAM_ARB,1),[1,2,3,4])
+		glProgramEnvParameterI4uivNV(GL_VERTEX_PROGRAM_ARB,1, [5,6,7,8])
+		assert_equal(glGetProgramEnvParameterIuivNV(GL_VERTEX_PROGRAM_ARB,1),[5,6,7,8])
+		glProgramEnvParametersI4ivNV(GL_VERTEX_PROGRAM_ARB,1, [1,2,3,4])
+		assert_equal(glGetProgramEnvParameterIivNV(GL_VERTEX_PROGRAM_ARB,1),[1,2,3,4])
+		glProgramEnvParametersI4uivNV(GL_VERTEX_PROGRAM_ARB,1, [5,6,7,8])
+		assert_equal(glGetProgramEnvParameterIuivNV(GL_VERTEX_PROGRAM_ARB,1),[5,6,7,8])
+
+		glDeleteProgramsARB(programs)
+	end
+
+	def test_gl_nv_gpu_program4
+		return if not supported?(["GL_NV_gpu_program4","GL_EXT_framebuffer_object"])
+		geometry_program = <<-EOP
+!!NVgp4.0
+PRIMITIVE_IN TRIANGLES;
+PRIMITIVE_OUT TRIANGLE_STRIP;
+VERTICES_OUT 1;
+END
+		EOP
+			
+    program_id = glGenProgramsARB(1)[0]
+		glBindProgramARB(GL_GEOMETRY_PROGRAM_NV, program_id)
+    glProgramStringARB(GL_GEOMETRY_PROGRAM_NV, GL_PROGRAM_FORMAT_ASCII_ARB, geometry_program);
+
+		assert_equal(glGetProgramivARB(GL_GEOMETRY_PROGRAM_NV,GL_GEOMETRY_VERTICES_OUT_EXT),1)
+    glProgramVertexLimitNV(GL_GEOMETRY_PROGRAM_NV, 2)
+		assert_equal(glGetProgramivARB(GL_GEOMETRY_PROGRAM_NV,GL_GEOMETRY_VERTICES_OUT_EXT),2)
+
+		#
+
+		fbo = glGenFramebuffersEXT(1)[0]
+		glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,fbo)
+	
+		texture2d,texture3d,texture_cube = glGenTextures(3)
+		glBindTexture(GL_TEXTURE_2D, texture2d)
+		glBindTexture(GL_TEXTURE_3D, texture3d)
+		glBindTexture(GL_TEXTURE_CUBE_MAP, texture_cube)
+
+		glFramebufferTextureEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,texture2d,0)
+		assert_equal(glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT),texture2d)
+		assert_equal(glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT),0)
+		glFramebufferTextureLayerEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,texture3d,0,1)
+		assert_equal(glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT),texture3d)
+		assert_equal(glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT),0)
+		assert_equal(glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT),1)
+
+		glFramebufferTextureFaceEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,texture_cube,0,GL_TEXTURE_CUBE_MAP_POSITIVE_X)
+		assert_equal(glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT),texture_cube)
+		assert_equal(glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT),0)
+		assert_equal(glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT),GL_TEXTURE_CUBE_MAP_POSITIVE_X)
+
+		glDeleteTextures([texture2d,texture3d])
+		glDeleteFramebuffersEXT(fbo)
+		glDeleteProgramsARB(program_id)
+	end
+
+	def test_gl_nv_primitive_restart
+		return if not supported?("GL_NV_primitive_restart")
+		glBegin(GL_TRIANGLES)
+	  glPrimitiveRestartNV()
+		glEnd
+		glPrimitiveRestartIndexNV(2)
+		assert_equal(glGetIntegerv(GL_PRIMITIVE_RESTART_INDEX_NV),2)
+	end
+
+	def test_gl_nv_point_sprite
+		return if not supported?("GL_NV_point_sprite")
+		glPointParameteriNV(GL_POINT_SPRITE_R_MODE_NV, GL_ZERO)
+		assert_equal(glGetIntegerv(GL_POINT_SPRITE_R_MODE_NV),GL_ZERO)
+		glPointParameteriNV(GL_POINT_SPRITE_R_MODE_NV, GL_S)
+		assert_equal(glGetIntegerv(GL_POINT_SPRITE_R_MODE_NV),GL_S)
+
+		glPointParameterivNV(GL_POINT_SPRITE_R_MODE_NV, [GL_ZERO])
+		assert_equal(glGetIntegerv(GL_POINT_SPRITE_R_MODE_NV),GL_ZERO)
+		glPointParameterivNV(GL_POINT_SPRITE_R_MODE_NV, [GL_S])
+		assert_equal(glGetIntegerv(GL_POINT_SPRITE_R_MODE_NV),GL_S)
+	end
+end

data/test/tc_func_10_11.rb

@@ -33,29 +33,29 @@ class Test_10_11 < Test::Unit::TestCase
 
 	def test_glindex
 		glIndexd(2.0)
-		assert_equal(glGetDoublev(GL_CURRENT_INDEX),2.0)
+		assert_in_delta(glGetDoublev(GL_CURRENT_INDEX),2.0,0.001)
 		glIndexdv([3.0])
-		assert_equal(glGetDoublev(GL_CURRENT_INDEX),3.0)
+		assert_in_delta(glGetDoublev(GL_CURRENT_INDEX),3.0,0.001)
 
 		glIndexf(4.0)
-		assert_equal(glGetFloatv(GL_CURRENT_INDEX),4.0)
+		assert_in_delta(glGetFloatv(GL_CURRENT_INDEX),4.0,0.001)
 		glIndexfv([5.0])
-		assert_equal(glGetFloatv(GL_CURRENT_INDEX),5.0)
+		assert_in_delta(glGetFloatv(GL_CURRENT_INDEX),5.0,0.001)
 
 		glIndexi(6)
-		assert_equal(glGetIntegerv(GL_CURRENT_INDEX),6)
+		assert_in_delta(glGetIntegerv(GL_CURRENT_INDEX),6,0.001)
 		glIndexiv([7])
-		assert_equal(glGetIntegerv(GL_CURRENT_INDEX),7)
+		assert_in_delta(glGetIntegerv(GL_CURRENT_INDEX),7,0.001)
 
 		glIndexs(8)
-		assert_equal(glGetIntegerv(GL_CURRENT_INDEX),8)
+		assert_in_delta(glGetIntegerv(GL_CURRENT_INDEX),8,0.001)
 		glIndexsv([9])
-		assert_equal(glGetIntegerv(GL_CURRENT_INDEX),9)
+		assert_in_delta(glGetIntegerv(GL_CURRENT_INDEX),9,0.001)
 
 		glIndexub(10)
-		assert_equal(glGetIntegerv(GL_CURRENT_INDEX),10)
+		assert_in_delta(glGetIntegerv(GL_CURRENT_INDEX),10,0.001)
 		glIndexubv([11])
-		assert_equal(glGetIntegerv(GL_CURRENT_INDEX),11)
+		assert_in_delta(glGetIntegerv(GL_CURRENT_INDEX),11,0.001)
 
 		# index pointer
 		glIndexPointer(GL_INT,2,"")
@@ -137,22 +137,42 @@ class Test_10_11 < Test::Unit::TestCase
 		assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m_b)
 		glPopMatrix()
 		assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m_a)
+	
+		# 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)
+		glLoadIdentity()
+		glLoadMatrixd(m)
+		assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m.to_a)
+		glLoadIdentity()
+		glMultMatrixf(m)
+		assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m.to_a)
+		glLoadIdentity()
+		glMultMatrixd(m)
+		assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m.to_a)
+
+		assert_raise ArgumentError do glLoadMatrixf([1,2,3,4]) end
+		assert_raise ArgumentError do glLoadMatrixd([1,2,3,4]) end
+		assert_raise ArgumentError do glMultMatrixf([1,2,3,4]) end
+		assert_raise ArgumentError do glMultMatrixd([1,2,3,4]) end
 	end
 
 	def test_gledge
 		glEdgeFlag(GL_FALSE)
-		assert_equal(glGetBooleanv(GL_EDGE_FLAG),GL_FALSE)
+		assert_equal(glGetBooleanv(GL_EDGE_FLAG),false)
 		glEdgeFlag(GL_TRUE)
-		assert_equal(glGetBooleanv(GL_EDGE_FLAG),GL_TRUE)
+		assert_equal(glGetBooleanv(GL_EDGE_FLAG),true)
 		glEdgeFlagv([GL_FALSE])
-		assert_equal(glGetBooleanv(GL_EDGE_FLAG),GL_FALSE)
+		assert_equal(glGetBooleanv(GL_EDGE_FLAG),false)
 	end
 
 	def test_clientstate
 		glEnableClientState(GL_COLOR_ARRAY)
-		assert_equal(glIsEnabled(GL_COLOR_ARRAY),GL_TRUE)
+		assert_equal(glIsEnabled(GL_COLOR_ARRAY),true)
 		glDisableClientState(GL_COLOR_ARRAY)
-		assert_equal(glIsEnabled(GL_COLOR_ARRAY),GL_FALSE)
+		assert_equal(glIsEnabled(GL_COLOR_ARRAY),false)
 	end
 
 	def test_glshademodel
@@ -185,12 +205,12 @@ class Test_10_11 < Test::Unit::TestCase
 		assert_equal(glGetIntegerv(GL_STENCIL_BACK_WRITEMASK), 1)
 
 		glColorMask(GL_TRUE,GL_FALSE,GL_TRUE,GL_FALSE)
-		assert_equal(glGetBooleanv(GL_COLOR_WRITEMASK),[GL_TRUE,GL_FALSE,GL_TRUE,GL_FALSE])
+		assert_equal(glGetBooleanv(GL_COLOR_WRITEMASK),[true,false,true,false])
 
 		glDepthMask(GL_TRUE)
-		assert_equal(glGetBooleanv(GL_DEPTH_WRITEMASK),GL_TRUE)
+		assert_equal(glGetBooleanv(GL_DEPTH_WRITEMASK),true)
 		glDepthMask(GL_FALSE)
-		assert_equal(glGetBooleanv(GL_DEPTH_WRITEMASK),GL_FALSE)
+		assert_equal(glGetBooleanv(GL_DEPTH_WRITEMASK),false)
 
 		glIndexMask(2)
 		assert_equal(glGetIntegerv(GL_INDEX_WRITEMASK), 2)
@@ -199,17 +219,23 @@ class Test_10_11 < Test::Unit::TestCase
 	end
 
 	def test_glflush
-		glBegin(GL_POINTS)
-		glFlush()
-		glEnd
-		assert_equal(glGetError(),GL_INVALID_OPERATION)
+		begin
+			glBegin(GL_POINTS)
+			glFlush()
+			glEnd
+		rescue Gl::Error => err
+			assert(err.id == GL_INVALID_OPERATION)
+		end	
 	end
 
 	def test_glfinish
-		glBegin(GL_POINTS)
-		glFinish()
-		glEnd
-		assert_equal(glGetError(),GL_INVALID_OPERATION)
+		begin
+			glBegin(GL_POINTS)
+			glFinish()
+			glEnd
+		rescue Gl::Error => err
+			assert(err.id == GL_INVALID_OPERATION)
+		end	
 	end
 
 	def test_glgetstring
@@ -561,13 +587,13 @@ class Test_10_11 < Test::Unit::TestCase
 
 	def test_gllight
 		glLightf(GL_LIGHT0,GL_SPOT_CUTOFF,80.0)
-		assert_equal(glGetLightfv(GL_LIGHT0,GL_SPOT_CUTOFF),[80.0])
+		assert_equal(glGetLightfv(GL_LIGHT0,GL_SPOT_CUTOFF),80.0)
 		glLighti(GL_LIGHT0,GL_SPOT_CUTOFF,75)
-		assert_equal(glGetLightiv(GL_LIGHT0,GL_SPOT_CUTOFF),[75])
+		assert_equal(glGetLightiv(GL_LIGHT0,GL_SPOT_CUTOFF),75)
 		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])
 		glLightiv(GL_LIGHT0,GL_CONSTANT_ATTENUATION,[32])
-		assert_equal(glGetLightiv(GL_LIGHT0,GL_CONSTANT_ATTENUATION),[32])
+		assert_equal(glGetLightiv(GL_LIGHT0,GL_CONSTANT_ATTENUATION),32)
 	end
 
 	def test_glmaterial
@@ -575,13 +601,13 @@ class Test_10_11 < Test::Unit::TestCase
 		assert_equal(glGetMaterialfv(GL_FRONT,GL_AMBIENT),[0.0,1.0,0.0,1.0])
 
 		glMaterialiv(GL_FRONT,GL_SHININESS,[50])
-		assert_equal(glGetMaterialiv(GL_FRONT,GL_SHININESS),[50])
+		assert_equal(glGetMaterialiv(GL_FRONT,GL_SHININESS),50)
 
 		glMaterialf(GL_FRONT,GL_SHININESS,49.0)
-		assert_equal(glGetMaterialfv(GL_FRONT,GL_SHININESS),[49.0])
+		assert_equal(glGetMaterialfv(GL_FRONT,GL_SHININESS),49.0)
 
 		glMateriali(GL_FRONT,GL_SHININESS,48)
-		assert_equal(glGetMaterialiv(GL_FRONT,GL_SHININESS),[48])
+		assert_equal(glGetMaterialiv(GL_FRONT,GL_SHININESS),48)
 	
 	end
 
@@ -597,9 +623,9 @@ class Test_10_11 < Test::Unit::TestCase
 
 	def test_gllightmodel
 		glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE)
-		assert_equal(glGetIntegerv(GL_LIGHT_MODEL_TWO_SIDE),GL_TRUE)
+		assert_equal(glGetBooleanv(GL_LIGHT_MODEL_TWO_SIDE),GL_TRUE)
 		glLightModelf(GL_LIGHT_MODEL_TWO_SIDE,GL_FALSE)
-		assert_equal(glGetIntegerv(GL_LIGHT_MODEL_TWO_SIDE),GL_FALSE)
+		assert_equal(glGetBooleanv(GL_LIGHT_MODEL_TWO_SIDE),GL_FALSE)
 
 		glLightModelfv(GL_LIGHT_MODEL_AMBIENT,[0.5,0.5,0.5,1.0])
 		assert_equal(glGetDoublev(GL_LIGHT_MODEL_AMBIENT),[0.5,0.5,0.5,1.0])
@@ -680,23 +706,23 @@ class Test_10_11 < Test::Unit::TestCase
 
 	def test_glenable_disable
 		glEnable(GL_FOG)
-		assert_equal(glIsEnabled(GL_FOG),GL_TRUE)
+		assert_equal(glIsEnabled(GL_FOG),true)
 		glDisable(GL_FOG)
-		assert_equal(glIsEnabled(GL_FOG),GL_FALSE)
+		assert_equal(glIsEnabled(GL_FOG),false)
 	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(glGetTexParameteriv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S),GL_CLAMP)
 		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(glGetTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S),GL_MIRRORED_REPEAT)
 		glTexParameteriv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,[GL_CLAMP])
-		assert_equal(glGetTexParameteriv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S),[GL_CLAMP])
+		assert_equal(glGetTexParameteriv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S),GL_CLAMP)
 		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(glGetTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S),GL_MIRRORED_REPEAT)
 
-		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(glGetTexLevelParameterfv(GL_TEXTURE_2D,0,GL_TEXTURE_WIDTH),0.0)
+		assert_equal(glGetTexLevelParameteriv(GL_TEXTURE_2D,0,GL_TEXTURE_WIDTH),0)
 	end
 
 	def test_glcullface
@@ -852,38 +878,38 @@ class Test_10_11 < Test::Unit::TestCase
 
 	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(glGetTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE),GL_ADD)
 		glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE)
-		assert_equal(glGetTexEnviv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE),[GL_MODULATE])
+		assert_equal(glGetTexEnviv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE),GL_MODULATE)
 
 		glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,[GL_ADD])
-		assert_equal(glGetTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE),[GL_ADD])
+		assert_equal(glGetTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE),GL_ADD)
 		glTexEnviv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,[GL_MODULATE])
-		assert_equal(glGetTexEnviv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE),[GL_MODULATE])
+		assert_equal(glGetTexEnviv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE),GL_MODULATE)
 	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(glGetTexGendv(GL_S,GL_TEXTURE_GEN_MODE),GL_REFLECTION_MAP)
 		glTexGenf(GL_S,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR)
-		assert_equal(glGetTexGenfv(GL_S,GL_TEXTURE_GEN_MODE),[GL_EYE_LINEAR])
+		assert_equal(glGetTexGenfv(GL_S,GL_TEXTURE_GEN_MODE),GL_EYE_LINEAR)
 		glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_SPHERE_MAP)
-		assert_equal(glGetTexGeniv(GL_S,GL_TEXTURE_GEN_MODE),[GL_SPHERE_MAP])
+		assert_equal(glGetTexGeniv(GL_S,GL_TEXTURE_GEN_MODE),GL_SPHERE_MAP)
 
 		glTexGendv(GL_S,GL_TEXTURE_GEN_MODE,[GL_REFLECTION_MAP])
-		assert_equal(glGetTexGendv(GL_S,GL_TEXTURE_GEN_MODE),[GL_REFLECTION_MAP])
+		assert_equal(glGetTexGendv(GL_S,GL_TEXTURE_GEN_MODE),GL_REFLECTION_MAP)
 		glTexGenfv(GL_S,GL_TEXTURE_GEN_MODE,[GL_EYE_LINEAR])
-		assert_equal(glGetTexGenfv(GL_S,GL_TEXTURE_GEN_MODE),[GL_EYE_LINEAR])
+		assert_equal(glGetTexGenfv(GL_S,GL_TEXTURE_GEN_MODE),GL_EYE_LINEAR)
 		glTexGeniv(GL_S,GL_TEXTURE_GEN_MODE,[GL_SPHERE_MAP])
-		assert_equal(glGetTexGeniv(GL_S,GL_TEXTURE_GEN_MODE),[GL_SPHERE_MAP])
+		assert_equal(glGetTexGeniv(GL_S,GL_TEXTURE_GEN_MODE),GL_SPHERE_MAP)
 	end
 
 	def test_textures
 		textures = glGenTextures(2)
 		assert_equal(textures.size, 2)
-		assert_equal(glIsTexture(textures[0]),GL_FALSE)
+		assert_equal(glIsTexture(textures[0]),false)
 		glBindTexture(GL_TEXTURE_2D,textures[0])
-		assert_equal(glIsTexture(textures[0]),GL_TRUE)
+		assert_equal(glIsTexture(textures[0]),true)
 
 		image = ([0,0,0,1,1,1] * 8).pack("f*") # 16 RGB pixels
 
@@ -896,7 +922,7 @@ class Test_10_11 < Test::Unit::TestCase
 		assert_equal(glGetTexImage(GL_TEXTURE_1D,0,GL_RGB,GL_FLOAT), image)
 
 		glDeleteTextures(textures)
-		assert_equal(glIsTexture(textures[0]),GL_FALSE)
+		assert_equal(glIsTexture(textures[0]),false)
 	end
 
 	def test_pixels
@@ -967,8 +993,8 @@ class Test_10_11 < Test::Unit::TestCase
 		glBindTexture(GL_TEXTURE_2D,textures[1])
 		assert_equal(glAreTexturesResident(textures).size,2)
 		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(glGetTexParameterfv(GL_TEXTURE_1D,GL_TEXTURE_PRIORITY),0.5)
+		assert_equal(glGetTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_PRIORITY),1.0)
 
 		tex = ([0,0,0,1,1,1] * 2).pack("f*")
 		tex2 = ([1] * 3 * 4).pack("f*")
@@ -1017,7 +1043,7 @@ class Test_10_11 < Test::Unit::TestCase
 		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(glGetMapiv(GL_MAP1_VERTEX_3,GL_ORDER),[2])
+		assert_equal(glGetMapiv(GL_MAP1_VERTEX_3,GL_ORDER),2)
 
 		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)
@@ -1132,7 +1158,7 @@ class Test_10_11 < Test::Unit::TestCase
 
 	def test_displaylists
 		base = glGenLists(2)
-		assert_equal(base,GL_TRUE)
+		assert(base>0)
 		glListBase(1)
 		assert_equal(glGetIntegerv(GL_LIST_BASE),1)
 		glListBase(0)
@@ -1154,16 +1180,16 @@ class Test_10_11 < Test::Unit::TestCase
 		glEnd()
 		glEndList()
 
-		assert_equal(glIsList(base+0),GL_TRUE)
-		assert_equal(glIsList(base+1),GL_TRUE)
-		assert_equal(glIsList(base+2),GL_FALSE)
+		assert_equal(glIsList(base+0),true)
+		assert_equal(glIsList(base+1),true)
+		assert_equal(glIsList(base+2),false)
 
 		#		
 		buf = glFeedbackBuffer(256,GL_3D)
 		glRenderMode(GL_FEEDBACK)
 
 		glCallList(base+0)
-		glCallLists([base+0,base+1])
+		glCallLists(GL_INT,[base+0,base+1])
 
 		count = glRenderMode(GL_RENDER)
 		assert_equal(count,(3*3+2) * 3) # 3 triangles
@@ -1171,8 +1197,8 @@ class Test_10_11 < Test::Unit::TestCase
 
 		glDeleteLists(base,2)
 
-		assert_equal(glIsList(base+0),GL_FALSE)
-		assert_equal(glIsList(base+1),GL_FALSE)
+		assert_equal(glIsList(base+0),false)
+		assert_equal(glIsList(base+1),false)
 	end
 
 	def test_arrays
@@ -1212,7 +1238,7 @@ class Test_10_11 < Test::Unit::TestCase
 	def test_arrays_2
 		na = [0,1,0].pack("f*")
 		ta = [1,0,1,0].pack("f*")
-		ea = [GL_FALSE].pack("C*")
+		ea = [0].pack("C*")
 		ca = [1,0,1,0].pack("f*")
 		
 		glNormalPointer(GL_FLOAT,0,na)
@@ -1245,7 +1271,7 @@ class Test_10_11 < Test::Unit::TestCase
 		assert_equal(glGetDoublev(GL_CURRENT_COLOR),[1,0,1,0])
 		assert_equal(glGetDoublev(GL_CURRENT_NORMAL),[0,1,0])
 		assert_equal(glGetDoublev(GL_CURRENT_TEXTURE_COORDS),[1,0,1,0])
-		assert_equal(glGetDoublev(GL_EDGE_FLAG),GL_FALSE)
+		assert_equal(glGetBooleanv(GL_EDGE_FLAG),false)
 
 		glDisable(GL_EDGE_FLAG_ARRAY)
 		glDisable(GL_TEXTURE_COORD_ARRAY)