Lines Matching defs:const
76 static bool comparePixels(glw::GLenum left_internal_format, const glw::GLdouble& left_red,
77 const glw::GLdouble& left_green, const glw::GLdouble& left_blue,
78 const glw::GLdouble& left_alpha, glw::GLenum right_internal_format,
79 const glw::GLdouble& right_red, const glw::GLdouble& right_green,
80 const glw::GLdouble& right_blue, const glw::GLdouble& right_alpha);
82 static bool comparePixels(glw::GLuint left_pixel_size, const glw::GLubyte* left_pixel_data,
83 glw::GLuint right_pixel_size, const glw::GLubyte* right_pixel_data);
100 static std::string getPixelString(glw::GLenum internal_format, const glw::GLubyte* pixel);
117 glw::GLuint width, glw::GLuint height, glw::GLuint depth, const glw::GLvoid* pixels,
123 static void readChannel(glw::GLenum type, glw::GLuint channel, const glw::GLubyte* pixel, glw::GLdouble& out_value);
130 static void unpackPixel(glw::GLenum format, glw::GLenum type, const glw::GLubyte* pixel, glw::GLdouble& out_red,
134 const glw::GLubyte* left_pixel, glw::GLenum right_format, glw::GLenum right_type,
135 glw::GLenum right_internal_format, const glw::GLubyte* right_pixel);
141 static const GLenum s_internal_formats[] = {
203 static const GLenum s_invalid_targets[] = {
223 static const GLenum s_valid_targets[] = {
237 static const GLuint s_n_internal_formats = sizeof(s_internal_formats) / sizeof(s_internal_formats[0]);
238 static const GLuint s_n_invalid_targets = sizeof(s_invalid_targets) / sizeof(s_invalid_targets[0]);
239 static const GLuint s_n_valid_targets = sizeof(s_valid_targets) / sizeof(s_valid_targets[0]);
370 const GLuint dst_size = getPixelSizeForCompatibilityVerification(dst);
371 const GLuint src_size = getPixelSizeForCompatibilityVerification(src);
453 bool Utils::comparePixels(GLenum left_internal_format, const GLdouble& left_red, const GLdouble& left_green,
454 const GLdouble& left_blue, const GLdouble& left_alpha, GLenum right_internal_format,
455 const GLdouble& right_red, const GLdouble& right_green, const GLdouble& right_blue,
456 const GLdouble& right_alpha)
458 const GLuint left_n_channels = getNumberOfChannels(left_internal_format);
459 const GLuint right_n_channels = getNumberOfChannels(right_internal_format);
460 const GLuint n_channels = (left_n_channels >= right_n_channels) ? right_n_channels : left_n_channels;
462 const GLdouble left_channels[4] = { left_red, left_green, left_blue, left_alpha };
464 const GLdouble right_channels[4] = { right_red, right_green, right_blue, right_alpha };
468 const GLdouble left = left_channels[i];
469 const GLdouble right = right_channels[i];
470 const GLdouble left_eps = getEpsilon(left_internal_format);
471 const GLdouble right_eps = getEpsilon(right_internal_format);
472 const GLdouble eps = fabs(std::max(left_eps, right_eps));
492 bool Utils::comparePixels(GLuint left_pixel_size, const GLubyte* left_pixel_data, GLuint right_pixel_size,
493 const GLubyte* right_pixel_data)
495 const GLuint pixel_size = (left_pixel_size >= right_pixel_size) ? left_pixel_size : right_pixel_size;
508 const Functions& gl = context.getRenderContext().getFunctions();
1089 std::string Utils::getPixelString(GLenum internal_format, const GLubyte* pixel)
1091 const GLuint pixel_size = Utils::getPixelSizeForFormat(internal_format);
1188 const Functions& gl = context.getRenderContext().getFunctions();
1217 const Functions& gl = context.getRenderContext().getFunctions();
1274 static const GLuint depth = 6;
1275 const Functions& gl = context.getRenderContext().getFunctions();
1276 static const GLuint height = 16;
1277 static const GLenum internal_format = GL_RGBA8;
1279 static const GLuint width = 16;
1326 const Functions& gl = context.getRenderContext().getFunctions();
1327 static const GLuint height = 16;
1329 static const GLuint width = 16;
1362 static const GLuint depth = 6;
1363 static const GLuint height = 16;
1364 static const GLuint level = 0;
1366 static const GLchar* pixels = 0;
1367 static const GLuint width = 16;
1395 GLenum type, GLuint level, GLuint width, GLuint height, GLuint depth, const GLvoid* pixels,
1398 static const GLint border = 0;
1400 const GLchar* function_name = "unknown";
1401 const Functions& gl = context.getRenderContext().getFunctions();
1402 static const GLsizei samples = 1;
1488 const GLvoid* data = 0;
1650 void readBaseTypeFromUnsignedChannel(GLuint channel, const GLubyte* pixel, GLdouble& out_value)
1652 static const T max = -1;
1654 const GLdouble d_max = (GLdouble)max;
1655 const T* ptr = (T*)pixel;
1656 const T t_value = ptr[channel];
1657 const GLdouble d_value = (GLdouble)t_value;
1671 void readBaseTypeFromSignedChannel(GLuint channel, const GLubyte* pixel, GLdouble& out_value)
1673 static const GLuint n_bytes = sizeof(T);
1674 static const GLuint n_bits = 8u * n_bytes;
1675 static const T max = (T)((1u << (n_bits - 1u)) - 1u);
1677 const GLdouble d_max = (GLdouble)max;
1678 const T* ptr = (T*)pixel;
1679 const T t_value = ptr[channel];
1680 const GLdouble d_value = (GLdouble)t_value;
1693 void readBaseTypeFromFloatChannel(GLuint channel, const GLubyte* pixel, GLdouble& out_value)
1695 const GLfloat* ptr = (const GLfloat*)pixel;
1696 const GLfloat t_value = ptr[channel];
1697 const GLdouble d_value = (GLdouble)t_value;
1710 void readBaseTypeFromHalfFloatChannel(GLuint channel, const GLubyte* pixel, GLdouble& out_value)
1712 const deUint16* ptr = (const deUint16*)pixel;
1713 const deUint16 bits = ptr[channel];
1715 const GLdouble d_value = val.asDouble();
1736 void read3Channel(GLuint channel, const GLubyte* pixel, GLdouble& out_value)
1741 const T* ptr = (T*)pixel;
1743 const T t_value = ptr[0];
1745 static const T max_1 = (1 << size_1) - 1;
1746 static const T max_2 = (1 << size_2) - 1;
1747 static const T max_3 = (1 << size_3) - 1;
1773 const GLdouble d_max = (GLdouble)max;
1774 const GLdouble d_value = (GLdouble)result;
1797 void read4Channel(GLuint channel, const GLubyte* pixel, GLdouble& out_value)
1802 const T* ptr = (T*)pixel;
1804 const T t_value = ptr[0];
1806 static const T max_1 = (1 << size_1) - 1;
1807 static const T max_2 = (1 << size_2) - 1;
1808 static const T max_3 = (1 << size_3) - 1;
1809 static const T max_4 = (1 << size_4) - 1;
1840 const GLdouble d_max = (GLdouble)max;
1841 const GLdouble d_value = (GLdouble)result;
1852 void read11F_11F_10F_Channel(GLuint channel, const GLubyte* pixel, GLdouble& out_value)
1854 const deUint32* ptr = (deUint32*)pixel;
1899 static const T max = -1;
1901 const GLdouble d_max = (GLdouble)max;
1902 const GLdouble d_value = value * d_max;
1903 const T t_value = (T)d_value;
1921 static const GLuint n_bytes = sizeof(T);
1922 static const GLuint n_bits = 8u * n_bytes;
1923 static const T max = (T)((1u << (n_bits - 1u)) - 1u);
1925 const GLdouble d_max = (GLdouble)max;
1926 const GLdouble d_value = value * d_max;
1927 const T t_value = (T)d_value;
1942 const GLfloat t_value = (GLfloat)value;
1988 static const T max_1 = (1 << size_1) - 1;
1989 static const T max_2 = (1 << size_2) - 1;
1990 static const T max_3 = (1 << size_3) - 1;
2014 const GLdouble d_max = (GLdouble)max;
2015 const GLdouble d_value = value * d_max;
2016 const T t_value = (T)d_value;
2049 static const T max_1 = (1 << size_1) - 1;
2050 static const T max_2 = (1 << size_2) - 1;
2051 static const T max_3 = (1 << size_3) - 1;
2052 static const T max_4 = (1 << size_4) - 1;
2081 const GLdouble d_max = (GLdouble)max;
2082 const GLdouble d_value = value * d_max;
2083 const T t_value = (T)d_value;
2138 void Utils::readChannel(GLenum type, GLuint channel, const GLubyte* pixel, GLdouble& value)
2381 void Utils::unpackPixel(GLenum format, GLenum type, const GLubyte* pixel, GLdouble& out_red, GLdouble& out_green,
2460 const GLubyte* left_pixel, GLenum right_format, GLenum right_type,
2461 GLenum right_internal_format, const GLubyte* right_pixel)
2507 const GLenum src_target = s_valid_targets[src_tgt_id];
2519 const GLenum dst_target = s_valid_targets[dst_tgt_id];
2543 const GLenum src_format = s_internal_formats[src_frmt_id];
2552 const GLenum dst_format = s_internal_formats[dst_frmt_id];
2574 const Functions& gl = m_context.getRenderContext().getFunctions();
2578 const testCase& test_case = m_test_cases[m_test_case_index];
2591 m_dst_tex_name = prepareTexture(test_case.m_dst, (const GLubyte**)dst_pixels, m_dst_buf_name);
2598 m_rb_name = prepareTexture(test_case.m_src, (const GLubyte**)src_pixels, m_src_buf_name);
2599 m_src_tex_name = prepareTexture(desc, (const GLubyte**)src_pixels, m_src_buf_name);
2603 m_src_tex_name = prepareTexture(test_case.m_src, (const GLubyte**)src_pixels, m_src_buf_name);
2607 result = copyAndVerify(test_case, (const GLubyte**)dst_pixels, (const GLubyte**)src_pixels);
2658 GLuint* out_heights, GLuint* out_depths) const
2663 const bool is_multi_layer = Utils::isTargetMultilayer(target);
2664 const GLuint n_layers = (true == is_multi_layer) ? FUNCTIONAL_TEST_N_LAYERS : 1;
2703 bool FunctionalTest::copyAndVerify(const testCase& test_case, const GLubyte** dst_pixels, const GLubyte** src_pixels)
2706 const Functions& gl = m_context.getRenderContext().getFunctions();
2709 const bool is_dst_multi_layer = Utils::isTargetMultilayer(test_case.m_dst.m_target);
2710 const bool is_src_multi_layer = Utils::isTargetMultilayer(test_case.m_src.m_target);
2817 const Functions& gl = m_context.getRenderContext().getFunctions();
2849 void FunctionalTest::cleanPixels(GLubyte** pixels) const
2879 bool FunctionalTest::compareImages(const targetDesc& left_desc, const GLubyte* left_data, GLuint left_x, GLuint left_y,
2880 GLuint left_layer, GLuint left_level, const targetDesc& right_desc,
2881 const glw::GLubyte* right_data, GLuint right_x, GLuint right_y, GLuint right_layer,
2882 GLuint right_level, GLuint region_width, GLuint region_height) const
2900 const GLuint left_height = left_heights[left_level];
2901 const GLuint left_width = left_widths[left_level];
2902 const GLuint right_height = right_heights[right_level];
2903 const GLuint right_width = right_widths[right_level];
2905 const GLuint left_pixel_size = Utils::getPixelSizeForFormat(left_desc.m_internal_format);
2906 const GLuint left_line_size = left_pixel_size * left_width;
2907 const GLuint left_layer_size = left_line_size * left_height;
2908 const GLuint right_pixel_size = Utils::getPixelSizeForFormat(right_desc.m_internal_format);
2909 const GLuint right_line_size = right_pixel_size * right_width;
2910 const GLuint right_layer_size = right_line_size * right_height;
2913 const GLuint left_layer_offset = left_layer_size * left_layer;
2914 const GLuint left_reg_line_offset = left_line_size * left_y;
2915 const GLuint left_reg_pix_offset = left_pixel_size * left_x;
2916 const GLuint right_layer_offset = right_layer_size * right_layer;
2917 const GLuint right_reg_line_offset = right_line_size * right_y;
2918 const GLuint right_reg_pix_offset = right_pixel_size * right_x;
2921 const GLubyte* left_layer_data = left_data + left_layer_offset;
2922 const GLubyte* right_layer_data = right_data + right_layer_offset;
2928 const GLuint left_line_offset = left_reg_line_offset + y * left_line_size;
2929 const GLuint right_line_offset = right_reg_line_offset + y * right_line_size;
2932 const GLubyte* left_line_data = left_layer_data + left_line_offset;
2933 const GLubyte* right_line_data = right_layer_data + right_line_offset;
2939 const GLuint left_pixel_offset = left_reg_pix_offset + x * left_pixel_size;
2940 const GLuint right_pixel_offset = right_reg_pix_offset + x * right_pixel_size;
2943 const GLubyte* left_pixel_data = left_line_data + left_pixel_offset;
2944 const GLubyte* right_pixel_data = right_line_data + right_pixel_offset;
2980 void FunctionalTest::getCleanRegions(const testCase& test_case, GLuint dst_level, GLuint out_regions[4][4],
2981 GLuint& out_n_regions) const
2994 const GLuint reg_x = test_case.m_dst_x;
2995 const GLuint reg_y = test_case.m_dst_y;
2996 const GLuint reg_w = test_case.m_width;
2997 const GLuint reg_h = test_case.m_height;
2998 const GLuint reg_r = reg_x + reg_w;
2999 const GLuint reg_t = reg_y + reg_h;
3002 const GLuint img_w = dst_widths[dst_level];
3003 const GLuint img_h = dst_heights[dst_level];
3053 void FunctionalTest::getPixels(GLuint name, const targetDesc& desc, GLuint level, GLubyte* out_pixels) const
3055 const Functions& gl = m_context.getRenderContext().getFunctions();
3072 void FunctionalTest::prepareDstPxls(const FunctionalTest::targetDesc& desc, GLubyte** out_pixels) const
3074 const GLenum internal_format = desc.m_internal_format;
3075 const bool is_multi_level = Utils::isTargetMultilevel(desc.m_target);
3077 const GLuint pixel_size = Utils::getPixelSizeForFormat(desc.m_internal_format);
3078 const GLenum type = desc.m_type;
3096 const GLuint req_memory_per_layer = pixel_size * widths[i] * heights[i];
3097 const GLuint req_memory_for_level = req_memory_per_layer * depths[i];
3112 const GLuint n_layers = depths[i];
3113 const GLuint n_pixels = widths[i] * heights[i];
3131 void FunctionalTest::prepareSrcPxls(const FunctionalTest::targetDesc& desc, GLenum /* dst_internal_format */,
3132 GLubyte** out_pixels) const
3134 const GLenum internal_format = desc.m_internal_format;
3135 const bool is_multi_level = Utils::isTargetMultilevel(desc.m_target);
3137 const GLuint pixel_size = Utils::getPixelSizeForFormat(desc.m_internal_format);
3138 const GLenum type = desc.m_type;
3156 const GLuint req_memory_per_layer = pixel_size * widths[i] * heights[i];
3157 const GLuint req_memory_for_level = req_memory_per_layer * depths[i];
3171 const GLuint n_layers = depths[lvl];
3172 const GLuint line_size = pixel_size * widths[lvl];
3173 const GLuint req_memory_per_layer = line_size * heights[lvl];
3178 const GLuint layer_offset = lay * req_memory_per_layer;
3184 const GLuint line_offset = line_size * y;
3190 const GLuint pixel_offset = x * pixel_size;
3195 const GLdouble red = ((GLdouble)x) / 255.0 + (((GLdouble)y) / 15.9375);
3196 const GLdouble green = ((GLdouble)lay) / 255.0 + (((GLdouble)lvl) / 15.9375);
3197 const GLdouble blue = 0.125;
3198 const GLdouble alpha = 1.0; /* This value has special meaning for some internal_formats */
3217 static const GLuint image_dimmensions[] = {
3231 static const GLuint region_dimmensions[] = {
3243 static const GLuint n_image_dimmensions = sizeof(image_dimmensions) / sizeof(image_dimmensions[0]);
3244 static const GLuint n_region_dimmensions = sizeof(region_dimmensions) / sizeof(region_dimmensions[0]);
3246 const bool is_dst_multi_level = Utils::isTargetMultilevel(dst_target);
3247 const bool is_src_multi_level = Utils::isTargetMultilevel(src_target);
3248 const GLenum dst_format = Utils::getFormat(dst_internal_format);
3249 const GLuint dst_n_levels = (true == is_dst_multi_level) ? FUNCTIONAL_TEST_N_LEVELS : 1;
3250 const GLenum dst_type = Utils::getType(dst_internal_format);
3251 const GLenum src_format = Utils::getFormat(src_internal_format);
3252 const GLuint src_n_levels = (true == is_src_multi_level) ? FUNCTIONAL_TEST_N_LEVELS : 1;
3253 const GLenum src_type = Utils::getType(src_internal_format);
3261 const GLuint src_image_dimmension = image_dimmensions[src_img_dim_id];
3265 const GLuint dst_image_dimmension = image_dimmensions[dst_img_dim_id];
3269 const GLuint region_dimmension = region_dimmensions[reg_dim_id];
3271 const GLuint dst_dim_diff = dst_image_dimmension - region_dimmension;
3277 const GLuint src_dim_diff = src_image_dimmension - region_dimmension;
3381 GLuint FunctionalTest::prepareTexture(const targetDesc& desc, const GLubyte** pixels, GLuint& out_buf_id)
3426 bool FunctionalTest::verify(const testCase& test_case, GLuint dst_layer, const GLubyte** dst_pixels, GLuint src_layer,
3427 const GLubyte** src_pixels, GLuint depth)
3429 const bool is_dst_multi_level = Utils::isTargetMultilevel(test_case.m_dst.m_target);
3430 const bool is_src_multi_level = Utils::isTargetMultilevel(test_case.m_src.m_target);
3431 const GLuint dst_level = test_case.m_dst.m_level;
3433 const GLuint dst_pixel_size = Utils::getPixelSizeForFormat(test_case.m_dst.m_internal_format);
3435 const GLuint src_level = src_desc.m_level;
3437 const GLuint src_pixel_size = Utils::getPixelSizeForFormat(src_desc.m_internal_format);
3480 const GLuint n_levels = (true == is_src_multi_level) ? FUNCTIONAL_TEST_N_LEVELS : 1;
3504 const GLuint n_levels = (true == is_dst_multi_level) ? FUNCTIONAL_TEST_N_LEVELS : 1;
3566 const GLuint x = regions[region][0];
3567 const GLuint y = regions[region][1];
3568 const GLuint w = regions[region][2];
3569 const GLuint h = regions[region][3];
3604 const GLuint SmokeTest::m_width = 16;
3605 const GLuint SmokeTest::m_height = 16;
3606 const GLuint SmokeTest::m_depth = 1;
3624 const GLenum target = s_valid_targets[tgt_id];
3631 const testCase test_case = { target, GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT };
3639 const GLenum internal_format = s_internal_formats[fmt_id];
3640 const GLenum format = Utils::getFormat(internal_format);
3641 const GLenum type = Utils::getType(internal_format);
3643 const testCase test_case = { GL_TEXTURE_2D, internal_format, format, type };
3654 const Functions& gl = m_context.getRenderContext().getFunctions();
3686 void SmokeTest::cleanPixels(GLubyte*& pixels) const
3704 bool SmokeTest::compareImages(const testCase& test_case, const GLubyte* left_data, const GLubyte* right_data) const
3708 const GLuint pixel_size = Utils::getPixelSizeForFormat(test_case.m_internal_format);
3709 const GLuint line_size = pixel_size * m_width;
3722 const GLuint line_offset = y * line_size;
3725 const GLubyte* left_line_data = left_data + line_offset;
3726 const GLubyte* right_line_data = right_data + line_offset;
3732 const GLuint pixel_offset = x * pixel_size;
3735 const GLubyte* left_pixel_data = left_line_data + pixel_offset;
3736 const GLubyte* right_pixel_data = right_line_data + pixel_offset;
3768 bool SmokeTest::copyAndVerify(const testCase& test_case, const GLubyte* src_pixels)
3771 const Functions& gl = m_context.getRenderContext().getFunctions();
3839 void SmokeTest::getPixels(GLuint name, const SmokeTest::testCase& test_case, GLubyte* out_pixels) const
3841 const Functions& gl = m_context.getRenderContext().getFunctions();
3872 const Functions& gl = m_context.getRenderContext().getFunctions();
3876 const testCase& test_case = m_test_cases[m_test_case_index];
3952 void SmokeTest::prepareDstPxls(const SmokeTest::testCase& test_case, GLubyte*& out_pixels) const
3954 static const GLuint n_pixels_per_layer = m_width * m_height;
3956 const GLenum internal_format = test_case.m_internal_format;
3957 const GLuint n_layers = (GL_TEXTURE_CUBE_MAP_ARRAY != test_case.m_target) ? m_depth : 6;
3958 const GLuint n_pixels = n_pixels_per_layer * n_layers;
3959 const GLuint pixel_size = Utils::getPixelSizeForFormat(internal_format);
3960 const GLuint req_memory = pixel_size * n_pixels;
3961 const GLenum type = test_case.m_type;
3987 void SmokeTest::prepareSrcPxls(const SmokeTest::testCase& test_case, GLubyte*& out_pixels) const
3989 static const GLuint n_pixels_per_layer = m_width * m_height;
3991 const GLenum internal_format = test_case.m_internal_format;
3992 const GLuint n_layers = (GL_TEXTURE_CUBE_MAP_ARRAY != test_case.m_target) ? m_depth : 6;
3993 const GLuint n_pixels = n_pixels_per_layer * n_layers;
3994 const GLuint pixel_size = Utils::getPixelSizeForFormat(internal_format);
3995 const GLuint layer_size = pixel_size * n_pixels_per_layer;
3996 const GLuint line_size = pixel_size * m_width;
3997 const GLuint req_memory = pixel_size * n_pixels;
3998 const GLenum type = test_case.m_type;
4013 const GLuint layer_offset = layer * layer_size;
4019 const GLuint line_offset = line_size * y;
4025 const GLuint pixel_offset = x * pixel_size;
4030 const GLdouble red = ((GLdouble)x) / 255.0 + (((GLdouble)y) / 15.9375);
4031 const GLdouble green = ((GLdouble)layer) / 255.0 + (1.0 / 15.9375);
4032 const GLdouble blue = 0.125;
4033 const GLdouble alpha = 1.0; /* This value has special meaning for some internal_formats */
4049 GLuint SmokeTest::prepareTexture(const testCase& test_case, const GLubyte* pixels, GLuint& out_buf_id)
4051 const GLuint n_layers = (GL_TEXTURE_CUBE_MAP_ARRAY != test_case.m_target) ? m_depth : 6;
4069 bool SmokeTest::verify(const testCase& test_case, const GLubyte* src_pixels)
4072 const GLuint n_layers = (GL_TEXTURE_CUBE_MAP_ARRAY != test_case.m_target) ? m_depth : 6;
4073 const GLuint pixel_size = Utils::getPixelSizeForFormat(test_case.m_internal_format);
4074 const GLuint line_size = pixel_size * m_width;
4075 const GLuint req_memory = line_size * m_height * n_layers;
4133 const GLenum src_target = s_valid_targets[src];
4134 const GLenum dst_target = s_valid_targets[dst];
4151 const GLenum src_target = s_invalid_targets[src];
4152 const GLenum dst_target = s_invalid_targets[dst];
4153 const testCase test_case = { src_target, dst_target, GL_INVALID_ENUM };
4164 const GLenum src_target = s_invalid_targets[src];
4165 const GLenum dst_target = s_valid_targets[dst];
4166 const testCase test_case = { src_target, dst_target, GL_INVALID_ENUM };
4177 const GLenum src_target = s_valid_targets[src];
4178 const GLenum dst_target = s_invalid_targets[dst];
4179 const testCase test_case = { src_target, dst_target, GL_INVALID_ENUM };
4193 const Functions& gl = m_context.getRenderContext().getFunctions();
4196 const testCase& test_case = m_test_cases[m_test_case_index];
4262 const Functions& gl = m_context.getRenderContext().getFunctions();
4263 const testCase& test_case = m_test_cases[m_test_case_index];
4305 const GLenum dst_target = s_valid_targets[dst];
4306 const GLenum src_target = s_valid_targets[target];
4307 const GLenum tex_target = s_valid_targets[target];
4337 const GLenum dst_target = s_valid_targets[target];
4338 const GLenum src_target = s_valid_targets[src];
4339 const GLenum tex_target = s_valid_targets[target];
4372 const Functions& gl = m_context.getRenderContext().getFunctions();
4375 const testCase& test_case = m_test_cases[m_test_case_index];
4441 const Functions& gl = m_context.getRenderContext().getFunctions();
4480 const GLenum tex_target = s_valid_targets[target];
4513 const Functions& gl = m_context.getRenderContext().getFunctions();
4516 const testCase& test_case = m_test_cases[m_test_case_index];
4589 const Functions& gl = m_context.getRenderContext().getFunctions();
4629 const GLenum tex_target = s_valid_targets[target];
4646 const GLenum tex_target = s_valid_targets[target];
4663 const GLenum tex_target = s_valid_targets[target];
4680 const GLenum tex_target = s_valid_targets[target];
4697 const GLenum tex_target = s_valid_targets[target];
4719 const Functions& gl = m_context.getRenderContext().getFunctions();
4722 const testCase& test_case = m_test_cases[m_test_case_index];
4789 const Functions& gl = m_context.getRenderContext().getFunctions();
4790 const testCase& test_case = m_test_cases[m_test_case_index];
4826 static const GLsizei n_samples[2] = { 1, 4 };
4828 static const GLenum targets[2] = { GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_2D_MULTISAMPLE_ARRAY };
4866 const Functions& gl = m_context.getRenderContext().getFunctions();
4869 const testCase& test_case = m_test_cases[m_test_case_index];
4962 const Functions& gl = m_context.getRenderContext().getFunctions();
4987 const GLenum tex_target = s_valid_targets[target];
5031 const Functions& gl = m_context.getRenderContext().getFunctions();
5035 const testCase& test_case = m_test_cases[m_test_case_index];
5102 const Functions& gl = m_context.getRenderContext().getFunctions();
5126 static const GLuint n_arg_types = sizeof(arg_types) / sizeof(arg_types[0]);
5141 const testCase test_case = { arg_types[dst], !!dst_valid, arg_types[src], !!src_valid,
5158 const Functions& gl = m_context.getRenderContext().getFunctions();
5162 const testCase& test_case = m_test_cases[m_test_case_index];
5257 const Functions& gl = m_context.getRenderContext().getFunctions();
5258 const testCase& test_case = m_test_cases[m_test_case_index];
5302 const GLenum tex_target = s_valid_targets[target];
5336 const Functions& gl = m_context.getRenderContext().getFunctions();
5340 const testCase& test_case = m_test_cases[m_test_case_index];
5407 const Functions& gl = m_context.getRenderContext().getFunctions();
5418 const glw::GLuint ExceedingBoundariesTest::m_region_depth = 4;
5419 const glw::GLuint ExceedingBoundariesTest::m_region_height = 4;
5420 const glw::GLuint ExceedingBoundariesTest::m_region_width = 4;
5434 static const GLuint invalid_x = 16 - (m_region_width / 2);
5435 static const GLuint invalid_y = 16 - (m_region_height / 2);
5436 static const GLuint invalid_z = 6 - (m_region_depth / 2);
5438 static const GLuint x_vals[] = { 0, invalid_x };
5439 static const GLuint y_vals[] = { 0, invalid_y };
5440 static const GLuint z_vals[] = { 0, invalid_z };
5442 static const GLuint n_x_vals = sizeof(x_vals) / sizeof(x_vals[0]);
5443 static const GLuint n_y_vals = sizeof(y_vals) / sizeof(y_vals[0]);
5444 static const GLuint n_z_vals = sizeof(z_vals) / sizeof(z_vals[0]);
5448 const GLenum tex_target = s_valid_targets[target];
5467 const GLuint x_val = x_vals[x];
5468 const GLuint y_val = y_vals[y];
5469 const GLuint z_val = z_vals[z];
5470 const GLenum res = ((0 == x_val) && (0 == y_val) && (0 == z_val)) ? GL_NO_ERROR : GL_INVALID_VALUE;
5509 const Functions& gl = m_context.getRenderContext().getFunctions();
5513 const testCase& test_case = m_test_cases[m_test_case_index];
5583 const testCase& test_case = m_test_cases[m_test_case_index];
5606 static const GLuint invalid_h = 2;
5607 static const GLuint invalid_w = 2;
5608 static const GLuint invalid_x = 2;
5609 static const GLuint invalid_y = 2;
5610 static const GLuint valid_h = 4;
5611 static const GLuint valid_w = 4;
5613 static const GLuint h_vals[] = { valid_h, invalid_h };
5614 static const GLuint w_vals[] = { valid_w, invalid_w };
5615 static const GLuint x_vals[] = { 0, invalid_x };
5616 static const GLuint y_vals[] = { 0, invalid_y };
5618 static const GLuint n_h_vals = sizeof(h_vals) / sizeof(h_vals[0]);
5619 static const GLuint n_w_vals = sizeof(w_vals) / sizeof(w_vals[0]);
5620 static const GLuint n_x_vals = sizeof(x_vals) / sizeof(x_vals[0]);
5621 static const GLuint n_y_vals = sizeof(y_vals) / sizeof(y_vals[0]);
5631 const GLuint h_val = h_vals[h];
5632 const GLuint w_val = w_vals[w];
5633 const GLuint x_val = x_vals[x];
5634 const GLuint y_val = y_vals[y];
5635 const GLenum res = ((valid_h == h_val) && (valid_w == w_val) && (0 == x_val) && (0 == y_val)) ?
5658 const Functions& gl = m_context.getRenderContext().getFunctions();
5662 const testCase& test_case = m_test_cases[m_test_case_index];
5729 const Functions& gl = m_context.getRenderContext().getFunctions();
5763 const unsigned int width = 16;
5764 const unsigned int height = 16;
5766 const Functions& gl = m_context.getRenderContext().getFunctions();
5768 const testCase& test_case = testCases[m_test_case_index];
5832 unsigned int IntegerTexTest::createTexture(int width, int height, GLint internalFormat, GLuint type, const void* data,
5835 const Functions& gl = m_context.getRenderContext().getFunctions();
5862 const Functions& gl = m_context.getRenderContext().getFunctions();