static void assert_eql(skiatest::Reporter* reporter,
const SkString& skString,
const char* str,
size_t len) {
if (!eq(skString, str, len)) {
REPORT_FAILURE(reporter, "", SkStringPrintf(
"'%*s' != '%s'", len, str, skString.c_str()));
}
}
bool
API2Test::testDrawBuffers(void)
{
const int MAX = 2;
GLint maxBuf = -1, i, n, val;
GLenum buffers[MAX], err;
GLint initDrawBuffer;
glGetIntegerv(GL_DRAW_BUFFER, &initDrawBuffer);
glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxBuf);
if (maxBuf < 1) {
REPORT_FAILURE("GL_MAX_DRAW_BUFFERS query failed");
return false;
}
n = maxBuf < MAX ? maxBuf : MAX;
assert(n > 0);
for (i = 0; i < n; i++) {
buffers[i] = (i & 1) ? GL_FRONT_LEFT : GL_BACK_LEFT;
}
glDrawBuffers_func(n, buffers);
for (i = 0; i < n; i++) {
glGetIntegerv(GL_DRAW_BUFFER0 + i, &val);
if (val != (GLint) buffers[i]) {
REPORT_FAILURE("glDrawBuffers failed");
return false;
}
}
// restore
glDrawBuffer(initDrawBuffer);
err = glGetError();
if (err) {
REPORT_FAILURE("glDrawBuffers generrated an OpenGL error");
return false;
}
return true;
}
bool
API2Test::testBlendEquationSeparate(void)
{
GLint val;
glBlendEquationSeparate_func(GL_MAX, GL_FUNC_SUBTRACT);
glGetIntegerv(GL_BLEND_EQUATION, &val);
if (val != GL_MAX) {
REPORT_FAILURE("GL_BLEND_EQUATION (rgb) query returned wrong value");
return false;
}
glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &val);
if (val != GL_FUNC_SUBTRACT) {
REPORT_FAILURE("GL_BLEND_EQUATION (rgb) query returned wrong value");
return false;
}
return true;
}
GLuint
API2Test::loadAndCompileShader(GLenum target, const char *text)
{
GLint stat, val;
GLuint shader = glCreateShader_func(target);
if (!shader) {
REPORT_FAILURE("glCreateShader failed (fragment)");
return 0;
}
glShaderSource_func(shader, 1,
(const GLchar **) &text, NULL);
glCompileShader_func(shader);
glGetShaderiv_func(shader, GL_COMPILE_STATUS, &stat);
if (!stat) {
REPORT_FAILURE_T("glShaderSource or glCompileShader failed", target);
return 0;
}
if (!glIsShader_func(shader)) {
REPORT_FAILURE("glIsShader failed (fragment)");
return false;
}
glGetShaderiv_func(shader, GL_SHADER_TYPE, &val);
if (val != (GLint) target) {
REPORT_FAILURE_T("glGetShaderiv(GL_SHADER_TYPE) failed", target);
return 0;
}
glGetShaderiv_func(shader, GL_COMPILE_STATUS, &val);
if (val != GL_TRUE) {
REPORT_FAILURE_T("glGetShaderiv(GL_COMPILE_STATUS) failed", target);
return 0;
}
glGetShaderiv_func(shader, GL_SHADER_SOURCE_LENGTH, &val);
// Note: some OpenGLs return a 1-char shorter length than strlen(text)
if (abs(val - (int) strlen(text)) > 1) {
REPORT_FAILURE_T("glGetShaderiv(GL_SHADER_SOURCE_LENGTH) failed", target);
return 0;
}
return shader;
}
bool
API2Test::testStencilMaskSeparate(void)
{
GLint val;
// face, fail, zfail, zpass
glStencilMaskSeparate_func(GL_BACK, 0xa);
glStencilMaskSeparate_func(GL_FRONT, 0xb);
glGetIntegerv(GL_STENCIL_BACK_WRITEMASK, &val);
if (val != 0xa) {
REPORT_FAILURE("GL_STENCIL_BACK_WRITEMASK query returned wrong value");
return false;
}
glGetIntegerv(GL_STENCIL_WRITEMASK, &val);
if (val != 0xb) {
REPORT_FAILURE("GL_STENCIL_WRITEMASK (front) query returned wrong value");
return false;
}
return true;
}
DEF_TEST(TypefaceStyle, reporter) {
std::unique_ptr<SkStreamAsset> stream(GetResourceAsStream("/fonts/Em.ttf"));
if (!stream) {
REPORT_FAILURE(reporter, "/fonts/Em.ttf", SkString("Cannot load resource"));
return;
}
sk_sp<SkData> data(SkData::MakeFromStream(stream.get(), stream->getLength()));
using SkFS = SkFontStyle;
for (int weight = SkFS::kInvisible_Weight; weight <= SkFS::kExtraBlack_Weight; ++weight) {
TypefaceStyle_test(reporter, weight, 5, data.get());
}
for (int width = SkFS::kUltraCondensed_Width; width <= SkFS::kUltaExpanded_Width; ++width) {
TypefaceStyle_test(reporter, 400, width, data.get());
}
}
enum piglit_result
test_sanity(void *null)
{
GLuint pbs[1];
GLuint pb_binding;
glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING_ARB,
(GLint *) & pb_binding);
if (pb_binding != 0) {
REPORT_FAILURE("Failed to bind unpack pixel buffer object");
return PIGLIT_FAIL;
}
glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING_ARB,
(GLint *) & pb_binding);
if (pb_binding != 0) {
REPORT_FAILURE("Failed to bind pack pixel buffer object");
return PIGLIT_FAIL;
}
glGenBuffersARB(1, pbs);
if (glIsBufferARB(pbs[0]) != GL_FALSE) {
REPORT_FAILURE("glIsBufferARB failed");
return PIGLIT_FAIL;
}
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbs[0]);
glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING_ARB,
(GLint *) & pb_binding);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
if (pb_binding != pbs[0]) {
REPORT_FAILURE("Failed to bind unpack pixel buffer object");
return PIGLIT_FAIL;
}
glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, pbs[0]);
glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING_ARB,
(GLint *) & pb_binding);
glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
if (pb_binding != pbs[0]) {
REPORT_FAILURE("Failed to bind unpack pixel buffer object");
return PIGLIT_FAIL;
}
glDeleteBuffersARB(1, pbs);
if (glIsBufferARB(pbs[0]) == GL_TRUE) {
REPORT_FAILURE("glIsBufferARB failed");
return PIGLIT_FAIL;
}
return PIGLIT_PASS;
}
bool
API2Test::testStencilFuncSeparate(void)
{
GLint val;
GLint stencilBits, stencilMax;
glGetIntegerv(GL_STENCIL_BITS, &stencilBits);
stencilMax = (1 << stencilBits) - 1;
glStencilFuncSeparate_func(GL_FRONT, GL_LEQUAL, 12, 0xf);
glStencilFuncSeparate_func(GL_BACK, GL_GEQUAL, 13, 0xe);
glGetIntegerv(GL_STENCIL_BACK_FUNC, &val);
if (val != GL_GEQUAL) {
REPORT_FAILURE("GL_STENCIL_BACK_FUNC query returned wrong value");
return false;
}
glGetIntegerv(GL_STENCIL_FUNC, &val);
if (val != GL_LEQUAL) {
REPORT_FAILURE("GL_STENCIL_FUNC (front) query returned wrong value");
return false;
}
glGetIntegerv(GL_STENCIL_BACK_REF, &val);
if (val != CLAMP(13, 0, stencilMax)) {
REPORT_FAILURE("GL_STENCIL_BACK_REF query returned wrong value");
return false;
}
glGetIntegerv(GL_STENCIL_REF, &val);
if (val != CLAMP(12, 0, stencilMax)) {
REPORT_FAILURE("GL_STENCIL_REF (front) query returned wrong value");
return false;
}
glGetIntegerv(GL_STENCIL_BACK_VALUE_MASK, &val);
if (val != 0xe) {
REPORT_FAILURE("GL_STENCIL_BACK_VALUE_MASK query returned wrong value");
return false;
}
glGetIntegerv(GL_STENCIL_VALUE_MASK, &val);
if (val != 0xf) {
REPORT_FAILURE("GL_STENCIL_VALUE_MASK (front) query returned wrong value");
return false;
}
return true;
}
static
bool valid_fix_message(fix_group* const group, const fix_message_data* const data)
{
const char
type = data->hdr.MsgType,
real_type = get_fix_group_error_details(group)->msg_type.begin[0];
ENSURE(real_type == type, "Message type mismatch: expected '%c', got '%c'", type, real_type);
if(!valid_header(group, &data->hdr))
return false;
switch(type)
{
case 'D':
return valid_new_order_single(group, &data->order);
default:
REPORT_FAILURE("Unexpected message type '%c'", type);
return false;
}
}
bool
API2Test::testStencilOpSeparate(void)
{
GLint val;
// face, fail, zfail, zpass
glStencilOpSeparate_func(GL_FRONT, GL_INVERT, GL_ZERO, GL_INCR);
glStencilOpSeparate_func(GL_BACK, GL_INCR, GL_KEEP, GL_REPLACE);
glGetIntegerv(GL_STENCIL_BACK_FAIL, &val);
if (val != GL_INCR) {
REPORT_FAILURE("GL_STENCIL_BACK_FAIL query returned wrong value");
return false;
}
glGetIntegerv(GL_STENCIL_FAIL, &val);
if (val != GL_INVERT) {
REPORT_FAILURE("GL_STENCIL_FAIL (front) query returned wrong value");
return false;
}
glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_FAIL, &val);
if (val != GL_KEEP) {
REPORT_FAILURE("GL_STENCIL_BACK_PASS_DEPTH_FAIL query returned wrong value");
return false;
}
glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &val);
if (val != GL_ZERO) {
REPORT_FAILURE("GL_STENCIL_PASS_DEPTH_FAIL (front) query returned wrong value");
return false;
}
glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_PASS, &val);
if (val != GL_REPLACE) {
REPORT_FAILURE("GL_STENCIL_BACK_PASS_DEPTH_PASS query returned wrong value");
return false;
}
glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &val);
if (val != GL_INCR) {
REPORT_FAILURE("GL_STENCIL_PASS_DEPTH_PASS (front) query returned wrong value");
return false;
}
return true;
}
enum piglit_result
test_tex_image(void *null)
{
bool pass = true;
int break_pbo_cow, break_tex_cow; /* cow = copy on write */
int use_unpack, use_pack;
GLuint unpack_pb[1];
GLuint pack_pb[1];
GLenum pack = GL_PIXEL_PACK_BUFFER_ARB;
GLenum unpack = GL_PIXEL_UNPACK_BUFFER_ARB;
GLfloat t1[TEXTURE_SIZE];
GLfloat t2[TEXTURE_SIZE];
GLfloat *pbo_mem = NULL;
int i, j;
GLfloat green[3] = { 1.0, 1.0, 0.0 };
GLfloat black[3] = { 0.0, 0.0, 0.0 };
GLfloat buf[WINDOW_SIZE];
GLfloat exp_tex[TEXTURE_SIZE];
GLfloat exp_win[WINDOW_SIZE];
GLfloat tolerance[4];
piglit_compute_probe_tolerance(GL_RGB, tolerance);
glBindBufferARB(unpack, 0);
glBindBufferARB(pack, 0);
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
for (use_pack = 0; use_pack < 2; use_pack++) {
for (use_unpack = 0; use_unpack < 2;
use_unpack++) {
for (break_pbo_cow = 0; break_pbo_cow < use_unpack + 1;
break_pbo_cow++) {
for (break_tex_cow = 0;
break_tex_cow < use_unpack + 1;
break_tex_cow++) {
if (use_unpack) {
glGenBuffersARB(1, unpack_pb);
glBindBufferARB(unpack,
unpack_pb[0]);
glBufferDataARB(unpack,
TEXTURE_SIZE *
sizeof(GLfloat),
NULL, GL_STREAM_DRAW);
}
glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
if (use_unpack) {
pbo_mem = (GLfloat *)
glMapBufferARB(unpack,
GL_WRITE_ONLY);
}
else {
pbo_mem = t1;
}
for (i = 0; i < TEXTURE_SIZE/3; i++) {
pbo_mem[3 * i] = 1.0;
pbo_mem[3 * i + 1] = 1.0;
pbo_mem[3 * i + 2] = 0.0;
}
if (use_unpack) {
glUnmapBufferARB(unpack);
glTexImage2D(GL_TEXTURE_2D, 0,
GL_RGB, TEXSIZE,
TEXSIZE, 0,
GL_RGB, GL_FLOAT,
NULL);
glBindBufferARB(unpack, 0);
}
else
glTexImage2D(GL_TEXTURE_2D, 0,
GL_RGB, TEXSIZE,
TEXSIZE, 0,
GL_RGB, GL_FLOAT,
pbo_mem);
if (use_unpack && break_pbo_cow) {
glBindBufferARB(unpack,
unpack_pb[0]);
pbo_mem = (GLfloat *)
glMapBufferARB(
unpack,
GL_WRITE_ONLY);
for (i = 0; i < TEXTURE_SIZE; i++)
pbo_mem[i] = 0.2;
glUnmapBufferARB(unpack);
glBindBufferARB(unpack, 0);
}
if (use_unpack && break_tex_cow) {
GLfloat temp[3];
for (i = 0; i < 3; i++)
temp[i] = 0.8;
glTexSubImage2D(GL_TEXTURE_2D,
0, 0, 0, 1, 1,
GL_RGB,
GL_FLOAT,
temp);
}
/* Check PBO's content */
if (use_unpack) {
glBindBufferARB(unpack,
unpack_pb[0]);
pbo_mem = (GLfloat *)
glMapBuffer(unpack,
GL_READ_ONLY);
if (break_pbo_cow) {
for (i = 0; i < TEXTURE_SIZE; i++)
if (fabsf(pbo_mem[i] - 0.2f) > tolerance[0]) {
REPORT_FAILURE
("PBO modified by someone else, "
"there must be something wrong");
return PIGLIT_FAIL;
}
}
glUnmapBufferARB(unpack);
glBindBufferARB(unpack, 0);
}
/* Read texture back */
if (use_pack) {
glGenBuffersARB(1, pack_pb);
glBindBufferARB(pack, pack_pb[0]);
glBufferDataARB(pack,
TEXTURE_SIZE *
sizeof(GLfloat),
NULL, GL_STREAM_DRAW);
glGetTexImage(GL_TEXTURE_2D,
0, GL_RGB,
GL_FLOAT, NULL);
pbo_mem = (GLfloat *)
glMapBufferARB(pack,
GL_READ_ONLY);
}
else {
glGetTexImage(GL_TEXTURE_2D,
0, GL_RGB,
GL_FLOAT, t2);
pbo_mem = t2;
}
/* Check texture image */
for (i = 0; i < TEXTURE_SIZE/3; i++) {
int idx = i * 3;
if (i == 0 && break_tex_cow
&& use_unpack) {
exp_tex[idx + 0] = 0.8;
exp_tex[idx + 1] = 0.8;
exp_tex[idx + 2] = 0.8;
}
else {
exp_tex[idx + 0] = 1.0;
exp_tex[idx + 1] = 1.0;
exp_tex[idx + 2] = 0.0;
}
}
pass &= piglit_compare_images_color(0,
0, TEXSIZE,
TEXSIZE, 3,
tolerance, exp_tex,
pbo_mem);
if (use_pack) {
glUnmapBufferARB(pack);
glBindBufferARB(pack, 0);
glDeleteBuffersARB(1, pack_pb);
}
if (use_unpack) {
glDeleteBuffersARB(1, unpack_pb);
}
glEnable(GL_TEXTURE_2D);
glBegin(GL_POLYGON);
glTexCoord2f(0, 0);
glVertex2f(0, 0);
glTexCoord2f(1, 0);
glVertex2f(TEXSIZE, 0);
glTexCoord2f(1, 1);
glVertex2f(TEXSIZE, TEXSIZE);
glTexCoord2f(0, 1);
glVertex2f(0, TEXSIZE);
glEnd();
glDisable(GL_TEXTURE_2D);
glReadPixels(0, 0, WINSIZE, WINSIZE,
GL_RGB, GL_FLOAT,
buf);
for (j = 0; j < WINSIZE; j++) {
for (i = 0; i < WINSIZE; i++) {
int idx = (j * WINSIZE + i) * 3;
if (i == 0 && j == 0
&& break_tex_cow
&& use_unpack) {
exp_win[idx + 0] = 0.8;
exp_win[idx + 1] = 0.8;
exp_win[idx + 2] = 0.8;
}
else if (i < TEXSIZE && j < TEXSIZE) {
exp_win[idx + 0] = green[0];
exp_win[idx + 1] = green[1];
exp_win[idx + 2] = green[2];
}
else {
exp_win[idx + 0] = black[0];
exp_win[idx + 1] = black[1];
exp_win[idx + 2] = black[2];
}
}
}
pass &= piglit_compare_images_color(0,
0, WINSIZE,
WINSIZE, 3,
tolerance, exp_win,
buf);
}
}
}
}
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
bool
API2Test::testUniformfFuncs(void)
{
static const char *fragShaderText =
"uniform float uf1; \n"
"uniform vec2 uf2; \n"
"uniform vec3 uf3; \n"
"uniform vec4 uf4; \n"
"void main() { \n"
" gl_FragColor = vec4(uf1, uf2.y, uf3.z, uf4.w); \n"
"} \n";
GLuint fragShader, program;
GLint uf1, uf2, uf3, uf4;
GLfloat value[4];
fragShader = loadAndCompileShader(GL_FRAGMENT_SHADER, fragShaderText);
if (!fragShader) {
return false;
}
program = createProgram(0, fragShader);
if (!program) {
REPORT_FAILURE("glCreateProgram (uniform test) failed");
return false;
}
glUseProgram_func(program);
uf1 = glGetUniformLocation_func(program, "uf1");
if (uf1 < 0) {
REPORT_FAILURE("glGetUniform \"uf1\" failed");
return false;
}
uf2 = glGetUniformLocation_func(program, "uf2");
if (uf2 < 0) {
REPORT_FAILURE("glGetUniform \"uf2\" failed");
return false;
}
uf3 = glGetUniformLocation_func(program, "uf3");
if (uf3 < 0) {
REPORT_FAILURE("glGetUniform \"uf3\" failed");
return false;
}
uf4 = glGetUniformLocation_func(program, "uf4");
if (uf4 < 0) {
REPORT_FAILURE("glGetUniform \"uf4\" failed");
return false;
}
GLfloat pixel[4], expected[4];
// Test glUniform[1234]f()
expected[0] = 0.1;
expected[1] = 0.2;
expected[2] = 0.3;
expected[3] = 0.4;
glUniform1f_func(uf1, expected[0]);
glUniform2f_func(uf2, 0.0, expected[1]);
glUniform3f_func(uf3, 0.0, 0.0, expected[2]);
glUniform4f_func(uf4, 0.0, 0.0, 0.0, expected[3]);
renderQuad(pixel);
if (!equalColors(pixel, expected)) {
REPORT_FAILURE("glUniform[1234]f failed");
//printf("found: %f %f %f %f\n", pixel[0], pixel[1], pixel[2], pixel[3]);
//printf("expected: %f %f %f %f\n", expected[0], expected[1], expected[2], expected[3]);
return false;
}
// Test glUniform[1234]fv()
GLfloat u[4];
expected[0] = 0.9;
expected[1] = 0.8;
expected[2] = 0.7;
expected[3] = 0.6;
u[0] = expected[0];
glUniform1fv_func(uf1, 1, u);
u[0] = 0.0; u[1] = expected[1];
glUniform2fv_func(uf2, 1, u);
u[0] = 0.0; u[1] = 0.0; u[2] = expected[2];
glUniform3fv_func(uf3, 1, u);
u[0] = 0.0; u[1] = 0.0; u[2] = 0.0; u[3] = expected[3];
glUniform4fv_func(uf4, 1, u);
renderQuad(pixel);
if (!equalColors(pixel, expected)) {
REPORT_FAILURE("glUniform[1234]f failed");
return false;
}
// Test glGetUniformfv
glUniform4fv_func(uf4, 1, expected);
glGetUniformfv_func(program, uf4, value);
if (value[0] != expected[0] ||
value[1] != expected[1] ||
value[2] != expected[2] ||
value[3] != expected[3]) {
REPORT_FAILURE("glGetUniformfv failed");
return false;
}
return true;
}
bool
API2Test::testShaderObjectFuncs(void)
{
static const char *vertShaderText =
"void main() { \n"
" gl_Position = ftransform(); \n"
"} \n";
static const char *fragShaderText =
"void main() { \n"
" gl_FragColor = vec4(1.0, 0.5, 0.25, 0.0); \n"
"} \n";
GLuint vertShader, fragShader, program;
GLint stat, val, err;
vertShader = loadAndCompileShader(GL_VERTEX_SHADER, vertShaderText);
if (!vertShader)
return false;
fragShader = loadAndCompileShader(GL_FRAGMENT_SHADER, fragShaderText);
if (!fragShader)
return false;
program = createProgram(vertShader, fragShader);
if (!program) {
REPORT_FAILURE("glCreateProgram failed");
return false;
}
glGetProgramiv_func(program, GL_LINK_STATUS, &stat);
if (!stat) {
REPORT_FAILURE("glLinkProgram failed");
return false;
}
glUseProgram_func(program);
glGetIntegerv(GL_CURRENT_PROGRAM, &val);
if (val != (GLint) program) {
REPORT_FAILURE("glGetInteger(GL_CURRENT_PROGRAM) failed");
return false;
}
err = glGetError();
if (err) {
REPORT_FAILURE("OpenGL error detected in testShaderFuncs");
return false;
}
if (!glIsProgram_func(program)) {
REPORT_FAILURE("glIsProgram failed");
return false;
}
GLuint objects[2];
GLsizei count;
glGetProgramiv_func(program, GL_ATTACHED_SHADERS, &val);
if (val != 2) {
REPORT_FAILURE("glGetProgramiv(GL_ATTACHED_SHADERS) failed");
return false;
}
glGetAttachedShaders_func(program, 2, &count, objects);
if (count != 2) {
REPORT_FAILURE("glGetAttachedShaders failed (wrong count)");
return false;
}
if (objects[0] != vertShader && objects[1] != vertShader) {
REPORT_FAILURE("glGetAttachedShaders failed (vertex shader missing)");
return false;
}
if (objects[0] != fragShader && objects[1] != fragShader) {
REPORT_FAILURE("glGetAttachedShaders failed (fragment shader missing)");
return false;
}
glValidateProgram_func(program);
glGetProgramiv_func(program, GL_VALIDATE_STATUS, &stat);
if (!stat) {
REPORT_FAILURE("glValidateProgram failed");
return false;
}
// Delete vertex shader
glDeleteShader_func(vertShader);
if (!glIsShader_func(vertShader)) {
// the shader is still attached so the handle should be valid
REPORT_FAILURE("glIsShader(deleted shader) failed");
return false;
}
glGetShaderiv_func(vertShader, GL_DELETE_STATUS, &stat);
if (stat != GL_TRUE) {
REPORT_FAILURE("Incorrect shader delete status");
return false;
}
// Delete fragment shader
glDeleteShader_func(fragShader);
// Delete program object
glDeleteProgram_func(program);
if (!glIsProgram_func(program)) {
// the program is still in use so the handle should be valid
REPORT_FAILURE("glIsProgram(deleted program) failed");
return false;
}
glGetProgramiv_func(program, GL_DELETE_STATUS, &stat);
if (stat != GL_TRUE) {
REPORT_FAILURE("Incorrect program delete status");
return false;
}
// now unbind the program
glUseProgram_func(0);
stat = glIsProgram_func(program);
if (stat) {
// the program and handle should have really been deleted now
REPORT_FAILURE("glIsProgram(deleted program) failed");
return false;
}
glGetProgramiv_func(program, GL_DELETE_STATUS, &stat);
err = glGetError();
if (!err) {
// the program and handle should have been deleted now
// so glGetProgramiv() should have generated an error
REPORT_FAILURE("glGetProgramiv(deleted program) failed");
return false;
}
return true;
}
enum piglit_result
test_polygon_stip(void *null)
{
int use_unpack = 0;
int use_pack = 0;
GLuint unpack_pb[1];
GLuint pack_pb[1];
GLubyte t1[32 * 32 / 8];
GLubyte t2[32 * 32 / 8];
GLubyte *pbo_mem = NULL;
int i, j;
GLfloat white[3] = { 1.0, 1.0, 1.0 };
GLfloat black[3] = { 0.0, 0.0, 0.0 };
GLfloat buf[WINSIZE * WINSIZE * 3];
bool pass = true;
GLfloat expected[WINSIZE * WINSIZE * 3];
GLfloat tolerance[4];
piglit_compute_probe_tolerance(GL_RGB, &tolerance[0]);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
for (use_unpack = 0; use_unpack < 2; use_unpack++) {
for (use_pack = 0; use_pack < 2; use_pack++) {
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
if (use_unpack) {
glGenBuffersARB(1, unpack_pb);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
unpack_pb[0]);
glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB,
32 * 32 / 8, NULL,
GL_STREAM_DRAW);
pbo_mem = (GLubyte *) glMapBufferARB(
GL_PIXEL_UNPACK_BUFFER_ARB,
GL_WRITE_ONLY);
}
else {
pbo_mem = t1;
}
/* Fill in the stipple pattern */
for (i = 0; i < 32 * 32 / 8; i++) {
pbo_mem[i] = 0xAA; /* Checkerboard */
}
if (use_unpack) {
glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB);
glPolygonStipple(NULL);
}
else {
glPolygonStipple(pbo_mem);
}
/* Read back the stipple pattern */
if (use_pack) {
glGenBuffersARB(1, pack_pb);
glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB,
pack_pb[0]);
glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB,
32 * 32 / 8, NULL,
GL_STREAM_DRAW);
glGetPolygonStipple(NULL);
pbo_mem = (GLubyte *) glMapBufferARB(
GL_PIXEL_PACK_BUFFER_ARB,
GL_READ_ONLY);
}
else {
glGetPolygonStipple(t2);
pbo_mem = t2;
}
for (i = 0; i < 32 * 32 / 8; i++) {
if (pbo_mem[i] != 0xAA) {
REPORT_FAILURE("glGetPolygonStipple failed");
return PIGLIT_FAIL;
}
}
if (use_unpack) {
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
glDeleteBuffersARB(1, unpack_pb);
}
if (use_pack) {
glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
glDeleteBuffersARB(1, pack_pb);
}
glEnable(GL_POLYGON_STIPPLE);
glColor4f(1.0, 1.0, 1.0, 0.0);
glBegin(GL_POLYGON);
glVertex2f(0, 0);
glVertex2f(10, 0);
glVertex2f(10, 10);
glVertex2f(0, 10);
glEnd();
glDisable(GL_POLYGON_STIPPLE);
/* Check the result */
glReadPixels(0, 0, WINSIZE, WINSIZE, GL_RGB, GL_FLOAT, buf);
for (j = 0; j < WINSIZE; j++) {
for (i = 0; i < WINSIZE; i++) {
int idx = (j * WINSIZE + i) * 3;
if (!(i & 1) && i < 10 && j < 10) {
expected[idx + 0] = white[0];
expected[idx + 1] = white[1];
expected[idx + 2] = white[2];
}
else {
expected[idx + 0] = black[0];
expected[idx + 1] = black[1];
expected[idx + 2] = black[2];
}
}
}
pass &= piglit_compare_images_color(0, 0, WINSIZE,
WINSIZE, 3,
tolerance,
expected, buf);
}
}
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
bool
API2Test::testUniformiFuncs(void)
{
static const char *fragShaderText =
"uniform int ui1; \n"
"uniform ivec2 ui2; \n"
"uniform ivec3 ui3; \n"
"uniform ivec4 ui4; \n"
"void main() { \n"
" gl_FragColor = vec4(ui1, ui2.y, ui3.z, ui4.w) * 0.1; \n"
"} \n";
GLuint fragShader, program;
GLint ui1, ui2, ui3, ui4;
fragShader = loadAndCompileShader(GL_FRAGMENT_SHADER, fragShaderText);
if (!fragShader) {
return false;
}
program = createProgram(0, fragShader);
if (!program) {
REPORT_FAILURE("glCreateProgram (uniform test) failed");
return false;
}
glUseProgram_func(program);
ui1 = glGetUniformLocation_func(program, "ui1");
if (ui1 < 0) {
REPORT_FAILURE("glGetUniform \"ui1\" failed");
return false;
}
ui2 = glGetUniformLocation_func(program, "ui2");
if (ui2 < 0) {
REPORT_FAILURE("glGetUniform \"ui2\" failed");
return false;
}
ui3 = glGetUniformLocation_func(program, "ui3");
if (ui3 < 0) {
REPORT_FAILURE("glGetUniform \"ui3\" failed");
return false;
}
ui4 = glGetUniformLocation_func(program, "ui4");
if (ui4 < 0) {
REPORT_FAILURE("glGetUniform \"ui4\" failed");
return false;
}
GLfloat pixel[4], expected[4];
GLint expectedInt[4];
// Test glUniform[1234]i()
expectedInt[0] = 1;
expectedInt[1] = 2;
expectedInt[2] = 3;
expectedInt[3] = 4;
expected[0] = 0.1;
expected[1] = 0.2;
expected[2] = 0.3;
expected[3] = 0.4;
glUniform1i_func(ui1, expectedInt[0]);
glUniform2i_func(ui2, 0, expectedInt[1]);
glUniform3i_func(ui3, 0, 0, expectedInt[2]);
glUniform4i_func(ui4, 0, 0, 0, expectedInt[3]);
renderQuad(pixel);
if (!equalColors(pixel, expected)) {
REPORT_FAILURE("glUniform[1234]i failed");
//printf("%f %f %f %f\n", pixel[0], pixel[1], pixel[2], pixel[3]);
return false;
}
// Test glUniform[1234]iv()
GLint u[4];
expectedInt[0] = 9;
expectedInt[1] = 8;
expectedInt[2] = 7;
expectedInt[3] = 6;
expected[0] = 0.9;
expected[1] = 0.8;
expected[2] = 0.7;
expected[3] = 0.6;
u[0] = expectedInt[0];
glUniform1iv_func(ui1, 1, u);
u[0] = 0; u[1] = expectedInt[1];
glUniform2iv_func(ui2, 1, u);
u[0] = 0; u[1] = 0; u[2] = expectedInt[2];
glUniform3iv_func(ui3, 1, u);
u[0] = 0; u[1] = 0; u[2] = 0; u[3] = expectedInt[3];
glUniform4iv_func(ui4, 1, u);
renderQuad(pixel);
if (!equalColors(pixel, expected)) {
REPORT_FAILURE("glUniform[1234]i failed");
#if 0
printf("Expected color %f %f %f %f\n",
expected[0], expected[1], expected[2], expected[3]);
printf("Found color %f %f %f %f\n",
pixel[0], pixel[1], pixel[2], pixel[3]);
#endif
return false;
}
return true;
}
static
bool simple_random_messages_test()
{
bool ret = false;
char* str;
unsigned len;
// construct messages
const fix_message_data* const messages = make_n_messages(NUM_MESSAGES, &str, &len);
// construct parser
fix_parser* const parser = create_FIX44_parser();
if(!parser)
{
REPORT_FAILURE("NULL parser");
goto EXIT;
}
// parser loop
unsigned i = 0;
for(const fix_parser_result* res = get_first_fix_message(parser, str, len);
res;
res = get_next_fix_message(parser))
{
// check for errors
if(!parser_result_ok(res, __FILE__, __LINE__))
{
print_raw_message(parser);
goto EXIT;
}
// check message index
if(i == NUM_MESSAGES)
{
REPORT_FAILURE("Parser unexpectedly produced too many messages");
goto EXIT;
}
// validate message
if(!valid_fix_message(res->root, messages + i))
{
print_raw_message(parser);
goto EXIT;
}
++i;
}
// check for fatal errors
const fix_error_details* const error = get_fix_parser_error_details(parser);
if(error->code > FE_OTHER)
{
report_error_details(error, __FILE__, __LINE__);
goto EXIT;
}
// final check of message index
if(i != NUM_MESSAGES)
{
REPORT_FAILURE("Parser produced %u messages instead of %u", i, (unsigned)NUM_MESSAGES);
goto EXIT;
}
// all clear
ret = true;
EXIT:
// clean-up
free(str);
free((void*)messages);
free_fix_parser(parser);
TEST_END(ret);
}
bool
API2Test::testShaderAttribs(void)
{
static const char *vertShaderText =
"attribute vec4 generic; \n"
"void main() { \n"
" gl_Position = ftransform(); \n"
" gl_FrontColor = generic; \n"
"} \n";
GLuint vertShader, program;
vertShader = loadAndCompileShader(GL_VERTEX_SHADER, vertShaderText);
if (!vertShader) {
return false;
}
program = createProgram(vertShader, 0);
if (!program) {
REPORT_FAILURE("glCreateProgram (uniform test) failed");
return false;
}
glUseProgram_func(program);
static const GLfloat testColors[3][4] = {
{ 1.0, 0.5, 0.25, 0.0 },
{ 0.0, 0.1, 0.2, 0.3 },
{ 0.5, 0.6, 0.7, 0.8 },
};
// let compiler allocate the attribute location
const GLint attr = glGetAttribLocation_func(program, "generic");
if (attr < 0) {
REPORT_FAILURE("glGetAttribLocation failed");
return false;
}
for (int i = 0; i < 3; i++) {
GLfloat pixel[4];
renderQuadWithArrays(attr, testColors[i], pixel);
if (!equalColors(pixel, testColors[i])) {
#if 0
printf("Expected color %f %f %f\n",
testColors[i][0],
testColors[i][1],
testColors[i][2]);
printf("Found color %f %f %f\n",
pixel[0], pixel[1], pixel[2]);
#endif
REPORT_FAILURE("Vertex array test failed");
return false;
}
}
// Test explicit attribute binding.
const GLint bindAttr = 6; // XXX a non-colliding alias
glBindAttribLocation_func(program, bindAttr, "generic");
glLinkProgram_func(program);
GLint loc = glGetAttribLocation_func(program, "generic");
if (loc != bindAttr) {
REPORT_FAILURE("glBindAttribLocation failed");
return false;
}
for (int i = 0; i < 3; i++) {
GLfloat pixel[4];
renderQuadWithArrays(bindAttr, testColors[i], pixel);
if (!equalColors(pixel, testColors[i])) {
REPORT_FAILURE("Vertex array test failed (2)");
return false;
}
}
return true;
}
// Validate an EEType extracted from an object.
bool EEType::Validate(bool assertOnFail /* default: true */)
{
#define REPORT_FAILURE() do { if (assertOnFail) { ASSERT_UNCONDITIONALLY("EEType::Validate check failed"); } return false; } while (false)
// Deal with the most common case of a bad pointer without an exception.
if (this == NULL)
REPORT_FAILURE();
// EEType structures should be at least pointer aligned.
if (dac_cast<TADDR>(this) & (sizeof(TADDR)-1))
REPORT_FAILURE();
// Verify object size is bigger than min_obj_size
size_t minObjSize = get_BaseSize();
if (get_ComponentSize() != 0)
{
// If it is an array, we will align the size to the nearest pointer alignment, even if there are
// zero elements. Our strings take advantage of this.
minObjSize = (size_t)ALIGN_UP(minObjSize, sizeof(TADDR));
}
if (minObjSize < (3 * sizeof(TADDR)))
REPORT_FAILURE();
switch (get_Kind())
{
case CanonicalEEType:
{
// If the parent type is NULL this had better look like Object.
if (!IsInterface() && (m_RelatedType.m_pBaseType == NULL))
{
if (IsRelatedTypeViaIAT() ||
get_IsValueType() ||
HasFinalizer() ||
HasReferenceFields() ||
HasGenericVariance())
{
REPORT_FAILURE();
}
}
break;
}
case ClonedEEType:
{
// Cloned types must have a related type.
if (m_RelatedType.m_ppCanonicalTypeViaIAT == NULL)
REPORT_FAILURE();
// Either we're dealing with a clone of String or a generic type. We can tell the difference based
// on the component size.
switch (get_ComponentSize())
{
case 0:
{
// Cloned generic type.
if (!IsRelatedTypeViaIAT())
{
REPORT_FAILURE();
}
break;
}
case 2:
{
// Cloned string.
if (get_IsValueType() ||
HasFinalizer() ||
HasReferenceFields() ||
HasGenericVariance())
{
REPORT_FAILURE();
}
break;
}
default:
// Apart from cloned strings we don't expected cloned types to have a component size.
REPORT_FAILURE();
}
break;
}
case ParameterizedEEType:
{
// The only parameter EETypes that can exist on the heap are arrays
// Array types must have a related type.
if (m_RelatedType.m_pRelatedParameterType == NULL)
REPORT_FAILURE();
// Component size cannot be zero in this case.
if (get_ComponentSize() == 0)
REPORT_FAILURE();
if (get_IsValueType() ||
HasFinalizer() ||
HasGenericVariance())
{
REPORT_FAILURE();
}
break;
}
case GenericTypeDefEEType:
{
// We should never see uninstantiated generic type definitions here
// since we should never construct an object instance around them.
REPORT_FAILURE();
}
default:
// Should be unreachable.
REPORT_FAILURE();
}
#undef REPORT_FAILURE
return true;
}
enum piglit_result
test_pixel_map(void *null)
{
int use_unpack;
int use_pack;
GLuint pb_pack[1];
GLuint pb_unpack[1];
int i;
int size;
int max;
GLushort *pbo_mem;
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
glGetIntegerv(GL_MAX_PIXEL_MAP_TABLE, &max);
for (use_pack = 0; use_pack < 2; use_pack++) {
for (use_unpack = 0; use_unpack < 2;
use_unpack++) {
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
if (use_unpack) {
glGenBuffersARB(1, pb_unpack);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
pb_unpack[0]);
glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB,
max * sizeof(GLushort), NULL,
GL_STREAM_DRAW);
}
pbo_mem = NULL;
if (use_unpack) {
pbo_mem = (GLushort *) glMapBufferARB(
GL_PIXEL_UNPACK_BUFFER_ARB,
GL_WRITE_ONLY);
}
else {
pbo_mem = (GLushort *)
malloc(sizeof(GLushort) * max);
}
for (i = 0; i < max; i++)
pbo_mem[i] = max - i - 1;
if (use_unpack) {
glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB);
glPixelMapusv(GL_PIXEL_MAP_R_TO_R, max, NULL);
glPixelMapusv(GL_PIXEL_MAP_G_TO_G, max, NULL);
glPixelMapusv(GL_PIXEL_MAP_B_TO_B, max, NULL);
glPixelMapusv(GL_PIXEL_MAP_A_TO_A, max, NULL);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
0);
}
else {
glPixelMapusv(GL_PIXEL_MAP_R_TO_R, max,
pbo_mem);
glPixelMapusv(GL_PIXEL_MAP_G_TO_G, max,
pbo_mem);
glPixelMapusv(GL_PIXEL_MAP_B_TO_B, max,
pbo_mem);
glPixelMapusv(GL_PIXEL_MAP_A_TO_A, max,
pbo_mem);
free(pbo_mem);
}
glGetIntegerv(GL_PIXEL_MAP_R_TO_R_SIZE, &size);
if (size != max) {
REPORT_FAILURE("glPixelMap failed");
return PIGLIT_FAIL;
}
glPixelTransferi(GL_MAP_COLOR, GL_FALSE);
/* Read back pixel map */
if (use_pack) {
glGenBuffersARB(1, pb_pack);
glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB,
pb_pack[0]);
glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB,
max * sizeof(GLushort),
NULL, GL_STREAM_DRAW);
glGetPixelMapusv(GL_PIXEL_MAP_R_TO_R, NULL);
pbo_mem = (GLushort *) glMapBufferARB(
GL_PIXEL_PACK_BUFFER_ARB,
GL_READ_ONLY);
}
else {
pbo_mem = (GLushort *)
malloc(sizeof(GLushort) * max);
glGetPixelMapusv(GL_PIXEL_MAP_R_TO_R, pbo_mem);
}
for (i = 0; i < max; i++) {
if (pbo_mem[i] != max - i - 1) {
REPORT_FAILURE("get PixelMap failed");
return PIGLIT_FAIL;
}
}
if (use_pack) {
glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
glDeleteBuffersARB(1, pb_pack);
}
else {
free(pbo_mem);
}
if (use_unpack) {
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
0);
glDeleteBuffersARB(1, pb_unpack);
}
if (!piglit_automatic)
piglit_present_results();
}
}
return PIGLIT_PASS;
}
