1 # -*- coding: utf-8 -*- 2 3 #------------------------------------------------------------------------- 4 # drawElements Quality Program utilities 5 # -------------------------------------- 6 # 7 # Copyright 2015 The Android Open Source Project 8 # 9 # Licensed under the Apache License, Version 2.0 (the "License"); 10 # you may not use this file except in compliance with the License. 11 # You may obtain a copy of the License at 12 # 13 # http://www.apache.org/licenses/LICENSE-2.0 14 # 15 # Unless required by applicable law or agreed to in writing, software 16 # distributed under the License is distributed on an "AS IS" BASIS, 17 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 # See the License for the specific language governing permissions and 19 # limitations under the License. 20 # 21 #------------------------------------------------------------------------- 22 23 from genutil import * 24 25 allCases = [] 26 27 VERTEX = "VERTEX" 28 FRAGMENT = "FRAGMENT" 29 30 CASE_FRAGMENT_SHADER_TEMPLATE = """ 31 case ${{NAME}} 32 version 300 es 33 expect ${{EXPECT}} 34 35 vertex "" 36 #version 300 es 37 precision highp float; 38 39 in vec4 a_pos; 40 41 void main() 42 { 43 gl_Position = a_pos; 44 } 45 "" 46 47 fragment "" 48 ${{SOURCE}} 49 "" 50 end"""[1:] 51 52 CASE_VERTEX_SHADER_TEMPLATE = """ 53 case ${{NAME}} 54 version 300 es 55 expect ${{EXPECT}} 56 57 vertex "" 58 ${{SOURCE}} 59 "" 60 61 fragment "" 62 #version 300 es 63 precision highp float; 64 65 layout(location=0) out vec4 o_color; 66 67 void main() 68 { 69 o_color = vec4(1.0); 70 } 71 "" 72 end"""[1:] 73 74 class UniformBlockCase(ShaderCase): 75 def __init__(self, name, shaderType, source, valid): 76 self.name = name 77 self.shaderType = shaderType 78 self.source = source 79 self.valid = valid 80 81 def __str__(self): 82 if self.shaderType == FRAGMENT: 83 sourceParams = { 84 "OUTPUT": "o_color", 85 "OUTPUT_DECLARATION": "layout(location=0) out vec4 o_color;" 86 } 87 88 source = fillTemplate(self.source, sourceParams) 89 90 testCaseParams = { 91 "NAME": self.name, 92 "SOURCE": source, 93 "EXPECT": ("build_successful" if self.valid else "compile_fail") 94 } 95 96 return fillTemplate(CASE_FRAGMENT_SHADER_TEMPLATE, testCaseParams) 97 elif self.shaderType == VERTEX: 98 sourceParams = { 99 "OUTPUT": "gl_Position", 100 "OUTPUT_DECLARATION": "" 101 } 102 103 source = fillTemplate(self.source, sourceParams) 104 105 testCaseParams = { 106 "NAME": self.name, 107 "SOURCE": source, 108 "EXPECT": ("build_successful" if self.valid else "compile_fail") 109 } 110 111 return fillTemplate(CASE_VERTEX_SHADER_TEMPLATE, testCaseParams) 112 113 assert False 114 115 def createCases(name, source, valid): 116 return [UniformBlockCase(name + "_vertex", VERTEX, source, valid), 117 UniformBlockCase(name + "_fragment", FRAGMENT, source, valid)] 118 119 repeatShaderTemplate = """ 120 #version 300 es 121 precision highp float; 122 123 ${{OUTPUT_DECLARATION}} 124 125 uniform UniformBlock 126 { 127 uniform vec4 uniformMember; 128 } uniformBlock; 129 130 void main() 131 { 132 ${{OUTPUT}} = uniformBlock.uniformMember; 133 }"""[1:] 134 135 layoutQualifierShaderTemplate = """ 136 #version 300 es 137 precision highp float; 138 139 ${{OUTPUT_DECLARATION}} 140 141 layout(%s) uniform UniformBlock 142 { 143 vec4 uniformMember; 144 } uniformBlock; 145 146 void main() 147 { 148 ${{OUTPUT}} = uniformBlock.uniformMember; 149 }"""[1:] 150 151 layoutGlobalQualifierShaderTemplate = """ 152 #version 300 es 153 precision highp float; 154 155 layout(%s) uniform; 156 157 ${{OUTPUT_DECLARATION}} 158 159 uniform UniformBlock 160 { 161 vec4 uniformMember; 162 } uniformBlock; 163 164 void main() 165 { 166 ${{OUTPUT}} = uniformBlock.uniformMember; 167 }"""[1:] 168 169 layoutMemberQualifierShaderTemplate = """ 170 #version 300 es 171 precision highp float; 172 173 ${{OUTPUT_DECLARATION}} 174 175 uniform UniformBlock 176 { 177 layout(%s) mat4 uniformMember; 178 } uniformBlock; 179 180 void main() 181 { 182 ${{OUTPUT}} = uniformBlock.uniformMember[0]; 183 }"""[1:] 184 185 layoutMemberVec4QualifierShaderTemplate = """ 186 #version 300 es 187 precision highp float; 188 189 ${{OUTPUT_DECLARATION}} 190 191 uniform UniformBlock 192 { 193 layout(%s) vec4 uniformMember; 194 } uniformBlock; 195 196 void main() 197 { 198 ${{OUTPUT}} = uniformBlock.uniformMember; 199 }"""[1:] 200 201 noInstanceNameShaderTemplate = """ 202 #version 300 es 203 precision highp float; 204 205 ${{OUTPUT_DECLARATION}} 206 207 uniform UniformBlock 208 { 209 vec4 uniformMember; 210 }; 211 212 void main() 213 { 214 ${{OUTPUT}} = uniformMember; 215 }"""[1:] 216 217 sameVariableAndInstanceNameShaderTemplate = """ 218 #version 300 es 219 precision highp float; 220 221 ${{OUTPUT_DECLARATION}} 222 223 uniform UniformBlock 224 { 225 vec4 uniformMember; 226 } uniformBlock; 227 228 void main() 229 { 230 vec4 uniformBlock = vec4(0.0); 231 ${{OUTPUT}} = uniformBlock; 232 }"""[1:] 233 234 sameVariableAndBlockNameShaderTemplate = """ 235 #version 300 es 236 precision highp float; 237 238 ${{OUTPUT_DECLARATION}} 239 240 uniform UniformBlock 241 { 242 vec4 uniformMember; 243 } uniformBlock; 244 245 void main() 246 { 247 vec4 UniformBlock = vec4(0.0); 248 ${{OUTPUT}} = UniformBlock + uniformBlock.uniformMember; 249 }"""[1:] 250 251 repeatedBlockShaderTemplate = """ 252 #version 300 es 253 precision highp float; 254 255 ${{OUTPUT_DECLARATION}} 256 257 uniform UniformBlock 258 { 259 vec4 uniformMember; 260 } uniformBlockA; 261 262 uniform UniformBlock 263 { 264 vec4 uniformMember; 265 } uniformBlockB; 266 267 void main() 268 { 269 ${{OUTPUT}} = uniformBlockA.uniformMember + uniformBlockB.uniformMember; 270 }"""[1:] 271 272 repeatedBlockNoInstanceNameShaderTemplate = """ 273 #version 300 es 274 precision highp float; 275 276 ${{OUTPUT_DECLARATION}} 277 278 uniform UniformBlock 279 { 280 vec4 uniformMember; 281 } uniformBlock; 282 283 uniform UniformBlock 284 { 285 vec4 uniformMember; 286 }; 287 288 void main() 289 { 290 ${{OUTPUT}} = uniformBlock.uniformMember + uniformMember; 291 }"""[1:] 292 293 structMemberShaderTemplate = """ 294 #version 300 es 295 precision highp float; 296 297 ${{OUTPUT_DECLARATION}} 298 299 struct Struct 300 { 301 vec4 uniformMember; 302 }; 303 304 uniform UniformBlock 305 { 306 Struct st; 307 } uniformBlock; 308 309 void main() 310 { 311 ${{OUTPUT}} = uniformBlock.st.uniformMember; 312 }"""[1:] 313 314 layoutStructMemberQualifierShaderTemplate = """ 315 #version 300 es 316 precision highp float; 317 318 ${{OUTPUT_DECLARATION}} 319 320 struct Struct 321 { 322 vec4 uniformMember; 323 }; 324 325 uniform UniformBlock 326 { 327 layout(%s) Struct st; 328 } uniformBlock; 329 330 void main() 331 { 332 ${{OUTPUT}} = uniformBlock.st.uniformMember; 333 }"""[1:] 334 335 longIdentifierBlockNameShaderTemplate = (""" 336 #version 300 es 337 precision highp float; 338 339 ${{OUTPUT_DECLARATION}} 340 341 // Total of 1024 characters 342 uniform """ + ("a" * 1024) + """ 343 { 344 vec4 uniformMember; 345 } uniformBlock; 346 347 void main() 348 { 349 ${{OUTPUT}} = uniformBlock.uniformMember; 350 }""")[1:] 351 352 longIdentifierInstanceNameShaderTemplate = (""" 353 #version 300 es 354 precision highp float; 355 356 ${{OUTPUT_DECLARATION}} 357 358 uniform UniformBlock 359 { 360 vec4 uniformMember; 361 } """ + ("a" * 1024) + """; 362 // Total of 1024 characters 363 364 void main() 365 { 366 ${{OUTPUT}} = """ + ("a" * 1024) + """.uniformMember; 367 }""")[1:] 368 369 underscoreIdentifierInstanceNameShaderTemplate = (""" 370 #version 300 es 371 precision highp float; 372 373 ${{OUTPUT_DECLARATION}} 374 375 uniform UniformBlock 376 { 377 vec4 uniformMember; 378 } _; 379 380 void main() 381 { 382 ${{OUTPUT}} = _.uniformMember; 383 }""")[1:] 384 385 underscoreIdentifierBlockNameShaderTemplate = (""" 386 #version 300 es 387 precision highp float; 388 389 ${{OUTPUT_DECLARATION}} 390 391 uniform _ 392 { 393 vec4 uniformMember; 394 } uniformBlock; 395 396 void main() 397 { 398 ${{OUTPUT}} = uniformBlock.uniformMember; 399 }""")[1:] 400 401 validCases = (createCases("repeat_interface_qualifier", repeatShaderTemplate, True) 402 + sum([createCases("layout_%s" % qualifier, layoutQualifierShaderTemplate % qualifier, True) 403 for qualifier in ["shared", "packed", "std140", "row_major", "column_major"]], []) 404 + createCases("layout_all", layoutQualifierShaderTemplate % "shared, packed, std140, row_major, column_major", True) 405 + createCases("layout_all_8_times", layoutQualifierShaderTemplate % str.join(", ", ["shared", "packed", "std140", "row_major", "column_major"] * 8), True) 406 + sum([createCases("global_layout_%s" % qualifier, layoutGlobalQualifierShaderTemplate % qualifier, True) 407 for qualifier in ["shared", "packed", "std140", "row_major", "column_major"]], []) 408 + createCases("global_layout_all", layoutGlobalQualifierShaderTemplate % "shared, packed, std140, row_major, column_major", True) 409 + createCases("global_layout_all_8_times", layoutGlobalQualifierShaderTemplate % str.join(", ", ["shared", "packed", "std140", "row_major", "column_major"] * 8), True) 410 + sum([createCases("member_layout_%s" % qualifier, layoutMemberQualifierShaderTemplate % qualifier, True) 411 for qualifier in ["row_major", "column_major"]], []) 412 + sum([createCases("member_layout_%s_vec4" % qualifier, layoutMemberVec4QualifierShaderTemplate % qualifier, True) 413 for qualifier in ["row_major", "column_major"]], []) 414 + createCases("member_layout_all", layoutMemberQualifierShaderTemplate % "row_major, column_major", True) 415 + createCases("member_layout_all_8_times", layoutMemberQualifierShaderTemplate % str.join(", ", ["row_major", "column_major"] * 8), True) 416 + createCases("no_instance_name", noInstanceNameShaderTemplate, True) 417 + createCases("same_variable_and_block_name", sameVariableAndBlockNameShaderTemplate, True) 418 + createCases("same_variable_and_instance_name", sameVariableAndInstanceNameShaderTemplate, True) 419 + createCases("struct_member", structMemberShaderTemplate, True) 420 + sum([createCases("struct_member_layout_%s" % qualifier, layoutStructMemberQualifierShaderTemplate % qualifier, True) 421 for qualifier in ["row_major", "column_major"]], []) 422 + createCases("struct_member_layout_all", layoutStructMemberQualifierShaderTemplate % "row_major, column_major", True) 423 + createCases("struct_member_layout_all_8_times", layoutStructMemberQualifierShaderTemplate % str.join(", ", ["row_major", "column_major"] * 8), True) 424 + createCases("long_block_name", longIdentifierBlockNameShaderTemplate, True) 425 + createCases("long_instance_name", longIdentifierInstanceNameShaderTemplate, True) 426 + createCases("underscore_block_name", underscoreIdentifierBlockNameShaderTemplate, True) 427 + createCases("underscore_instance_name", underscoreIdentifierInstanceNameShaderTemplate, True)) 428 429 invalidMemberInterfaceQualifierShaderTemplate = """ 430 #version 300 es 431 precision highp float; 432 433 ${{OUTPUT_DECLARATION}} 434 435 uniform UniformBlock 436 { 437 %s vec4 uniformMember; 438 } uniformBlock; 439 440 void main() 441 { 442 ${{OUTPUT}} = uniformBlock.uniformMember; 443 }"""[1:] 444 445 conflictingInstanceNamesShaderTemplate = """ 446 #version 300 es 447 precision highp float; 448 449 ${{OUTPUT_DECLARATION}} 450 451 uniform UniformBlockA 452 { 453 vec4 uniformMember; 454 } uniformBlock; 455 456 uniform UniformBlockB 457 { 458 vec4 uniformMember; 459 } uniformBlock; 460 461 void main() 462 { 463 ${{OUTPUT}} = uniformBlock.uniformMember; 464 }"""[1:] 465 466 conflictingFunctionAndInstanceNameShaderTemplate = """ 467 #version 300 es 468 precision highp float; 469 470 ${{OUTPUT_DECLARATION}} 471 472 uniform UniformBlock 473 { 474 vec4 uniformMember; 475 } uniformBlock; 476 477 float uniformBlock (float x) 478 { 479 return x; 480 } 481 482 void main() 483 { 484 ${{OUTPUT}} = uniformBlock.uniformMember; 485 }"""[1:] 486 487 conflictingFunctionAndBlockNameShaderTemplate = """ 488 #version 300 es 489 precision highp float; 490 491 ${{OUTPUT_DECLARATION}} 492 493 uniform UniformBlock 494 { 495 vec4 uniformMember; 496 } uniformBlock; 497 498 float UniformBlock (float x) 499 { 500 return x; 501 } 502 503 void main() 504 { 505 ${{OUTPUT}} = uniformBlock.uniformMember; 506 }"""[1:] 507 508 conflictingVariableAndInstanceNameShaderTemplate = """ 509 #version 300 es 510 precision highp float; 511 512 ${{OUTPUT_DECLARATION}} 513 514 uniform UniformBlock 515 { 516 vec4 uniformMember; 517 } uniformBlock; 518 519 %s vec4 uniformBlock; 520 521 void main() 522 { 523 ${{OUTPUT}} = uniformBlock.uniformMember; 524 }"""[1:] 525 526 conflictingVariableAndBlockNameShaderTemplate = """ 527 #version 300 es 528 precision highp float; 529 530 ${{OUTPUT_DECLARATION}} 531 532 uniform UniformBlock 533 { 534 vec4 uniformMember; 535 } uniformBlock; 536 537 %s vec4 UniformBlock; 538 539 void main() 540 { 541 ${{OUTPUT}} = uniformBlock.uniformMember; 542 }"""[1:] 543 544 545 matchingInstanceAndBlockNameShaderTemplate = """ 546 #version 300 es 547 precision highp float; 548 549 ${{OUTPUT_DECLARATION}} 550 551 uniform UniformBlock 552 { 553 vec4 uniformMember; 554 } UniformBlock; 555 556 void main() 557 { 558 ${{OUTPUT}} = UniformBlock.uniformMember; 559 }"""[1:] 560 561 referenceUsingBlockNameShaderTemplate = """ 562 #version 300 es 563 precision highp float; 564 565 ${{OUTPUT_DECLARATION}} 566 567 uniform UniformBlock 568 { 569 vec4 uniformMember; 570 } uniformBlock; 571 572 void main() 573 { 574 ${{OUTPUT}} = UniformBlock.uniformMember; 575 }"""[1:] 576 577 emptyBlockShaderTemplate = """ 578 #version 300 es 579 precision highp float; 580 581 ${{OUTPUT_DECLARATION}} 582 583 uniform UniformBlock 584 { 585 } uniformBlock; 586 587 void main() 588 { 589 ${{OUTPUT}} = vec4(0.0); 590 }"""[1:] 591 592 emptyLayoutShaderTemplate = """ 593 #version 300 es 594 precision highp float; 595 596 ${{OUTPUT_DECLARATION}} 597 598 layout() uniform UniformBlock 599 { 600 vec4 uniformMember; 601 } uniformBlock; 602 603 void main() 604 { 605 ${{OUTPUT}} = uniformBlock.uniformMember; 606 }"""[1:] 607 608 emptyGlobalLayoutShaderTemplate = """ 609 #version 300 es 610 precision highp float; 611 612 layout() uniform; 613 614 ${{OUTPUT_DECLARATION}} 615 616 uniform UniformBlock 617 { 618 vec4 uniformMember; 619 } uniformBlock; 620 621 void main() 622 { 623 ${{OUTPUT}} = uniformBlock.uniformMember; 624 }"""[1:] 625 626 emptyMemberLayoutShaderTemplate = """ 627 #version 300 es 628 precision highp float; 629 630 ${{OUTPUT_DECLARATION}} 631 632 uniform UniformBlock 633 { 634 layout() vec4 uniformMember; 635 } uniformBlock; 636 637 void main() 638 { 639 ${{OUTPUT}} = uniformBlock.uniformMember; 640 }"""[1:] 641 642 invalidMemberLayoutShaderTemplate = """ 643 #version 300 es 644 precision highp float; 645 646 ${{OUTPUT_DECLARATION}} 647 648 uniform UniformBlock 649 { 650 layout(%s) vec4 uniformMember; 651 } uniformBlock; 652 653 void main() 654 { 655 ${{OUTPUT}} = uniformBlock.uniformMember; 656 }"""[1:] 657 658 structureDefinitionShaderTemplate = """ 659 #version 300 es 660 precision highp float; 661 662 ${{OUTPUT_DECLARATION}} 663 664 uniform UniformBlock 665 { 666 struct A 667 { 668 vec4 uniformMember; 669 } a; 670 } uniformBlock; 671 672 void main() 673 { 674 ${{OUTPUT}} = uniformBlock.a.uniformMember; 675 }"""[1:] 676 677 samplerShaderTemplate = """ 678 #version 300 es 679 precision highp float; 680 681 ${{OUTPUT_DECLARATION}} 682 683 uniform UniformBlock 684 { 685 sampler2D sampler; 686 vec4 uniformMember; 687 } uniformBlock; 688 689 void main() 690 { 691 ${{OUTPUT}} = uniformBlock.uniformMember; 692 }"""[1:] 693 694 missingBlockNameShaderTemplate = """ 695 #version 300 es 696 precision highp float; 697 698 ${{OUTPUT_DECLARATION}} 699 700 uniform 701 { 702 vec4 uniformMember; 703 } uniformBlock; 704 705 void main() 706 { 707 ${{OUTPUT}} = uniformBlock.uniformMember; 708 }"""[1:] 709 710 invalidNumberBlockNameShaderTemplate = """ 711 #version 300 es 712 precision highp float; 713 714 ${{OUTPUT_DECLARATION}} 715 716 uniform 0UniformBlock 717 { 718 vec4 uniformMember; 719 } uniformBlock; 720 721 void main() 722 { 723 ${{OUTPUT}} = uniformBlock.uniformMember; 724 }"""[1:] 725 726 invalidHashBlockNameShaderTemplate = """ 727 #version 300 es 728 precision highp float; 729 730 ${{OUTPUT_DECLARATION}} 731 732 uniform #UniformBlock 733 { 734 vec4 uniformMember; 735 } uniformBlock; 736 737 void main() 738 { 739 ${{OUTPUT}} = uniformBlock.uniformMember; 740 }"""[1:] 741 742 invalidDollarBlockNameShaderTemplate = """ 743 #version 300 es 744 precision highp float; 745 746 ${{OUTPUT_DECLARATION}} 747 748 uniform $UniformBlock 749 { 750 vec4 uniformMember; 751 } uniformBlock; 752 753 void main() 754 { 755 ${{OUTPUT}} = uniformBlock.uniformMember; 756 }"""[1:] 757 758 invalidIdentifierBlockNameShaderTemplate = """ 759 #version 300 es 760 precision highp float; 761 762 ${{OUTPUT_DECLARATION}} 763 764 uniform gl_UniformBlock 765 { 766 vec4 uniformMember; 767 } uniformBlock; 768 769 void main() 770 { 771 ${{OUTPUT}} = uniformBlock.uniformMember; 772 }"""[1:] 773 774 tooLongIdentifierBlockNameShaderTemplate = (""" 775 #version 300 es 776 precision highp float; 777 778 ${{OUTPUT_DECLARATION}} 779 780 // Total of 1025 characters 781 uniform """ + ("a" * 1025) + """ 782 { 783 vec4 uniformMember; 784 } uniformBlock; 785 786 void main() 787 { 788 ${{OUTPUT}} = uniformBlock.uniformMember; 789 }""")[1:] 790 791 invalidNumberInstanceNameShaderTemplate = """ 792 #version 300 es 793 precision highp float; 794 795 ${{OUTPUT_DECLARATION}} 796 797 uniform UniformInstance 798 { 799 vec4 uniformMember; 800 } 0uniformBlock; 801 802 void main() 803 { 804 ${{OUTPUT}} = 0uniformBlock.uniformMember; 805 }"""[1:] 806 807 invalidHashInstanceNameShaderTemplate = """ 808 #version 300 es 809 precision highp float; 810 811 ${{OUTPUT_DECLARATION}} 812 813 uniform UniformInstance 814 { 815 vec4 uniformMember; 816 } #uniformBlock; 817 818 void main() 819 { 820 ${{OUTPUT}} = #uniformBlock.uniformMember; 821 }"""[1:] 822 823 invalidDollarInstanceNameShaderTemplate = """ 824 #version 300 es 825 precision highp float; 826 827 ${{OUTPUT_DECLARATION}} 828 829 uniform UniformInstance 830 { 831 vec4 uniformMember; 832 } $uniformBlock; 833 834 void main() 835 { 836 ${{OUTPUT}} = $uniformBlock.uniformMember; 837 }"""[1:] 838 839 invalidIdentifierInstanceNameShaderTemplate = """ 840 #version 300 es 841 precision highp float; 842 843 ${{OUTPUT_DECLARATION}} 844 845 uniform UniformBlock 846 { 847 vec4 uniformMember; 848 } gl_uniformBlock; 849 850 void main() 851 { 852 ${{OUTPUT}} = gl_uniformBlock.uniformMember; 853 }"""[1:] 854 855 tooLongIdentifierInstanceNameShaderTemplate = (""" 856 #version 300 es 857 precision highp float; 858 859 ${{OUTPUT_DECLARATION}} 860 861 uniform UniformBlock 862 { 863 vec4 uniformMember; 864 } """ + ("a" * 1025) + """; 865 // Total of 1025 characters 866 867 void main() 868 { 869 ${{OUTPUT}} = """ + ("a" * 1025) + """.uniformMember; 870 }""")[1:] 871 872 invalidCases = ( 873 sum([createCases("member_%s_interface_qualifier" % qualifier, invalidMemberInterfaceQualifierShaderTemplate % qualifier, False) 874 for qualifier in ["in", "out", "buffer", "attribute", "varying"]], []) 875 + createCases("conflicting_instance_names", conflictingInstanceNamesShaderTemplate, False) 876 + createCases("conflicting_function_and_instance_name", conflictingFunctionAndInstanceNameShaderTemplate, False) 877 + createCases("conflicting_function_and_block_name", conflictingFunctionAndBlockNameShaderTemplate, False) 878 + sum([createCases("conflicting_%s_and_instance_name" % qualifier, conflictingVariableAndInstanceNameShaderTemplate % qualifier, False) 879 for qualifier in ["uniform", "in", "out"]], []) 880 + sum([createCases("conflicting_%s_and_block_name" % qualifier, conflictingVariableAndBlockNameShaderTemplate % qualifier, False) 881 for qualifier in ["uniform", "in", "out"]], []) 882 + createCases("matching_instance_and_block_name", matchingInstanceAndBlockNameShaderTemplate, False) 883 + createCases("reference_using_block_name", referenceUsingBlockNameShaderTemplate, False) 884 + createCases("empty_block", emptyBlockShaderTemplate, False) 885 + createCases("empty_layout", emptyLayoutShaderTemplate, False) 886 + createCases("empty_member_layout", emptyMemberLayoutShaderTemplate, False) 887 + createCases("empty_global_layout", emptyGlobalLayoutShaderTemplate, False) 888 + createCases("structure_definition", structureDefinitionShaderTemplate, False) 889 + sum([createCases("member_layout_%s" % qualifier, invalidMemberLayoutShaderTemplate % qualifier, False) 890 for qualifier in ["shared", "packed", "std140"]], []) 891 + createCases("missing_block_name", missingBlockNameShaderTemplate, False) 892 + createCases("invalid_number_block_name", invalidNumberBlockNameShaderTemplate, False) 893 + createCases("invalid_hash_block_name", invalidHashBlockNameShaderTemplate, False) 894 + createCases("invalid_dollar_block_name", invalidDollarBlockNameShaderTemplate, False) 895 + createCases("invalid_identifier_block_name", invalidIdentifierBlockNameShaderTemplate, False) 896 + createCases("too_long_block_name", tooLongIdentifierBlockNameShaderTemplate, False) 897 + createCases("invalid_number_instance_name", invalidNumberInstanceNameShaderTemplate, False) 898 + createCases("invalid_hash_instance_name", invalidDollarInstanceNameShaderTemplate, False) 899 + createCases("invalid_dollar_instance_name", invalidDollarInstanceNameShaderTemplate, False) 900 + createCases("invalid_identifier_instance_name", invalidIdentifierInstanceNameShaderTemplate, False) 901 + createCases("repeated_block", repeatedBlockShaderTemplate, False) 902 + createCases("repeated_block_no_instance_name", repeatedBlockNoInstanceNameShaderTemplate, False) 903 ) 904 905 allCases.append(CaseGroup("valid", "Valid uniform interface block syntax tests.", validCases)) 906 allCases.append(CaseGroup("invalid", "Invalid uniform interface block syntax tests.", invalidCases)) 907 908 if __name__ == "__main__": 909 print "Generating shader case files." 910 writeAllCases("uniform_block.test", allCases) 911
