framework/egl/egluCallLogWrapper.inl

   1 /* WARNING: This is auto-generated file. Do not modify, since changes will
   2  * be lost! Modify the generating script instead.
   3  *
   4  * Generated from Khronos EGL API description (egl.xml) revision 32725.
   5  */
   6
   7 eglw::EGLBoolean CallLogWrapper::eglBindAPI (eglw::EGLenum api)
   8 {
   9         if (m_enableLog)
  10                 m_log << TestLog::Message << "eglBindAPI(" << getAPIStr(api) << ");" << TestLog::EndMessage;
  11         eglw::EGLBoolean returnValue = m_egl.bindAPI(api);
  12         if (m_enableLog)
  13                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
  14         return returnValue;
  15 }
  16
  17 eglw::EGLBoolean CallLogWrapper::eglBindTexImage (eglw::EGLDisplay dpy, eglw::EGLSurface surface, eglw::EGLint buffer)
  18 {
  19         if (m_enableLog)
  20                 m_log << TestLog::Message << "eglBindTexImage(" << dpy << ", " << toHex(surface) << ", " << buffer << ");" << TestLog::EndMessage;
  21         eglw::EGLBoolean returnValue = m_egl.bindTexImage(dpy, surface, buffer);
  22         if (m_enableLog)
  23                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
  24         return returnValue;
  25 }
  26
  27 eglw::EGLBoolean CallLogWrapper::eglChooseConfig (eglw::EGLDisplay dpy, const eglw::EGLint *attrib_list, eglw::EGLConfig *configs, eglw::EGLint config_size, eglw::EGLint *num_config)
  28 {
  29         if (m_enableLog)
  30                 m_log << TestLog::Message << "eglChooseConfig(" << dpy << ", " << getConfigAttribListStr(attrib_list) << ", " << configs << ", " << config_size << ", " << num_config << ");" << TestLog::EndMessage;
  31         eglw::EGLBoolean returnValue = m_egl.chooseConfig(dpy, attrib_list, configs, config_size, num_config);
  32         if (m_enableLog)
  33         {
  34                 m_log << TestLog::Message << "// configs = " << getPointerStr(configs, (num_config && returnValue) ? deMin32(config_size, *num_config) : 0) << TestLog::EndMessage;
  35                 m_log << TestLog::Message << "// num_config = " << (num_config ? de::toString(*num_config) : "NULL") << TestLog::EndMessage;
  36         }
  37         if (m_enableLog)
  38                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
  39         return returnValue;
  40 }
  41
  42 eglw::EGLint CallLogWrapper::eglClientWaitSync (eglw::EGLDisplay dpy, eglw::EGLSync sync, eglw::EGLint flags, eglw::EGLTime timeout)
  43 {
  44         if (m_enableLog)
  45                 m_log << TestLog::Message << "eglClientWaitSync(" << dpy << ", " << sync << ", " << flags << ", " << timeout << ");" << TestLog::EndMessage;
  46         eglw::EGLint returnValue = m_egl.clientWaitSync(dpy, sync, flags, timeout);
  47         if (m_enableLog)
  48                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
  49         return returnValue;
  50 }
  51
  52 eglw::EGLint CallLogWrapper::eglClientWaitSyncKHR (eglw::EGLDisplay dpy, eglw::EGLSyncKHR sync, eglw::EGLint flags, eglw::EGLTimeKHR timeout)
  53 {
  54         if (m_enableLog)
  55                 m_log << TestLog::Message << "eglClientWaitSyncKHR(" << dpy << ", " << sync << ", " << flags << ", " << timeout << ");" << TestLog::EndMessage;
  56         eglw::EGLint returnValue = m_egl.clientWaitSyncKHR(dpy, sync, flags, timeout);
  57         if (m_enableLog)
  58                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
  59         return returnValue;
  60 }
  61
  62 eglw::EGLBoolean CallLogWrapper::eglCopyBuffers (eglw::EGLDisplay dpy, eglw::EGLSurface surface, eglw::EGLNativePixmapType target)
  63 {
  64         if (m_enableLog)
  65                 m_log << TestLog::Message << "eglCopyBuffers(" << dpy << ", " << toHex(surface) << ", " << toHex(target) << ");" << TestLog::EndMessage;
  66         eglw::EGLBoolean returnValue = m_egl.copyBuffers(dpy, surface, target);
  67         if (m_enableLog)
  68                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
  69         return returnValue;
  70 }
  71
  72 eglw::EGLContext CallLogWrapper::eglCreateContext (eglw::EGLDisplay dpy, eglw::EGLConfig config, eglw::EGLContext share_context, const eglw::EGLint *attrib_list)
  73 {
  74         if (m_enableLog)
  75                 m_log << TestLog::Message << "eglCreateContext(" << dpy << ", " << toHex(config) << ", " << share_context << ", " << getContextAttribListStr(attrib_list) << ");" << TestLog::EndMessage;
  76         eglw::EGLContext returnValue = m_egl.createContext(dpy, config, share_context, attrib_list);
  77         if (m_enableLog)
  78                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
  79         return returnValue;
  80 }
  81
  82 eglw::EGLImage CallLogWrapper::eglCreateImage (eglw::EGLDisplay dpy, eglw::EGLContext ctx, eglw::EGLenum target, eglw::EGLClientBuffer buffer, const eglw::EGLAttrib *attrib_list)
  83 {
  84         if (m_enableLog)
  85                 m_log << TestLog::Message << "eglCreateImage(" << dpy << ", " << ctx << ", " << toHex(target) << ", " << toHex(buffer) << ", " << attrib_list << ");" << TestLog::EndMessage;
  86         eglw::EGLImage returnValue = m_egl.createImage(dpy, ctx, target, buffer, attrib_list);
  87         if (m_enableLog)
  88                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
  89         return returnValue;
  90 }
  91
  92 eglw::EGLImageKHR CallLogWrapper::eglCreateImageKHR (eglw::EGLDisplay dpy, eglw::EGLContext ctx, eglw::EGLenum target, eglw::EGLClientBuffer buffer, const eglw::EGLint *attrib_list)
  93 {
  94         if (m_enableLog)
  95                 m_log << TestLog::Message << "eglCreateImageKHR(" << dpy << ", " << ctx << ", " << toHex(target) << ", " << toHex(buffer) << ", " << attrib_list << ");" << TestLog::EndMessage;
  96         eglw::EGLImageKHR returnValue = m_egl.createImageKHR(dpy, ctx, target, buffer, attrib_list);
  97         if (m_enableLog)
  98                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
  99         return returnValue;
 100 }
 101
 102 eglw::EGLSurface CallLogWrapper::eglCreatePbufferFromClientBuffer (eglw::EGLDisplay dpy, eglw::EGLenum buftype, eglw::EGLClientBuffer buffer, eglw::EGLConfig config, const eglw::EGLint *attrib_list)
 103 {
 104         if (m_enableLog)
 105                 m_log << TestLog::Message << "eglCreatePbufferFromClientBuffer(" << dpy << ", " << toHex(buftype) << ", " << toHex(buffer) << ", " << toHex(config) << ", " << attrib_list << ");" << TestLog::EndMessage;
 106         eglw::EGLSurface returnValue = m_egl.createPbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
 107         if (m_enableLog)
 108                 m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
 109         return returnValue;
 110 }
 111
 112 eglw::EGLSurface CallLogWrapper::eglCreatePbufferSurface (eglw::EGLDisplay dpy, eglw::EGLConfig config, const eglw::EGLint *attrib_list)
 113 {
 114         if (m_enableLog)
 115                 m_log << TestLog::Message << "eglCreatePbufferSurface(" << dpy << ", " << toHex(config) << ", " << getSurfaceAttribListStr(attrib_list) << ");" << TestLog::EndMessage;
 116         eglw::EGLSurface returnValue = m_egl.createPbufferSurface(dpy, config, attrib_list);
 117         if (m_enableLog)
 118                 m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
 119         return returnValue;
 120 }
 121
 122 eglw::EGLSurface CallLogWrapper::eglCreatePixmapSurface (eglw::EGLDisplay dpy, eglw::EGLConfig config, eglw::EGLNativePixmapType pixmap, const eglw::EGLint *attrib_list)
 123 {
 124         if (m_enableLog)
 125                 m_log << TestLog::Message << "eglCreatePixmapSurface(" << dpy << ", " << toHex(config) << ", " << toHex(pixmap) << ", " << getSurfaceAttribListStr(attrib_list) << ");" << TestLog::EndMessage;
 126         eglw::EGLSurface returnValue = m_egl.createPixmapSurface(dpy, config, pixmap, attrib_list);
 127         if (m_enableLog)
 128                 m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
 129         return returnValue;
 130 }
 131
 132 eglw::EGLSurface CallLogWrapper::eglCreatePlatformPixmapSurface (eglw::EGLDisplay dpy, eglw::EGLConfig config, void *native_pixmap, const eglw::EGLAttrib *attrib_list)
 133 {
 134         if (m_enableLog)
 135                 m_log << TestLog::Message << "eglCreatePlatformPixmapSurface(" << dpy << ", " << toHex(config) << ", " << native_pixmap << ", " << attrib_list << ");" << TestLog::EndMessage;
 136         eglw::EGLSurface returnValue = m_egl.createPlatformPixmapSurface(dpy, config, native_pixmap, attrib_list);
 137         if (m_enableLog)
 138                 m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
 139         return returnValue;
 140 }
 141
 142 eglw::EGLSurface CallLogWrapper::eglCreatePlatformPixmapSurfaceEXT (eglw::EGLDisplay dpy, eglw::EGLConfig config, void *native_pixmap, const eglw::EGLint *attrib_list)
 143 {
 144         if (m_enableLog)
 145                 m_log << TestLog::Message << "eglCreatePlatformPixmapSurfaceEXT(" << dpy << ", " << toHex(config) << ", " << native_pixmap << ", " << attrib_list << ");" << TestLog::EndMessage;
 146         eglw::EGLSurface returnValue = m_egl.createPlatformPixmapSurfaceEXT(dpy, config, native_pixmap, attrib_list);
 147         if (m_enableLog)
 148                 m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
 149         return returnValue;
 150 }
 151
 152 eglw::EGLSurface CallLogWrapper::eglCreatePlatformWindowSurface (eglw::EGLDisplay dpy, eglw::EGLConfig config, void *native_window, const eglw::EGLAttrib *attrib_list)
 153 {
 154         if (m_enableLog)
 155                 m_log << TestLog::Message << "eglCreatePlatformWindowSurface(" << dpy << ", " << toHex(config) << ", " << native_window << ", " << attrib_list << ");" << TestLog::EndMessage;
 156         eglw::EGLSurface returnValue = m_egl.createPlatformWindowSurface(dpy, config, native_window, attrib_list);
 157         if (m_enableLog)
 158                 m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
 159         return returnValue;
 160 }
 161
 162 eglw::EGLSurface CallLogWrapper::eglCreatePlatformWindowSurfaceEXT (eglw::EGLDisplay dpy, eglw::EGLConfig config, void *native_window, const eglw::EGLint *attrib_list)
 163 {
 164         if (m_enableLog)
 165                 m_log << TestLog::Message << "eglCreatePlatformWindowSurfaceEXT(" << dpy << ", " << toHex(config) << ", " << native_window << ", " << attrib_list << ");" << TestLog::EndMessage;
 166         eglw::EGLSurface returnValue = m_egl.createPlatformWindowSurfaceEXT(dpy, config, native_window, attrib_list);
 167         if (m_enableLog)
 168                 m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
 169         return returnValue;
 170 }
 171
 172 eglw::EGLSync CallLogWrapper::eglCreateSync (eglw::EGLDisplay dpy, eglw::EGLenum type, const eglw::EGLAttrib *attrib_list)
 173 {
 174         if (m_enableLog)
 175                 m_log << TestLog::Message << "eglCreateSync(" << dpy << ", " << toHex(type) << ", " << attrib_list << ");" << TestLog::EndMessage;
 176         eglw::EGLSync returnValue = m_egl.createSync(dpy, type, attrib_list);
 177         if (m_enableLog)
 178                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
 179         return returnValue;
 180 }
 181
 182 eglw::EGLSyncKHR CallLogWrapper::eglCreateSyncKHR (eglw::EGLDisplay dpy, eglw::EGLenum type, const eglw::EGLint *attrib_list)
 183 {
 184         if (m_enableLog)
 185                 m_log << TestLog::Message << "eglCreateSyncKHR(" << dpy << ", " << toHex(type) << ", " << attrib_list << ");" << TestLog::EndMessage;
 186         eglw::EGLSyncKHR returnValue = m_egl.createSyncKHR(dpy, type, attrib_list);
 187         if (m_enableLog)
 188                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
 189         return returnValue;
 190 }
 191
 192 eglw::EGLSurface CallLogWrapper::eglCreateWindowSurface (eglw::EGLDisplay dpy, eglw::EGLConfig config, eglw::EGLNativeWindowType win, const eglw::EGLint *attrib_list)
 193 {
 194         if (m_enableLog)
 195                 m_log << TestLog::Message << "eglCreateWindowSurface(" << dpy << ", " << toHex(config) << ", " << toHex(win) << ", " << getSurfaceAttribListStr(attrib_list) << ");" << TestLog::EndMessage;
 196         eglw::EGLSurface returnValue = m_egl.createWindowSurface(dpy, config, win, attrib_list);
 197         if (m_enableLog)
 198                 m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
 199         return returnValue;
 200 }
 201
 202 eglw::EGLBoolean CallLogWrapper::eglDestroyContext (eglw::EGLDisplay dpy, eglw::EGLContext ctx)
 203 {
 204         if (m_enableLog)
 205                 m_log << TestLog::Message << "eglDestroyContext(" << dpy << ", " << ctx << ");" << TestLog::EndMessage;
 206         eglw::EGLBoolean returnValue = m_egl.destroyContext(dpy, ctx);
 207         if (m_enableLog)
 208                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 209         return returnValue;
 210 }
 211
 212 eglw::EGLBoolean CallLogWrapper::eglDestroyImage (eglw::EGLDisplay dpy, eglw::EGLImage image)
 213 {
 214         if (m_enableLog)
 215                 m_log << TestLog::Message << "eglDestroyImage(" << dpy << ", " << image << ");" << TestLog::EndMessage;
 216         eglw::EGLBoolean returnValue = m_egl.destroyImage(dpy, image);
 217         if (m_enableLog)
 218                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 219         return returnValue;
 220 }
 221
 222 eglw::EGLBoolean CallLogWrapper::eglDestroyImageKHR (eglw::EGLDisplay dpy, eglw::EGLImageKHR image)
 223 {
 224         if (m_enableLog)
 225                 m_log << TestLog::Message << "eglDestroyImageKHR(" << dpy << ", " << image << ");" << TestLog::EndMessage;
 226         eglw::EGLBoolean returnValue = m_egl.destroyImageKHR(dpy, image);
 227         if (m_enableLog)
 228                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 229         return returnValue;
 230 }
 231
 232 eglw::EGLBoolean CallLogWrapper::eglDestroySurface (eglw::EGLDisplay dpy, eglw::EGLSurface surface)
 233 {
 234         if (m_enableLog)
 235                 m_log << TestLog::Message << "eglDestroySurface(" << dpy << ", " << toHex(surface) << ");" << TestLog::EndMessage;
 236         eglw::EGLBoolean returnValue = m_egl.destroySurface(dpy, surface);
 237         if (m_enableLog)
 238                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 239         return returnValue;
 240 }
 241
 242 eglw::EGLBoolean CallLogWrapper::eglDestroySync (eglw::EGLDisplay dpy, eglw::EGLSync sync)
 243 {
 244         if (m_enableLog)
 245                 m_log << TestLog::Message << "eglDestroySync(" << dpy << ", " << sync << ");" << TestLog::EndMessage;
 246         eglw::EGLBoolean returnValue = m_egl.destroySync(dpy, sync);
 247         if (m_enableLog)
 248                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 249         return returnValue;
 250 }
 251
 252 eglw::EGLBoolean CallLogWrapper::eglDestroySyncKHR (eglw::EGLDisplay dpy, eglw::EGLSyncKHR sync)
 253 {
 254         if (m_enableLog)
 255                 m_log << TestLog::Message << "eglDestroySyncKHR(" << dpy << ", " << sync << ");" << TestLog::EndMessage;
 256         eglw::EGLBoolean returnValue = m_egl.destroySyncKHR(dpy, sync);
 257         if (m_enableLog)
 258                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 259         return returnValue;
 260 }
 261
 262 eglw::EGLBoolean CallLogWrapper::eglGetConfigAttrib (eglw::EGLDisplay dpy, eglw::EGLConfig config, eglw::EGLint attribute, eglw::EGLint *value)
 263 {
 264         if (m_enableLog)
 265                 m_log << TestLog::Message << "eglGetConfigAttrib(" << dpy << ", " << toHex(config) << ", " << getConfigAttribStr(attribute) << ", " << value << ");" << TestLog::EndMessage;
 266         eglw::EGLBoolean returnValue = m_egl.getConfigAttrib(dpy, config, attribute, value);
 267         if (m_enableLog)
 268         {
 269                 m_log << TestLog::Message << "// value = " << getConfigAttribValuePointerStr(attribute, value) << TestLog::EndMessage;
 270         }
 271         if (m_enableLog)
 272                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 273         return returnValue;
 274 }
 275
 276 eglw::EGLBoolean CallLogWrapper::eglGetConfigs (eglw::EGLDisplay dpy, eglw::EGLConfig *configs, eglw::EGLint config_size, eglw::EGLint *num_config)
 277 {
 278         if (m_enableLog)
 279                 m_log << TestLog::Message << "eglGetConfigs(" << dpy << ", " << configs << ", " << config_size << ", " << num_config << ");" << TestLog::EndMessage;
 280         eglw::EGLBoolean returnValue = m_egl.getConfigs(dpy, configs, config_size, num_config);
 281         if (m_enableLog)
 282                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 283         return returnValue;
 284 }
 285
 286 eglw::EGLContext CallLogWrapper::eglGetCurrentContext ()
 287 {
 288         if (m_enableLog)
 289                 m_log << TestLog::Message << "eglGetCurrentContext(" << ");" << TestLog::EndMessage;
 290         eglw::EGLContext returnValue = m_egl.getCurrentContext();
 291         if (m_enableLog)
 292                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
 293         return returnValue;
 294 }
 295
 296 eglw::EGLDisplay CallLogWrapper::eglGetCurrentDisplay ()
 297 {
 298         if (m_enableLog)
 299                 m_log << TestLog::Message << "eglGetCurrentDisplay(" << ");" << TestLog::EndMessage;
 300         eglw::EGLDisplay returnValue = m_egl.getCurrentDisplay();
 301         if (m_enableLog)
 302                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
 303         return returnValue;
 304 }
 305
 306 eglw::EGLSurface CallLogWrapper::eglGetCurrentSurface (eglw::EGLint readdraw)
 307 {
 308         if (m_enableLog)
 309                 m_log << TestLog::Message << "eglGetCurrentSurface(" << getSurfaceTargetStr(readdraw) << ");" << TestLog::EndMessage;
 310         eglw::EGLSurface returnValue = m_egl.getCurrentSurface(readdraw);
 311         if (m_enableLog)
 312                 m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
 313         return returnValue;
 314 }
 315
 316 eglw::EGLDisplay CallLogWrapper::eglGetDisplay (eglw::EGLNativeDisplayType display_id)
 317 {
 318         if (m_enableLog)
 319                 m_log << TestLog::Message << "eglGetDisplay(" << toHex(display_id) << ");" << TestLog::EndMessage;
 320         eglw::EGLDisplay returnValue = m_egl.getDisplay(display_id);
 321         if (m_enableLog)
 322                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
 323         return returnValue;
 324 }
 325
 326 eglw::EGLint CallLogWrapper::eglGetError ()
 327 {
 328         if (m_enableLog)
 329                 m_log << TestLog::Message << "eglGetError(" << ");" << TestLog::EndMessage;
 330         eglw::EGLint returnValue = m_egl.getError();
 331         if (m_enableLog)
 332                 m_log << TestLog::Message << "// " << getErrorStr(returnValue) << " returned" << TestLog::EndMessage;
 333         return returnValue;
 334 }
 335
 336 eglw::EGLDisplay CallLogWrapper::eglGetPlatformDisplay (eglw::EGLenum platform, void *native_display, const eglw::EGLAttrib *attrib_list)
 337 {
 338         if (m_enableLog)
 339                 m_log << TestLog::Message << "eglGetPlatformDisplay(" << toHex(platform) << ", " << native_display << ", " << attrib_list << ");" << TestLog::EndMessage;
 340         eglw::EGLDisplay returnValue = m_egl.getPlatformDisplay(platform, native_display, attrib_list);
 341         if (m_enableLog)
 342                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
 343         return returnValue;
 344 }
 345
 346 eglw::EGLDisplay CallLogWrapper::eglGetPlatformDisplayEXT (eglw::EGLenum platform, void *native_display, const eglw::EGLint *attrib_list)
 347 {
 348         if (m_enableLog)
 349                 m_log << TestLog::Message << "eglGetPlatformDisplayEXT(" << toHex(platform) << ", " << native_display << ", " << attrib_list << ");" << TestLog::EndMessage;
 350         eglw::EGLDisplay returnValue = m_egl.getPlatformDisplayEXT(platform, native_display, attrib_list);
 351         if (m_enableLog)
 352                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
 353         return returnValue;
 354 }
 355
 356 eglw::__eglMustCastToProperFunctionPointerType CallLogWrapper::eglGetProcAddress (const char *procname)
 357 {
 358         if (m_enableLog)
 359                 m_log << TestLog::Message << "eglGetProcAddress(" << getStringStr(procname) << ");" << TestLog::EndMessage;
 360         eglw::__eglMustCastToProperFunctionPointerType returnValue = m_egl.getProcAddress(procname);
 361         if (m_enableLog)
 362                 m_log << TestLog::Message << "// " << tcu::toHex(returnValue) << " returned" << TestLog::EndMessage;
 363         return returnValue;
 364 }
 365
 366 eglw::EGLBoolean CallLogWrapper::eglGetSyncAttrib (eglw::EGLDisplay dpy, eglw::EGLSync sync, eglw::EGLint attribute, eglw::EGLAttrib *value)
 367 {
 368         if (m_enableLog)
 369                 m_log << TestLog::Message << "eglGetSyncAttrib(" << dpy << ", " << sync << ", " << attribute << ", " << value << ");" << TestLog::EndMessage;
 370         eglw::EGLBoolean returnValue = m_egl.getSyncAttrib(dpy, sync, attribute, value);
 371         if (m_enableLog)
 372                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 373         return returnValue;
 374 }
 375
 376 eglw::EGLBoolean CallLogWrapper::eglGetSyncAttribKHR (eglw::EGLDisplay dpy, eglw::EGLSyncKHR sync, eglw::EGLint attribute, eglw::EGLint *value)
 377 {
 378         if (m_enableLog)
 379                 m_log << TestLog::Message << "eglGetSyncAttribKHR(" << dpy << ", " << sync << ", " << attribute << ", " << value << ");" << TestLog::EndMessage;
 380         eglw::EGLBoolean returnValue = m_egl.getSyncAttribKHR(dpy, sync, attribute, value);
 381         if (m_enableLog)
 382                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 383         return returnValue;
 384 }
 385
 386 eglw::EGLBoolean CallLogWrapper::eglInitialize (eglw::EGLDisplay dpy, eglw::EGLint *major, eglw::EGLint *minor)
 387 {
 388         if (m_enableLog)
 389                 m_log << TestLog::Message << "eglInitialize(" << dpy << ", " << major << ", " << minor << ");" << TestLog::EndMessage;
 390         eglw::EGLBoolean returnValue = m_egl.initialize(dpy, major, minor);
 391         if (m_enableLog)
 392                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 393         return returnValue;
 394 }
 395
 396 eglw::EGLBoolean CallLogWrapper::eglLockSurfaceKHR (eglw::EGLDisplay dpy, eglw::EGLSurface surface, const eglw::EGLint *attrib_list)
 397 {
 398         if (m_enableLog)
 399                 m_log << TestLog::Message << "eglLockSurfaceKHR(" << dpy << ", " << toHex(surface) << ", " << attrib_list << ");" << TestLog::EndMessage;
 400         eglw::EGLBoolean returnValue = m_egl.lockSurfaceKHR(dpy, surface, attrib_list);
 401         if (m_enableLog)
 402                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 403         return returnValue;
 404 }
 405
 406 eglw::EGLBoolean CallLogWrapper::eglMakeCurrent (eglw::EGLDisplay dpy, eglw::EGLSurface draw, eglw::EGLSurface read, eglw::EGLContext ctx)
 407 {
 408         if (m_enableLog)
 409                 m_log << TestLog::Message << "eglMakeCurrent(" << dpy << ", " << toHex(draw) << ", " << toHex(read) << ", " << ctx << ");" << TestLog::EndMessage;
 410         eglw::EGLBoolean returnValue = m_egl.makeCurrent(dpy, draw, read, ctx);
 411         if (m_enableLog)
 412                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 413         return returnValue;
 414 }
 415
 416 eglw::EGLenum CallLogWrapper::eglQueryAPI ()
 417 {
 418         if (m_enableLog)
 419                 m_log << TestLog::Message << "eglQueryAPI(" << ");" << TestLog::EndMessage;
 420         eglw::EGLenum returnValue = m_egl.queryAPI();
 421         if (m_enableLog)
 422                 m_log << TestLog::Message << "// " << getAPIStr(returnValue) << " returned" << TestLog::EndMessage;
 423         return returnValue;
 424 }
 425
 426 eglw::EGLBoolean CallLogWrapper::eglQueryContext (eglw::EGLDisplay dpy, eglw::EGLContext ctx, eglw::EGLint attribute, eglw::EGLint *value)
 427 {
 428         if (m_enableLog)
 429                 m_log << TestLog::Message << "eglQueryContext(" << dpy << ", " << ctx << ", " << getContextAttribStr(attribute) << ", " << value << ");" << TestLog::EndMessage;
 430         eglw::EGLBoolean returnValue = m_egl.queryContext(dpy, ctx, attribute, value);
 431         if (m_enableLog)
 432         {
 433                 m_log << TestLog::Message << "// value = " << getContextAttribValuePointerStr(attribute, value) << TestLog::EndMessage;
 434         }
 435         if (m_enableLog)
 436                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 437         return returnValue;
 438 }
 439
 440 const char * CallLogWrapper::eglQueryString (eglw::EGLDisplay dpy, eglw::EGLint name)
 441 {
 442         if (m_enableLog)
 443                 m_log << TestLog::Message << "eglQueryString(" << dpy << ", " << name << ");" << TestLog::EndMessage;
 444         const char * returnValue = m_egl.queryString(dpy, name);
 445         if (m_enableLog)
 446                 m_log << TestLog::Message << "// " << getStringStr(returnValue) << " returned" << TestLog::EndMessage;
 447         return returnValue;
 448 }
 449
 450 eglw::EGLBoolean CallLogWrapper::eglQuerySurface (eglw::EGLDisplay dpy, eglw::EGLSurface surface, eglw::EGLint attribute, eglw::EGLint *value)
 451 {
 452         if (m_enableLog)
 453                 m_log << TestLog::Message << "eglQuerySurface(" << dpy << ", " << toHex(surface) << ", " << getSurfaceAttribStr(attribute) << ", " << value << ");" << TestLog::EndMessage;
 454         eglw::EGLBoolean returnValue = m_egl.querySurface(dpy, surface, attribute, value);
 455         if (m_enableLog)
 456         {
 457                 m_log << TestLog::Message << "// value = " << getSurfaceAttribValuePointerStr(attribute, value) << TestLog::EndMessage;
 458         }
 459         if (m_enableLog)
 460                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 461         return returnValue;
 462 }
 463
 464 eglw::EGLBoolean CallLogWrapper::eglReleaseTexImage (eglw::EGLDisplay dpy, eglw::EGLSurface surface, eglw::EGLint buffer)
 465 {
 466         if (m_enableLog)
 467                 m_log << TestLog::Message << "eglReleaseTexImage(" << dpy << ", " << toHex(surface) << ", " << buffer << ");" << TestLog::EndMessage;
 468         eglw::EGLBoolean returnValue = m_egl.releaseTexImage(dpy, surface, buffer);
 469         if (m_enableLog)
 470                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 471         return returnValue;
 472 }
 473
 474 eglw::EGLBoolean CallLogWrapper::eglReleaseThread ()
 475 {
 476         if (m_enableLog)
 477                 m_log << TestLog::Message << "eglReleaseThread(" << ");" << TestLog::EndMessage;
 478         eglw::EGLBoolean returnValue = m_egl.releaseThread();
 479         if (m_enableLog)
 480                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 481         return returnValue;
 482 }
 483
 484 eglw::EGLBoolean CallLogWrapper::eglSetDamageRegionKHR (eglw::EGLDisplay dpy, eglw::EGLSurface surface, eglw::EGLint *rects, eglw::EGLint n_rects)
 485 {
 486         if (m_enableLog)
 487                 m_log << TestLog::Message << "eglSetDamageRegionKHR(" << dpy << ", " << toHex(surface) << ", " << rects << ", " << n_rects << ");" << TestLog::EndMessage;
 488         eglw::EGLBoolean returnValue = m_egl.setDamageRegionKHR(dpy, surface, rects, n_rects);
 489         if (m_enableLog)
 490                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 491         return returnValue;
 492 }
 493
 494 eglw::EGLBoolean CallLogWrapper::eglSignalSyncKHR (eglw::EGLDisplay dpy, eglw::EGLSyncKHR sync, eglw::EGLenum mode)
 495 {
 496         if (m_enableLog)
 497                 m_log << TestLog::Message << "eglSignalSyncKHR(" << dpy << ", " << sync << ", " << toHex(mode) << ");" << TestLog::EndMessage;
 498         eglw::EGLBoolean returnValue = m_egl.signalSyncKHR(dpy, sync, mode);
 499         if (m_enableLog)
 500                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 501         return returnValue;
 502 }
 503
 504 eglw::EGLBoolean CallLogWrapper::eglSurfaceAttrib (eglw::EGLDisplay dpy, eglw::EGLSurface surface, eglw::EGLint attribute, eglw::EGLint value)
 505 {
 506         if (m_enableLog)
 507                 m_log << TestLog::Message << "eglSurfaceAttrib(" << dpy << ", " << toHex(surface) << ", " << getSurfaceAttribStr(attribute) << ", " << getSurfaceAttribValueStr(attribute, value) << ");" << TestLog::EndMessage;
 508         eglw::EGLBoolean returnValue = m_egl.surfaceAttrib(dpy, surface, attribute, value);
 509         if (m_enableLog)
 510                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 511         return returnValue;
 512 }
 513
 514 eglw::EGLBoolean CallLogWrapper::eglSwapBuffers (eglw::EGLDisplay dpy, eglw::EGLSurface surface)
 515 {
 516         if (m_enableLog)
 517                 m_log << TestLog::Message << "eglSwapBuffers(" << dpy << ", " << toHex(surface) << ");" << TestLog::EndMessage;
 518         eglw::EGLBoolean returnValue = m_egl.swapBuffers(dpy, surface);
 519         if (m_enableLog)
 520                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 521         return returnValue;
 522 }
 523
 524 eglw::EGLBoolean CallLogWrapper::eglSwapBuffersWithDamageKHR (eglw::EGLDisplay dpy, eglw::EGLSurface surface, eglw::EGLint *rects, eglw::EGLint n_rects)
 525 {
 526         if (m_enableLog)
 527                 m_log << TestLog::Message << "eglSwapBuffersWithDamageKHR(" << dpy << ", " << toHex(surface) << ", " << rects << ", " << n_rects << ");" << TestLog::EndMessage;
 528         eglw::EGLBoolean returnValue = m_egl.swapBuffersWithDamageKHR(dpy, surface, rects, n_rects);
 529         if (m_enableLog)
 530                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 531         return returnValue;
 532 }
 533
 534 eglw::EGLBoolean CallLogWrapper::eglSwapInterval (eglw::EGLDisplay dpy, eglw::EGLint interval)
 535 {
 536         if (m_enableLog)
 537                 m_log << TestLog::Message << "eglSwapInterval(" << dpy << ", " << interval << ");" << TestLog::EndMessage;
 538         eglw::EGLBoolean returnValue = m_egl.swapInterval(dpy, interval);
 539         if (m_enableLog)
 540                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 541         return returnValue;
 542 }
 543
 544 eglw::EGLBoolean CallLogWrapper::eglTerminate (eglw::EGLDisplay dpy)
 545 {
 546         if (m_enableLog)
 547                 m_log << TestLog::Message << "eglTerminate(" << dpy << ");" << TestLog::EndMessage;
 548         eglw::EGLBoolean returnValue = m_egl.terminate(dpy);
 549         if (m_enableLog)
 550                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 551         return returnValue;
 552 }
 553
 554 eglw::EGLBoolean CallLogWrapper::eglUnlockSurfaceKHR (eglw::EGLDisplay dpy, eglw::EGLSurface surface)
 555 {
 556         if (m_enableLog)
 557                 m_log << TestLog::Message << "eglUnlockSurfaceKHR(" << dpy << ", " << toHex(surface) << ");" << TestLog::EndMessage;
 558         eglw::EGLBoolean returnValue = m_egl.unlockSurfaceKHR(dpy, surface);
 559         if (m_enableLog)
 560                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 561         return returnValue;
 562 }
 563
 564 eglw::EGLBoolean CallLogWrapper::eglWaitClient ()
 565 {
 566         if (m_enableLog)
 567                 m_log << TestLog::Message << "eglWaitClient(" << ");" << TestLog::EndMessage;
 568         eglw::EGLBoolean returnValue = m_egl.waitClient();
 569         if (m_enableLog)
 570                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 571         return returnValue;
 572 }
 573
 574 eglw::EGLBoolean CallLogWrapper::eglWaitGL ()
 575 {
 576         if (m_enableLog)
 577                 m_log << TestLog::Message << "eglWaitGL(" << ");" << TestLog::EndMessage;
 578         eglw::EGLBoolean returnValue = m_egl.waitGL();
 579         if (m_enableLog)
 580                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 581         return returnValue;
 582 }
 583
 584 eglw::EGLBoolean CallLogWrapper::eglWaitNative (eglw::EGLint engine)
 585 {
 586         if (m_enableLog)
 587                 m_log << TestLog::Message << "eglWaitNative(" << engine << ");" << TestLog::EndMessage;
 588         eglw::EGLBoolean returnValue = m_egl.waitNative(engine);
 589         if (m_enableLog)
 590                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 591         return returnValue;
 592 }
 593
 594 eglw::EGLBoolean CallLogWrapper::eglWaitSync (eglw::EGLDisplay dpy, eglw::EGLSync sync, eglw::EGLint flags)
 595 {
 596         if (m_enableLog)
 597                 m_log << TestLog::Message << "eglWaitSync(" << dpy << ", " << sync << ", " << flags << ");" << TestLog::EndMessage;
 598         eglw::EGLBoolean returnValue = m_egl.waitSync(dpy, sync, flags);
 599         if (m_enableLog)
 600                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
 601         return returnValue;
 602 }
 603
 604 eglw::EGLint CallLogWrapper::eglWaitSyncKHR (eglw::EGLDisplay dpy, eglw::EGLSyncKHR sync, eglw::EGLint flags)
 605 {
 606         if (m_enableLog)
 607                 m_log << TestLog::Message << "eglWaitSyncKHR(" << dpy << ", " << sync << ", " << flags << ");" << TestLog::EndMessage;
 608         eglw::EGLint returnValue = m_egl.waitSyncKHR(dpy, sync, flags);
 609         if (m_enableLog)
 610                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
 611         return returnValue;
 612 }