opengl 0.7.0.pre1-x86-mingw32 → 0.7.0.pre2-x86-mingw32

data/test/test_gl_12.rb

@@ -0,0 +1,182 @@
+#
+# 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 'opengl/test_case'
+
+class TestGl12 < OpenGL::TestCase
+
+  def test_glblend
+    supported?(1.2)
+    glBlendColor(0.0, 1.0, 0.0, 1.0)
+    assert_equal(glGetDoublev(GL_BLEND_COLOR), [0, 1, 0, 1])
+
+    glBlendEquation(GL_MIN)
+    assert_equal(glGetIntegerv(GL_BLEND_EQUATION), GL_MIN)
+    glBlendEquation(GL_MAX)
+    assert_equal(glGetIntegerv(GL_BLEND_EQUATION), GL_MAX)
+  end
+
+  def test_gldrawrangeelements
+    supported?(1.2)
+    va = [0, 0, 0, 1, 1, 1].pack("f*")
+    glVertexPointer(2, GL_FLOAT, 0, va)
+
+    buf = glFeedbackBuffer(256, GL_3D)
+    glRenderMode(GL_FEEDBACK)
+
+    glEnableClientState(GL_VERTEX_ARRAY)
+
+    glDrawRangeElements(GL_POINTS, 0, 2, 3, GL_UNSIGNED_BYTE, [0, 1, 2].pack("C*"))
+    count = glRenderMode(GL_RENDER)
+    assert_equal(count, 12)
+
+    glDisableClientState(GL_VERTEX_ARRAY)
+  end
+
+  def test_colortable
+    supported?(1.2)
+
+    ct = ([0]*3+[1]*3+[0]*3+[1]*3).pack("f*")
+    ct2 = ([1]*3+[0]*3+[1]*3+[0]*3).pack("f*")
+    glColorTable(GL_COLOR_TABLE, GL_RGB8, 4, GL_RGB, GL_FLOAT, ct)
+    assert_equal(glGetColorTable(GL_COLOR_TABLE, GL_RGB, GL_FLOAT), ct)
+
+    glColorSubTable(GL_COLOR_TABLE, 0, 4, GL_RGB, GL_FLOAT, ct2)
+    assert_equal(glGetColorTable(GL_COLOR_TABLE, GL_RGB, GL_FLOAT), ct2)
+
+    glDrawPixels(4, 1, GL_RGB, GL_FLOAT, ct)
+    glCopyColorTable(GL_COLOR_TABLE, GL_RGB8, 0, 0, 4)
+    assert_equal(glGetColorTable(GL_COLOR_TABLE, GL_RGB, GL_FLOAT), ct)
+
+    glDrawPixels(4, 1, GL_RGB, GL_FLOAT, ct2)
+    glCopyColorSubTable(GL_COLOR_TABLE, 0, 0, 0, 4)
+    assert_equal(glGetColorTable(GL_COLOR_TABLE, GL_RGB, GL_FLOAT), ct2)
+
+    glColorTableParameterfv(GL_COLOR_TABLE, GL_COLOR_TABLE_BIAS, [0, 1, 0, 1])
+    assert_equal(glGetColorTableParameterfv(GL_COLOR_TABLE, GL_COLOR_TABLE_BIAS), [0, 1, 0, 1])
+
+    glColorTableParameteriv(GL_COLOR_TABLE, GL_COLOR_TABLE_BIAS, [1, 0, 1, 0])
+    assert_equal(glGetColorTableParameteriv(GL_COLOR_TABLE, GL_COLOR_TABLE_BIAS), [1, 0, 1, 0])
+  end
+
+  def test_convolutionfilter
+    supported?(1.2)
+
+    cf = ([0]*3+[1]*3+[0]*3+[1]*3).pack("f*")
+    cf2 = ([1]*3+[0]*3+[1]*3+[0]*3).pack("f*")
+    glConvolutionFilter1D(GL_CONVOLUTION_1D, GL_RGB8, 4, GL_RGB, GL_FLOAT,cf)
+    assert_equal(glGetConvolutionFilter(GL_CONVOLUTION_1D, GL_RGB, GL_FLOAT),cf)
+
+    glConvolutionFilter2D(GL_CONVOLUTION_2D, GL_RGB8, 2,2, GL_RGB, GL_FLOAT,cf2)
+    assert_equal(glGetConvolutionFilter(GL_CONVOLUTION_2D, GL_RGB, GL_FLOAT),cf2)
+
+    glDrawPixels(4,1,GL_RGB,GL_FLOAT,cf2)
+    glCopyConvolutionFilter1D(GL_CONVOLUTION_1D,GL_RGB8,0,0,4)
+    assert_equal(glGetConvolutionFilter(GL_CONVOLUTION_1D, GL_RGB, GL_FLOAT),cf2)
+
+    glDrawPixels(2,2,GL_RGB,GL_FLOAT,cf)
+    glCopyConvolutionFilter2D(GL_CONVOLUTION_2D,GL_RGB8,0,0,2,2)
+    assert_equal(glGetConvolutionFilter(GL_CONVOLUTION_2D, GL_RGB, GL_FLOAT),cf)
+
+    glConvolutionParameterf(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE,GL_CONSTANT_BORDER)
+    assert_equal(glGetConvolutionParameterfv(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE),GL_CONSTANT_BORDER)
+
+    glConvolutionParameterf(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE,GL_REPLICATE_BORDER)
+    assert_equal(glGetConvolutionParameterfv(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE),GL_REPLICATE_BORDER)
+
+    glConvolutionParameterfv(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE,[GL_CONSTANT_BORDER])
+    assert_equal(glGetConvolutionParameterfv(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE),GL_CONSTANT_BORDER)
+
+    glConvolutionParameteri(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE,GL_REPLICATE_BORDER)
+    assert_equal(glGetConvolutionParameteriv(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE),GL_REPLICATE_BORDER)
+
+    glConvolutionParameteriv(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE,[GL_CONSTANT_BORDER])
+    assert_equal(glGetConvolutionParameteriv(GL_CONVOLUTION_1D,GL_CONVOLUTION_BORDER_MODE),GL_CONSTANT_BORDER)
+  end
+
+  def test_separablefilter
+    supported?(1.2)
+    sf_a = ([0]*3+[1]*3).pack("f*")
+    sf_b = ([1]*3+[0]*3).pack("f*")
+
+    glSeparableFilter2D(GL_SEPARABLE_2D, GL_RGB8, 2, 2, GL_RGB, GL_FLOAT, sf_a, sf_b)
+    assert_equal(glGetSeparableFilter(GL_SEPARABLE_2D, GL_RGB, GL_FLOAT), [sf_a, sf_b])
+  end
+
+  def test_histogram
+    supported?(1.2)
+
+    glEnable(GL_HISTOGRAM)
+
+    glHistogram(GL_HISTOGRAM, 1, GL_RGB, GL_FALSE)
+    assert_equal(glGetHistogramParameterfv(GL_HISTOGRAM, GL_HISTOGRAM_WIDTH), 1)
+    assert_equal(glGetHistogramParameteriv(GL_HISTOGRAM, GL_HISTOGRAM_FORMAT), GL_RGB)
+    assert_equal(glGetHistogramParameteriv(GL_HISTOGRAM, GL_HISTOGRAM_SINK), GL_FALSE)
+
+    glDrawPixels(2, 1, GL_RGB, GL_FLOAT, [1, 1, 1, 1, 1, 1].pack("f*"))
+    h = glGetHistogram(GL_HISTOGRAM, GL_FALSE, GL_RGB, GL_FLOAT)
+    assert_equal(h.unpack("f*"), [2, 2, 2])
+    glResetHistogram(GL_HISTOGRAM)
+    h = glGetHistogram(GL_HISTOGRAM, GL_FALSE, GL_RGB, GL_FLOAT)
+    assert_equal(h.unpack("f*"), [0, 0, 0])
+
+    glDisable(GL_HISTOGRAM)
+  end
+
+  def test_minmax
+    supported?(1.2)
+
+    glEnable(GL_MINMAX)
+
+    glMinmax(GL_MINMAX, GL_RGB, GL_FALSE)
+    assert_equal(glGetMinmaxParameteriv(GL_MINMAX, GL_MINMAX_FORMAT), GL_RGB)
+    assert_equal(glGetMinmaxParameterfv(GL_MINMAX, GL_MINMAX_FORMAT), GL_RGB)
+    assert_equal(glGetMinmaxParameteriv(GL_MINMAX, GL_MINMAX_SINK), GL_FALSE)
+
+    glDrawPixels(2, 1, GL_RGB, GL_FLOAT, [0, 0, 0, 1, 1, 1].pack("f*"))
+    mm = glGetMinmax(GL_MINMAX, GL_FALSE, GL_RGB, GL_FLOAT)
+    assert_each_in_delta [0, 0, 0, 1, 1, 1], mm.unpack("f*")
+
+    glResetMinmax(GL_MINMAX)
+    mm = glGetMinmax(GL_MINMAX, GL_FALSE, GL_RGB, GL_UNSIGNED_BYTE)
+    assert_equal [-1, -1, -1, 0, 0, 0], mm.unpack("c*")
+
+    glDisable(GL_MINMAX)
+  end
+
+  def test_texture_3D
+    supported?(1.2)
+    image = ([0, 0, 0, 1, 1, 1] * 2 * 2).pack("f*")
+    image2 = ([1, 1, 1, 0, 0, 0] * 2 * 2).pack("f*")
+
+    textures = glGenTextures(1)
+    glBindTexture(GL_TEXTURE_3D, textures[0])
+
+    glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB8, 2, 2, 2, 0, GL_RGB, GL_FLOAT, image)
+    assert_equal(glGetTexImage(GL_TEXTURE_3D, 0, GL_RGB, GL_FLOAT), image)
+
+    glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 2, 2, 2, GL_RGB, GL_FLOAT, image2)
+    assert_equal(glGetTexImage(GL_TEXTURE_3D, 0, GL_RGB, GL_FLOAT), image2)
+
+    glDrawPixels(2, 2, GL_RGB, GL_FLOAT, image)
+    glCopyTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, 0, 0, 2, 2)
+    ti = glGetTexImage(GL_TEXTURE_3D, 0, GL_RGB, GL_FLOAT).unpack("f*")
+    assert_equal(ti, ([0]*3 + [1]*3) * 2 + ([1]*3 + [0]*3) * 2)
+
+    glDeleteTextures(textures)
+  end
+
+end
+

data/test/{tc_func_13.rb → test_gl_13.rb}

@@ -13,19 +13,19 @@
 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 
-require 'test/unit'
+require 'opengl/test_case'
 
-class Test_13 < Test::Unit::TestCase
+class TestGl13 < OpenGL::TestCase
 	def setup
-		common_setup()
+		super()
 	end
 
 	def teardown
-		common_teardown()
+		super()
 	end
 
 	def test_glsamplecoverage
-		return if not supported?(1.3)
+		supported?(1.3)
 		glSampleCoverage(0.0,GL_TRUE)
 		assert_equal(glGetDoublev(GL_SAMPLE_COVERAGE_VALUE),0.0)
 		assert_equal(glGetBooleanv(GL_SAMPLE_COVERAGE_INVERT),GL_TRUE)
@@ -35,7 +35,7 @@ class Test_13 < Test::Unit::TestCase
 	end
 
 	def test_multitexture
-		return if not supported?(1.3)
+		supported?(1.3)
 		glActiveTexture(GL_TEXTURE1)
 		glClientActiveTexture(GL_TEXTURE2)
 		assert_equal(glGetIntegerv(GL_ACTIVE_TEXTURE),GL_TEXTURE1)
@@ -43,7 +43,7 @@ class Test_13 < Test::Unit::TestCase
 	end
 
 	def test_transposematrix
-		return if not supported?(1.3)
+		supported?(1.3)
 		m_a = [[1.0,2.0,3.0,4.0],
 					 [0.0,2.0,0.0,0.0],
 					 [0.0,0.0,2.0,0.0],
@@ -84,15 +84,15 @@ class Test_13 < Test::Unit::TestCase
 		glMultTransposeMatrixd(m)
 		assert_equal(glGetDoublev(GL_MODELVIEW_MATRIX), m.to_a.transpose)
 
-		assert_raise ArgumentError do glLoadTransposeMatrixf([1,2,3,4]) end
-		assert_raise ArgumentError do glLoadTransposeMatrixd([1,2,3,4]) end
-		assert_raise ArgumentError do glMultTransposeMatrixf([1,2,3,4]) end
-		assert_raise ArgumentError do glMultTransposeMatrixd([1,2,3,4]) end
+		assert_raises ArgumentError do glLoadTransposeMatrixf([1,2,3,4]) end
+		assert_raises ArgumentError do glLoadTransposeMatrixd([1,2,3,4]) end
+		assert_raises ArgumentError do glMultTransposeMatrixf([1,2,3,4]) end
+		assert_raises ArgumentError do glMultTransposeMatrixd([1,2,3,4]) end
 	end
 	
 	def test_texturecompression
-		return if not supported?(1.3)
-		return if not supported?("GL_EXT_texture_compression_s3tc")
+		supported?(1.3)
+		supported?("GL_EXT_texture_compression_s3tc")
 
 		# S3TC/DXT5 compressed 2x2 pixels stipple patterns [w,b,b,w] and [b,w,w,b]
 		image_1 = [0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0x00,0x00,0x01,0x54,0x5C,0x5C].pack("C*")
@@ -151,7 +151,7 @@ class Test_13 < Test::Unit::TestCase
 	end
 	
 	def test_glmultitexcoord
-		return if not supported?(1.3)
+		supported?(1.3)
 	
 		glActiveTexture(GL_TEXTURE1)
 

data/test/test_gl_14.rb

@@ -0,0 +1,221 @@
+#
+# 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 'opengl/test_case'
+
+class TestGl14 < OpenGL::TestCase
+
+  def setup
+    super
+
+    supported? 1.4
+  end
+
+  def test_arrays_2
+    sc = [0, 1, 0, 1, 0, 1].pack("f*")
+    fc = [1, 0].pack("f*")
+
+    glSecondaryColorPointer(3, GL_FLOAT, 0, 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)
+    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)
+
+    glEnableClientState(GL_SECONDARY_COLOR_ARRAY)
+    glEnableClientState(GL_FOG_COORD_ARRAY)
+
+    glBegin(GL_TRIANGLES)
+    glArrayElement(0)
+    glEnd()
+
+    assert_equal(glGetDoublev(GL_CURRENT_SECONDARY_COLOR), [0, 1, 0, 1])
+    assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD), 1)
+
+    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)
+
+    glDisableClientState(GL_SECONDARY_COLOR_ARRAY)
+    glDisableClientState(GL_FOG_COORD_ARRAY)
+  end
+
+  def test_arrays_3
+    va = [0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1].pack("f*")
+    glVertexPointer(2, GL_FLOAT, 0, va)
+
+    glEnableClientState(GL_VERTEX_ARRAY)
+
+    buf = glFeedbackBuffer(256, GL_3D)
+    glRenderMode(GL_FEEDBACK)
+
+    glMultiDrawArrays(GL_POLYGON, [0, 3], [3, 3])
+
+    i1 = [0, 1, 2].pack("C*")
+    i2 = [3, 4, 5].pack("C*")
+    glMultiDrawElements(GL_TRIANGLES, GL_UNSIGNED_BYTE, [i1, i2])
+
+    count = glRenderMode(GL_RENDER)
+    assert_equal(count, (3*3+2)*4)
+    glDisableClientState(GL_VERTEX_ARRAY)
+  end
+
+  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)
+  end
+
+  def test_glpointparameter
+    glPointParameterf(GL_POINT_SIZE_MIN, 2.0)
+    assert_equal(glGetDoublev(GL_POINT_SIZE_MIN), 2.0)
+
+    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)
+
+    glPointParameteriv(GL_POINT_DISTANCE_ATTENUATION, [1, 0, 1])
+    assert_equal([1, 0, 1], glGetDoublev(GL_POINT_DISTANCE_ATTENUATION))
+  end
+
+  def test_glfogcoord
+    glFogCoordf(2.0)
+    assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD), 2.0)
+    glFogCoordfv([3.0])
+    assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD), 3.0)
+
+    glFogCoordd(2.0)
+    assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD), 2.0)
+    glFogCoorddv([3.0])
+    assert_equal(glGetDoublev(GL_CURRENT_FOG_COORD), 3.0)
+  end
+
+  def test_glsecondarycolor
+    glSecondaryColor3b(2**7-1, 0, 2**7-1)
+    assert_each_in_delta [1.0, 0.0, 1.0, 1.0], glGetDoublev(GL_CURRENT_SECONDARY_COLOR)
+
+    glSecondaryColor3bv([0, 2**7-1, 0])
+    assert_each_in_delta([0.0, 1.0, 0.0, 1.0], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+
+    glSecondaryColor3d(1.0, 0.0, 1.0)
+    assert_each_in_delta([1.0, 0.0, 1.0, 1.0], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+
+    glSecondaryColor3dv([0.0, 1.0, 0.0])
+    assert_each_in_delta([0.0, 1.0, 0.0, 1.0], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+
+    glSecondaryColor3f(1.0, 0.0, 1.0)
+    assert_each_in_delta([1.0, 0.0, 1.0, 1.0], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+
+    glSecondaryColor3fv([0.0, 1.0, 0.0])
+    assert_each_in_delta([0.0, 1.0, 0.0, 1.0], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+
+    glSecondaryColor3i(2**31-1, 0, 2**31-1)
+    assert_each_in_delta([1.0, 0.0, 1.0, 1.0], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+
+    glSecondaryColor3iv([0, 2**31-1, 0])
+    assert_each_in_delta([0.0, 1.0, 0.0, 1.0], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+
+    glSecondaryColor3s(2**15-1, 0, 2**15-1)
+    assert_each_in_delta([1.0, 0.0, 1.0, 1.0], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+
+    glSecondaryColor3sv([0, 2**15-1, 0])
+    assert_each_in_delta([0.0, 1.0, 0.0, 1.0], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+
+    glSecondaryColor3ub(2**8-1, 0, 2**8-1)
+    assert_each_in_delta([1.0, 0.0, 1.0, 1.0], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+
+    glSecondaryColor3ubv([0, 2**8-1, 0])
+    assert_each_in_delta([0.0, 1.0, 0.0, 1.0], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+
+    glSecondaryColor3ui(2**32-1, 0, 2**32-1)
+    assert_each_in_delta([1.0, 0.0, 1.0, 1.0], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+
+    glSecondaryColor3uiv([0, 2**32-1, 0])
+    assert_each_in_delta([0.0, 1.0, 0.0, 1.0], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+
+    glSecondaryColor3us(2**16-1, 0, 2**16-1)
+    assert_each_in_delta([1.0, 0.0, 1.0, 1.0], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+
+    glSecondaryColor3usv([0, 2**16-1, 0])
+    assert_each_in_delta([0.0, 1.0, 0.0, 1.0], glGetDoublev(GL_CURRENT_SECONDARY_COLOR))
+  end
+
+  def test_glwindowpos_2
+    glLoadIdentity
+
+    glWindowPos2d 1.0, 2.0
+    assert_each_in_delta [1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
+
+    glWindowPos2dv [2.0, 1.0]
+    assert_each_in_delta [2, 1, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
+
+    glWindowPos2f 1.0, 2.0
+    assert_each_in_delta [1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
+
+    glWindowPos2fv [2.0, 1.0]
+    assert_each_in_delta [2, 1, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
+
+    glWindowPos2i 1, 2
+    assert_each_in_delta [1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
+
+    glWindowPos2iv [2, 1]
+    assert_each_in_delta [2, 1, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
+
+    glWindowPos2s 1, 2
+    assert_each_in_delta [1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
+
+    glWindowPos2sv [2, 1]
+    assert_each_in_delta [2, 1, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
+  end
+
+  def test_glwindowspos_3
+    glWindowPos3d 1.0, 2.0, 0.5
+    assert_each_in_delta [1, 2, 0.5, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
+
+    glWindowPos3dv [3.0, 2.0, 1.0]
+    assert_each_in_delta [3, 2, 1, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
+
+    glWindowPos3f 1.0, 2.0, 0.5
+    assert_each_in_delta [1, 2, 0.5, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
+
+    glWindowPos3fv [3.0, 2.0, 1.0]
+    assert_each_in_delta [3, 2, 1, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
+
+    glWindowPos3i 1, 2, 0
+    assert_each_in_delta [1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
+
+    glWindowPos3iv [3, 2, 1]
+    assert_each_in_delta [3, 2, 1, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
+
+    glWindowPos3s 1, 2, 0
+    assert_each_in_delta [1, 2, 0, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
+
+    glWindowPos3sv [3, 2, 1]
+    assert_each_in_delta [3, 2, 1, 1], glGetDoublev(GL_CURRENT_RASTER_POSITION)
+  end
+
+end
+