arb_gpu_shader_fp64: Adds conversion tests generator

Submitted by Andres Gomez on April 14, 2016, 9:40 a.m.

Details

Message ID 1460626825-4965-2-git-send-email-agomez@igalia.com
State Accepted
Headers show
Series "arb_gpu_shader_fp64: Adds conversion tests generator" ( rev: 1 ) in Piglit

Not browsing as part of any series.

Commit Message

Andres Gomez April 14, 2016, 9:40 a.m.
Also, removed 5 redundant tests replaced by
the generator.

Signed-off-by: Andres Gomez <agomez@igalia.com>
---
 generated_tests/CMakeLists.txt                     |  24 +
 generated_tests/gen_conversion_fp64.py             | 604 +++++++++++++++++++++
 .../templates/gen_conversion_fp64/base.mako        |  12 +
 .../gen_conversion_fp64/compiler.frag.mako         |   3 +
 .../gen_conversion_fp64/compiler.geom.mako         |   3 +
 .../gen_conversion_fp64/compiler.vert.mako         |   3 +
 .../gen_conversion_fp64/compiler_base.mako         |  25 +
 .../execution-zero-sign.frag.shader_test.mako      |   8 +
 .../execution-zero-sign.geom.shader_test.mako      |  27 +
 .../execution-zero-sign.vert.shader_test.mako      |  16 +
 .../execution.frag.shader_test.mako                |   7 +
 .../execution.geom.shader_test.mako                |  27 +
 .../execution.vert.shader_test.mako                |  16 +
 .../gen_conversion_fp64/execution_base.mako        |  28 +
 .../gen_conversion_fp64/shader-zero-sign.frag.mako |  18 +
 .../gen_conversion_fp64/shader-zero-sign.geom.mako |  27 +
 .../gen_conversion_fp64/shader-zero-sign.vert.mako |  20 +
 .../templates/gen_conversion_fp64/shader.frag.mako |  16 +
 .../templates/gen_conversion_fp64/shader.geom.mako |  25 +
 .../templates/gen_conversion_fp64/shader.vert.mako |  18 +
 .../templates/gen_conversion_fp64/shader_base.mako |  11 +
 .../implicit-conversion-double-float-bad.vert      |  20 -
 .../implicit-conversion-dvec2-vec2-bad.vert        |  20 -
 .../implicit-conversion-dvec3-vec3-bad.vert        |  20 -
 .../implicit-conversion-dvec4-vec4-bad.vert        |  20 -
 .../compiler/implicit-conversions.vert             | 115 ----
 26 files changed, 938 insertions(+), 195 deletions(-)
 create mode 100644 generated_tests/gen_conversion_fp64.py
 create mode 100644 generated_tests/templates/gen_conversion_fp64/base.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/compiler.frag.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/compiler.geom.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/compiler.vert.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/compiler_base.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/execution-zero-sign.frag.shader_test.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/execution-zero-sign.geom.shader_test.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/execution-zero-sign.vert.shader_test.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/execution.frag.shader_test.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/execution.geom.shader_test.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/execution.vert.shader_test.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/execution_base.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/shader-zero-sign.frag.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/shader-zero-sign.geom.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/shader-zero-sign.vert.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/shader.frag.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/shader.geom.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/shader.vert.mako
 create mode 100644 generated_tests/templates/gen_conversion_fp64/shader_base.mako
 delete mode 100644 tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-double-float-bad.vert
 delete mode 100644 tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec2-vec2-bad.vert
 delete mode 100644 tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec3-vec3-bad.vert
 delete mode 100644 tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec4-vec4-bad.vert
 delete mode 100644 tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversions.vert

Patch hide | download patch | download mbox

diff --git a/generated_tests/CMakeLists.txt b/generated_tests/CMakeLists.txt
index 3c5b11a..c2505e2 100644
--- a/generated_tests/CMakeLists.txt
+++ b/generated_tests/CMakeLists.txt
@@ -130,6 +130,29 @@  piglit_make_generated_tests(
 	templates/gen_flat_interpolation_qualifier/template.frag.mako
 	)
 piglit_make_generated_tests(
+	conversion_fp64.list
+	gen_conversion_fp64.py
+	templates/gen_conversion_fp64/base.mako
+	templates/gen_conversion_fp64/compiler.frag.mako
+	templates/gen_conversion_fp64/compiler.geom.mako
+	templates/gen_conversion_fp64/compiler.vert.mako
+	templates/gen_conversion_fp64/compiler_base.mako
+	templates/gen_conversion_fp64/execution-zero-sign.frag.shader_test.mako
+	templates/gen_conversion_fp64/execution-zero-sign.geom.shader_test.mako
+	templates/gen_conversion_fp64/execution-zero-sign.vert.shader_test.mako
+	templates/gen_conversion_fp64/execution.frag.shader_test.mako
+	templates/gen_conversion_fp64/execution.geom.shader_test.mako
+	templates/gen_conversion_fp64/execution.vert.shader_test.mako
+	templates/gen_conversion_fp64/execution_base.mako
+	templates/gen_conversion_fp64/shader-zero-sign.frag.mako
+	templates/gen_conversion_fp64/shader-zero-sign.geom.mako
+	templates/gen_conversion_fp64/shader-zero-sign.vert.mako
+	templates/gen_conversion_fp64/shader.frag.mako
+	templates/gen_conversion_fp64/shader.geom.mako
+	templates/gen_conversion_fp64/shader.vert.mako
+	templates/gen_conversion_fp64/shader_base.mako
+	)
+piglit_make_generated_tests(
 	shader_precision_tests.list
 	gen_shader_precision_tests.py
 	builtin_function.py
@@ -188,6 +211,7 @@  add_custom_target(gen-gl-tests
 			constant_array_size_tests_fp64.list
 			inout_fp64.list
 			flat_interpolation_qualifier.list
+			conversion_fp64.list
 			shader_precision_tests.list
 			shader_image_load_store_tests.list
 			variable_index_read_tests.list
diff --git a/generated_tests/gen_conversion_fp64.py b/generated_tests/gen_conversion_fp64.py
new file mode 100644
index 0000000..5fe0bf2
--- /dev/null
+++ b/generated_tests/gen_conversion_fp64.py
@@ -0,0 +1,604 @@ 
+# coding=utf-8
+#
+# Copyright © 2016 Intel Corporation
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice (including the next
+# paragraph) shall be included in all copies or substantial portions of the
+# Software.
+#
+# 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.
+
+"""Generate fp64 types conversion tests."""
+
+from __future__ import print_function, division, absolute_import
+import abc
+import argparse
+import os
+import itertools
+import struct
+import numpy as np
+
+from templates import template_dir
+from modules import utils
+
+TEMPLATES = template_dir(os.path.basename(os.path.splitext(__file__)[0]))
+
+# pylint: disable=bad-whitespace,line-too-long,bad-continuation
+DOUBLE_INFS                 = ['0xfff0000000000000', # -inf
+                               '0x7ff0000000000000'] # +inf
+
+DOUBLE_NEG_ZERO             = ['0x8000000000000000'] # Negative underflow (-0.0)
+
+DOUBLE_POS_ZERO             = ['0x0000000000000000'] # Positive underflow (+0.0)
+
+# Double values causing an underflow to zero in any other type
+DOUBLE_DENORMAL_VALUES      = ['0x800fffffffffffff', # Negative maximum denormalized -- Denormalized may be flushed to 0
+                               '0x8000000000000001', # Negative minimum denormalized -- Denormalized may be flushed to 0
+                               '0x0000000000000001', # Positive minimum denormalized -- Denormalized may be flushed to 0
+                               '0x000fffffffffffff'] # Positive maximum denormalized -- Denormalized may be flushed to 0
+
+DOUBLE_NORMAL_VALUES        = ['0x8010000000000000', # Negative minimum normalized
+                               '0x0010000000000000'] # Positive minimum normalized
+
+# Double +/-inf
+DOUBLE_FLOAT_INFS           = ['0xc7effffff0000000', # Negative overflow (-inf)
+                               '0x47effffff0000000'] # Positive overflow (+inf)
+
+DOUBLE_FLOAT_VALUES         = ['0xc7efffffefffffff', # Negative maximum normalized
+                               '0xc170000000000000', # -16777216.0
+                               '0xc014000000000000', # -5.0
+                               '0xbfff25ce60000000', # -1.9467300176620483
+                               '0xb80fffffe0000000', # Negative minimum normalized
+                               '0xb69fffffffffffff', # Negative underflow
+                               '0x369fffffffffffff', # Positive underflow
+                               '0x380fffffe0000000', # Positive minimum normalized
+                               '0x3fff25ce60000000', # +1.9467300176620483
+                               '0x4014000000000000', # +5.0
+                               '0x4170000000000000', # +16777216.0
+                               '0x47efffffefffffff'] # Positive maximum normalized
+
+DOUBLE_UINT_VALUES          = ['0xbfeccccccccccccd', # -0.9
+                               #'0x8010000000000000', # Negative minimum normalized          -- Already checked
+                               #'0x800fffffffffffff', # Negative maximum denormalized        -- Already checked
+                               #'0x8000000000000001', # Negative minimum denormalized        -- Already checked
+                               #'0x8000000000000000', # Negative minimum        (-0)         -- Already checked
+                               #'0x0000000000000000', # Positive minimum        (+0)         -- Already checked
+                               '0x3fff25ce60000000', # +1.9467300176620483
+                               '0x4014000000000000', # +5.0
+                               '0x4170000000000000', # +16777216.0
+                               '0x41dfffffffc00000', # Signed int low frontier (+2147483647)
+                               '0x41e0000000000000', # Signed int up frontier  (+2147483648)
+                               '0x41efffffffe00000'] # Maximum                 (+4294967295)
+
+DOUBLE_INT_VALUES           = ['0xc1e0000000000000', # Minimum          (-2147483648)
+                               '0xc170000000000000', # -16777216.0
+                               '0xc014000000000000', # -5.0
+                               '0xbfff25ce60000000', # -1.9467300176620483
+                               #'0x8000000000000000', # Negative minimum        (-0)         -- Already checked
+                               #'0x0000000000000000', # Minimum                 (+0)         -- Already checked
+                               '0x3fff25ce60000000', # +1.9467300176620483
+                               '0x4014000000000000', # +5.0
+                               '0x4170000000000000', # +16777216.0
+                               '0x41dfffffffc00000'] # Maximum          (+2147483647)
+
+DOUBLE_BOOL_VALUES          = [#'0x8010000000000000', # Minimum negative True value -- Already checked
+                               #'0x0000000000000000', # False                       -- Already checked
+                               #'0x0010000000000000', # Minimum positive True value -- Already checked
+                              ]
+
+FLOAT_INFS                  = ['0xff800000', # -inf
+                               '0x7f800000'] # +inf
+
+FLOAT_NEG_ZERO              = ['0x80000000'] # Negative underflow (-0.0)
+
+FLOAT_POS_ZERO              = ['0x00000000'] # Positive underflow (+0.0)
+
+FLOAT_VALUES                = ['0xff7fffff', # Negative maximum normalized
+                               '0xcb800000', # -16777216.0
+                               '0xc0a00000', # -5.0
+                               '0xbff92e73', # -1.9467300176620483
+                               '0x80800000', # Negative minimum normalized
+                               #'0x807fffff', # Negative maximum denormalized -- Denormalized may be flushed to 0
+                               #'0x80000001', # Negative minimum denormalized -- Denormalized may be flushed to 0
+                               #'0x00000001', # Positive minimum denormalized -- Denormalized may be flushed to 0
+                               #'0x007fffff', # Positive maximum denormalized -- Denormalized may be flushed to 0
+                               '0x00800000', # Positive minimum normalized
+                               '0x3ff92e73', # +1.9467300176620483
+                               '0x40a00000', # +5.0
+                               '0x4b800000', # +16777216.0
+                               '0x7f7fffff'] # Positive maximum normalized
+
+UINT_VALUES                 = ['0', # Minimum
+                               '5',
+                               '2147483647', # Signed int low frontier
+                               '2147483648', # Signed int up frontier
+                               '4294967295'] # Maximum
+
+INT_VALUES                  = ['-2147483648', # Minimum
+                               '-5',
+                               '-1',
+                               '0',
+                               '1',
+                               '5',
+                               '2147483647'] # Maximum
+
+BOOL_VALUES                 = ['0', # False
+                               '1'] # True
+# pylint: enable=bad-whitespace,line-too-long,bad-continuation
+
+def get_dir_name(ver, test_type):
+    """Returns the directory name to save tests given a GLSL version and a
+       test type.
+    """
+
+    assert isinstance(ver, str)
+    assert isinstance(test_type, str)
+    if ver.startswith('GL_'):
+        feature_dir = ver[3:].lower()
+    else:
+        feature_dir = 'glsl-{}.{}'.format(ver[0], ver[1:])
+
+    return os.path.join('spec', feature_dir, test_type,
+                        'conversion')
+
+
+class TestTuple(object):
+    """A float64 derived and other type derived tuple to generate the
+       needed conversion tests.
+    """
+
+    @staticmethod
+    def float_to_hex(fvalue):
+        """Returns the hexadecimal representation from a float32 value."""
+        assert isinstance(fvalue, np.float32)
+        return hex(struct.unpack('<I', struct.pack('<f', fvalue))[0])
+
+    @staticmethod
+    def double_to_hex(fvalue):
+        """Returns the hexadecimal representation from a float64 value."""
+        assert isinstance(fvalue, float)
+        return hex(struct.unpack('<Q', struct.pack('<d', fvalue))[0]).rstrip("L")
+
+    @staticmethod
+    def hex_to_float(hstr):
+        """Returns a float32 value from its hexadecimal representation."""
+        assert isinstance(hstr, str)
+        return struct.unpack('<f', struct.pack('<I', int(hstr, 16)))[0]
+
+    @staticmethod
+    def hex_to_double(hstr):
+        """Returns a float64 value from its hexadecimal representation."""
+
+        assert isinstance(hstr, str)
+        return struct.unpack('<d', struct.pack('<Q', int(hstr, 16)))[0]
+
+    @staticmethod
+    def float_hex_to_double_hex(hstr):
+        """Returns the float64 hexadecimal representation from a float32
+           hexadecimal representation.
+        """
+        assert isinstance(hstr, str)
+        double_value = TestTuple.hex_to_float(hstr)
+        return TestTuple.double_to_hex(double_value)
+
+    @staticmethod
+    def float_hex_to_inv_double_hex(hstr):
+        """Returns the inverted float64 hexadecimal representation from a
+           float32 hexadecimal representation.
+        """
+        assert isinstance(hstr, str)
+        temp = TestTuple.hex_to_float(hstr)
+        double_value = np.divide(1.0, temp)
+        return TestTuple.double_to_hex(double_value)
+
+    @staticmethod
+    def int_str_to_double_str(istr):
+        """Returns a float64 string from an int32 string."""
+        assert isinstance(istr, str)
+        return str(float(istr))
+
+    @staticmethod
+    def doble_hex_to_bool_str(hstr):
+        """Returns a bool string from a float64 hexadecimal representation."""
+        assert isinstance(hstr, str)
+        bool_double = TestTuple.hex_to_double(hstr)
+        return '1' if bool_double != 0.0 else '0'
+
+    @staticmethod
+    def doble_hex_to_int_str(hstr):
+        """Returns an int32 string from a float64 hexadecimal
+           representation.
+        """
+        assert isinstance(hstr, str)
+        int_double = TestTuple.hex_to_double(hstr)
+        if int_double > np.iinfo(np.dtype('int32')).max:
+            return str(np.iinfo(np.dtype('int32')).max)
+        if int_double < np.iinfo(np.dtype('int32')).min:
+            return str(np.iinfo(np.dtype('int32')).min)
+        return str(int(int_double))
+
+    @staticmethod
+    def doble_hex_to_uint_str(hstr):
+        """Returns an uint32 string from a float64 hexadecimal
+           representation.
+        """
+        assert isinstance(hstr, str)
+        uint_double = TestTuple.hex_to_double(hstr)
+        if uint_double > np.iinfo(np.dtype('uint32')).max:
+            return str(np.iinfo(np.dtype('uint32')).max)
+        if uint_double < np.iinfo(np.dtype('uint32')).min:
+            return str(np.iinfo(np.dtype('uint32')).min)
+        return str(int(uint_double))
+
+    @staticmethod
+    def doble_hex_to_float_hex(hstr):
+        """Returns the float32 hexadecimal representation from a float64
+           hexadecimal representation.
+        """
+        assert isinstance(hstr, str)
+        float_double = np.float32(TestTuple.hex_to_double(hstr))
+        return TestTuple.float_to_hex(float_double)
+
+    @staticmethod
+    def doble_hex_to_inv_float_hex(hstr):
+        """Returns the inverted float32 hexadecimal representation from a
+           float64 hexadecimal representation.
+        """
+        assert isinstance(hstr, str)
+        temp = np.divide(1.0, TestTuple.hex_to_double(hstr))
+        float_double = np.float32(temp)
+        return TestTuple.float_to_hex(float_double)
+
+    def __init__(self, ver, stage,
+                 first_dimension, second_dimension,
+                 basic_type, names_only):
+        assert stage in ('vert', 'geom', 'frag')
+        assert first_dimension in ('1', '2', '3', '4')
+        assert second_dimension in ('1', '2', '3', '4')
+        assert isinstance(names_only, bool)
+
+        self._ver = ver
+        self._stage = stage
+        self._basic_type = basic_type
+        self._names_only = names_only
+        self._double_type = ''
+        self._conversion_type = ''
+        self._uniform_type = ''
+        self._amount = int(first_dimension) * int(second_dimension)
+        self._filenames = []
+
+        if first_dimension != '1':
+            dimensional_type = 'mat' + first_dimension
+            if first_dimension != second_dimension:
+                dimensional_type += 'x' + second_dimension
+        elif second_dimension != '1':
+            dimensional_type = 'vec' + second_dimension
+        else:
+            dimensional_type = ''
+
+        if dimensional_type == '':
+            if basic_type == 'b':
+                self._conversion_type = 'bool'
+                self._uniform_type = 'int'
+            elif basic_type == 'i':
+                self._conversion_type = 'int'
+            elif basic_type == 'u':
+                self._conversion_type = 'uint'
+            elif basic_type == 'f':
+                self._conversion_type = 'float'
+            self._double_type = 'double'
+            if self._uniform_type == '':
+                self._uniform_type = self._conversion_type
+        else:
+            self._conversion_type = (basic_type if basic_type != 'f' else '') + dimensional_type
+            if basic_type == 'b':
+                self._uniform_type = 'i' + dimensional_type
+            else:
+                self._uniform_type = self._conversion_type
+            self._double_type = 'd' + dimensional_type
+
+    @abc.abstractmethod
+    def _gen_to_double(self):
+        """Generates the test files for conversions to float64."""
+
+    @abc.abstractmethod
+    def _gen_from_double(self):
+        """Generates the test files for conversions from float64."""
+
+    @property
+    def filenames(self):
+        """Returns the test file names this tuple will generate."""
+        if self._filenames == []:
+            tmp = self._names_only
+            self._names_only = True
+            self.generate_test_files()
+            self._names_only = tmp
+        return self._filenames
+
+    def generate_test_files(self):
+        """Generate the GLSL parser tests."""
+        self._filenames = []
+
+        self._gen_to_double()
+        self._gen_from_double()
+
+
+class RegularTestTuple(TestTuple):
+    """Derived class for conversion tests using regular values within the
+       edges of the used types.
+    """
+
+    @staticmethod
+    def all_tests(names_only):
+        """Returns all the possible contained conversion test instances."""
+
+        assert isinstance(names_only, bool)
+        stages = ['vert', 'geom', 'frag']
+        dimensions = ['1', '2', '3', '4']
+        basic_types = ['b', 'u', 'i', 'f']
+        glsl_ver = ['GL_ARB_gpu_shader_fp64', '400']
+
+        if not names_only:
+            test_types = ['compiler', 'execution']
+            for ver, test_type in itertools.product(glsl_ver, test_types):
+                utils.safe_makedirs(get_dir_name(ver, test_type))
+
+        for ver, stage, first_dimension, second_dimension, basic_type in itertools.product(
+                glsl_ver,
+                stages,
+                dimensions,
+                dimensions,
+                basic_types):
+            if not (first_dimension != '1' and (second_dimension == '1' or basic_type != 'f')):
+                yield RegularTestTuple(ver, stage,
+                                       first_dimension, second_dimension,
+                                       basic_type, names_only)
+
+    def __init__(self, ver, stage,
+                 first_dimension, second_dimension,
+                 basic_type, names_only):
+        assert ver in ('GL_ARB_gpu_shader_fp64', '400')
+        assert basic_type in ('b', 'u', 'i', 'f')
+        assert not (first_dimension != '1' and (second_dimension == '1' or basic_type != 'f'))
+        super(RegularTestTuple, self).__init__(ver, stage,
+                                               first_dimension, second_dimension,
+                                               basic_type, names_only)
+
+    def _gen_comp_test(self, from_type, to_type, converted_from):
+        filename = os.path.join(
+            get_dir_name(self._ver, 'compiler'),
+            '{}-conversion-implicit-{}-{}-bad.{}'.format(self._stage, from_type, to_type,
+                                                         self._stage))
+
+        self._filenames.append(filename)
+
+        if not self._names_only:
+            with open(filename, 'w') as test_file:
+                test_file.write(TEMPLATES.get_template(
+                    'compiler.{}.mako'.format(self._stage)).render_unicode(
+                        ver=self._ver,
+                        from_type=from_type,
+                        to_type=to_type,
+                        converted_from=converted_from))
+
+    def _gen_exec_test(self, from_type, to_type,
+                       uniform_from_type, uniform_to_type,
+                       explicit, converted_from, conversions):
+        filename = os.path.join(
+            get_dir_name(self._ver, 'execution'),
+            '{}-conversion-{}-{}-{}.shader_test'.format(self._stage, explicit,
+                                                        from_type, to_type))
+
+        self._filenames.append(filename)
+
+        if not self._names_only:
+            with open(filename, 'w') as test_file:
+                test_file.write(TEMPLATES.get_template(
+                    'execution.{}.shader_test.mako'.format(self._stage)).render_unicode(
+                        ver=self._ver,
+                        amount=self._amount,
+                        from_type=from_type,
+                        to_type=to_type,
+                        converted_from=converted_from,
+                        uniform_from_type=uniform_from_type,
+                        uniform_to_type=uniform_to_type,
+                        conversions=conversions))
+
+    def _gen_to_double(self):
+        converted_from = 'from'
+        explicit = 'implicit'
+
+        if self._basic_type == 'b':
+            explicit = 'explicit'
+            self._gen_comp_test(self._conversion_type, self._double_type,
+                                converted_from)
+            converted_from = self._double_type + '(from)'
+            conversion_values = BOOL_VALUES
+            conversion_function = TestTuple.int_str_to_double_str
+        elif self._basic_type == 'i':
+            conversion_values = INT_VALUES
+            conversion_function = TestTuple.int_str_to_double_str
+        elif self._basic_type == 'u':
+            conversion_values = UINT_VALUES
+            conversion_function = TestTuple.int_str_to_double_str
+        elif self._basic_type == 'f':
+            conversion_values = FLOAT_INFS + FLOAT_NEG_ZERO + FLOAT_POS_ZERO + FLOAT_VALUES
+            conversion_function = TestTuple.float_hex_to_double_hex
+
+        conversions = []
+        for value in conversion_values:
+            to_value = conversion_function(value)
+            item = {'from': value, 'to': to_value}
+            conversions.append(item)
+
+        self._gen_exec_test(self._conversion_type, self._double_type,
+                            self._uniform_type, self._double_type,
+                            explicit, converted_from, conversions)
+
+    def _gen_from_double(self):
+        converted_from = 'from'
+        self._gen_comp_test(self._double_type, self._conversion_type,
+                            converted_from)
+
+        converted_from = self._conversion_type + '(from)'
+        explicit = 'explicit'
+
+        if self._basic_type == 'b':
+            conversion_values = DOUBLE_INFS + DOUBLE_NORMAL_VALUES + DOUBLE_BOOL_VALUES
+            conversion_function = TestTuple.doble_hex_to_bool_str
+        elif self._basic_type == 'i':
+            conversion_values = DOUBLE_DENORMAL_VALUES + DOUBLE_NORMAL_VALUES + DOUBLE_INT_VALUES
+            conversion_function = TestTuple.doble_hex_to_int_str
+        elif self._basic_type == 'u':
+            conversion_values = DOUBLE_DENORMAL_VALUES + DOUBLE_NORMAL_VALUES + DOUBLE_UINT_VALUES
+            conversion_function = TestTuple.doble_hex_to_uint_str
+        elif self._basic_type == 'f':
+            conversion_values = DOUBLE_INFS + DOUBLE_FLOAT_INFS + DOUBLE_FLOAT_VALUES
+            conversion_function = TestTuple.doble_hex_to_float_hex
+
+        conversions = []
+        for value in DOUBLE_NEG_ZERO + DOUBLE_POS_ZERO + conversion_values:
+            to_value = conversion_function(value)
+            item = {'from': value, 'to': to_value}
+            conversions.append(item)
+
+        self._gen_exec_test(self._double_type, self._conversion_type,
+                            self._double_type, self._uniform_type,
+                            explicit, converted_from, conversions)
+
+
+class ZeroSignTestTuple(TestTuple):
+    """Derived class for conversion tests using the float32 and float64
+       +/-0.0 values.
+    """
+
+    @staticmethod
+    def all_tests(names_only):
+        """Returns all the possible zero sign conversion test instances."""
+
+        assert isinstance(names_only, bool)
+        stages = ['vert', 'geom', 'frag']
+        dimensions = ['1', '2', '3', '4']
+        basic_types = ['f']
+        glsl_ver = ['410', '420']
+
+        if not names_only:
+            for ver in glsl_ver:
+                utils.safe_makedirs(get_dir_name(ver, 'execution'))
+
+        for ver, stage, first_dimension, second_dimension, basic_type in itertools.product(
+                glsl_ver,
+                stages,
+                dimensions,
+                dimensions,
+                basic_types):
+            if not (first_dimension != '1' and second_dimension == '1'):
+                yield ZeroSignTestTuple(ver, stage,
+                                        first_dimension, second_dimension,
+                                        basic_type, names_only)
+
+    def __init__(self, ver, stage,
+                 first_dimension, second_dimension,
+                 basic_type, names_only):
+        assert ver in ('410', '420')
+        assert basic_type == 'f'
+        assert not (first_dimension != '1' and second_dimension == '1')
+        super(ZeroSignTestTuple, self).__init__(ver, stage,
+                                                first_dimension, second_dimension,
+                                                basic_type, names_only)
+
+    def __gen_zero_sign_exec_test(self, from_type, to_type,
+                                  uniform_from_type, uniform_to_type,
+                                  explicit, converted_from, conversions):
+        filename = os.path.join(
+            get_dir_name(self._ver, 'execution'),
+            '{}-conversion-{}-{}-{}-zero-sign.shader_test'.format(self._stage, explicit,
+                                                                  from_type, to_type))
+
+        self._filenames.append(filename)
+
+        if not self._names_only:
+            with open(filename, 'w') as test_file:
+                test_file.write(TEMPLATES.get_template(
+                    'execution-zero-sign.{}.shader_test.mako'.format(
+                        self._stage)).render_unicode(
+                            ver=self._ver,
+                            amount=self._amount,
+                            from_type=from_type,
+                            to_type=to_type,
+                            converted_from=converted_from,
+                            uniform_from_type=uniform_from_type,
+                            uniform_to_type=uniform_to_type,
+                            conversions=conversions))
+
+    def _gen_to_double(self):
+        if self._ver == '410':
+            conversion_values = FLOAT_POS_ZERO
+        elif self._ver == '420':
+            conversion_values = FLOAT_NEG_ZERO
+
+        conversions = []
+        for value in conversion_values:
+            to_value = TestTuple.float_hex_to_inv_double_hex(value)
+            item = {'from': value, 'to': to_value}
+            conversions.append(item)
+
+        self.__gen_zero_sign_exec_test(self._conversion_type, self._double_type,
+                                       self._uniform_type, self._double_type,
+                                       'implicit', 'from', conversions)
+
+    def _gen_from_double(self):
+        if self._ver == '410':
+            conversion_values = DOUBLE_POS_ZERO
+        elif self._ver == '420':
+            conversion_values = DOUBLE_NEG_ZERO
+
+        conversions = []
+        for value in conversion_values:
+            to_value = TestTuple.doble_hex_to_inv_float_hex(value)
+            item = {'from': value, 'to': to_value}
+            conversions.append(item)
+
+        self.__gen_zero_sign_exec_test(self._double_type, self._conversion_type,
+                                       self._double_type, self._uniform_type,
+                                       'explicit', self._conversion_type + '(from)', conversions)
+
+
+def main():
+    """Main function."""
+
+    parser = argparse.ArgumentParser(
+        description="Generate shader tests that check the conversions from and "
+        "to fp64")
+    parser.add_argument(
+        '--names-only',
+        dest='names_only',
+        action='store_true',
+        default=False,
+        help="Don't output files, just generate a list of filenames to stdout")
+    args = parser.parse_args()
+
+    np.seterr(divide='ignore')
+
+    for test in (list(RegularTestTuple.all_tests(args.names_only)) +
+                 list(ZeroSignTestTuple.all_tests(args.names_only))):
+        test.generate_test_files()
+        for filename in test.filenames:
+            print(filename)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/generated_tests/templates/gen_conversion_fp64/base.mako b/generated_tests/templates/gen_conversion_fp64/base.mako
new file mode 100644
index 0000000..bcb479f
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/base.mako
@@ -0,0 +1,12 @@ 
+## coding=utf-8
+<%def name="versioning()"><%
+    if ver == 'GL_ARB_gpu_shader_fp64':
+        glsl_version_int = '150'
+    else:
+        glsl_version_int = ver
+
+    glsl_version = '{}.{}'.format(glsl_version_int[0], glsl_version_int[1:3])
+
+    return (glsl_version, glsl_version_int)
+%></%def>\
+${next.body()}\
diff --git a/generated_tests/templates/gen_conversion_fp64/compiler.frag.mako b/generated_tests/templates/gen_conversion_fp64/compiler.frag.mako
new file mode 100644
index 0000000..2ae22df
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/compiler.frag.mako
@@ -0,0 +1,3 @@ 
+## coding=utf-8
+<%inherit file="compiler_base.mako"/>\
+<%include file="shader.frag.mako"/>\
diff --git a/generated_tests/templates/gen_conversion_fp64/compiler.geom.mako b/generated_tests/templates/gen_conversion_fp64/compiler.geom.mako
new file mode 100644
index 0000000..1e2e340
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/compiler.geom.mako
@@ -0,0 +1,3 @@ 
+## coding=utf-8
+<%inherit file="compiler_base.mako"/>\
+<%include file="shader.geom.mako"/>\
diff --git a/generated_tests/templates/gen_conversion_fp64/compiler.vert.mako b/generated_tests/templates/gen_conversion_fp64/compiler.vert.mako
new file mode 100644
index 0000000..d9148f1
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/compiler.vert.mako
@@ -0,0 +1,3 @@ 
+## coding=utf-8
+<%inherit file="compiler_base.mako"/>\
+<%include file="shader.vert.mako"/>\
diff --git a/generated_tests/templates/gen_conversion_fp64/compiler_base.mako b/generated_tests/templates/gen_conversion_fp64/compiler_base.mako
new file mode 100644
index 0000000..96ecc36
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/compiler_base.mako
@@ -0,0 +1,25 @@ 
+## coding=utf-8
+<%inherit file="base.mako"/>\
+<%
+    (glsl_version, glsl_version_int) = self.versioning()
+%>\
+/* [config]
+ * expect_result: fail
+ * glsl_version: ${glsl_version}
+% if ver == 'GL_ARB_gpu_shader_fp64':
+ * require_extensions: ${ver}
+ * [end config]
+ *
+ * ${ver} spec states:
+ *
+ *     "No implicit conversions are
+ *      provided to convert from unsigned to signed integer types, from
+ *      floating-point to integer types, or from higher-precision to
+ *      lower-precision types.  There are no implicit array or structure
+ *      conversions."
+% else:
+ * [end config]
+% endif
+ */
+
+${next.body()}\
diff --git a/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.frag.shader_test.mako b/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.frag.shader_test.mako
new file mode 100644
index 0000000..2d0123b
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.frag.shader_test.mako
@@ -0,0 +1,8 @@ 
+## coding=utf-8
+<%inherit file="execution_base.mako"/>\
+
+[vertex shader passthrough]
+
+[fragment shader]
+<%include file="shader-zero-sign.frag.mako"/>
+
diff --git a/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.geom.shader_test.mako b/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.geom.shader_test.mako
new file mode 100644
index 0000000..a4fef76
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.geom.shader_test.mako
@@ -0,0 +1,27 @@ 
+## coding=utf-8
+<%inherit file="execution_base.mako"/>\
+
+[vertex shader]
+#version 150
+
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+    vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+<%include file="shader-zero-sign.geom.mako"/>
+[fragment shader]
+#version 150
+
+in vec4 fs_color;
+out vec4 color;
+
+void main()
+{
+    color = fs_color;
+}
+
diff --git a/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.vert.shader_test.mako b/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.vert.shader_test.mako
new file mode 100644
index 0000000..5715a61
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.vert.shader_test.mako
@@ -0,0 +1,16 @@ 
+## coding=utf-8
+<%inherit file="execution_base.mako"/>\
+
+[vertex shader]
+<%include file="shader-zero-sign.vert.mako"/>
+[fragment shader]
+#version 150
+
+in vec4 fs_color;
+out vec4 color;
+
+void main()
+{
+    color = fs_color;
+}
+
diff --git a/generated_tests/templates/gen_conversion_fp64/execution.frag.shader_test.mako b/generated_tests/templates/gen_conversion_fp64/execution.frag.shader_test.mako
new file mode 100644
index 0000000..60507ee
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/execution.frag.shader_test.mako
@@ -0,0 +1,7 @@ 
+## coding=utf-8
+<%inherit file="execution_base.mako"/>\
+
+[vertex shader passthrough]
+
+[fragment shader]
+<%include file="shader.frag.mako"/>
diff --git a/generated_tests/templates/gen_conversion_fp64/execution.geom.shader_test.mako b/generated_tests/templates/gen_conversion_fp64/execution.geom.shader_test.mako
new file mode 100644
index 0000000..ed53475
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/execution.geom.shader_test.mako
@@ -0,0 +1,27 @@ 
+## coding=utf-8
+<%inherit file="execution_base.mako"/>\
+
+[vertex shader]
+#version 150
+
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+    vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+<%include file="shader.geom.mako"/>
+[fragment shader]
+#version 150
+
+in vec4 fs_color;
+out vec4 color;
+
+void main()
+{
+    color = fs_color;
+}
+
diff --git a/generated_tests/templates/gen_conversion_fp64/execution.vert.shader_test.mako b/generated_tests/templates/gen_conversion_fp64/execution.vert.shader_test.mako
new file mode 100644
index 0000000..a0d13c2
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/execution.vert.shader_test.mako
@@ -0,0 +1,16 @@ 
+## coding=utf-8
+<%inherit file="execution_base.mako"/>\
+
+[vertex shader]
+<%include file="shader.vert.mako"/>
+[fragment shader]
+#version 150
+
+in vec4 fs_color;
+out vec4 color;
+
+void main()
+{
+    color = fs_color;
+}
+
diff --git a/generated_tests/templates/gen_conversion_fp64/execution_base.mako b/generated_tests/templates/gen_conversion_fp64/execution_base.mako
new file mode 100644
index 0000000..419259c
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/execution_base.mako
@@ -0,0 +1,28 @@ 
+## coding=utf-8
+<%inherit file="base.mako"/>\
+<%
+    (glsl_version, glsl_version_int) = self.versioning()
+%>\
+<%! from six.moves import range %>\
+[require]
+GLSL >= ${glsl_version}
+% if ver == 'GL_ARB_gpu_shader_fp64':
+${ver}
+% endif
+${next.body()}\
+[test]
+% for conversion in conversions:
+uniform ${uniform_from_type} from \
+% for i in range(amount):
+${conversion['from']} \
+% endfor
+
+uniform ${uniform_to_type} to \
+% for i in range(amount):
+${conversion['to']} \
+% endfor
+
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
+
+% endfor
diff --git a/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.frag.mako b/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.frag.mako
new file mode 100644
index 0000000..1a38b7a
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.frag.mako
@@ -0,0 +1,18 @@ 
+## coding=utf-8
+<%inherit file="shader_base.mako"/>\
+uniform ${from_type} from;
+uniform ${to_type} to;
+
+out vec4 color;
+
+#define ONE 1.0
+#define RED vec4(1.0, 0.0, 0.0, 1.0)
+#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
+
+void main()
+{
+    ${to_type} pre_converted = ${converted_from};
+    ${to_type} converted = ONE / pre_converted;
+    bool match = converted == to;
+    color = match ? GREEN : RED;
+}
diff --git a/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.geom.mako b/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.geom.mako
new file mode 100644
index 0000000..22f366f
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.geom.mako
@@ -0,0 +1,27 @@ 
+## coding=utf-8
+<%inherit file="shader_base.mako"/>\
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform ${from_type} from;
+uniform ${to_type} to;
+
+in vec4 vertex_to_gs[3];
+out vec4 fs_color;
+
+#define ONE 1.0
+#define RED vec4(1.0, 0.0, 0.0, 1.0)
+#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
+
+void main()
+{
+    ${to_type} pre_converted = ${converted_from};
+    ${to_type} converted = ONE / pre_converted;
+    bool match = converted == to;
+    fs_color = match ? GREEN : RED;
+
+    for (int i = 0; i < 3; i++) {
+        gl_Position = vertex_to_gs[i];
+        EmitVertex();
+    }
+}
diff --git a/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.vert.mako b/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.vert.mako
new file mode 100644
index 0000000..a49add1
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.vert.mako
@@ -0,0 +1,20 @@ 
+## coding=utf-8
+<%inherit file="shader_base.mako"/>\
+uniform ${from_type} from;
+uniform ${to_type} to;
+
+in vec4 piglit_vertex;
+out vec4 fs_color;
+
+#define ONE 1.0
+#define RED vec4(1.0, 0.0, 0.0, 1.0)
+#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
+
+void main()
+{
+    gl_Position = piglit_vertex;
+    ${to_type} pre_converted = ${converted_from};
+    ${to_type} converted = ONE / pre_converted;
+    bool match = converted == to;
+    fs_color = match ? GREEN : RED;
+}
diff --git a/generated_tests/templates/gen_conversion_fp64/shader.frag.mako b/generated_tests/templates/gen_conversion_fp64/shader.frag.mako
new file mode 100644
index 0000000..346b77b
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/shader.frag.mako
@@ -0,0 +1,16 @@ 
+## coding=utf-8
+<%inherit file="shader_base.mako"/>\
+uniform ${from_type} from;
+uniform ${to_type} to;
+
+out vec4 color;
+
+#define RED vec4(1.0, 0.0, 0.0, 1.0)
+#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
+
+void main()
+{
+    ${to_type} converted = ${converted_from};
+    bool match = converted == to;
+    color = match ? GREEN : RED;
+}
diff --git a/generated_tests/templates/gen_conversion_fp64/shader.geom.mako b/generated_tests/templates/gen_conversion_fp64/shader.geom.mako
new file mode 100644
index 0000000..987adbc
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/shader.geom.mako
@@ -0,0 +1,25 @@ 
+## coding=utf-8
+<%inherit file="shader_base.mako"/>\
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform ${from_type} from;
+uniform ${to_type} to;
+
+in vec4 vertex_to_gs[3];
+out vec4 fs_color;
+
+#define RED vec4(1.0, 0.0, 0.0, 1.0)
+#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
+
+void main()
+{
+    ${to_type} converted = ${converted_from};
+    bool match = converted == to;
+    fs_color = match ? GREEN : RED;
+
+    for (int i = 0; i < 3; i++) {
+        gl_Position = vertex_to_gs[i];
+        EmitVertex();
+    }
+}
diff --git a/generated_tests/templates/gen_conversion_fp64/shader.vert.mako b/generated_tests/templates/gen_conversion_fp64/shader.vert.mako
new file mode 100644
index 0000000..8f5c797
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/shader.vert.mako
@@ -0,0 +1,18 @@ 
+## coding=utf-8
+<%inherit file="shader_base.mako"/>\
+uniform ${from_type} from;
+uniform ${to_type} to;
+
+in vec4 piglit_vertex;
+out vec4 fs_color;
+
+#define RED vec4(1.0, 0.0, 0.0, 1.0)
+#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
+
+void main()
+{
+    gl_Position = piglit_vertex;
+    ${to_type} converted = ${converted_from};
+    bool match = converted == to;
+    fs_color = match ? GREEN : RED;
+}
diff --git a/generated_tests/templates/gen_conversion_fp64/shader_base.mako b/generated_tests/templates/gen_conversion_fp64/shader_base.mako
new file mode 100644
index 0000000..33d88b8
--- /dev/null
+++ b/generated_tests/templates/gen_conversion_fp64/shader_base.mako
@@ -0,0 +1,11 @@ 
+## coding=utf-8
+<%inherit file="base.mako"/>\
+<%
+    (glsl_version, glsl_version_int) = self.versioning()
+%>\
+#version ${glsl_version_int}
+% if ver == 'GL_ARB_gpu_shader_fp64':
+#extension GL_ARB_gpu_shader_fp64 : require
+% endif
+
+${next.body()}\
diff --git a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-double-float-bad.vert b/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-double-float-bad.vert
deleted file mode 100644
index 3e2b15a..0000000
--- a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-double-float-bad.vert
+++ /dev/null
@@ -1,20 +0,0 @@ 
-// [config]
-// expect_result: fail
-// glsl_version: 1.50
-// require_extensions: GL_ARB_gpu_shader_fp64
-// [end config]
-//
-// Test double -> float implicit conversion doesn't happen
-
-#version 150
-#extension GL_ARB_gpu_shader_fp64 : enable
-
-float _float = 0.0f;
-
-double _double = 0.0lf;
-
-void test() {
-
-    /* double cannot be converted to float (and for vectors of same) */
-    _float = _double;
-}
diff --git a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec2-vec2-bad.vert b/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec2-vec2-bad.vert
deleted file mode 100644
index 225636d..0000000
--- a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec2-vec2-bad.vert
+++ /dev/null
@@ -1,20 +0,0 @@ 
-// [config]
-// expect_result: fail
-// glsl_version: 1.50
-// require_extensions: GL_ARB_gpu_shader_fp64
-// [end config]
-//
-// Test double -> float implicit conversion doesn't happen
-
-#version 150
-#extension GL_ARB_gpu_shader_fp64 : enable
-
-vec2 _vec2 = vec2(0.0f);
-
-dvec2 _dvec2 = dvec2(0.0lf);
-
-void test() {
-
-    /* double cannot be converted to float (and for vectors of same) */
-    _vec2 = _dvec2;
-}
diff --git a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec3-vec3-bad.vert b/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec3-vec3-bad.vert
deleted file mode 100644
index cf8583e..0000000
--- a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec3-vec3-bad.vert
+++ /dev/null
@@ -1,20 +0,0 @@ 
-// [config]
-// expect_result: fail
-// glsl_version: 1.50
-// require_extensions: GL_ARB_gpu_shader_fp64
-// [end config]
-//
-// Test double -> float implicit conversion doesn't happen
-
-#version 150
-#extension GL_ARB_gpu_shader_fp64 : enable
-
-vec3 _vec3 = vec3(0.0f);
-
-dvec3 _dvec3 = dvec3(0.0lf);
-
-void test() {
-
-    /* double cannot be converted to float (and for vectors of same) */
-    _vec3 = _dvec3;
-}
diff --git a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec4-vec4-bad.vert b/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec4-vec4-bad.vert
deleted file mode 100644
index dd394e5..0000000
--- a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec4-vec4-bad.vert
+++ /dev/null
@@ -1,20 +0,0 @@ 
-// [config]
-// expect_result: fail
-// glsl_version: 1.50
-// require_extensions: GL_ARB_gpu_shader_fp64
-// [end config]
-//
-// Test double -> float implicit conversion doesn't happen
-
-#version 150
-#extension GL_ARB_gpu_shader_fp64 : enable
-
-vec4 _vec4 = vec4(0.0f);
-
-dvec4 _dvec4 = dvec4(0.0lf);
-
-void test() {
-
-    /* double cannot be converted to float (and for vectors of same) */
-    _vec4 = _dvec4;
-}
diff --git a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversions.vert b/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversions.vert
deleted file mode 100644
index 0b88b40..0000000
--- a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversions.vert
+++ /dev/null
@@ -1,115 +0,0 @@ 
-// [config]
-// expect_result: pass
-// glsl_version: 1.50
-// require_extensions: GL_ARB_gpu_shader_fp64
-// [end config]
-//
-// Test that implicit conversions are allowed as specified in GL_ARB_gpu_shader_fp64
-//
-// GL_ARB_gpu_shader_fp64 spec presents following conversion table:
-//
-//                             Can be implicitly
-//     Type of expression        converted to
-//     ---------------------   -------------------
-//     int                     uint(*), float, double
-//     ivec2                   uvec2(*), vec2, dvec2
-//     ivec3                   uvec3(*), vec3, dvec3
-//     ivec4                   uvec4(*), vec4, dvec4
-//
-//     uint                    float, double
-//     uvec2                   vec2, dvec2
-//     uvec3                   vec3, dvec3
-//     uvec4                   vec4, dvec4
-//
-//     float                   double
-//     vec2                    dvec2
-//     vec3                    dvec3
-//     vec4                    dvec4
-//
-//     mat2                    dmat2
-//     mat3                    dmat3
-//     mat4                    dmat4
-//     mat2x3                  dmat2x3
-//     mat2x4                  dmat2x4
-//     mat3x2                  dmat3x2
-//     mat3x4                  dmat3x4
-//     mat4x2                  dmat4x2
-//     mat4x3                  dmat4x3
-//
-//     (*) if ARB_gpu_shader5 or NV_gpu_shader5 is supported
-//
-
-#version 150
-#extension GL_ARB_gpu_shader_fp64 : enable
-
-int _int = 0;
-ivec2 _ivec2 = ivec2(0);
-ivec3 _ivec3 = ivec3(0);
-ivec4 _ivec4 = ivec4(0);
-
-uint _uint = 0u;
-uvec2 _uvec2 = uvec2(0u);
-uvec3 _uvec3 = uvec3(0u);
-uvec4 _uvec4 = uvec4(0u);
-
-float _float = 0.0f;
-vec2 _vec2 = vec2(0.0f);
-vec3 _vec3 = vec3(0.0f);
-vec4 _vec4 = vec4(0.0f);
-
-double _double;
-dvec2 _dvec2;
-dvec3 _dvec3;
-dvec4 _dvec4;
-
-mat2 _mat2 = mat2(1.0);
-mat3 _mat3 = mat3(1.0);
-mat4 _mat4 = mat4(1.0);
-mat2x3 _mat2x3 = mat2x3(1.0);
-mat2x4 _mat2x4 = mat2x4(1.0);
-mat3x2 _mat3x2 = mat3x2(1.0);
-mat3x4 _mat3x4 = mat3x4(1.0);
-mat4x2 _mat4x2 = mat4x2(1.0);
-mat4x3 _mat4x3 = mat4x3(1.0);
-
-dmat2 _dmat2;
-dmat3 _dmat3;
-dmat4 _dmat4;
-dmat2x3 _dmat2x3;
-dmat2x4 _dmat2x4;
-dmat3x2 _dmat3x2;
-dmat3x4 _dmat3x4;
-dmat4x2 _dmat4x2;
-dmat4x3 _dmat4x3;
-
-void test() {
-
-	/* int can be converted to double (and for vectors of same) */
-	_double = _int;
-	_dvec2 = _ivec2;
-	_dvec3 = _ivec3;
-	_dvec4 = _ivec4;
-
-	/* uint can be converted to double (and for vectors of same) */
-	_double = _uint;
-	_dvec2 = _uvec2;
-	_dvec3 = _uvec3;
-	_dvec4 = _uvec4;
-
-	/* float can be converted to double (and for vectors of same) */
-	_double = _float;
-	_dvec2 = _vec2;
-	_dvec3 = _vec3;
-	_dvec4 = _vec4;
-
-	/* mat -> dmat conversions */
-	_dmat2 = _mat2;
-	_dmat3 = _mat3;
-	_dmat4 = _mat4;
-	_dmat2x3 = _mat2x3;
-	_dmat2x4 = _mat2x4;
-	_dmat3x2 = _mat3x2;
-	_dmat3x4 = _mat3x4;
-	_dmat4x2 = _mat4x2;
-	_dmat4x3 = _mat4x3;
-}

Comments

Quoting Andres Gomez (2016-04-14 02:40:25)
> Also, removed 5 redundant tests replaced by
> the generator.
> 
> Signed-off-by: Andres Gomez <agomez@igalia.com>
> ---
>  generated_tests/CMakeLists.txt                     |  24 +
>  generated_tests/gen_conversion_fp64.py             | 604 +++++++++++++++++++++
>  .../templates/gen_conversion_fp64/base.mako        |  12 +
>  .../gen_conversion_fp64/compiler.frag.mako         |   3 +
>  .../gen_conversion_fp64/compiler.geom.mako         |   3 +
>  .../gen_conversion_fp64/compiler.vert.mako         |   3 +
>  .../gen_conversion_fp64/compiler_base.mako         |  25 +
>  .../execution-zero-sign.frag.shader_test.mako      |   8 +
>  .../execution-zero-sign.geom.shader_test.mako      |  27 +
>  .../execution-zero-sign.vert.shader_test.mako      |  16 +
>  .../execution.frag.shader_test.mako                |   7 +
>  .../execution.geom.shader_test.mako                |  27 +
>  .../execution.vert.shader_test.mako                |  16 +
>  .../gen_conversion_fp64/execution_base.mako        |  28 +
>  .../gen_conversion_fp64/shader-zero-sign.frag.mako |  18 +
>  .../gen_conversion_fp64/shader-zero-sign.geom.mako |  27 +
>  .../gen_conversion_fp64/shader-zero-sign.vert.mako |  20 +
>  .../templates/gen_conversion_fp64/shader.frag.mako |  16 +
>  .../templates/gen_conversion_fp64/shader.geom.mako |  25 +
>  .../templates/gen_conversion_fp64/shader.vert.mako |  18 +
>  .../templates/gen_conversion_fp64/shader_base.mako |  11 +
>  .../implicit-conversion-double-float-bad.vert      |  20 -
>  .../implicit-conversion-dvec2-vec2-bad.vert        |  20 -
>  .../implicit-conversion-dvec3-vec3-bad.vert        |  20 -
>  .../implicit-conversion-dvec4-vec4-bad.vert        |  20 -
>  .../compiler/implicit-conversions.vert             | 115 ----
>  26 files changed, 938 insertions(+), 195 deletions(-)
>  create mode 100644 generated_tests/gen_conversion_fp64.py
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/base.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/compiler.frag.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/compiler.geom.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/compiler.vert.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/compiler_base.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/execution-zero-sign.frag.shader_test.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/execution-zero-sign.geom.shader_test.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/execution-zero-sign.vert.shader_test.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/execution.frag.shader_test.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/execution.geom.shader_test.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/execution.vert.shader_test.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/execution_base.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/shader-zero-sign.frag.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/shader-zero-sign.geom.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/shader-zero-sign.vert.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/shader.frag.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/shader.geom.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/shader.vert.mako
>  create mode 100644 generated_tests/templates/gen_conversion_fp64/shader_base.mako
>  delete mode 100644 tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-double-float-bad.vert
>  delete mode 100644 tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec2-vec2-bad.vert
>  delete mode 100644 tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec3-vec3-bad.vert
>  delete mode 100644 tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec4-vec4-bad.vert
>  delete mode 100644 tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversions.vert
> 
> diff --git a/generated_tests/CMakeLists.txt b/generated_tests/CMakeLists.txt
> index 3c5b11a..c2505e2 100644
> --- a/generated_tests/CMakeLists.txt
> +++ b/generated_tests/CMakeLists.txt
> @@ -130,6 +130,29 @@ piglit_make_generated_tests(
>         templates/gen_flat_interpolation_qualifier/template.frag.mako
>         )
>  piglit_make_generated_tests(
> +       conversion_fp64.list
> +       gen_conversion_fp64.py
> +       templates/gen_conversion_fp64/base.mako
> +       templates/gen_conversion_fp64/compiler.frag.mako
> +       templates/gen_conversion_fp64/compiler.geom.mako
> +       templates/gen_conversion_fp64/compiler.vert.mako
> +       templates/gen_conversion_fp64/compiler_base.mako
> +       templates/gen_conversion_fp64/execution-zero-sign.frag.shader_test.mako
> +       templates/gen_conversion_fp64/execution-zero-sign.geom.shader_test.mako
> +       templates/gen_conversion_fp64/execution-zero-sign.vert.shader_test.mako
> +       templates/gen_conversion_fp64/execution.frag.shader_test.mako
> +       templates/gen_conversion_fp64/execution.geom.shader_test.mako
> +       templates/gen_conversion_fp64/execution.vert.shader_test.mako
> +       templates/gen_conversion_fp64/execution_base.mako
> +       templates/gen_conversion_fp64/shader-zero-sign.frag.mako
> +       templates/gen_conversion_fp64/shader-zero-sign.geom.mako
> +       templates/gen_conversion_fp64/shader-zero-sign.vert.mako
> +       templates/gen_conversion_fp64/shader.frag.mako
> +       templates/gen_conversion_fp64/shader.geom.mako
> +       templates/gen_conversion_fp64/shader.vert.mako
> +       templates/gen_conversion_fp64/shader_base.mako
> +       )
> +piglit_make_generated_tests(
>         shader_precision_tests.list
>         gen_shader_precision_tests.py
>         builtin_function.py
> @@ -188,6 +211,7 @@ add_custom_target(gen-gl-tests
>                         constant_array_size_tests_fp64.list
>                         inout_fp64.list
>                         flat_interpolation_qualifier.list
> +                       conversion_fp64.list
>                         shader_precision_tests.list
>                         shader_image_load_store_tests.list
>                         variable_index_read_tests.list
> diff --git a/generated_tests/gen_conversion_fp64.py b/generated_tests/gen_conversion_fp64.py
> new file mode 100644
> index 0000000..5fe0bf2
> --- /dev/null
> +++ b/generated_tests/gen_conversion_fp64.py
> @@ -0,0 +1,604 @@
> +# coding=utf-8
> +#
> +# Copyright © 2016 Intel Corporation
> +#
> +# Permission is hereby granted, free of charge, to any person obtaining a
> +# copy of this software and associated documentation files (the "Software"),
> +# to deal in the Software without restriction, including without limitation
> +# the rights to use, copy, modify, merge, publish, distribute, sublicense,
> +# and/or sell copies of the Software, and to permit persons to whom the
> +# Software is furnished to do so, subject to the following conditions:
> +#
> +# The above copyright notice and this permission notice (including the next
> +# paragraph) shall be included in all copies or substantial portions of the
> +# Software.
> +#
> +# 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.
> +
> +"""Generate fp64 types conversion tests."""
> +
> +from __future__ import print_function, division, absolute_import
> +import abc
> +import argparse
> +import os
> +import itertools
> +import struct

small nit, could you put a newline between numpy ans struct, and then
sort the above imports?

> +import numpy as np
> +
> +from templates import template_dir
> +from modules import utils
> +
> +TEMPLATES = template_dir(os.path.basename(os.path.splitext(__file__)[0]))
> +
> +# pylint: disable=bad-whitespace,line-too-long,bad-continuation
> +DOUBLE_INFS                 = ['0xfff0000000000000', # -inf
> +                               '0x7ff0000000000000'] # +inf
> +
> +DOUBLE_NEG_ZERO             = ['0x8000000000000000'] # Negative underflow (-0.0)
> +
> +DOUBLE_POS_ZERO             = ['0x0000000000000000'] # Positive underflow (+0.0)
> +
> +# Double values causing an underflow to zero in any other type
> +DOUBLE_DENORMAL_VALUES      = ['0x800fffffffffffff', # Negative maximum denormalized -- Denormalized may be flushed to 0
> +                               '0x8000000000000001', # Negative minimum denormalized -- Denormalized may be flushed to 0
> +                               '0x0000000000000001', # Positive minimum denormalized -- Denormalized may be flushed to 0
> +                               '0x000fffffffffffff'] # Positive maximum denormalized -- Denormalized may be flushed to 0
> +
> +DOUBLE_NORMAL_VALUES        = ['0x8010000000000000', # Negative minimum normalized
> +                               '0x0010000000000000'] # Positive minimum normalized
> +
> +# Double +/-inf
> +DOUBLE_FLOAT_INFS           = ['0xc7effffff0000000', # Negative overflow (-inf)
> +                               '0x47effffff0000000'] # Positive overflow (+inf)
> +
> +DOUBLE_FLOAT_VALUES         = ['0xc7efffffefffffff', # Negative maximum normalized
> +                               '0xc170000000000000', # -16777216.0
> +                               '0xc014000000000000', # -5.0
> +                               '0xbfff25ce60000000', # -1.9467300176620483
> +                               '0xb80fffffe0000000', # Negative minimum normalized
> +                               '0xb69fffffffffffff', # Negative underflow
> +                               '0x369fffffffffffff', # Positive underflow
> +                               '0x380fffffe0000000', # Positive minimum normalized
> +                               '0x3fff25ce60000000', # +1.9467300176620483
> +                               '0x4014000000000000', # +5.0
> +                               '0x4170000000000000', # +16777216.0
> +                               '0x47efffffefffffff'] # Positive maximum normalized
> +
> +DOUBLE_UINT_VALUES          = ['0xbfeccccccccccccd', # -0.9
> +                               #'0x8010000000000000', # Negative minimum normalized          -- Already checked
> +                               #'0x800fffffffffffff', # Negative maximum denormalized        -- Already checked
> +                               #'0x8000000000000001', # Negative minimum denormalized        -- Already checked
> +                               #'0x8000000000000000', # Negative minimum        (-0)         -- Already checked
> +                               #'0x0000000000000000', # Positive minimum        (+0)         -- Already checked
> +                               '0x3fff25ce60000000', # +1.9467300176620483
> +                               '0x4014000000000000', # +5.0
> +                               '0x4170000000000000', # +16777216.0
> +                               '0x41dfffffffc00000', # Signed int low frontier (+2147483647)
> +                               '0x41e0000000000000', # Signed int up frontier  (+2147483648)
> +                               '0x41efffffffe00000'] # Maximum                 (+4294967295)
> +
> +DOUBLE_INT_VALUES           = ['0xc1e0000000000000', # Minimum          (-2147483648)
> +                               '0xc170000000000000', # -16777216.0
> +                               '0xc014000000000000', # -5.0
> +                               '0xbfff25ce60000000', # -1.9467300176620483
> +                               #'0x8000000000000000', # Negative minimum        (-0)         -- Already checked
> +                               #'0x0000000000000000', # Minimum                 (+0)         -- Already checked
> +                               '0x3fff25ce60000000', # +1.9467300176620483
> +                               '0x4014000000000000', # +5.0
> +                               '0x4170000000000000', # +16777216.0
> +                               '0x41dfffffffc00000'] # Maximum          (+2147483647)
> +
> +DOUBLE_BOOL_VALUES          = [#'0x8010000000000000', # Minimum negative True value -- Already checked
> +                               #'0x0000000000000000', # False                       -- Already checked
> +                               #'0x0010000000000000', # Minimum positive True value -- Already checked
> +                              ]
> +
> +FLOAT_INFS                  = ['0xff800000', # -inf
> +                               '0x7f800000'] # +inf
> +
> +FLOAT_NEG_ZERO              = ['0x80000000'] # Negative underflow (-0.0)
> +
> +FLOAT_POS_ZERO              = ['0x00000000'] # Positive underflow (+0.0)
> +
> +FLOAT_VALUES                = ['0xff7fffff', # Negative maximum normalized
> +                               '0xcb800000', # -16777216.0
> +                               '0xc0a00000', # -5.0
> +                               '0xbff92e73', # -1.9467300176620483
> +                               '0x80800000', # Negative minimum normalized
> +                               #'0x807fffff', # Negative maximum denormalized -- Denormalized may be flushed to 0
> +                               #'0x80000001', # Negative minimum denormalized -- Denormalized may be flushed to 0
> +                               #'0x00000001', # Positive minimum denormalized -- Denormalized may be flushed to 0
> +                               #'0x007fffff', # Positive maximum denormalized -- Denormalized may be flushed to 0
> +                               '0x00800000', # Positive minimum normalized
> +                               '0x3ff92e73', # +1.9467300176620483
> +                               '0x40a00000', # +5.0
> +                               '0x4b800000', # +16777216.0
> +                               '0x7f7fffff'] # Positive maximum normalized
> +
> +UINT_VALUES                 = ['0', # Minimum
> +                               '5',
> +                               '2147483647', # Signed int low frontier
> +                               '2147483648', # Signed int up frontier
> +                               '4294967295'] # Maximum
> +
> +INT_VALUES                  = ['-2147483648', # Minimum
> +                               '-5',
> +                               '-1',
> +                               '0',
> +                               '1',
> +                               '5',
> +                               '2147483647'] # Maximum
> +
> +BOOL_VALUES                 = ['0', # False
> +                               '1'] # True
> +# pylint: enable=bad-whitespace,line-too-long,bad-continuation
> +
> +def get_dir_name(ver, test_type):
> +    """Returns the directory name to save tests given a GLSL version and a
> +       test type.
> +    """
> +
> +    assert isinstance(ver, str)
> +    assert isinstance(test_type, str)
> +    if ver.startswith('GL_'):
> +        feature_dir = ver[3:].lower()
> +    else:
> +        feature_dir = 'glsl-{}.{}'.format(ver[0], ver[1:])
> +
> +    return os.path.join('spec', feature_dir, test_type,
> +                        'conversion')
> +
> +
> +class TestTuple(object):
> +    """A float64 derived and other type derived tuple to generate the
> +       needed conversion tests.
> +    """
> +
> +    @staticmethod
> +    def float_to_hex(fvalue):
> +        """Returns the hexadecimal representation from a float32 value."""
> +        assert isinstance(fvalue, np.float32)
> +        return hex(struct.unpack('<I', struct.pack('<f', fvalue))[0])
> +
> +    @staticmethod
> +    def double_to_hex(fvalue):
> +        """Returns the hexadecimal representation from a float64 value."""
> +        assert isinstance(fvalue, float)
> +        return hex(struct.unpack('<Q', struct.pack('<d', fvalue))[0]).rstrip("L")
> +
> +    @staticmethod
> +    def hex_to_float(hstr):
> +        """Returns a float32 value from its hexadecimal representation."""
> +        assert isinstance(hstr, str)
> +        return struct.unpack('<f', struct.pack('<I', int(hstr, 16)))[0]
> +
> +    @staticmethod
> +    def hex_to_double(hstr):
> +        """Returns a float64 value from its hexadecimal representation."""
> +
> +        assert isinstance(hstr, str)
> +        return struct.unpack('<d', struct.pack('<Q', int(hstr, 16)))[0]
> +
> +    @staticmethod
> +    def float_hex_to_double_hex(hstr):
> +        """Returns the float64 hexadecimal representation from a float32
> +           hexadecimal representation.
> +        """
> +        assert isinstance(hstr, str)
> +        double_value = TestTuple.hex_to_float(hstr)
> +        return TestTuple.double_to_hex(double_value)
> +
> +    @staticmethod
> +    def float_hex_to_inv_double_hex(hstr):
> +        """Returns the inverted float64 hexadecimal representation from a
> +           float32 hexadecimal representation.
> +        """
> +        assert isinstance(hstr, str)
> +        temp = TestTuple.hex_to_float(hstr)
> +        double_value = np.divide(1.0, temp)
> +        return TestTuple.double_to_hex(double_value)
> +
> +    @staticmethod
> +    def int_str_to_double_str(istr):
> +        """Returns a float64 string from an int32 string."""
> +        assert isinstance(istr, str)
> +        return str(float(istr))
> +
> +    @staticmethod
> +    def doble_hex_to_bool_str(hstr):
> +        """Returns a bool string from a float64 hexadecimal representation."""
> +        assert isinstance(hstr, str)
> +        bool_double = TestTuple.hex_to_double(hstr)
> +        return '1' if bool_double != 0.0 else '0'
> +
> +    @staticmethod
> +    def doble_hex_to_int_str(hstr):
> +        """Returns an int32 string from a float64 hexadecimal
> +           representation.
> +        """
> +        assert isinstance(hstr, str)
> +        int_double = TestTuple.hex_to_double(hstr)
> +        if int_double > np.iinfo(np.dtype('int32')).max:
> +            return str(np.iinfo(np.dtype('int32')).max)
> +        if int_double < np.iinfo(np.dtype('int32')).min:
> +            return str(np.iinfo(np.dtype('int32')).min)
> +        return str(int(int_double))
> +
> +    @staticmethod
> +    def doble_hex_to_uint_str(hstr):
> +        """Returns an uint32 string from a float64 hexadecimal
> +           representation.
> +        """
> +        assert isinstance(hstr, str)
> +        uint_double = TestTuple.hex_to_double(hstr)
> +        if uint_double > np.iinfo(np.dtype('uint32')).max:
> +            return str(np.iinfo(np.dtype('uint32')).max)
> +        if uint_double < np.iinfo(np.dtype('uint32')).min:
> +            return str(np.iinfo(np.dtype('uint32')).min)
> +        return str(int(uint_double))
> +
> +    @staticmethod
> +    def doble_hex_to_float_hex(hstr):
> +        """Returns the float32 hexadecimal representation from a float64
> +           hexadecimal representation.
> +        """
> +        assert isinstance(hstr, str)
> +        float_double = np.float32(TestTuple.hex_to_double(hstr))
> +        return TestTuple.float_to_hex(float_double)
> +
> +    @staticmethod
> +    def doble_hex_to_inv_float_hex(hstr):
> +        """Returns the inverted float32 hexadecimal representation from a
> +           float64 hexadecimal representation.
> +        """
> +        assert isinstance(hstr, str)
> +        temp = np.divide(1.0, TestTuple.hex_to_double(hstr))
> +        float_double = np.float32(temp)
> +        return TestTuple.float_to_hex(float_double)
> +
> +    def __init__(self, ver, stage,
> +                 first_dimension, second_dimension,
> +                 basic_type, names_only):
> +        assert stage in ('vert', 'geom', 'frag')
> +        assert first_dimension in ('1', '2', '3', '4')
> +        assert second_dimension in ('1', '2', '3', '4')
> +        assert isinstance(names_only, bool)
> +
> +        self._ver = ver
> +        self._stage = stage
> +        self._basic_type = basic_type
> +        self._names_only = names_only
> +        self._double_type = ''
> +        self._conversion_type = ''
> +        self._uniform_type = ''
> +        self._amount = int(first_dimension) * int(second_dimension)
> +        self._filenames = []
> +
> +        if first_dimension != '1':
> +            dimensional_type = 'mat' + first_dimension
> +            if first_dimension != second_dimension:
> +                dimensional_type += 'x' + second_dimension
> +        elif second_dimension != '1':
> +            dimensional_type = 'vec' + second_dimension
> +        else:
> +            dimensional_type = ''
> +
> +        if dimensional_type == '':
> +            if basic_type == 'b':
> +                self._conversion_type = 'bool'
> +                self._uniform_type = 'int'
> +            elif basic_type == 'i':
> +                self._conversion_type = 'int'
> +            elif basic_type == 'u':
> +                self._conversion_type = 'uint'
> +            elif basic_type == 'f':
> +                self._conversion_type = 'float'
> +            self._double_type = 'double'
> +            if self._uniform_type == '':
> +                self._uniform_type = self._conversion_type
> +        else:
> +            self._conversion_type = (basic_type if basic_type != 'f' else '') + dimensional_type
> +            if basic_type == 'b':
> +                self._uniform_type = 'i' + dimensional_type
> +            else:
> +                self._uniform_type = self._conversion_type
> +            self._double_type = 'd' + dimensional_type
> +
> +    @abc.abstractmethod
> +    def _gen_to_double(self):
> +        """Generates the test files for conversions to float64."""
> +
> +    @abc.abstractmethod
> +    def _gen_from_double(self):
> +        """Generates the test files for conversions from float64."""
> +
> +    @property
> +    def filenames(self):
> +        """Returns the test file names this tuple will generate."""
> +        if self._filenames == []:
> +            tmp = self._names_only
> +            self._names_only = True
> +            self.generate_test_files()
> +            self._names_only = tmp
> +        return self._filenames
> +
> +    def generate_test_files(self):
> +        """Generate the GLSL parser tests."""
> +        self._filenames = []
> +
> +        self._gen_to_double()
> +        self._gen_from_double()
> +
> +
> +class RegularTestTuple(TestTuple):
> +    """Derived class for conversion tests using regular values within the
> +       edges of the used types.
> +    """
> +
> +    @staticmethod
> +    def all_tests(names_only):
> +        """Returns all the possible contained conversion test instances."""
> +
> +        assert isinstance(names_only, bool)
> +        stages = ['vert', 'geom', 'frag']
> +        dimensions = ['1', '2', '3', '4']
> +        basic_types = ['b', 'u', 'i', 'f']
> +        glsl_ver = ['GL_ARB_gpu_shader_fp64', '400']
> +
> +        if not names_only:
> +            test_types = ['compiler', 'execution']
> +            for ver, test_type in itertools.product(glsl_ver, test_types):
> +                utils.safe_makedirs(get_dir_name(ver, test_type))
> +
> +        for ver, stage, first_dimension, second_dimension, basic_type in itertools.product(
> +                glsl_ver,
> +                stages,
> +                dimensions,
> +                dimensions,
> +                basic_types):
> +            if not (first_dimension != '1' and (second_dimension == '1' or basic_type != 'f')):
> +                yield RegularTestTuple(ver, stage,
> +                                       first_dimension, second_dimension,
> +                                       basic_type, names_only)
> +
> +    def __init__(self, ver, stage,
> +                 first_dimension, second_dimension,
> +                 basic_type, names_only):
> +        assert ver in ('GL_ARB_gpu_shader_fp64', '400')
> +        assert basic_type in ('b', 'u', 'i', 'f')
> +        assert not (first_dimension != '1' and (second_dimension == '1' or basic_type != 'f'))
> +        super(RegularTestTuple, self).__init__(ver, stage,
> +                                               first_dimension, second_dimension,
> +                                               basic_type, names_only)
> +
> +    def _gen_comp_test(self, from_type, to_type, converted_from):
> +        filename = os.path.join(
> +            get_dir_name(self._ver, 'compiler'),
> +            '{}-conversion-implicit-{}-{}-bad.{}'.format(self._stage, from_type, to_type,
> +                                                         self._stage))
> +
> +        self._filenames.append(filename)
> +
> +        if not self._names_only:
> +            with open(filename, 'w') as test_file:
> +                test_file.write(TEMPLATES.get_template(
> +                    'compiler.{}.mako'.format(self._stage)).render_unicode(
> +                        ver=self._ver,
> +                        from_type=from_type,
> +                        to_type=to_type,
> +                        converted_from=converted_from))
> +
> +    def _gen_exec_test(self, from_type, to_type,
> +                       uniform_from_type, uniform_to_type,
> +                       explicit, converted_from, conversions):
> +        filename = os.path.join(
> +            get_dir_name(self._ver, 'execution'),
> +            '{}-conversion-{}-{}-{}.shader_test'.format(self._stage, explicit,
> +                                                        from_type, to_type))
> +
> +        self._filenames.append(filename)
> +
> +        if not self._names_only:
> +            with open(filename, 'w') as test_file:
> +                test_file.write(TEMPLATES.get_template(
> +                    'execution.{}.shader_test.mako'.format(self._stage)).render_unicode(
> +                        ver=self._ver,
> +                        amount=self._amount,
> +                        from_type=from_type,
> +                        to_type=to_type,
> +                        converted_from=converted_from,
> +                        uniform_from_type=uniform_from_type,
> +                        uniform_to_type=uniform_to_type,
> +                        conversions=conversions))
> +
> +    def _gen_to_double(self):
> +        converted_from = 'from'
> +        explicit = 'implicit'
> +
> +        if self._basic_type == 'b':
> +            explicit = 'explicit'
> +            self._gen_comp_test(self._conversion_type, self._double_type,
> +                                converted_from)
> +            converted_from = self._double_type + '(from)'
> +            conversion_values = BOOL_VALUES
> +            conversion_function = TestTuple.int_str_to_double_str
> +        elif self._basic_type == 'i':
> +            conversion_values = INT_VALUES
> +            conversion_function = TestTuple.int_str_to_double_str
> +        elif self._basic_type == 'u':
> +            conversion_values = UINT_VALUES
> +            conversion_function = TestTuple.int_str_to_double_str
> +        elif self._basic_type == 'f':
> +            conversion_values = FLOAT_INFS + FLOAT_NEG_ZERO + FLOAT_POS_ZERO + FLOAT_VALUES
> +            conversion_function = TestTuple.float_hex_to_double_hex
> +
> +        conversions = []
> +        for value in conversion_values:
> +            to_value = conversion_function(value)
> +            item = {'from': value, 'to': to_value}
> +            conversions.append(item)
> +
> +        self._gen_exec_test(self._conversion_type, self._double_type,
> +                            self._uniform_type, self._double_type,
> +                            explicit, converted_from, conversions)
> +
> +    def _gen_from_double(self):
> +        converted_from = 'from'
> +        self._gen_comp_test(self._double_type, self._conversion_type,
> +                            converted_from)
> +
> +        converted_from = self._conversion_type + '(from)'
> +        explicit = 'explicit'
> +
> +        if self._basic_type == 'b':
> +            conversion_values = DOUBLE_INFS + DOUBLE_NORMAL_VALUES + DOUBLE_BOOL_VALUES
> +            conversion_function = TestTuple.doble_hex_to_bool_str
> +        elif self._basic_type == 'i':
> +            conversion_values = DOUBLE_DENORMAL_VALUES + DOUBLE_NORMAL_VALUES + DOUBLE_INT_VALUES
> +            conversion_function = TestTuple.doble_hex_to_int_str
> +        elif self._basic_type == 'u':
> +            conversion_values = DOUBLE_DENORMAL_VALUES + DOUBLE_NORMAL_VALUES + DOUBLE_UINT_VALUES
> +            conversion_function = TestTuple.doble_hex_to_uint_str
> +        elif self._basic_type == 'f':
> +            conversion_values = DOUBLE_INFS + DOUBLE_FLOAT_INFS + DOUBLE_FLOAT_VALUES
> +            conversion_function = TestTuple.doble_hex_to_float_hex
> +
> +        conversions = []
> +        for value in DOUBLE_NEG_ZERO + DOUBLE_POS_ZERO + conversion_values:
> +            to_value = conversion_function(value)
> +            item = {'from': value, 'to': to_value}
> +            conversions.append(item)
> +
> +        self._gen_exec_test(self._double_type, self._conversion_type,
> +                            self._double_type, self._uniform_type,
> +                            explicit, converted_from, conversions)
> +
> +
> +class ZeroSignTestTuple(TestTuple):
> +    """Derived class for conversion tests using the float32 and float64
> +       +/-0.0 values.
> +    """
> +
> +    @staticmethod
> +    def all_tests(names_only):
> +        """Returns all the possible zero sign conversion test instances."""
> +
> +        assert isinstance(names_only, bool)
> +        stages = ['vert', 'geom', 'frag']
> +        dimensions = ['1', '2', '3', '4']
> +        basic_types = ['f']
> +        glsl_ver = ['410', '420']
> +
> +        if not names_only:
> +            for ver in glsl_ver:
> +                utils.safe_makedirs(get_dir_name(ver, 'execution'))
> +
> +        for ver, stage, first_dimension, second_dimension, basic_type in itertools.product(
> +                glsl_ver,
> +                stages,
> +                dimensions,
> +                dimensions,
> +                basic_types):
> +            if not (first_dimension != '1' and second_dimension == '1'):
> +                yield ZeroSignTestTuple(ver, stage,
> +                                        first_dimension, second_dimension,
> +                                        basic_type, names_only)
> +
> +    def __init__(self, ver, stage,
> +                 first_dimension, second_dimension,
> +                 basic_type, names_only):
> +        assert ver in ('410', '420')
> +        assert basic_type == 'f'
> +        assert not (first_dimension != '1' and second_dimension == '1')
> +        super(ZeroSignTestTuple, self).__init__(ver, stage,
> +                                                first_dimension, second_dimension,
> +                                                basic_type, names_only)
> +
> +    def __gen_zero_sign_exec_test(self, from_type, to_type,
> +                                  uniform_from_type, uniform_to_type,
> +                                  explicit, converted_from, conversions):
> +        filename = os.path.join(
> +            get_dir_name(self._ver, 'execution'),
> +            '{}-conversion-{}-{}-{}-zero-sign.shader_test'.format(self._stage, explicit,
> +                                                                  from_type, to_type))
> +
> +        self._filenames.append(filename)
> +
> +        if not self._names_only:
> +            with open(filename, 'w') as test_file:
> +                test_file.write(TEMPLATES.get_template(
> +                    'execution-zero-sign.{}.shader_test.mako'.format(
> +                        self._stage)).render_unicode(
> +                            ver=self._ver,
> +                            amount=self._amount,
> +                            from_type=from_type,
> +                            to_type=to_type,
> +                            converted_from=converted_from,
> +                            uniform_from_type=uniform_from_type,
> +                            uniform_to_type=uniform_to_type,
> +                            conversions=conversions))
> +
> +    def _gen_to_double(self):
> +        if self._ver == '410':
> +            conversion_values = FLOAT_POS_ZERO
> +        elif self._ver == '420':
> +            conversion_values = FLOAT_NEG_ZERO
> +
> +        conversions = []
> +        for value in conversion_values:
> +            to_value = TestTuple.float_hex_to_inv_double_hex(value)
> +            item = {'from': value, 'to': to_value}
> +            conversions.append(item)
> +
> +        self.__gen_zero_sign_exec_test(self._conversion_type, self._double_type,
> +                                       self._uniform_type, self._double_type,
> +                                       'implicit', 'from', conversions)
> +
> +    def _gen_from_double(self):
> +        if self._ver == '410':
> +            conversion_values = DOUBLE_POS_ZERO
> +        elif self._ver == '420':
> +            conversion_values = DOUBLE_NEG_ZERO
> +
> +        conversions = []
> +        for value in conversion_values:
> +            to_value = TestTuple.doble_hex_to_inv_float_hex(value)
> +            item = {'from': value, 'to': to_value}
> +            conversions.append(item)
> +
> +        self.__gen_zero_sign_exec_test(self._double_type, self._conversion_type,
> +                                       self._double_type, self._uniform_type,
> +                                       'explicit', self._conversion_type + '(from)', conversions)
> +
> +
> +def main():
> +    """Main function."""
> +
> +    parser = argparse.ArgumentParser(
> +        description="Generate shader tests that check the conversions from and "
> +        "to fp64")
> +    parser.add_argument(
> +        '--names-only',
> +        dest='names_only',
> +        action='store_true',
> +        default=False,
> +        help="Don't output files, just generate a list of filenames to stdout")
> +    args = parser.parse_args()
> +
> +    np.seterr(divide='ignore')
> +
> +    for test in (list(RegularTestTuple.all_tests(args.names_only)) +
> +                 list(ZeroSignTestTuple.all_tests(args.names_only))):
> +        test.generate_test_files()
> +        for filename in test.filenames:
> +            print(filename)
> +
> +
> +if __name__ == '__main__':
> +    main()
> diff --git a/generated_tests/templates/gen_conversion_fp64/base.mako b/generated_tests/templates/gen_conversion_fp64/base.mako
> new file mode 100644
> index 0000000..bcb479f
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/base.mako
> @@ -0,0 +1,12 @@
> +## coding=utf-8
> +<%def name="versioning()"><%
> +    if ver == 'GL_ARB_gpu_shader_fp64':
> +        glsl_version_int = '150'
> +    else:
> +        glsl_version_int = ver
> +
> +    glsl_version = '{}.{}'.format(glsl_version_int[0], glsl_version_int[1:3])
> +
> +    return (glsl_version, glsl_version_int)
> +%></%def>\
> +${next.body()}\
> diff --git a/generated_tests/templates/gen_conversion_fp64/compiler.frag.mako b/generated_tests/templates/gen_conversion_fp64/compiler.frag.mako
> new file mode 100644
> index 0000000..2ae22df
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/compiler.frag.mako
> @@ -0,0 +1,3 @@
> +## coding=utf-8
> +<%inherit file="compiler_base.mako"/>\
> +<%include file="shader.frag.mako"/>\
> diff --git a/generated_tests/templates/gen_conversion_fp64/compiler.geom.mako b/generated_tests/templates/gen_conversion_fp64/compiler.geom.mako
> new file mode 100644
> index 0000000..1e2e340
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/compiler.geom.mako
> @@ -0,0 +1,3 @@
> +## coding=utf-8
> +<%inherit file="compiler_base.mako"/>\
> +<%include file="shader.geom.mako"/>\
> diff --git a/generated_tests/templates/gen_conversion_fp64/compiler.vert.mako b/generated_tests/templates/gen_conversion_fp64/compiler.vert.mako
> new file mode 100644
> index 0000000..d9148f1
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/compiler.vert.mako
> @@ -0,0 +1,3 @@
> +## coding=utf-8
> +<%inherit file="compiler_base.mako"/>\
> +<%include file="shader.vert.mako"/>\
> diff --git a/generated_tests/templates/gen_conversion_fp64/compiler_base.mako b/generated_tests/templates/gen_conversion_fp64/compiler_base.mako
> new file mode 100644
> index 0000000..96ecc36
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/compiler_base.mako
> @@ -0,0 +1,25 @@
> +## coding=utf-8
> +<%inherit file="base.mako"/>\
> +<%
> +    (glsl_version, glsl_version_int) = self.versioning()
> +%>\
> +/* [config]
> + * expect_result: fail
> + * glsl_version: ${glsl_version}
> +% if ver == 'GL_ARB_gpu_shader_fp64':
> + * require_extensions: ${ver}
> + * [end config]
> + *
> + * ${ver} spec states:
> + *
> + *     "No implicit conversions are
> + *      provided to convert from unsigned to signed integer types, from
> + *      floating-point to integer types, or from higher-precision to
> + *      lower-precision types.  There are no implicit array or structure
> + *      conversions."
> +% else:
> + * [end config]
> +% endif
> + */
> +
> +${next.body()}\
> diff --git a/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.frag.shader_test.mako b/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.frag.shader_test.mako
> new file mode 100644
> index 0000000..2d0123b
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.frag.shader_test.mako
> @@ -0,0 +1,8 @@
> +## coding=utf-8
> +<%inherit file="execution_base.mako"/>\
> +
> +[vertex shader passthrough]
> +
> +[fragment shader]
> +<%include file="shader-zero-sign.frag.mako"/>
> +
> diff --git a/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.geom.shader_test.mako b/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.geom.shader_test.mako
> new file mode 100644
> index 0000000..a4fef76
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.geom.shader_test.mako
> @@ -0,0 +1,27 @@
> +## coding=utf-8
> +<%inherit file="execution_base.mako"/>\
> +
> +[vertex shader]
> +#version 150
> +
> +in vec4 piglit_vertex;
> +out vec4 vertex_to_gs;
> +
> +void main()
> +{
> +    vertex_to_gs = piglit_vertex;
> +}
> +
> +[geometry shader]
> +<%include file="shader-zero-sign.geom.mako"/>
> +[fragment shader]
> +#version 150
> +
> +in vec4 fs_color;
> +out vec4 color;
> +
> +void main()
> +{
> +    color = fs_color;
> +}
> +
> diff --git a/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.vert.shader_test.mako b/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.vert.shader_test.mako
> new file mode 100644
> index 0000000..5715a61
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/execution-zero-sign.vert.shader_test.mako
> @@ -0,0 +1,16 @@
> +## coding=utf-8
> +<%inherit file="execution_base.mako"/>\
> +
> +[vertex shader]
> +<%include file="shader-zero-sign.vert.mako"/>
> +[fragment shader]
> +#version 150
> +
> +in vec4 fs_color;
> +out vec4 color;
> +
> +void main()
> +{
> +    color = fs_color;
> +}
> +
> diff --git a/generated_tests/templates/gen_conversion_fp64/execution.frag.shader_test.mako b/generated_tests/templates/gen_conversion_fp64/execution.frag.shader_test.mako
> new file mode 100644
> index 0000000..60507ee
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/execution.frag.shader_test.mako
> @@ -0,0 +1,7 @@
> +## coding=utf-8
> +<%inherit file="execution_base.mako"/>\
> +
> +[vertex shader passthrough]
> +
> +[fragment shader]
> +<%include file="shader.frag.mako"/>
> diff --git a/generated_tests/templates/gen_conversion_fp64/execution.geom.shader_test.mako b/generated_tests/templates/gen_conversion_fp64/execution.geom.shader_test.mako
> new file mode 100644
> index 0000000..ed53475
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/execution.geom.shader_test.mako
> @@ -0,0 +1,27 @@
> +## coding=utf-8
> +<%inherit file="execution_base.mako"/>\
> +
> +[vertex shader]
> +#version 150
> +
> +in vec4 piglit_vertex;
> +out vec4 vertex_to_gs;
> +
> +void main()
> +{
> +    vertex_to_gs = piglit_vertex;
> +}
> +
> +[geometry shader]
> +<%include file="shader.geom.mako"/>
> +[fragment shader]
> +#version 150
> +
> +in vec4 fs_color;
> +out vec4 color;
> +
> +void main()
> +{
> +    color = fs_color;
> +}
> +
> diff --git a/generated_tests/templates/gen_conversion_fp64/execution.vert.shader_test.mako b/generated_tests/templates/gen_conversion_fp64/execution.vert.shader_test.mako
> new file mode 100644
> index 0000000..a0d13c2
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/execution.vert.shader_test.mako
> @@ -0,0 +1,16 @@
> +## coding=utf-8
> +<%inherit file="execution_base.mako"/>\
> +
> +[vertex shader]
> +<%include file="shader.vert.mako"/>
> +[fragment shader]
> +#version 150
> +
> +in vec4 fs_color;
> +out vec4 color;
> +
> +void main()
> +{
> +    color = fs_color;
> +}
> +
> diff --git a/generated_tests/templates/gen_conversion_fp64/execution_base.mako b/generated_tests/templates/gen_conversion_fp64/execution_base.mako
> new file mode 100644
> index 0000000..419259c
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/execution_base.mako
> @@ -0,0 +1,28 @@
> +## coding=utf-8
> +<%inherit file="base.mako"/>\
> +<%
> +    (glsl_version, glsl_version_int) = self.versioning()
> +%>\
> +<%! from six.moves import range %>\
> +[require]
> +GLSL >= ${glsl_version}
> +% if ver == 'GL_ARB_gpu_shader_fp64':
> +${ver}
> +% endif
> +${next.body()}\
> +[test]
> +% for conversion in conversions:
> +uniform ${uniform_from_type} from \
> +% for i in range(amount):
> +${conversion['from']} \
> +% endfor
> +
> +uniform ${uniform_to_type} to \
> +% for i in range(amount):
> +${conversion['to']} \
> +% endfor
> +
> +draw rect -1 -1 2 2
> +probe all rgba 0.0 1.0 0.0 1.0
> +
> +% endfor
> diff --git a/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.frag.mako b/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.frag.mako
> new file mode 100644
> index 0000000..1a38b7a
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.frag.mako
> @@ -0,0 +1,18 @@
> +## coding=utf-8
> +<%inherit file="shader_base.mako"/>\
> +uniform ${from_type} from;
> +uniform ${to_type} to;
> +
> +out vec4 color;
> +
> +#define ONE 1.0
> +#define RED vec4(1.0, 0.0, 0.0, 1.0)
> +#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
> +
> +void main()
> +{
> +    ${to_type} pre_converted = ${converted_from};
> +    ${to_type} converted = ONE / pre_converted;
> +    bool match = converted == to;
> +    color = match ? GREEN : RED;
> +}
> diff --git a/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.geom.mako b/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.geom.mako
> new file mode 100644
> index 0000000..22f366f
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.geom.mako
> @@ -0,0 +1,27 @@
> +## coding=utf-8
> +<%inherit file="shader_base.mako"/>\
> +layout(triangles) in;
> +layout(triangle_strip, max_vertices = 3) out;
> +
> +uniform ${from_type} from;
> +uniform ${to_type} to;
> +
> +in vec4 vertex_to_gs[3];
> +out vec4 fs_color;
> +
> +#define ONE 1.0
> +#define RED vec4(1.0, 0.0, 0.0, 1.0)
> +#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
> +
> +void main()
> +{
> +    ${to_type} pre_converted = ${converted_from};
> +    ${to_type} converted = ONE / pre_converted;
> +    bool match = converted == to;
> +    fs_color = match ? GREEN : RED;
> +
> +    for (int i = 0; i < 3; i++) {
> +        gl_Position = vertex_to_gs[i];
> +        EmitVertex();
> +    }
> +}
> diff --git a/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.vert.mako b/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.vert.mako
> new file mode 100644
> index 0000000..a49add1
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/shader-zero-sign.vert.mako
> @@ -0,0 +1,20 @@
> +## coding=utf-8
> +<%inherit file="shader_base.mako"/>\
> +uniform ${from_type} from;
> +uniform ${to_type} to;
> +
> +in vec4 piglit_vertex;
> +out vec4 fs_color;
> +
> +#define ONE 1.0
> +#define RED vec4(1.0, 0.0, 0.0, 1.0)
> +#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
> +
> +void main()
> +{
> +    gl_Position = piglit_vertex;
> +    ${to_type} pre_converted = ${converted_from};
> +    ${to_type} converted = ONE / pre_converted;
> +    bool match = converted == to;
> +    fs_color = match ? GREEN : RED;
> +}
> diff --git a/generated_tests/templates/gen_conversion_fp64/shader.frag.mako b/generated_tests/templates/gen_conversion_fp64/shader.frag.mako
> new file mode 100644
> index 0000000..346b77b
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/shader.frag.mako
> @@ -0,0 +1,16 @@
> +## coding=utf-8
> +<%inherit file="shader_base.mako"/>\
> +uniform ${from_type} from;
> +uniform ${to_type} to;
> +
> +out vec4 color;
> +
> +#define RED vec4(1.0, 0.0, 0.0, 1.0)
> +#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
> +
> +void main()
> +{
> +    ${to_type} converted = ${converted_from};
> +    bool match = converted == to;
> +    color = match ? GREEN : RED;
> +}
> diff --git a/generated_tests/templates/gen_conversion_fp64/shader.geom.mako b/generated_tests/templates/gen_conversion_fp64/shader.geom.mako
> new file mode 100644
> index 0000000..987adbc
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/shader.geom.mako
> @@ -0,0 +1,25 @@
> +## coding=utf-8
> +<%inherit file="shader_base.mako"/>\
> +layout(triangles) in;
> +layout(triangle_strip, max_vertices = 3) out;
> +
> +uniform ${from_type} from;
> +uniform ${to_type} to;
> +
> +in vec4 vertex_to_gs[3];
> +out vec4 fs_color;
> +
> +#define RED vec4(1.0, 0.0, 0.0, 1.0)
> +#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
> +
> +void main()
> +{
> +    ${to_type} converted = ${converted_from};
> +    bool match = converted == to;
> +    fs_color = match ? GREEN : RED;
> +
> +    for (int i = 0; i < 3; i++) {
> +        gl_Position = vertex_to_gs[i];
> +        EmitVertex();
> +    }
> +}
> diff --git a/generated_tests/templates/gen_conversion_fp64/shader.vert.mako b/generated_tests/templates/gen_conversion_fp64/shader.vert.mako
> new file mode 100644
> index 0000000..8f5c797
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/shader.vert.mako
> @@ -0,0 +1,18 @@
> +## coding=utf-8
> +<%inherit file="shader_base.mako"/>\
> +uniform ${from_type} from;
> +uniform ${to_type} to;
> +
> +in vec4 piglit_vertex;
> +out vec4 fs_color;
> +
> +#define RED vec4(1.0, 0.0, 0.0, 1.0)
> +#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
> +
> +void main()
> +{
> +    gl_Position = piglit_vertex;
> +    ${to_type} converted = ${converted_from};
> +    bool match = converted == to;
> +    fs_color = match ? GREEN : RED;
> +}
> diff --git a/generated_tests/templates/gen_conversion_fp64/shader_base.mako b/generated_tests/templates/gen_conversion_fp64/shader_base.mako
> new file mode 100644
> index 0000000..33d88b8
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/shader_base.mako
> @@ -0,0 +1,11 @@
> +## coding=utf-8
> +<%inherit file="base.mako"/>\
> +<%
> +    (glsl_version, glsl_version_int) = self.versioning()
> +%>\
> +#version ${glsl_version_int}
> +% if ver == 'GL_ARB_gpu_shader_fp64':
> +#extension GL_ARB_gpu_shader_fp64 : require
> +% endif
> +
> +${next.body()}\
> diff --git a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-double-float-bad.vert b/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-double-float-bad.vert
> deleted file mode 100644
> index 3e2b15a..0000000
> --- a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-double-float-bad.vert
> +++ /dev/null
> @@ -1,20 +0,0 @@
> -// [config]
> -// expect_result: fail
> -// glsl_version: 1.50
> -// require_extensions: GL_ARB_gpu_shader_fp64
> -// [end config]
> -//
> -// Test double -> float implicit conversion doesn't happen
> -
> -#version 150
> -#extension GL_ARB_gpu_shader_fp64 : enable
> -
> -float _float = 0.0f;
> -
> -double _double = 0.0lf;
> -
> -void test() {
> -
> -    /* double cannot be converted to float (and for vectors of same) */
> -    _float = _double;
> -}
> diff --git a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec2-vec2-bad.vert b/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec2-vec2-bad.vert
> deleted file mode 100644
> index 225636d..0000000
> --- a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec2-vec2-bad.vert
> +++ /dev/null
> @@ -1,20 +0,0 @@
> -// [config]
> -// expect_result: fail
> -// glsl_version: 1.50
> -// require_extensions: GL_ARB_gpu_shader_fp64
> -// [end config]
> -//
> -// Test double -> float implicit conversion doesn't happen
> -
> -#version 150
> -#extension GL_ARB_gpu_shader_fp64 : enable
> -
> -vec2 _vec2 = vec2(0.0f);
> -
> -dvec2 _dvec2 = dvec2(0.0lf);
> -
> -void test() {
> -
> -    /* double cannot be converted to float (and for vectors of same) */
> -    _vec2 = _dvec2;
> -}
> diff --git a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec3-vec3-bad.vert b/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec3-vec3-bad.vert
> deleted file mode 100644
> index cf8583e..0000000
> --- a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec3-vec3-bad.vert
> +++ /dev/null
> @@ -1,20 +0,0 @@
> -// [config]
> -// expect_result: fail
> -// glsl_version: 1.50
> -// require_extensions: GL_ARB_gpu_shader_fp64
> -// [end config]
> -//
> -// Test double -> float implicit conversion doesn't happen
> -
> -#version 150
> -#extension GL_ARB_gpu_shader_fp64 : enable
> -
> -vec3 _vec3 = vec3(0.0f);
> -
> -dvec3 _dvec3 = dvec3(0.0lf);
> -
> -void test() {
> -
> -    /* double cannot be converted to float (and for vectors of same) */
> -    _vec3 = _dvec3;
> -}
> diff --git a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec4-vec4-bad.vert b/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec4-vec4-bad.vert
> deleted file mode 100644
> index dd394e5..0000000
> --- a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec4-vec4-bad.vert
> +++ /dev/null
> @@ -1,20 +0,0 @@
> -// [config]
> -// expect_result: fail
> -// glsl_version: 1.50
> -// require_extensions: GL_ARB_gpu_shader_fp64
> -// [end config]
> -//
> -// Test double -> float implicit conversion doesn't happen
> -
> -#version 150
> -#extension GL_ARB_gpu_shader_fp64 : enable
> -
> -vec4 _vec4 = vec4(0.0f);
> -
> -dvec4 _dvec4 = dvec4(0.0lf);
> -
> -void test() {
> -
> -    /* double cannot be converted to float (and for vectors of same) */
> -    _vec4 = _dvec4;
> -}
> diff --git a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversions.vert b/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversions.vert
> deleted file mode 100644
> index 0b88b40..0000000
> --- a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversions.vert
> +++ /dev/null
> @@ -1,115 +0,0 @@
> -// [config]
> -// expect_result: pass
> -// glsl_version: 1.50
> -// require_extensions: GL_ARB_gpu_shader_fp64
> -// [end config]
> -//
> -// Test that implicit conversions are allowed as specified in GL_ARB_gpu_shader_fp64
> -//
> -// GL_ARB_gpu_shader_fp64 spec presents following conversion table:
> -//
> -//                             Can be implicitly
> -//     Type of expression        converted to
> -//     ---------------------   -------------------
> -//     int                     uint(*), float, double
> -//     ivec2                   uvec2(*), vec2, dvec2
> -//     ivec3                   uvec3(*), vec3, dvec3
> -//     ivec4                   uvec4(*), vec4, dvec4
> -//
> -//     uint                    float, double
> -//     uvec2                   vec2, dvec2
> -//     uvec3                   vec3, dvec3
> -//     uvec4                   vec4, dvec4
> -//
> -//     float                   double
> -//     vec2                    dvec2
> -//     vec3                    dvec3
> -//     vec4                    dvec4
> -//
> -//     mat2                    dmat2
> -//     mat3                    dmat3
> -//     mat4                    dmat4
> -//     mat2x3                  dmat2x3
> -//     mat2x4                  dmat2x4
> -//     mat3x2                  dmat3x2
> -//     mat3x4                  dmat3x4
> -//     mat4x2                  dmat4x2
> -//     mat4x3                  dmat4x3
> -//
> -//     (*) if ARB_gpu_shader5 or NV_gpu_shader5 is supported
> -//
> -
> -#version 150
> -#extension GL_ARB_gpu_shader_fp64 : enable
> -
> -int _int = 0;
> -ivec2 _ivec2 = ivec2(0);
> -ivec3 _ivec3 = ivec3(0);
> -ivec4 _ivec4 = ivec4(0);
> -
> -uint _uint = 0u;
> -uvec2 _uvec2 = uvec2(0u);
> -uvec3 _uvec3 = uvec3(0u);
> -uvec4 _uvec4 = uvec4(0u);
> -
> -float _float = 0.0f;
> -vec2 _vec2 = vec2(0.0f);
> -vec3 _vec3 = vec3(0.0f);
> -vec4 _vec4 = vec4(0.0f);
> -
> -double _double;
> -dvec2 _dvec2;
> -dvec3 _dvec3;
> -dvec4 _dvec4;
> -
> -mat2 _mat2 = mat2(1.0);
> -mat3 _mat3 = mat3(1.0);
> -mat4 _mat4 = mat4(1.0);
> -mat2x3 _mat2x3 = mat2x3(1.0);
> -mat2x4 _mat2x4 = mat2x4(1.0);
> -mat3x2 _mat3x2 = mat3x2(1.0);
> -mat3x4 _mat3x4 = mat3x4(1.0);
> -mat4x2 _mat4x2 = mat4x2(1.0);
> -mat4x3 _mat4x3 = mat4x3(1.0);
> -
> -dmat2 _dmat2;
> -dmat3 _dmat3;
> -dmat4 _dmat4;
> -dmat2x3 _dmat2x3;
> -dmat2x4 _dmat2x4;
> -dmat3x2 _dmat3x2;
> -dmat3x4 _dmat3x4;
> -dmat4x2 _dmat4x2;
> -dmat4x3 _dmat4x3;
> -
> -void test() {
> -
> -       /* int can be converted to double (and for vectors of same) */
> -       _double = _int;
> -       _dvec2 = _ivec2;
> -       _dvec3 = _ivec3;
> -       _dvec4 = _ivec4;
> -
> -       /* uint can be converted to double (and for vectors of same) */
> -       _double = _uint;
> -       _dvec2 = _uvec2;
> -       _dvec3 = _uvec3;
> -       _dvec4 = _uvec4;
> -
> -       /* float can be converted to double (and for vectors of same) */
> -       _double = _float;
> -       _dvec2 = _vec2;
> -       _dvec3 = _vec3;
> -       _dvec4 = _vec4;
> -
> -       /* mat -> dmat conversions */
> -       _dmat2 = _mat2;
> -       _dmat3 = _mat3;
> -       _dmat4 = _mat4;
> -       _dmat2x3 = _mat2x3;
> -       _dmat2x4 = _mat2x4;
> -       _dmat3x2 = _mat3x2;
> -       _dmat3x4 = _mat3x4;
> -       _dmat4x2 = _mat4x2;
> -       _dmat4x3 = _mat4x3;
> -}
> -- 
> 2.8.0.rc3
> 

I didn't look over this too closely, but other than the one tiny nit it
looked okay.

For the python and mako:
Acked-by: Dylan Baker <baker.dylan.c@gmail.com>
On Thu, 2016-04-14 at 11:20 -0700, Dylan Baker wrote:
...
> diff --git a/generated_tests/gen_conversion_fp64.py
> > b/generated_tests/gen_conversion_fp64.py
> > new file mode 100644
> > index 0000000..5fe0bf2
> > --- /dev/null
> > +++ b/generated_tests/gen_conversion_fp64.py
> > @@ -0,0 +1,604 @@
> > 
...
> > +from __future__ import print_function, division, absolute_import
> > +import abc
> > +import argparse
> > +import os
> > +import itertools
> > +import struct
> small nit, could you put a newline between numpy ans struct, and then
> sort the above imports?
> 
> > 
> > +import numpy as np

I will :)

...
> > -       _dmat4x3 = _mat4x3;
> > -}
> > -- 
> > 2.8.0.rc3
> > 

> I didn't look over this too closely, but other than the one tiny nit 
> it looked okay.

> For the python and mako:
> Acked-by: Dylan Baker <baker.dylan.c@gmail.com>

Thanks!
On jue, 2016-04-14 at 12:40 +0300, Andres Gomez wrote:
> Also, removed 5 redundant tests replaced by
> the generator.
> 
> Signed-off-by: Andres Gomez <agomez@igalia.com>
> ---
>  generated_tests/CMakeLists.txt                     |  24 +
>  generated_tests/gen_conversion_fp64.py             | 604
> +++++++++++++++++++++
>  .../templates/gen_conversion_fp64/base.mako        |  12 +
>  .../gen_conversion_fp64/compiler.frag.mako         |   3 +
>  .../gen_conversion_fp64/compiler.geom.mako         |   3 +
>  .../gen_conversion_fp64/compiler.vert.mako         |   3 +
>  .../gen_conversion_fp64/compiler_base.mako         |  25 +
>  .../execution-zero-sign.frag.shader_test.mako      |   8 +
>  .../execution-zero-sign.geom.shader_test.mako      |  27 +
>  .../execution-zero-sign.vert.shader_test.mako      |  16 +
>  .../execution.frag.shader_test.mako                |   7 +
>  .../execution.geom.shader_test.mako                |  27 +
>  .../execution.vert.shader_test.mako                |  16 +
>  .../gen_conversion_fp64/execution_base.mako        |  28 +
>  .../gen_conversion_fp64/shader-zero-sign.frag.mako |  18 +
>  .../gen_conversion_fp64/shader-zero-sign.geom.mako |  27 +
>  .../gen_conversion_fp64/shader-zero-sign.vert.mako |  20 +
>  .../templates/gen_conversion_fp64/shader.frag.mako |  16 +
>  .../templates/gen_conversion_fp64/shader.geom.mako |  25 +
>  .../templates/gen_conversion_fp64/shader.vert.mako |  18 +
>  .../templates/gen_conversion_fp64/shader_base.mako |  11 +
>  .../implicit-conversion-double-float-bad.vert      |  20 -
>  .../implicit-conversion-dvec2-vec2-bad.vert        |  20 -
>  .../implicit-conversion-dvec3-vec3-bad.vert        |  20 -
>  .../implicit-conversion-dvec4-vec4-bad.vert        |  20 -
>  .../compiler/implicit-conversions.vert             | 115 ----
>  26 files changed, 938 insertions(+), 195 deletions(-)
>  create mode 100644 generated_tests/gen_conversion_fp64.py
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/base.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/compiler.frag.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/compiler.geom.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/compiler.vert.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/compiler_base.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/execution-zero-
> sign.frag.shader_test.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/execution-zero-
> sign.geom.shader_test.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/execution-zero-
> sign.vert.shader_test.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/execution.frag.shader_t
> est.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/execution.geom.shader_t
> est.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/execution.vert.shader_t
> est.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/execution_base.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/shader-zero-
> sign.frag.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/shader-zero-
> sign.geom.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/shader-zero-
> sign.vert.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/shader.frag.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/shader.geom.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/shader.vert.mako
>  create mode 100644
> generated_tests/templates/gen_conversion_fp64/shader_base.mako
>  delete mode 100644 tests/spec/arb_gpu_shader_fp64/compiler/implicit-
> conversion-double-float-bad.vert
>  delete mode 100644 tests/spec/arb_gpu_shader_fp64/compiler/implicit-
> conversion-dvec2-vec2-bad.vert
>  delete mode 100644 tests/spec/arb_gpu_shader_fp64/compiler/implicit-
> conversion-dvec3-vec3-bad.vert
>  delete mode 100644 tests/spec/arb_gpu_shader_fp64/compiler/implicit-
> conversion-dvec4-vec4-bad.vert
>  delete mode 100644 tests/spec/arb_gpu_shader_fp64/compiler/implicit-
> conversions.vert
> 
> diff --git a/generated_tests/CMakeLists.txt
> b/generated_tests/CMakeLists.txt
> index 3c5b11a..c2505e2 100644
> --- a/generated_tests/CMakeLists.txt
> +++ b/generated_tests/CMakeLists.txt
> @@ -130,6 +130,29 @@ piglit_make_generated_tests(
>  	templates/gen_flat_interpolation_qualifier/template.frag.mak
> o
>  	)
>  piglit_make_generated_tests(
> +	conversion_fp64.list
> +	gen_conversion_fp64.py
> +	templates/gen_conversion_fp64/base.mako
> +	templates/gen_conversion_fp64/compiler.frag.mako
> +	templates/gen_conversion_fp64/compiler.geom.mako
> +	templates/gen_conversion_fp64/compiler.vert.mako
> +	templates/gen_conversion_fp64/compiler_base.mako
> +	templates/gen_conversion_fp64/execution-zero-
> sign.frag.shader_test.mako
> +	templates/gen_conversion_fp64/execution-zero-
> sign.geom.shader_test.mako
> +	templates/gen_conversion_fp64/execution-zero-
> sign.vert.shader_test.mako
> +	templates/gen_conversion_fp64/execution.frag.shader_test.mak
> o
> +	templates/gen_conversion_fp64/execution.geom.shader_test.mak
> o
> +	templates/gen_conversion_fp64/execution.vert.shader_test.mak
> o
> +	templates/gen_conversion_fp64/execution_base.mako
> +	templates/gen_conversion_fp64/shader-zero-sign.frag.mako
> +	templates/gen_conversion_fp64/shader-zero-sign.geom.mako
> +	templates/gen_conversion_fp64/shader-zero-sign.vert.mako
> +	templates/gen_conversion_fp64/shader.frag.mako
> +	templates/gen_conversion_fp64/shader.geom.mako
> +	templates/gen_conversion_fp64/shader.vert.mako
> +	templates/gen_conversion_fp64/shader_base.mako
> +	)
> +piglit_make_generated_tests(
>  	shader_precision_tests.list
>  	gen_shader_precision_tests.py
>  	builtin_function.py
> @@ -188,6 +211,7 @@ add_custom_target(gen-gl-tests
>  			constant_array_size_tests_fp64.list
>  			inout_fp64.list
>  			flat_interpolation_qualifier.list
> +			conversion_fp64.list
>  			shader_precision_tests.list
>  			shader_image_load_store_tests.list
>  			variable_index_read_tests.list
> diff --git a/generated_tests/gen_conversion_fp64.py
> b/generated_tests/gen_conversion_fp64.py
> new file mode 100644
> index 0000000..5fe0bf2
> --- /dev/null
> +++ b/generated_tests/gen_conversion_fp64.py
> @@ -0,0 +1,604 @@
> +# coding=utf-8
> +#
> +# Copyright © 2016 Intel Corporation
> +#
> +# Permission is hereby granted, free of charge, to any person
> obtaining a
> +# copy of this software and associated documentation files (the
> "Software"),
> +# to deal in the Software without restriction, including without
> limitation
> +# the rights to use, copy, modify, merge, publish, distribute,
> sublicense,
> +# and/or sell copies of the Software, and to permit persons to whom
> the
> +# Software is furnished to do so, subject to the following
> conditions:
> +#
> +# The above copyright notice and this permission notice (including
> the next
> +# paragraph) shall be included in all copies or substantial portions
> of the
> +# Software.
> +#
> +# 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.
> +
> +"""Generate fp64 types conversion tests."""
> +
> +from __future__ import print_function, division, absolute_import
> +import abc
> +import argparse
> +import os
> +import itertools
> +import struct
> +import numpy as np
> +
> +from templates import template_dir
> +from modules import utils
> +
> +TEMPLATES =
> template_dir(os.path.basename(os.path.splitext(__file__)[0]))
> +
> +# pylint: disable=bad-whitespace,line-too-long,bad-continuation
> +DOUBLE_INFS                 = ['0xfff0000000000000', # -inf
> +                               '0x7ff0000000000000'] # +inf
> +
> +DOUBLE_NEG_ZERO             = ['0x8000000000000000'] # Negative
> underflow (-0.0)
> +
> +DOUBLE_POS_ZERO             = ['0x0000000000000000'] # Positive
> underflow (+0.0)
> +
> +# Double values causing an underflow to zero in any other type
> +DOUBLE_DENORMAL_VALUES      = ['0x800fffffffffffff', # Negative
> maximum denormalized -- Denormalized may be flushed to 0
> +                               '0x8000000000000001', # Negative
> minimum denormalized -- Denormalized may be flushed to 0
> +                               '0x0000000000000001', # Positive
> minimum denormalized -- Denormalized may be flushed to 0
> +                               '0x000fffffffffffff'] # Positive
> maximum denormalized -- Denormalized may be flushed to 0
> +
> +DOUBLE_NORMAL_VALUES        = ['0x8010000000000000', # Negative
> minimum normalized
> +                               '0x0010000000000000'] # Positive
> minimum normalized
> +
> +# Double +/-inf
> +DOUBLE_FLOAT_INFS           = ['0xc7effffff0000000', # Negative
> overflow (-inf)
> +                               '0x47effffff0000000'] # Positive
> overflow (+inf)
> +
> +DOUBLE_FLOAT_VALUES         = ['0xc7efffffefffffff', # Negative
> maximum normalized
> +                               '0xc170000000000000', # -16777216.0
> +                               '0xc014000000000000', # -5.0
> +                               '0xbfff25ce60000000', #
> -1.9467300176620483
> +                               '0xb80fffffe0000000', # Negative
> minimum normalized
> +                               '0xb69fffffffffffff', # Negative
> underflow
> +                               '0x369fffffffffffff', # Positive
> underflow
> +                               '0x380fffffe0000000', # Positive
> minimum normalized
> +                               '0x3fff25ce60000000', #
> +1.9467300176620483
> +                               '0x4014000000000000', # +5.0
> +                               '0x4170000000000000', # +16777216.0
> +                               '0x47efffffefffffff'] # Positive
> maximum normalized
> +
> +DOUBLE_UINT_VALUES          = ['0xbfeccccccccccccd', # -0.9
> +                               #'0x8010000000000000', # Negative
> minimum normalized          -- Already checked
> +                               #'0x800fffffffffffff', # Negative
> maximum denormalized        -- Already checked
> +                               #'0x8000000000000001', # Negative
> minimum denormalized        -- Already checked
> +                               #'0x8000000000000000', # Negative
> minimum        (-0)         -- Already checked
> +                               #'0x0000000000000000', # Positive
> minimum        (+0)         -- Already checked
> +                               '0x3fff25ce60000000', #
> +1.9467300176620483
> +                               '0x4014000000000000', # +5.0
> +                               '0x4170000000000000', # +16777216.0
> +                               '0x41dfffffffc00000', # Signed int
> low frontier (+2147483647)
> +                               '0x41e0000000000000', # Signed int up
> frontier  (+2147483648)
> +                               '0x41efffffffe00000'] #
> Maximum                 (+4294967295)
> +
> +DOUBLE_INT_VALUES           = ['0xc1e0000000000000', #
> Minimum          (-2147483648)
> +                               '0xc170000000000000', # -16777216.0
> +                               '0xc014000000000000', # -5.0
> +                               '0xbfff25ce60000000', #
> -1.9467300176620483
> +                               #'0x8000000000000000', # Negative
> minimum        (-0)         -- Already checked
> +                               #'0x0000000000000000', #
> Minimum                 (+0)         -- Already checked
> +                               '0x3fff25ce60000000', #
> +1.9467300176620483
> +                               '0x4014000000000000', # +5.0
> +                               '0x4170000000000000', # +16777216.0
> +                               '0x41dfffffffc00000'] #
> Maximum          (+2147483647)
> +
> +DOUBLE_BOOL_VALUES          = [#'0x8010000000000000', # Minimum
> negative True value -- Already checked
> +                               #'0x0000000000000000', #
> False                       -- Already checked
> +                               #'0x0010000000000000', # Minimum
> positive True value -- Already checked
> +                              ]
> +
> +FLOAT_INFS                  = ['0xff800000', # -inf
> +                               '0x7f800000'] # +inf
> +
> +FLOAT_NEG_ZERO              = ['0x80000000'] # Negative underflow (-
> 0.0)
> +
> +FLOAT_POS_ZERO              = ['0x00000000'] # Positive underflow
> (+0.0)
> +
> +FLOAT_VALUES                = ['0xff7fffff', # Negative maximum
> normalized
> +                               '0xcb800000', # -16777216.0
> +                               '0xc0a00000', # -5.0
> +                               '0xbff92e73', # -1.9467300176620483
> +                               '0x80800000', # Negative minimum
> normalized
> +                               #'0x807fffff', # Negative maximum
> denormalized -- Denormalized may be flushed to 0
> +                               #'0x80000001', # Negative minimum
> denormalized -- Denormalized may be flushed to 0
> +                               #'0x00000001', # Positive minimum
> denormalized -- Denormalized may be flushed to 0
> +                               #'0x007fffff', # Positive maximum
> denormalized -- Denormalized may be flushed to 0
> +                               '0x00800000', # Positive minimum
> normalized
> +                               '0x3ff92e73', # +1.9467300176620483
> +                               '0x40a00000', # +5.0
> +                               '0x4b800000', # +16777216.0
> +                               '0x7f7fffff'] # Positive maximum
> normalized
> +
> +UINT_VALUES                 = ['0', # Minimum
> +                               '5',
> +                               '2147483647', # Signed int low
> frontier
> +                               '2147483648', # Signed int up
> frontier
> +                               '4294967295'] # Maximum
> +
> +INT_VALUES                  = ['-2147483648', # Minimum
> +                               '-5',
> +                               '-1',
> +                               '0',
> +                               '1',
> +                               '5',
> +                               '2147483647'] # Maximum
> +
> +BOOL_VALUES                 = ['0', # False
> +                               '1'] # True
> +# pylint: enable=bad-whitespace,line-too-long,bad-continuation
> +
> +def get_dir_name(ver, test_type):
> +    """Returns the directory name to save tests given a GLSL version
> and a
> +       test type.
> +    """
> +
> +    assert isinstance(ver, str)
> +    assert isinstance(test_type, str)
> +    if ver.startswith('GL_'):
> +        feature_dir = ver[3:].lower()
> +    else:
> +        feature_dir = 'glsl-{}.{}'.format(ver[0], ver[1:])
> +
> +    return os.path.join('spec', feature_dir, test_type,
> +                        'conversion')
> +
> +
> +class TestTuple(object):
> +    """A float64 derived and other type derived tuple to generate
> the
> +       needed conversion tests.
> +    """
> +
> +    @staticmethod
> +    def float_to_hex(fvalue):
> +        """Returns the hexadecimal representation from a float32
> value."""
> +        assert isinstance(fvalue, np.float32)
> +        return hex(struct.unpack('<I', struct.pack('<f',
> fvalue))[0])
> +
> +    @staticmethod
> +    def double_to_hex(fvalue):
> +        """Returns the hexadecimal representation from a float64
> value."""
> +        assert isinstance(fvalue, float)
> +        return hex(struct.unpack('<Q', struct.pack('<d',
> fvalue))[0]).rstrip("L")
> +
> +    @staticmethod
> +    def hex_to_float(hstr):
> +        """Returns a float32 value from its hexadecimal
> representation."""
> +        assert isinstance(hstr, str)
> +        return struct.unpack('<f', struct.pack('<I', int(hstr,
> 16)))[0]
> +
> +    @staticmethod
> +    def hex_to_double(hstr):
> +        """Returns a float64 value from its hexadecimal
> representation."""
> +
> +        assert isinstance(hstr, str)
> +        return struct.unpack('<d', struct.pack('<Q', int(hstr,
> 16)))[0]
> +
> +    @staticmethod
> +    def float_hex_to_double_hex(hstr):
> +        """Returns the float64 hexadecimal representation from a
> float32
> +           hexadecimal representation.
> +        """
> +        assert isinstance(hstr, str)
> +        double_value = TestTuple.hex_to_float(hstr)
> +        return TestTuple.double_to_hex(double_value)
> +
> +    @staticmethod
> +    def float_hex_to_inv_double_hex(hstr):
> +        """Returns the inverted float64 hexadecimal representation
> from a
> +           float32 hexadecimal representation.
> +        """
> +        assert isinstance(hstr, str)
> +        temp = TestTuple.hex_to_float(hstr)
> +        double_value = np.divide(1.0, temp)
> +        return TestTuple.double_to_hex(double_value)
> +
> +    @staticmethod
> +    def int_str_to_double_str(istr):
> +        """Returns a float64 string from an int32 string."""
> +        assert isinstance(istr, str)
> +        return str(float(istr))
> +
> +    @staticmethod
> +    def doble_hex_to_bool_str(hstr):
           ^^^
	Typo here, it should be "double". Same for a few methods below.

> +        """Returns a bool string from a float64 hexadecimal
> representation."""
> +        assert isinstance(hstr, str)
> +        bool_double = TestTuple.hex_to_double(hstr)
> +        return '1' if bool_double != 0.0 else '0'
> +
> +    @staticmethod
> +    def doble_hex_to_int_str(hstr):
> +        """Returns an int32 string from a float64 hexadecimal
> +           representation.
> +        """
> +        assert isinstance(hstr, str)
> +        int_double = TestTuple.hex_to_double(hstr)
> +        if int_double > np.iinfo(np.dtype('int32')).max:
> +            return str(np.iinfo(np.dtype('int32')).max)
> +        if int_double < np.iinfo(np.dtype('int32')).min:
> +            return str(np.iinfo(np.dtype('int32')).min)
> +        return str(int(int_double))
> +
> +    @staticmethod
> +    def doble_hex_to_uint_str(hstr):
> +        """Returns an uint32 string from a float64 hexadecimal
> +           representation.
> +        """
> +        assert isinstance(hstr, str)
> +        uint_double = TestTuple.hex_to_double(hstr)
> +        if uint_double > np.iinfo(np.dtype('uint32')).max:
> +            return str(np.iinfo(np.dtype('uint32')).max)
> +        if uint_double < np.iinfo(np.dtype('uint32')).min:
> +            return str(np.iinfo(np.dtype('uint32')).min)
> +        return str(int(uint_double))
> +
> +    @staticmethod
> +    def doble_hex_to_float_hex(hstr):
> +        """Returns the float32 hexadecimal representation from a
> float64
> +           hexadecimal representation.
> +        """
> +        assert isinstance(hstr, str)
> +        float_double = np.float32(TestTuple.hex_to_double(hstr))
> +        return TestTuple.float_to_hex(float_double)
> +
> +    @staticmethod
> +    def doble_hex_to_inv_float_hex(hstr):
> +        """Returns the inverted float32 hexadecimal representation
> from a
> +           float64 hexadecimal representation.
> +        """
> +        assert isinstance(hstr, str)
> +        temp = np.divide(1.0, TestTuple.hex_to_double(hstr))
> +        float_double = np.float32(temp)
> +        return TestTuple.float_to_hex(float_double)
> +
> +    def __init__(self, ver, stage,
> +                 first_dimension, second_dimension,
> +                 basic_type, names_only):
> +        assert stage in ('vert', 'geom', 'frag')
> +        assert first_dimension in ('1', '2', '3', '4')
> +        assert second_dimension in ('1', '2', '3', '4')
> +        assert isinstance(names_only, bool)
> +
> +        self._ver = ver
> +        self._stage = stage
> +        self._basic_type = basic_type
> +        self._names_only = names_only
> +        self._double_type = ''
> +        self._conversion_type = ''
> +        self._uniform_type = ''
> +        self._amount = int(first_dimension) * int(second_dimension)
> +        self._filenames = []
> +
> +        if first_dimension != '1':
> +            dimensional_type = 'mat' + first_dimension
> +            if first_dimension != second_dimension:
> +                dimensional_type += 'x' + second_dimension
> +        elif second_dimension != '1':
> +            dimensional_type = 'vec' + second_dimension
> +        else:
> +            dimensional_type = ''
> +
> +        if dimensional_type == '':
> +            if basic_type == 'b':
> +                self._conversion_type = 'bool'
> +                self._uniform_type = 'int'
> +            elif basic_type == 'i':
> +                self._conversion_type = 'int'
> +            elif basic_type == 'u':
> +                self._conversion_type = 'uint'
> +            elif basic_type == 'f':
> +                self._conversion_type = 'float'
> +            self._double_type = 'double'
> +            if self._uniform_type == '':
> +                self._uniform_type = self._conversion_type
> +        else:
> +            self._conversion_type = (basic_type if basic_type != 'f'
> else '') + dimensional_type
> +            if basic_type == 'b':
> +                self._uniform_type = 'i' + dimensional_type
> +            else:
> +                self._uniform_type = self._conversion_type
> +            self._double_type = 'd' + dimensional_type
> +
> +    @abc.abstractmethod
> +    def _gen_to_double(self):
> +        """Generates the test files for conversions to float64."""
> +
> +    @abc.abstractmethod
> +    def _gen_from_double(self):
> +        """Generates the test files for conversions from float64."""
> +
> +    @property
> +    def filenames(self):
> +        """Returns the test file names this tuple will generate."""
> +        if self._filenames == []:
> +            tmp = self._names_only
> +            self._names_only = True
> +            self.generate_test_files()
> +            self._names_only = tmp
> +        return self._filenames
> +
> +    def generate_test_files(self):
> +        """Generate the GLSL parser tests."""
> +        self._filenames = []
> +
> +        self._gen_to_double()
> +        self._gen_from_double()
> +
> +
> +class RegularTestTuple(TestTuple):
> +    """Derived class for conversion tests using regular values
> within the
> +       edges of the used types.
> +    """
> +
> +    @staticmethod
> +    def all_tests(names_only):
> +        """Returns all the possible contained conversion test
> instances."""
> +
> +        assert isinstance(names_only, bool)
> +        stages = ['vert', 'geom', 'frag']
> +        dimensions = ['1', '2', '3', '4']
> +        basic_types = ['b', 'u', 'i', 'f']
> +        glsl_ver = ['GL_ARB_gpu_shader_fp64', '400']
> +
> +        if not names_only:
> +            test_types = ['compiler', 'execution']
> +            for ver, test_type in itertools.product(glsl_ver,
> test_types):
> +                utils.safe_makedirs(get_dir_name(ver, test_type))
> +
> +        for ver, stage, first_dimension, second_dimension,
> basic_type in itertools.product(
> +                glsl_ver,
> +                stages,
> +                dimensions,
> +                dimensions,
> +                basic_types):
> +            if not (first_dimension != '1' and (second_dimension ==
> '1' or basic_type != 'f')):
> +                yield RegularTestTuple(ver, stage,
> +                                       first_dimension,
> second_dimension,
> +                                       basic_type, names_only)
> +
> +    def __init__(self, ver, stage,
> +                 first_dimension, second_dimension,
> +                 basic_type, names_only):
> +        assert ver in ('GL_ARB_gpu_shader_fp64', '400')
> +        assert basic_type in ('b', 'u', 'i', 'f')
> +        assert not (first_dimension != '1' and (second_dimension ==
> '1' or basic_type != 'f'))
> +        super(RegularTestTuple, self).__init__(ver, stage,
> +                                               first_dimension,
> second_dimension,
> +                                               basic_type,
> names_only)
> +
> +    def _gen_comp_test(self, from_type, to_type, converted_from):
> +        filename = os.path.join(
> +            get_dir_name(self._ver, 'compiler'),
> +            '{}-conversion-implicit-{}-{}-
> bad.{}'.format(self._stage, from_type, to_type,
> +                                                         self._stage
> ))
> +
> +        self._filenames.append(filename)
> +
> +        if not self._names_only:
> +            with open(filename, 'w') as test_file:
> +                test_file.write(TEMPLATES.get_template(
> +                    'compiler.{}.mako'.format(self._stage)).render_u
> nicode(
> +                        ver=self._ver,
> +                        from_type=from_type,
> +                        to_type=to_type,
> +                        converted_from=converted_from))
> +
> +    def _gen_exec_test(self, from_type, to_type,
> +                       uniform_from_type, uniform_to_type,
> +                       explicit, converted_from, conversions):
> +        filename = os.path.join(
> +            get_dir_name(self._ver, 'execution'),
> +            '{}-conversion-{}-{}-{}.shader_test'.format(self._stage, 
> explicit,
> +                                                        from_type,
> to_type))
> +
> +        self._filenames.append(filename)
> +
> +        if not self._names_only:
> +            with open(filename, 'w') as test_file:
> +                test_file.write(TEMPLATES.get_template(
> +                    'execution.{}.shader_test.mako'.format(self._sta
> ge)).render_unicode(
> +                        ver=self._ver,
> +                        amount=self._amount,
> +                        from_type=from_type,
> +                        to_type=to_type,
> +                        converted_from=converted_from,
> +                        uniform_from_type=uniform_from_type,
> +                        uniform_to_type=uniform_to_type,
> +                        conversions=conversions))
> +
> +    def _gen_to_double(self):
> +        converted_from = 'from'
> +        explicit = 'implicit'
> +
> +        if self._basic_type == 'b':
> +            explicit = 'explicit'
> +            self._gen_comp_test(self._conversion_type,
> self._double_type,
> +                                converted_from)
> +            converted_from = self._double_type + '(from)'
> +            conversion_values = BOOL_VALUES
> +            conversion_function = TestTuple.int_str_to_double_str
> +        elif self._basic_type == 'i':
> +            conversion_values = INT_VALUES
> +            conversion_function = TestTuple.int_str_to_double_str
> +        elif self._basic_type == 'u':
> +            conversion_values = UINT_VALUES
> +            conversion_function = TestTuple.int_str_to_double_str
> +        elif self._basic_type == 'f':
> +            conversion_values = FLOAT_INFS + FLOAT_NEG_ZERO +
> FLOAT_POS_ZERO + FLOAT_VALUES
> +            conversion_function = TestTuple.float_hex_to_double_hex
> +
> +        conversions = []
> +        for value in conversion_values:
> +            to_value = conversion_function(value)
> +            item = {'from': value, 'to': to_value}
> +            conversions.append(item)
> +
> +        self._gen_exec_test(self._conversion_type,
> self._double_type,
> +                            self._uniform_type, self._double_type,
> +                            explicit, converted_from, conversions)
> +
> +    def _gen_from_double(self):
> +        converted_from = 'from'
> +        self._gen_comp_test(self._double_type,
> self._conversion_type,
> +                            converted_from)
> +
> +        converted_from = self._conversion_type + '(from)'
> +        explicit = 'explicit'
> +
> +        if self._basic_type == 'b':
> +            conversion_values = DOUBLE_INFS + DOUBLE_NORMAL_VALUES +
> DOUBLE_BOOL_VALUES
> +            conversion_function = TestTuple.doble_hex_to_bool_str
> +        elif self._basic_type == 'i':
> +            conversion_values = DOUBLE_DENORMAL_VALUES +
> DOUBLE_NORMAL_VALUES + DOUBLE_INT_VALUES
> +            conversion_function = TestTuple.doble_hex_to_int_str
> +        elif self._basic_type == 'u':
> +            conversion_values = DOUBLE_DENORMAL_VALUES +
> DOUBLE_NORMAL_VALUES + DOUBLE_UINT_VALUES
> +            conversion_function = TestTuple.doble_hex_to_uint_str
> +        elif self._basic_type == 'f':
> +            conversion_values = DOUBLE_INFS + DOUBLE_FLOAT_INFS +
> DOUBLE_FLOAT_VALUES
> +            conversion_function = TestTuple.doble_hex_to_float_hex
> +
> +        conversions = []
> +        for value in DOUBLE_NEG_ZERO + DOUBLE_POS_ZERO +
> conversion_values:
> +            to_value = conversion_function(value)
> +            item = {'from': value, 'to': to_value}
> +            conversions.append(item)
> +
> +        self._gen_exec_test(self._double_type,
> self._conversion_type,
> +                            self._double_type, self._uniform_type,
> +                            explicit, converted_from, conversions)
> +
> +
> +class ZeroSignTestTuple(TestTuple):
> +    """Derived class for conversion tests using the float32 and
> float64
> +       +/-0.0 values.
> +    """
> +
> +    @staticmethod
> +    def all_tests(names_only):
> +        """Returns all the possible zero sign conversion test
> instances."""
> +
> +        assert isinstance(names_only, bool)
> +        stages = ['vert', 'geom', 'frag']
> +        dimensions = ['1', '2', '3', '4']
> +        basic_types = ['f']
> +        glsl_ver = ['410', '420']
> +
> +        if not names_only:
> +            for ver in glsl_ver:
> +                utils.safe_makedirs(get_dir_name(ver, 'execution'))
> +
> +        for ver, stage, first_dimension, second_dimension,
> basic_type in itertools.product(
> +                glsl_ver,
> +                stages,
> +                dimensions,
> +                dimensions,
> +                basic_types):
> +            if not (first_dimension != '1' and second_dimension ==
> '1'):
> +                yield ZeroSignTestTuple(ver, stage,
> +                                        first_dimension,
> second_dimension,
> +                                        basic_type, names_only)
> +
> +    def __init__(self, ver, stage,
> +                 first_dimension, second_dimension,
> +                 basic_type, names_only):
> +        assert ver in ('410', '420')
> +        assert basic_type == 'f'
> +        assert not (first_dimension != '1' and second_dimension ==
> '1')
> +        super(ZeroSignTestTuple, self).__init__(ver, stage,
> +                                                first_dimension,
> second_dimension,
> +                                                basic_type,
> names_only)
> +
> +    def __gen_zero_sign_exec_test(self, from_type, to_type,
> +                                  uniform_from_type,
> uniform_to_type,
> +                                  explicit, converted_from,
> conversions):
> +        filename = os.path.join(
> +            get_dir_name(self._ver, 'execution'),
> +            '{}-conversion-{}-{}-{}-zero-
> sign.shader_test'.format(self._stage, explicit,
> +                                                                  fr
> om_type, to_type))
> +
> +        self._filenames.append(filename)
> +
> +        if not self._names_only:
> +            with open(filename, 'w') as test_file:
> +                test_file.write(TEMPLATES.get_template(
> +                    'execution-zero-
> sign.{}.shader_test.mako'.format(
> +                        self._stage)).render_unicode(
> +                            ver=self._ver,
> +                            amount=self._amount,
> +                            from_type=from_type,
> +                            to_type=to_type,
> +                            converted_from=converted_from,
> +                            uniform_from_type=uniform_from_type,
> +                            uniform_to_type=uniform_to_type,
> +                            conversions=conversions))
> +
> +    def _gen_to_double(self):
> +        if self._ver == '410':
> +            conversion_values = FLOAT_POS_ZERO
> +        elif self._ver == '420':
> +            conversion_values = FLOAT_NEG_ZERO
> +
> +        conversions = []
> +        for value in conversion_values:
> +            to_value = TestTuple.float_hex_to_inv_double_hex(value)
> +            item = {'from': value, 'to': to_value}
> +            conversions.append(item)
> +
> +        self.__gen_zero_sign_exec_test(self._conversion_type,
> self._double_type,
> +                                       self._uniform_type,
> self._double_type,
> +                                       'implicit', 'from',
> conversions)
> +
> +    def _gen_from_double(self):
> +        if self._ver == '410':
> +            conversion_values = DOUBLE_POS_ZERO
> +        elif self._ver == '420':
> +            conversion_values = DOUBLE_NEG_ZERO
> +
> +        conversions = []
> +        for value in conversion_values:
> +            to_value = TestTuple.doble_hex_to_inv_float_hex(value)
> +            item = {'from': value, 'to': to_value}
> +            conversions.append(item)
> +
> +        self.__gen_zero_sign_exec_test(self._double_type,
> self._conversion_type,
> +                                       self._double_type,
> self._uniform_type,
> +                                       'explicit',
> self._conversion_type + '(from)', conversions)
> +
> +
> +def main():
> +    """Main function."""
> +
> +    parser = argparse.ArgumentParser(
> +        description="Generate shader tests that check the
> conversions from and "
> +        "to fp64")
> +    parser.add_argument(
> +        '--names-only',
> +        dest='names_only',
> +        action='store_true',
> +        default=False,
> +        help="Don't output files, just generate a list of filenames
> to stdout")
> +    args = parser.parse_args()
> +
> +    np.seterr(divide='ignore')
> +
> +    for test in (list(RegularTestTuple.all_tests(args.names_only)) +
> +                 list(ZeroSignTestTuple.all_tests(args.names_only)))
> :
> +        test.generate_test_files()
> +        for filename in test.filenames:
> +            print(filename)
> +
> +
> +if __name__ == '__main__':
> +    main()
> diff --git a/generated_tests/templates/gen_conversion_fp64/base.mako
> b/generated_tests/templates/gen_conversion_fp64/base.mako
> new file mode 100644
> index 0000000..bcb479f
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/base.mako
> @@ -0,0 +1,12 @@
> +## coding=utf-8
> +<%def name="versioning()"><%
> +    if ver == 'GL_ARB_gpu_shader_fp64':
> +        glsl_version_int = '150'
> +    else:
> +        glsl_version_int = ver
> +
> +    glsl_version = '{}.{}'.format(glsl_version_int[0],
> glsl_version_int[1:3])
> +
> +    return (glsl_version, glsl_version_int)
> +%></%def>\
> +${next.body()}\
> diff --git
> a/generated_tests/templates/gen_conversion_fp64/compiler.frag.mako
> b/generated_tests/templates/gen_conversion_fp64/compiler.frag.mako
> new file mode 100644
> index 0000000..2ae22df
> --- /dev/null
> +++
> b/generated_tests/templates/gen_conversion_fp64/compiler.frag.mako
> @@ -0,0 +1,3 @@
> +## coding=utf-8
> +<%inherit file="compiler_base.mako"/>\
> +<%include file="shader.frag.mako"/>\
> diff --git
> a/generated_tests/templates/gen_conversion_fp64/compiler.geom.mako
> b/generated_tests/templates/gen_conversion_fp64/compiler.geom.mako
> new file mode 100644
> index 0000000..1e2e340
> --- /dev/null
> +++
> b/generated_tests/templates/gen_conversion_fp64/compiler.geom.mako
> @@ -0,0 +1,3 @@
> +## coding=utf-8
> +<%inherit file="compiler_base.mako"/>\
> +<%include file="shader.geom.mako"/>\
> diff --git
> a/generated_tests/templates/gen_conversion_fp64/compiler.vert.mako
> b/generated_tests/templates/gen_conversion_fp64/compiler.vert.mako
> new file mode 100644
> index 0000000..d9148f1
> --- /dev/null
> +++
> b/generated_tests/templates/gen_conversion_fp64/compiler.vert.mako
> @@ -0,0 +1,3 @@
> +## coding=utf-8
> +<%inherit file="compiler_base.mako"/>\
> +<%include file="shader.vert.mako"/>\
> diff --git
> a/generated_tests/templates/gen_conversion_fp64/compiler_base.mako
> b/generated_tests/templates/gen_conversion_fp64/compiler_base.mako
> new file mode 100644
> index 0000000..96ecc36
> --- /dev/null
> +++
> b/generated_tests/templates/gen_conversion_fp64/compiler_base.mako
> @@ -0,0 +1,25 @@
> +## coding=utf-8
> +<%inherit file="base.mako"/>\
> +<%
> +    (glsl_version, glsl_version_int) = self.versioning()
> +%>\
> +/* [config]
> + * expect_result: fail
> + * glsl_version: ${glsl_version}
> +% if ver == 'GL_ARB_gpu_shader_fp64':
> + * require_extensions: ${ver}
> + * [end config]
> + *
> + * ${ver} spec states:
> + *
> + *     "No implicit conversions are
> + *      provided to convert from unsigned to signed integer types,
> from
> + *      floating-point to integer types, or from higher-precision to
> + *      lower-precision types.  There are no implicit array or
> structure
> + *      conversions."
> +% else:
> + * [end config]
> +% endif
> + */
> +
> +${next.body()}\
> diff --git a/generated_tests/templates/gen_conversion_fp64/execution-
> zero-sign.frag.shader_test.mako
> b/generated_tests/templates/gen_conversion_fp64/execution-zero-
> sign.frag.shader_test.mako
> new file mode 100644
> index 0000000..2d0123b
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/execution-zero-
> sign.frag.shader_test.mako
> @@ -0,0 +1,8 @@
> +## coding=utf-8
> +<%inherit file="execution_base.mako"/>\
> +
> +[vertex shader passthrough]
> +
> +[fragment shader]
> +<%include file="shader-zero-sign.frag.mako"/>
> +
> diff --git a/generated_tests/templates/gen_conversion_fp64/execution-
> zero-sign.geom.shader_test.mako
> b/generated_tests/templates/gen_conversion_fp64/execution-zero-
> sign.geom.shader_test.mako
> new file mode 100644
> index 0000000..a4fef76
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/execution-zero-
> sign.geom.shader_test.mako
> @@ -0,0 +1,27 @@
> +## coding=utf-8
> +<%inherit file="execution_base.mako"/>\
> +
> +[vertex shader]
> +#version 150
> +
> +in vec4 piglit_vertex;
> +out vec4 vertex_to_gs;
> +
> +void main()
> +{
> +    vertex_to_gs = piglit_vertex;
> +}
> +
> +[geometry shader]
> +<%include file="shader-zero-sign.geom.mako"/>
> +[fragment shader]
> +#version 150
> +
> +in vec4 fs_color;
> +out vec4 color;
> +
> +void main()
> +{
> +    color = fs_color;
> +}
> +
> diff --git a/generated_tests/templates/gen_conversion_fp64/execution-
> zero-sign.vert.shader_test.mako
> b/generated_tests/templates/gen_conversion_fp64/execution-zero-
> sign.vert.shader_test.mako
> new file mode 100644
> index 0000000..5715a61
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/execution-zero-
> sign.vert.shader_test.mako
> @@ -0,0 +1,16 @@
> +## coding=utf-8
> +<%inherit file="execution_base.mako"/>\
> +
> +[vertex shader]
> +<%include file="shader-zero-sign.vert.mako"/>
> +[fragment shader]
> +#version 150
> +
> +in vec4 fs_color;
> +out vec4 color;
> +
> +void main()
> +{
> +    color = fs_color;
> +}
> +
> diff --git
> a/generated_tests/templates/gen_conversion_fp64/execution.frag.shader
> _test.mako
> b/generated_tests/templates/gen_conversion_fp64/execution.frag.shader
> _test.mako
> new file mode 100644
> index 0000000..60507ee
> --- /dev/null
> +++
> b/generated_tests/templates/gen_conversion_fp64/execution.frag.shader
> _test.mako
> @@ -0,0 +1,7 @@
> +## coding=utf-8
> +<%inherit file="execution_base.mako"/>\
> +
> +[vertex shader passthrough]
> +
> +[fragment shader]
> +<%include file="shader.frag.mako"/>
> diff --git
> a/generated_tests/templates/gen_conversion_fp64/execution.geom.shader
> _test.mako
> b/generated_tests/templates/gen_conversion_fp64/execution.geom.shader
> _test.mako
> new file mode 100644
> index 0000000..ed53475
> --- /dev/null
> +++
> b/generated_tests/templates/gen_conversion_fp64/execution.geom.shader
> _test.mako
> @@ -0,0 +1,27 @@
> +## coding=utf-8
> +<%inherit file="execution_base.mako"/>\
> +
> +[vertex shader]
> +#version 150
> +
> +in vec4 piglit_vertex;
> +out vec4 vertex_to_gs;
> +
> +void main()
> +{
> +    vertex_to_gs = piglit_vertex;
> +}
> +
> +[geometry shader]
> +<%include file="shader.geom.mako"/>
> +[fragment shader]
> +#version 150
> +
> +in vec4 fs_color;
> +out vec4 color;
> +
> +void main()
> +{
> +    color = fs_color;
> +}
> +
> diff --git
> a/generated_tests/templates/gen_conversion_fp64/execution.vert.shader
> _test.mako
> b/generated_tests/templates/gen_conversion_fp64/execution.vert.shader
> _test.mako
> new file mode 100644
> index 0000000..a0d13c2
> --- /dev/null
> +++
> b/generated_tests/templates/gen_conversion_fp64/execution.vert.shader
> _test.mako
> @@ -0,0 +1,16 @@
> +## coding=utf-8
> +<%inherit file="execution_base.mako"/>\
> +
> +[vertex shader]
> +<%include file="shader.vert.mako"/>
> +[fragment shader]
> +#version 150
> +
> +in vec4 fs_color;
> +out vec4 color;
> +
> +void main()
> +{
> +    color = fs_color;
> +}
> +
> diff --git
> a/generated_tests/templates/gen_conversion_fp64/execution_base.mako
> b/generated_tests/templates/gen_conversion_fp64/execution_base.mako
> new file mode 100644
> index 0000000..419259c
> --- /dev/null
> +++
> b/generated_tests/templates/gen_conversion_fp64/execution_base.mako
> @@ -0,0 +1,28 @@
> +## coding=utf-8
> +<%inherit file="base.mako"/>\
> +<%
> +    (glsl_version, glsl_version_int) = self.versioning()
> +%>\
> +<%! from six.moves import range %>\
> +[require]
> +GLSL >= ${glsl_version}
> +% if ver == 'GL_ARB_gpu_shader_fp64':
> +${ver}
> +% endif
> +${next.body()}\
> +[test]
> +% for conversion in conversions:
> +uniform ${uniform_from_type} from \
> +% for i in range(amount):
> +${conversion['from']} \
> +% endfor
> +
> +uniform ${uniform_to_type} to \
> +% for i in range(amount):
> +${conversion['to']} \
> +% endfor
> +
> +draw rect -1 -1 2 2
> +probe all rgba 0.0 1.0 0.0 1.0
> +
> +% endfor
> diff --git a/generated_tests/templates/gen_conversion_fp64/shader-
> zero-sign.frag.mako
> b/generated_tests/templates/gen_conversion_fp64/shader-zero-
> sign.frag.mako
> new file mode 100644
> index 0000000..1a38b7a
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/shader-zero-
> sign.frag.mako
> @@ -0,0 +1,18 @@
> +## coding=utf-8
> +<%inherit file="shader_base.mako"/>\
> +uniform ${from_type} from;
> +uniform ${to_type} to;
> +
> +out vec4 color;
> +
> +#define ONE 1.0
> +#define RED vec4(1.0, 0.0, 0.0, 1.0)
> +#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
> +
> +void main()
> +{
> +    ${to_type} pre_converted = ${converted_from};
> +    ${to_type} converted = ONE / pre_converted;
> +    bool match = converted == to;
> +    color = match ? GREEN : RED;
> +}
> diff --git a/generated_tests/templates/gen_conversion_fp64/shader-
> zero-sign.geom.mako
> b/generated_tests/templates/gen_conversion_fp64/shader-zero-
> sign.geom.mako
> new file mode 100644
> index 0000000..22f366f
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/shader-zero-
> sign.geom.mako
> @@ -0,0 +1,27 @@
> +## coding=utf-8
> +<%inherit file="shader_base.mako"/>\
> +layout(triangles) in;
> +layout(triangle_strip, max_vertices = 3) out;
> +
> +uniform ${from_type} from;
> +uniform ${to_type} to;
> +
> +in vec4 vertex_to_gs[3];
> +out vec4 fs_color;
> +
> +#define ONE 1.0
> +#define RED vec4(1.0, 0.0, 0.0, 1.0)
> +#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
> +
> +void main()
> +{
> +    ${to_type} pre_converted = ${converted_from};
> +    ${to_type} converted = ONE / pre_converted;
> +    bool match = converted == to;
> +    fs_color = match ? GREEN : RED;
> +
> +    for (int i = 0; i < 3; i++) {
> +        gl_Position = vertex_to_gs[i];
> +        EmitVertex();
> +    }
> +}
> diff --git a/generated_tests/templates/gen_conversion_fp64/shader-
> zero-sign.vert.mako
> b/generated_tests/templates/gen_conversion_fp64/shader-zero-
> sign.vert.mako
> new file mode 100644
> index 0000000..a49add1
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/shader-zero-
> sign.vert.mako
> @@ -0,0 +1,20 @@
> +## coding=utf-8
> +<%inherit file="shader_base.mako"/>\
> +uniform ${from_type} from;
> +uniform ${to_type} to;
> +
> +in vec4 piglit_vertex;
> +out vec4 fs_color;
> +
> +#define ONE 1.0
> +#define RED vec4(1.0, 0.0, 0.0, 1.0)
> +#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
> +
> +void main()
> +{
> +    gl_Position = piglit_vertex;
> +    ${to_type} pre_converted = ${converted_from};
> +    ${to_type} converted = ONE / pre_converted;
> +    bool match = converted == to;
> +    fs_color = match ? GREEN : RED;
> +}
> diff --git
> a/generated_tests/templates/gen_conversion_fp64/shader.frag.mako
> b/generated_tests/templates/gen_conversion_fp64/shader.frag.mako
> new file mode 100644
> index 0000000..346b77b
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/shader.frag.mako
> @@ -0,0 +1,16 @@
> +## coding=utf-8
> +<%inherit file="shader_base.mako"/>\
> +uniform ${from_type} from;
> +uniform ${to_type} to;
> +
> +out vec4 color;
> +
> +#define RED vec4(1.0, 0.0, 0.0, 1.0)
> +#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
> +
> +void main()
> +{
> +    ${to_type} converted = ${converted_from};
> +    bool match = converted == to;
> +    color = match ? GREEN : RED;
> +}
> diff --git
> a/generated_tests/templates/gen_conversion_fp64/shader.geom.mako
> b/generated_tests/templates/gen_conversion_fp64/shader.geom.mako
> new file mode 100644
> index 0000000..987adbc
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/shader.geom.mako
> @@ -0,0 +1,25 @@
> +## coding=utf-8
> +<%inherit file="shader_base.mako"/>\
> +layout(triangles) in;
> +layout(triangle_strip, max_vertices = 3) out;
> +
> +uniform ${from_type} from;
> +uniform ${to_type} to;
> +
> +in vec4 vertex_to_gs[3];
> +out vec4 fs_color;
> +
> +#define RED vec4(1.0, 0.0, 0.0, 1.0)
> +#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
> +
> +void main()
> +{
> +    ${to_type} converted = ${converted_from};
> +    bool match = converted == to;
> +    fs_color = match ? GREEN : RED;
> +
> +    for (int i = 0; i < 3; i++) {
> +        gl_Position = vertex_to_gs[i];
> +        EmitVertex();
> +    }
> +}
> diff --git
> a/generated_tests/templates/gen_conversion_fp64/shader.vert.mako
> b/generated_tests/templates/gen_conversion_fp64/shader.vert.mako
> new file mode 100644
> index 0000000..8f5c797
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/shader.vert.mako
> @@ -0,0 +1,18 @@
> +## coding=utf-8
> +<%inherit file="shader_base.mako"/>\
> +uniform ${from_type} from;
> +uniform ${to_type} to;
> +
> +in vec4 piglit_vertex;
> +out vec4 fs_color;
> +
> +#define RED vec4(1.0, 0.0, 0.0, 1.0)
> +#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
> +
> +void main()
> +{
> +    gl_Position = piglit_vertex;
> +    ${to_type} converted = ${converted_from};
> +    bool match = converted == to;
> +    fs_color = match ? GREEN : RED;
> +}
> diff --git
> a/generated_tests/templates/gen_conversion_fp64/shader_base.mako
> b/generated_tests/templates/gen_conversion_fp64/shader_base.mako
> new file mode 100644
> index 0000000..33d88b8
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_fp64/shader_base.mako
> @@ -0,0 +1,11 @@
> +## coding=utf-8
> +<%inherit file="base.mako"/>\
> +<%
> +    (glsl_version, glsl_version_int) = self.versioning()
> +%>\
> +#version ${glsl_version_int}
> +% if ver == 'GL_ARB_gpu_shader_fp64':
> +#extension GL_ARB_gpu_shader_fp64 : require
> +% endif
> +
> +${next.body()}\
> diff --git a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-
> conversion-double-float-bad.vert
> b/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-double-
> float-bad.vert
> deleted file mode 100644
> index 3e2b15a..0000000
> --- a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-
> double-float-bad.vert
> +++ /dev/null
> @@ -1,20 +0,0 @@
> -// [config]
> -// expect_result: fail
> -// glsl_version: 1.50
> -// require_extensions: GL_ARB_gpu_shader_fp64
> -// [end config]
> -//
> -// Test double -> float implicit conversion doesn't happen
> -
> -#version 150
> -#extension GL_ARB_gpu_shader_fp64 : enable
> -
> -float _float = 0.0f;
> -
> -double _double = 0.0lf;
> -
> -void test() {
> -
> -    /* double cannot be converted to float (and for vectors of same)
> */
> -    _float = _double;
> -}
> diff --git a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-
> conversion-dvec2-vec2-bad.vert
> b/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec2-
> vec2-bad.vert
> deleted file mode 100644
> index 225636d..0000000
> --- a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-
> dvec2-vec2-bad.vert
> +++ /dev/null
> @@ -1,20 +0,0 @@
> -// [config]
> -// expect_result: fail
> -// glsl_version: 1.50
> -// require_extensions: GL_ARB_gpu_shader_fp64
> -// [end config]
> -//
> -// Test double -> float implicit conversion doesn't happen
> -
> -#version 150
> -#extension GL_ARB_gpu_shader_fp64 : enable
> -
> -vec2 _vec2 = vec2(0.0f);
> -
> -dvec2 _dvec2 = dvec2(0.0lf);
> -
> -void test() {
> -
> -    /* double cannot be converted to float (and for vectors of same)
> */
> -    _vec2 = _dvec2;
> -}
> diff --git a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-
> conversion-dvec3-vec3-bad.vert
> b/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec3-
> vec3-bad.vert
> deleted file mode 100644
> index cf8583e..0000000
> --- a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-
> dvec3-vec3-bad.vert
> +++ /dev/null
> @@ -1,20 +0,0 @@
> -// [config]
> -// expect_result: fail
> -// glsl_version: 1.50
> -// require_extensions: GL_ARB_gpu_shader_fp64
> -// [end config]
> -//
> -// Test double -> float implicit conversion doesn't happen
> -
> -#version 150
> -#extension GL_ARB_gpu_shader_fp64 : enable
> -
> -vec3 _vec3 = vec3(0.0f);
> -
> -dvec3 _dvec3 = dvec3(0.0lf);
> -
> -void test() {
> -
> -    /* double cannot be converted to float (and for vectors of same)
> */
> -    _vec3 = _dvec3;
> -}
> diff --git a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-
> conversion-dvec4-vec4-bad.vert
> b/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-dvec4-
> vec4-bad.vert
> deleted file mode 100644
> index dd394e5..0000000
> --- a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-conversion-
> dvec4-vec4-bad.vert
> +++ /dev/null
> @@ -1,20 +0,0 @@
> -// [config]
> -// expect_result: fail
> -// glsl_version: 1.50
> -// require_extensions: GL_ARB_gpu_shader_fp64
> -// [end config]
> -//
> -// Test double -> float implicit conversion doesn't happen
> -
> -#version 150
> -#extension GL_ARB_gpu_shader_fp64 : enable
> -
> -vec4 _vec4 = vec4(0.0f);
> -
> -dvec4 _dvec4 = dvec4(0.0lf);
> -
> -void test() {
> -
> -    /* double cannot be converted to float (and for vectors of same)
> */
> -    _vec4 = _dvec4;
> -}
> diff --git a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-
> conversions.vert b/tests/spec/arb_gpu_shader_fp64/compiler/implicit-
> conversions.vert
> deleted file mode 100644
> index 0b88b40..0000000
> --- a/tests/spec/arb_gpu_shader_fp64/compiler/implicit-
> conversions.vert
> +++ /dev/null
> @@ -1,115 +0,0 @@
> -// [config]
> -// expect_result: pass
> -// glsl_version: 1.50
> -// require_extensions: GL_ARB_gpu_shader_fp64
> -// [end config]
> -//
> -// Test that implicit conversions are allowed as specified in
> GL_ARB_gpu_shader_fp64
> -//
> -// GL_ARB_gpu_shader_fp64 spec presents following conversion table:
> -//
> -//                             Can be implicitly
> -//     Type of expression        converted to
> -//     ---------------------   -------------------
> -//     int                     uint(*), float, double
> -//     ivec2                   uvec2(*), vec2, dvec2
> -//     ivec3                   uvec3(*), vec3, dvec3
> -//     ivec4                   uvec4(*), vec4, dvec4
> -//
> -//     uint                    float, double
> -//     uvec2                   vec2, dvec2
> -//     uvec3                   vec3, dvec3
> -//     uvec4                   vec4, dvec4
> -//
> -//     float                   double
> -//     vec2                    dvec2
> -//     vec3                    dvec3
> -//     vec4                    dvec4
> -//
> -//     mat2                    dmat2
> -//     mat3                    dmat3
> -//     mat4                    dmat4
> -//     mat2x3                  dmat2x3
> -//     mat2x4                  dmat2x4
> -//     mat3x2                  dmat3x2
> -//     mat3x4                  dmat3x4
> -//     mat4x2                  dmat4x2
> -//     mat4x3                  dmat4x3
> -//
> -//     (*) if ARB_gpu_shader5 or NV_gpu_shader5 is supported
> -//
> -
> -#version 150
> -#extension GL_ARB_gpu_shader_fp64 : enable
> -
> -int _int = 0;
> -ivec2 _ivec2 = ivec2(0);
> -ivec3 _ivec3 = ivec3(0);
> -ivec4 _ivec4 = ivec4(0);
> -
> -uint _uint = 0u;
> -uvec2 _uvec2 = uvec2(0u);
> -uvec3 _uvec3 = uvec3(0u);
> -uvec4 _uvec4 = uvec4(0u);
> -
> -float _float = 0.0f;
> -vec2 _vec2 = vec2(0.0f);
> -vec3 _vec3 = vec3(0.0f);
> -vec4 _vec4 = vec4(0.0f);
> -
> -double _double;
> -dvec2 _dvec2;
> -dvec3 _dvec3;
> -dvec4 _dvec4;
> -
> -mat2 _mat2 = mat2(1.0);
> -mat3 _mat3 = mat3(1.0);
> -mat4 _mat4 = mat4(1.0);
> -mat2x3 _mat2x3 = mat2x3(1.0);
> -mat2x4 _mat2x4 = mat2x4(1.0);
> -mat3x2 _mat3x2 = mat3x2(1.0);
> -mat3x4 _mat3x4 = mat3x4(1.0);
> -mat4x2 _mat4x2 = mat4x2(1.0);
> -mat4x3 _mat4x3 = mat4x3(1.0);
> -
> -dmat2 _dmat2;
> -dmat3 _dmat3;
> -dmat4 _dmat4;
> -dmat2x3 _dmat2x3;
> -dmat2x4 _dmat2x4;
> -dmat3x2 _dmat3x2;
> -dmat3x4 _dmat3x4;
> -dmat4x2 _dmat4x2;
> -dmat4x3 _dmat4x3;
> -
> -void test() {
> -
> -	/* int can be converted to double (and for vectors of same)
> */
> -	_double = _int;
> -	_dvec2 = _ivec2;
> -	_dvec3 = _ivec3;
> -	_dvec4 = _ivec4;
> -
> -	/* uint can be converted to double (and for vectors of same)
> */
> -	_double = _uint;
> -	_dvec2 = _uvec2;
> -	_dvec3 = _uvec3;
> -	_dvec4 = _uvec4;
> -
> -	/* float can be converted to double (and for vectors of
> same) */
> -	_double = _float;
> -	_dvec2 = _vec2;
> -	_dvec3 = _vec3;
> -	_dvec4 = _vec4;
> -
> -	/* mat -> dmat conversions */
> -	_dmat2 = _mat2;
> -	_dmat3 = _mat3;
> -	_dmat4 = _mat4;
> -	_dmat2x3 = _mat2x3;
> -	_dmat2x4 = _mat2x4;
> -	_dmat3x2 = _mat3x2;
> -	_dmat3x4 = _mat3x4;
> -	_dmat4x2 = _mat4x2;
> -	_dmat4x3 = _mat4x3;
> -}

Other than the typo commented the patch looks good to me.

Reviewed-by: Antia Puentes <apuentes@igalia.com>