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