utests/src/ut_tdm_helper.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
   4  *
   5  * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
   6  * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
   7  * Contact: Roman Marchenko <r.marchenko@samsung.com>
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the
  11  * "Software"), to deal in the Software without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sub license, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice (including the
  18  * next paragraph) shall be included in all copies or substantial portions
  19  * of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  22  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  24  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  25  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  26  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  27  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28  *
  29 **************************************************************************/
  30
  31 #include "ut_tdm.h"
  32
  33 /* LCOV_EXCL_START */
  34
  35 class TDMHelper : public TDMOutput
  36 {
  37 public:
  38         TDMHelper();
  39         void SetUp(void);
  40         void TearDown(void);
  41 };
  42
  43 TDMHelper::TDMHelper()
  44 {
  45 }
  46
  47 void TDMHelper::SetUp(void)
  48 {
  49         TDMOutput::SetUp();
  50 }
  51
  52 void TDMHelper::TearDown(void)
  53 {
  54         TDMOutput::TearDown();
  55 }
  56
  57 TEST_P(TDMHelper, HelperGetTime)
  58 {
  59         ASSERT_GT(tdm_helper_get_time(), 0.0);
  60 }
  61
  62 TEST_P(TDMHelper, HelperDumpBufferXR24)
  63 {
  64         tbm_surface_h buffer;
  65
  66         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_XRGB8888);
  67         ASSERT_NE(buffer, NULL);
  68
  69         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
  70
  71         char filename[256];
  72         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
  73         tdm_helper_dump_buffer(buffer, (const char*)filename);
  74
  75         tbm_surface_destroy(buffer);
  76 }
  77
  78 TEST_P(TDMHelper, HelperDumpBufferAR24)
  79 {
  80         tbm_surface_h buffer;
  81
  82         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
  83         ASSERT_NE(buffer, NULL);
  84
  85         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
  86
  87         char filename[256];
  88         snprintf(filename, sizeof filename, "%s.png", typeid(*this).name());
  89         tdm_helper_dump_buffer(buffer, (const char*)filename);
  90
  91         tbm_surface_destroy(buffer);
  92 }
  93
  94 TEST_P(TDMHelper, HelperDumpBufferNullObject)
  95 {
  96         char filename[256];
  97         tdm_helper_dump_buffer(NULL, (const char*)filename);
  98 }
  99
 100 TEST_P(TDMHelper, HelperDumpBufferNullOther)
 101 {
 102         tbm_surface_h buffer = (tbm_surface_h)TDM_UT_INVALID_VALUE;
 103         tdm_helper_dump_buffer(buffer, NULL);
 104 }
 105
 106 TEST_P(TDMHelper, HelperClearBufferPos)
 107 {
 108         tbm_surface_h buffer;
 109         tdm_pos pos = {.x = 40, .y = 40, .w = TDM_UT_BUFFER_SIZE - 80, .h = TDM_UT_BUFFER_SIZE - 80};
 110
 111         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 112         ASSERT_NE(buffer, NULL);
 113
 114         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 115
 116         tdm_helper_clear_buffer_pos(buffer, &pos);
 117
 118         tdm_helper_dump_buffer_str(buffer, NULL, (char*)typeid(*this).name());
 119
 120         tbm_surface_destroy(buffer);
 121 }
 122
 123 TEST_P(TDMHelper, HelperClearBufferColor)
 124 {
 125         tbm_surface_h buffer;
 126         tdm_pos pos = {.x = 40, .y = 40, .w = TDM_UT_BUFFER_SIZE - 80, .h = TDM_UT_BUFFER_SIZE - 80};
 127         unsigned int color = 0xffffff00;
 128
 129         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 130         ASSERT_NE(buffer, NULL);
 131
 132         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 133
 134         tdm_helper_clear_buffer_color(buffer, &pos, color);
 135
 136         tdm_helper_dump_buffer_str(buffer, NULL, (char*)typeid(*this).name());
 137
 138         tbm_surface_destroy(buffer);
 139 }
 140
 141 TEST_P(TDMHelper, HelperClearBufferARGB)
 142 {
 143         tbm_surface_h buffer;
 144
 145         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 146         ASSERT_NE(buffer, NULL);
 147
 148         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 149
 150         tdm_helper_clear_buffer(buffer);
 151
 152         tdm_helper_dump_buffer_str(buffer, NULL, (char*)typeid(*this).name());
 153
 154         tbm_surface_destroy(buffer);
 155 }
 156
 157 TEST_P(TDMHelper, HelperClearBufferXRGB)
 158 {
 159         tbm_surface_h buffer;
 160
 161         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_XRGB8888);
 162         ASSERT_NE(buffer, NULL);
 163
 164         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 165
 166         tdm_helper_clear_buffer(buffer);
 167
 168         tdm_helper_dump_buffer_str(buffer, NULL, (char*)typeid(*this).name());
 169
 170         tbm_surface_destroy(buffer);
 171 }
 172
 173 TEST_P(TDMHelper, HelperClearBufferYUV420)
 174 {
 175         tbm_surface_h buffer;
 176
 177         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_YUV420);
 178         ASSERT_NE(buffer, NULL);
 179
 180         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 181
 182         tdm_helper_clear_buffer(buffer);
 183
 184         tdm_helper_dump_buffer_str(buffer, NULL, (char*)typeid(*this).name());
 185
 186         tbm_surface_destroy(buffer);
 187 }
 188
 189 TEST_P(TDMHelper, HelperClearBufferNV12)
 190 {
 191         tbm_surface_h buffer;
 192
 193         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_NV12);
 194         ASSERT_NE(buffer, NULL);
 195
 196         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 197
 198         tdm_helper_clear_buffer(buffer);
 199
 200         tdm_helper_dump_buffer_str(buffer, NULL, (char*)typeid(*this).name());
 201
 202         tbm_surface_destroy(buffer);
 203 }
 204
 205 TEST_P(TDMHelper, HelperClearBufferNV21)
 206 {
 207         tbm_surface_h buffer;
 208
 209         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_NV21);
 210         ASSERT_NE(buffer, NULL);
 211
 212         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 213
 214         tdm_helper_clear_buffer(buffer);
 215
 216         tdm_helper_dump_buffer_str(buffer, NULL, (char*)typeid(*this).name());
 217
 218         tbm_surface_destroy(buffer);
 219 }
 220
 221 TEST_P(TDMHelper, HelperGetBufferFullSize)
 222 {
 223         tbm_surface_h buffer;
 224         int w = TDM_UT_INVALID_VALUE, h = TDM_UT_INVALID_VALUE;
 225
 226         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 227         ASSERT_NE(buffer, NULL);
 228
 229         tdm_helper_get_buffer_full_size(buffer, &w, &h);
 230         ASSERT_NE(w, TDM_UT_INVALID_VALUE);
 231         ASSERT_GE(w, tbm_surface_get_width(buffer));
 232         ASSERT_NE(h, TDM_UT_INVALID_VALUE);
 233         ASSERT_GE(h, tbm_surface_get_height(buffer));
 234
 235         tbm_surface_destroy(buffer);
 236 }
 237
 238 TEST_P(TDMHelper, HelperConvertBufferRotate0)
 239 {
 240         tbm_surface_h buffer, temp;
 241         tdm_pos sp, dp;
 242
 243         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 244         ASSERT_NE(buffer, NULL);
 245         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 246
 247         temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
 248         ASSERT_NE(temp, NULL);
 249
 250         sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
 251         dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
 252
 253         ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0), TDM_ERROR_NONE);
 254
 255         tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name());
 256
 257         tbm_surface_destroy(buffer);
 258         tbm_surface_destroy(temp);
 259 }
 260
 261 TEST_P(TDMHelper, HelperConvertBufferRotate0Flip)
 262 {
 263         tbm_surface_h buffer, temp;
 264         tdm_pos sp, dp;
 265
 266         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 267         ASSERT_NE(buffer, NULL);
 268         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 269
 270         temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
 271         ASSERT_NE(temp, NULL);
 272
 273         sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
 274         dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
 275
 276         ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_FLIPPED, 0), TDM_ERROR_NONE);
 277
 278         tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name());
 279
 280         tbm_surface_destroy(buffer);
 281         tbm_surface_destroy(temp);
 282 }
 283
 284 TEST_P(TDMHelper, HelperConvertBufferRotate90)
 285 {
 286         tbm_surface_h buffer, temp;
 287         tdm_pos sp, dp;
 288
 289         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 290         ASSERT_NE(buffer, NULL);
 291         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 292
 293         temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
 294         ASSERT_NE(temp, NULL);
 295
 296         sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
 297         dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
 298
 299         ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_90, 0), TDM_ERROR_NONE);
 300
 301         tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name());
 302
 303         tbm_surface_destroy(buffer);
 304         tbm_surface_destroy(temp);
 305 }
 306
 307 TEST_P(TDMHelper, HelperConvertBufferRotate180)
 308 {
 309         tbm_surface_h buffer, temp;
 310         tdm_pos sp, dp;
 311
 312         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 313         ASSERT_NE(buffer, NULL);
 314         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 315
 316         temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
 317         ASSERT_NE(temp, NULL);
 318
 319         sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
 320         dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
 321
 322         ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_180, 0), TDM_ERROR_NONE);
 323
 324         tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name());
 325
 326         tbm_surface_destroy(buffer);
 327         tbm_surface_destroy(temp);
 328 }
 329
 330 TEST_P(TDMHelper, HelperConvertBufferRotate270)
 331 {
 332         tbm_surface_h buffer, temp;
 333         tdm_pos sp, dp;
 334
 335         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 336         ASSERT_NE(buffer, NULL);
 337         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 338
 339         temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_ARGB8888);
 340         ASSERT_NE(temp, NULL);
 341
 342         sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
 343         dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
 344
 345         ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_270, 0), TDM_ERROR_NONE);
 346
 347         tdm_helper_dump_buffer_str(temp, NULL, (char*)typeid(*this).name());
 348
 349         tbm_surface_destroy(buffer);
 350         tbm_surface_destroy(temp);
 351 }
 352
 353 TEST_P(TDMHelper, HelperConvertBufferYUV420)
 354 {
 355         tbm_surface_h buffer, temp;
 356         tdm_pos sp, dp;
 357
 358         buffer = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_YUV420);
 359         ASSERT_NE(buffer, NULL);
 360         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
 361
 362         temp = tbm_surface_create(TDM_UT_BUFFER_SIZE * 2, TDM_UT_BUFFER_SIZE * 2, TBM_FORMAT_YUV420);
 363         ASSERT_NE(temp, NULL);
 364
 365         sp.x = sp.y = 0, sp.w = sp.h = TDM_UT_BUFFER_SIZE;
 366         dp.x = dp.y = 0, dp.w = dp.h = TDM_UT_BUFFER_SIZE * 2;
 367
 368         ASSERT_EQ(tdm_helper_convert_buffer(buffer, temp, &sp, &dp, TDM_TRANSFORM_NORMAL, 0), TDM_ERROR_OPERATION_FAILED);
 369
 370         tbm_surface_destroy(buffer);
 371         tbm_surface_destroy(temp);
 372 }
 373
 374 TEST_P(TDMHelper, HelperGetFD)
 375 {
 376         int fd = tdm_helper_get_fd("TDM_DRM_MASTER_FD");
 377         ASSERT_GE(fd, 0);
 378         close(fd);
 379         fd = tdm_helper_get_fd("BLURBLUR");
 380         ASSERT_EQ(fd, -1);
 381 }
 382
 383 TEST_P(TDMHelper, HelperSetFD)
 384 {
 385         tdm_helper_set_fd("TDM_DRM_MASTER_FD", -1);
 386         tdm_helper_set_fd("BLURBLUR", -1);
 387 }
 388
 389 TEST_P(TDMHelper, HelperDumpStart)
 390 {
 391         char path[256];
 392         int count = 0;
 393         snprintf(path, sizeof path, "blurblur");
 394         tdm_helper_dump_start(path, &count);
 395         tdm_helper_dump_stop();
 396 }
 397
 398 static void
 399 _ut_tdm_helper_capture_cb(tbm_surface_h buffer, void *user_data)
 400 {
 401 }
 402
 403 TEST_P(TDMHelper, HelperCaptureOutput)
 404 {
 405         tdm_error ret;
 406         tdm_output *output;
 407
 408         for (int o = 0; o < output_count; o++) {
 409                 tbm_surface_h dump;
 410
 411                 output = tdm_display_get_output(dpy, o, &ret);
 412                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 413                 ASSERT_NE(output, NULL);
 414
 415                 if (!ut_tdm_output_is_connected(output))
 416                         continue;
 417
 418                 ASSERT_EQ(ut_tdm_output_prepare(dpy, output, true), true);
 419
 420                 dump = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888);
 421                 ASSERT_NE(dump, NULL);
 422
 423                 ASSERT_EQ(tdm_helper_capture_output(output, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE,
 424                                                                                         _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_NONE);
 425
 426                 tdm_helper_dump_buffer_str(dump, NULL, (char*)typeid(*this).name());
 427
 428                 tbm_surface_destroy(dump);
 429         }
 430 }
 431
 432
 433 TEST_P(TDMHelper, HelperCaptureOutputNullObject)
 434 {
 435         tbm_surface_h dump = (tbm_surface_h)TDM_UT_INVALID_VALUE;
 436
 437         ASSERT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE,
 438                                                                                 _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
 439 }
 440
 441 TEST_P(TDMHelper, HelperCaptureOutputNullOther)
 442 {
 443         for (int o = 0; o < output_count; o++) {
 444                 tdm_error ret;
 445                 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
 446                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 447                 ASSERT_NE(output, NULL);
 448                 tdm_helper_output_commit_per_vblank_enabled(output);
 449         }
 450
 451         tbm_surface_h dump = (tbm_surface_h)TDM_UT_INVALID_VALUE;
 452
 453         ASSERT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE,
 454                                                                                 _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
 455 }
 456
 457 TEST_P(TDMHelper, HelperGetDisplayInformation)
 458 {
 459         char reply[8192];
 460         int len = sizeof reply;
 461
 462         for (int o = 0; o < output_count; o++) {
 463                 tdm_error ret;
 464                 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
 465                 ASSERT_EQ(ret, TDM_ERROR_NONE);
 466                 ASSERT_NE(output, NULL);
 467                 if (!ut_tdm_output_is_connected(output))
 468                         continue;
 469                 ASSERT_EQ(ut_tdm_output_prepare(dpy, output, true), true);
 470         }
 471
 472         tdm_helper_get_display_information(dpy, reply, &len);
 473         TDM_INFO("%s", reply);
 474 }
 475
 476 TEST_P(TDMHelper, HelperGetDisplayInformationNullObject)
 477 {
 478         char reply[8192];
 479         int len = sizeof reply;
 480
 481         tdm_helper_get_display_information(NULL, reply, &len);
 482 }
 483
 484 TEST_P(TDMHelper, HelperGetDisplayInformationNullOther)
 485 {
 486         tdm_helper_get_display_information(dpy, NULL, NULL);
 487 }
 488
 489 TEST_P(TDMHelper, HelperCommitPerVblankEnabled)
 490 {
 491         ASSERT_EQ(tdm_helper_commit_per_vblank_enabled(dpy), 0);
 492 }
 493
 494 TEST_P(TDMHelper, HelperCommitPerVblankEnabledNullOBject)
 495 {
 496         ASSERT_EQ(tdm_helper_commit_per_vblank_enabled(NULL), 0);
 497 }
 498
 499 TEST_P(TDMHelper, HelperOutputCommitPerVblankEnabledNullObject)
 500 {
 501         ASSERT_EQ(tdm_helper_output_commit_per_vblank_enabled(NULL), -1);
 502 }
 503
 504 #ifdef TDM_UT_TEST_WITH_PARAMS
 505 INSTANTIATE_TEST_CASE_P(TDMHelperParams,
 506                                                 TDMHelper,
 507                                                 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
 508 #else
 509 INSTANTIATE_TEST_CASE_P(TDMHelperParams,
 510                                                 TDMHelper,
 511                                                 Values(TDM_DEFAULT_MODULE));
 512 #endif
 513
 514 /* LCOV_EXCL_END */