tests/general/object_purgeable.c

   1 /*
   2  * Copyright © 2010 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *    Shuang He <shuang.he@intel.com>
  25  *    Ian Romanick <ian.d.romanick@intel.com>
  26  */
  27
  28 #include "piglit-util-gl.h"
  29 #include "object_purgeable.h"
  30
  31 #define FAIL_ON_ERROR(string)                                           \
  32         do {                                                            \
  33                 const GLenum err = glGetError();                        \
  34                 if (err != GL_NO_ERROR) {                               \
  35                         fprintf(stderr, "%s generated error 0x%04x\n",  \
  36                                 string, err);                           \
  37                         pass = GL_FALSE;                                \
  38                 }                                                       \
  39         } while (0)
  40
  41 #define EXPECT_AN_ERROR(string, expected)                               \
  42         do {                                                            \
  43                 const GLenum err = glGetError();                        \
  44                 if (err != expected) {                                  \
  45                         fprintf(stderr, "%s generated error 0x%04x, "   \
  46                                 "but error 0x%04x (%s) was expected\n", \
  47                                 string, err, expected, # expected);     \
  48                         pass = GL_FALSE;                                \
  49                 }                                                       \
  50         } while (0)
  51
  52 void
  53 init_ObjectPurgeableAPI(void)
  54 {
  55         piglit_require_extension("GL_APPLE_object_purgeable");
  56 }
  57
  58
  59 #define NO_ENUM 0xffffffff
  60 static void
  61 print_result(const char *fname, const GLenum option, const GLenum result,
  62              const GLenum expected_1, const GLenum expected_2)
  63 {
  64         fprintf(stderr, "%s:%s: ", fname, piglit_get_gl_enum_name(option));
  65         fprintf(stderr, "expected 0x%04x (%s)",
  66                 expected_1, piglit_get_gl_enum_name(expected_1));
  67         if (expected_2 != NO_ENUM)
  68                 fprintf(stderr, " or 0x%04x (%s), ",
  69                         expected_2, piglit_get_gl_enum_name(expected_2));
  70         fprintf(stderr, ", got 0x%04x (%s).",
  71                 result, piglit_get_gl_enum_name(result));
  72 }
  73
  74
  75 /**
  76  * Check the setting and querying purgeability on object 0 generates errors.
  77  */
  78 GLboolean
  79 test_DefaultObject(GLenum objectType)
  80 {
  81         GLboolean pass = GL_TRUE;
  82         GLint param;
  83
  84         /* From the GL_APPLE_object_purgeable spec:
  85          *
  86          *     "INVALID_VALUE is generated if the <name> parameter of
  87          *      ObjectUnpurgeableAPPLE or ObjectUnpurgeableAPPLE is zero."
  88          */
  89         glObjectPurgeableAPPLE(objectType, 0, GL_VOLATILE_APPLE);
  90         EXPECT_AN_ERROR("glObjectPurgeableAPPLE", GL_INVALID_VALUE);
  91
  92         glObjectUnpurgeableAPPLE(objectType, 0, GL_RETAINED_APPLE);
  93         EXPECT_AN_ERROR("glObjectUnpurgeableAPPLE", GL_INVALID_VALUE);
  94
  95         /* From the GL_APPLE_object_purgeable spec:
  96          *
  97          *     "INVALID_VALUE is generated if the <name> parameter of
  98          *      GetObjectParameterivAPPLE is zero."
  99          */
 100         glGetObjectParameterivAPPLE(objectType, 0, GL_PURGEABLE_APPLE,
 101                                         &param);
 102         EXPECT_AN_ERROR("glGetObjectParameterivAPPLE", GL_INVALID_VALUE);
 103
 104         return pass;
 105 }
 106
 107
 108 GLboolean
 109 test_ObjectpurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)
 110 {
 111         GLboolean pass = GL_TRUE;
 112         GLenum ret;
 113
 114         ret = glObjectPurgeableAPPLE(objectType, name, option);
 115         FAIL_ON_ERROR("glObjectPurgeableAPPLE");
 116
 117         switch (option) {
 118         case GL_VOLATILE_APPLE:
 119                 /* From the GL_APPLE_object_purgeable spec:
 120                  *
 121                  *     "If ObjectPurgeableAPPLE is called with an <option> of
 122                  *     VOLATILE_APPLE, then ObjectPurgeableAPPLE will also
 123                  *     return the value VOLATILE_APPLE."
 124                  */
 125                 if (ret != GL_VOLATILE_APPLE) {
 126                         print_result("glObjectPurgeableAPPLE", option, ret,
 127                                      GL_VOLATILE_APPLE, NO_ENUM);
 128                         pass = GL_FALSE;
 129                 }
 130                 break;
 131
 132         case GL_RELEASED_APPLE:
 133                 /* From the GL_APPLE_object_purgeable spec:
 134                  *
 135                  *     "If ObjectPurgeableAPPLE is called with an <option> of
 136                  *     RELEASED_APPLE, then ObjectPurgeableAPPLE may return
 137                  *     either the value RELEASED_APPLE or the value
 138                  *     VOLATILE_APPLE."
 139                  */
 140                 if (ret != GL_VOLATILE_APPLE && ret != GL_RELEASED_APPLE) {
 141                         print_result("glObjectPurgeableAPPLE", option, ret,
 142                                      GL_RELEASED_APPLE,
 143                                      GL_VOLATILE_APPLE);
 144                         pass = GL_FALSE;
 145                 }
 146                 break;
 147         }
 148
 149         /* From the GL_APPLE_object_purgeable spec:
 150          *
 151          *     "Calling ObjectPurgeableAPPLE with either option sets
 152          *     PURGEABLE_APPLE to TRUE..."
 153          */
 154         if (!test_GetObjectParameterivAPPLE(objectType, name, GL_TRUE)) {
 155                 fprintf(stderr,
 156                         "Object marked purgeable is not set to purgeable\n");
 157                 pass = GL_FALSE;
 158         }
 159
 160         /* From the GL_APPLE_object_purgeable spec:
 161          *
 162          *     "If ObjectPurgeableAPPLE is called and PURGEABLE_APPLE is
 163          *     already TRUE, the error INVALID_OPERATION is generated."
 164          */
 165         glObjectPurgeableAPPLE(objectType, name, option);
 166         EXPECT_AN_ERROR("glObjectPurgeableAPPLE", GL_INVALID_OPERATION);
 167
 168         return pass;
 169 }
 170
 171
 172 GLboolean
 173 test_ObjectunpurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)
 174 {
 175         GLboolean pass = GL_TRUE;
 176         GLenum ret;
 177
 178         ret = glObjectUnpurgeableAPPLE(objectType, name, option);
 179         FAIL_ON_ERROR("glObjectUnpurgeableAPPLE");
 180
 181         switch (option) {
 182         case GL_RETAINED_APPLE:
 183                 /* From the GL_APPLE_object_purgeable spec:
 184                  *
 185                  *     "If ObjectUnpurgeableAPPLE is called with an <option> of
 186                  *     RETAINED_APPLE, then ObjectPurgeableAPPLE may return
 187                  *     either the value RETAINED_APPLE or the value
 188                  *     UNDEFINED_APPLE."
 189                  */
 190                 if (ret != GL_RETAINED_APPLE && ret != GL_UNDEFINED_APPLE) {
 191                         print_result("glObjectUnpurgeableAPPLE", option, ret,
 192                                      GL_RETAINED_APPLE,
 193                                      GL_UNDEFINED_APPLE);
 194                         pass = GL_FALSE;
 195                 }
 196                 break;
 197
 198         case GL_UNDEFINED_APPLE:
 199                 /* From the GL_APPLE_object_purgeable spec:
 200                  *
 201                  *     "If ObjectUnpurgeableAPPLE is called with the <option>
 202                  *     set to UNDEFINED_APPLE, then ObjectUnpurgeableAPPLE will
 203                  *     return the value UNDEFINED_APPLE."
 204                  */
 205                 if (ret != GL_UNDEFINED_APPLE) {
 206                         print_result("glObjectUnpurgeableAPPLE", option, ret,
 207                                      GL_UNDEFINED_APPLE, NO_ENUM);
 208                         pass = GL_FALSE;
 209                 }
 210                 break;
 211         }
 212
 213         /* From the GL_APPLE_object_purgeable spec:
 214          *
 215          *     "Calling ObjectUnpurgeableAPPLE with either option sets
 216          *     PURGEABLE_APPLE to FALSE..."
 217          */
 218         if (!test_GetObjectParameterivAPPLE(objectType, name, GL_FALSE)) {
 219                 fprintf(stderr, "Object marked unpurgeable is not set to "
 220                         "unpurgeable\n");
 221                 pass = GL_FALSE;
 222         }
 223
 224         /* From the GL_APPLE_object_purgeable spec:
 225          *
 226          *     "If ObjectUnpurgeableAPPLE is called and PURGEABLE_APPLE is
 227          *     already FALSE, the error INVALID_OPERATION is returned."
 228          */
 229         glObjectUnpurgeableAPPLE(objectType, name, option);
 230         EXPECT_AN_ERROR("glObjectPurgeableAPPLE", GL_INVALID_OPERATION);
 231
 232         return pass;
 233 }
 234
 235
 236 GLboolean
 237 test_GetObjectParameterivAPPLE(GLenum objectType, GLuint name, GLenum expect)
 238 {
 239         GLboolean pass = GL_TRUE;
 240         GLint param;
 241
 242         glGetObjectParameterivAPPLE(objectType, name, GL_PURGEABLE_APPLE,
 243                                         &param);
 244         FAIL_ON_ERROR("glGetObjectParameterivAPPLE");
 245
 246         if (param != expect) {
 247                 print_result("glObjectParameterivAPPLE", GL_PURGEABLE_APPLE,
 248                              param, expect, NO_ENUM);
 249                 pass = GL_FALSE;
 250         }
 251
 252         return pass;
 253 }
 254
 255
 256 GLboolean test_Purgeable(GLuint object, GLenum type)
 257 {
 258         GLboolean pass = GL_TRUE;
 259
 260         glGetError();
 261
 262         if (!test_DefaultObject(type)) {
 263                 fprintf(stderr, "Default object tests failed.\n");
 264                 pass = GL_FALSE;
 265         }
 266
 267         if (!test_GetObjectParameterivAPPLE(type, object, GL_FALSE)) {
 268                 fprintf(stderr, "Default state test failed.\n");
 269                 pass = GL_FALSE;
 270         }
 271
 272         if (!test_ObjectpurgeableAPPLE(type, object, GL_VOLATILE_APPLE)) {
 273                 pass = GL_FALSE;
 274         }
 275
 276         if (!test_ObjectunpurgeableAPPLE(type, object, GL_RETAINED_APPLE)) {
 277                 pass = GL_FALSE;
 278         }
 279
 280         if (!test_ObjectpurgeableAPPLE(type, object, GL_RELEASED_APPLE)) {
 281                 pass = GL_FALSE;
 282         }
 283
 284         if (!test_ObjectunpurgeableAPPLE(type, object, GL_UNDEFINED_APPLE)) {
 285                 pass = GL_FALSE;
 286         }
 287
 288         return pass;
 289 }