external/vulkancts/data/vulkan/amber/graphicsfuzz/index.txt

   1 {       "access-new-vector-inside-if-condition.amber",  "access-new-vector-inside-if-condition","A shader that accesses a new vector within an if condition"                                                    },
   2 {       "always-false-if-in-do-while.amber",                    "always-false-if-in-do-while",                  "A fragment shader with an always false if."                                                                                    },
   3 {       "always-false-if-with-discard-return.amber",    "always-false-if-with-discard-return",  "A fragment shader with discard keyword and a return"                                                                   },
   4 {       "barrier-in-loop-with-break.amber",                             "barrier-in-loop-with-break",                   "A compute shader with a barrier in a loop with a break"                                                                },
   5 {       "call-if-while-switch.amber",                                   "call-if-while-switch",                                 "A fragment shader with a call, if, while, switch"                                                                              },
   6 {       "color-write-in-loop.amber",                                    "color-write-in-loop",                                  "A fragment shader that writes to color in a loop"                                                                              },
   7 {       "complex-nested-loops-and-call.amber",                  "complex-nested-loops-and-call",                "A fragment shader with complex nested loops, breaks, etc."                                                             },
   8 {       "conditional-return-in-infinite-while.amber",   "conditional-return-in-infinite-while", "A shader with conditional return inside an infinite loop"                                                              },
   9 {       "continue-and-merge.amber",                                             "continue-and-merge",                                   "A fragment shader with two nested loops"                                                                                               },
  10 {       "control-flow-in-function.amber",                               "control-flow-in-function",                             "A fragment shader with a lot of control flow"                                                                                  },
  11 {       "control-flow-switch.amber",                                    "control-flow-switch",                                  "A fragment shader with somewhat complex control flow and a switch"                                             },
  12 {       "dead-barriers-in-loops.amber",                                 "dead-barriers-in-loops",                               "A compute shader with dead barriers"                                                                                                   },
  13 {       "dead-struct-init.amber",                                               "dead-struct-init",                                             "A fragment shader that uses struct initializers"                                                                               },
  14 {       "disc-and-add-in-func-in-loop.amber",                   "disc-and-add-in-func-in-loop",                 "A fragment shader with discard and add in function in loop"                                                    },
  15 {       "discard-continue-return.amber",                                "discard-continue-return",                              "A fragment shader with a discard, continue, and return"                                                                },
  16 {       "discard-in-array-manipulating-loop.amber",             "discard-in-array-manipulating-loop",   "An array-manipulating fragment shader with a discard"                                                                  },
  17 {       "do-while-loop-in-conditionals.amber",                  "do-while-loop-in-conditionals",                "A fragment shader with do-while loop in conditional nest"                                                              },
  18 {       "do-while-with-always-true-if.amber",                   "do-while-with-always-true-if",                 "A fragment shader with a do while that always returns"                                                                 },
  19 {       "early-return-and-barrier.amber",                               "early-return-and-barrier",                             "A compute shader with an early return and a barrier"                                                                   },
  20 {       "for-condition-always-false.amber",                             "for-condition-always-false",                   "A fragment shader that uses a for loop with condition always false"                                    },
  21 {       "for-loop-with-return.amber",                                   "for-loop-with-return",                                 "A fragment shader with a for loop that loops only once"                                                                },
  22 {       "for-with-ifs-and-return.amber",                                "for-with-ifs-and-return",                              "A fragment shader with two ifs and return/continue inside a for loop"                                  },
  23 {       "fragcoord-control-flow.amber",                                 "fragcoord-control-flow",                               "A fragment shader that uses FragCoord and somewhat complex control flow"                               },
  24 {       "fragcoord-control-flow-2.amber",                               "fragcoord-control-flow-2",                             "A fragment shader that uses FragCoord and somewhat complex control flow"                               },
  25 {       "if-and-switch.amber",                                                  "if-and-switch",                                                "A fragment shader with a switch and some data flow"                                                                    },
  26 {       "loop-call-discard.amber",                                              "loop-call-discard",                                    "A fragment shader with nested loops and a function call"                                                               },
  27 {       "loop-dead-if-loop.amber",                                              "loop-dead-if-loop",                                    "A fragment shader with a loop, dead if, and a loop"                                                                    },
  28 {       "loop-nested-ifs.amber",                                                "loop-nested-ifs",                                              "A fragment shader with a for loop containing nested ifs"                                                               },
  29 {       "loops-breaks-returns.amber",                                   "loops-breaks-returns",                                 "A compute shader with loops, breaks, returns"                                                                                  },
  30 {       "loops-ifs-continues-call.amber",                               "loops-ifs-continues-call",                             "A fragment shader with nested control flow and a call"                                                                 },
  31 {       "mat-array-deep-control-flow.amber",                    "mat-array-deep-control-flow",                  "A fragment shader that uses an array of matrices and has deep control flow"                    },
  32 {       "mat-array-distance.amber",                                             "mat-array-distance",                                   "A fragment shader that uses an array of matrices and distance"                                                 },
  33 {       "matrices-and-return-in-loop.amber",                    "matrices-and-return-in-loop",                  "A fragment shader with matrices and a return in a loop"                                                                },
  34 {       "max-mix-conditional-discard.amber",                    "max-mix-conditional-discard",                  "A fragment shader with an expression used in two discard guards"                                               },
  35 {       "mix-floor-add.amber",                                                  "mix-floor-add",                                                "A fragment shader with mix, uintBitsToFloat, and floor"                                                                },
  36 {       "nested-for-loops-with-return.amber",                   "nested-for-loops-with-return",                 "A fragment shader with two nested for loops with return"                                                               },
  37 {       "nested-ifs-and-return-in-for-loop.amber",              "nested-ifs-and-return-in-for-loop",    "A fragment shader with return in nest of ifs, inside loop"                                                             },
  38 {       "nested-loops-switch.amber",                                    "nested-loops-switch",                                  "A fragment shader with nested loops and a switch"                                                                              },
  39 {       "pow-vec4.amber",                                                               "pow-vec4",                                                             "A fragment shader that uses pow"                                                                                                               },
  40 {       "return-before-writing-wrong-color.amber",              "return-before-writing-wrong-color",    "A fragment shader with return before writing wrong color"                                                              },
  41 {       "return-float-from-while-loop.amber",                   "return-float-from-while-loop",                 "A fragment shader with unreachable while loop"                                                                                 },
  42 {       "return-in-loop-in-function.amber",                             "return-in-loop-in-function",                   "A fragment shader with early return from loop in function"                                                             },
  43 {       "returned-boolean-in-vector.amber",                             "returned-boolean-in-vector",                   "A fragment shader with returned boolean in vector"                                                                             },
  44 {       "similar-nested-ifs.amber",                                             "similar-nested-ifs",                                   "A fragment shader with similar nested ifs and loops"                                                                   },
  45 {       "struct-used-as-temporary.amber",                               "struct-used-as-temporary",                             "A fragment shader that uses a temporary struct variable"                                                               },
  46 {       "switch-if-discard.amber",                                              "switch-if-discard",                                    "A fragment shader with a switch, if, and discard"                                                                              },
  47 {       "switch-with-empty-if-false.amber",                             "switch-with-empty-if-false",                   "A fragment shader with always false if in switch statement"                                                    },
  48 {       "swizzle-struct-init-min.amber",                                "swizzle-struct-init-min",                              "A fragment shader that uses vector swizzles, struct initializers, and min"                             },
  49 {       "two-for-loops-with-barrier-function.amber",    "two-for-loops-with-barrier-function",  "A compute shader with two barrier functions"                                                                                   },
  50 {       "two-loops-matrix.amber",                                               "two-loops-matrix",                                             "A fragment shader with two loops and some matrices"                                                                    },
  51 {       "two-loops-set-struct.amber",                                   "two-loops-set-struct",                                 "A fragment shader with two loops that write to a struct"                                                               },
  52 {       "two-loops-with-break.amber",                                   "two-loops-with-break",                                 "A fragment shader with two loops with breaks"                                                                                  },
  53 {       "two-nested-do-whiles.amber",                                   "two-nested-do-whiles",                                 "A fragment shader with nested do while"                                                                                                },
  54 {       "two-nested-for-loops-with-returns.amber",              "two-nested-for-loops-with-returns",    "A compute shader with two nested for loops"                                                                                    },
  55 {       "two-nested-infinite-loops-discard.amber",              "two-nested-infinite-loops-discard",    "A fragment shader with an always false if function"                                                                    },
  56 {       "undefined-integer-in-function.amber",                  "undefined-integer-in-function",                "A fragment shader with nested do while and undefined int"                                                              },
  57 {       "uninitialized-var-decrement-and-add.amber",    "uninitialized-var-decrement-and-add",  "A fragment shader that uses an uninitialized variable"                                                                 },
  58 {       "undefined-assign-in-infinite-loop.amber",              "undefined-assign-in-infinite-loop",    "A fragment shader with uninitialized read in infinite loop"                                                    },
  59 {       "unreachable-barrier-in-loops.amber",                   "unreachable-barrier-in-loops",                 "A compute shader with an unreachable barrier in a loop nest"                                                   },
  60 {       "unreachable-continue-statement.amber",                 "unreachable-continue-statement",               "A fragment shader with unreachable continue statement"                                                                 },
  61 {       "unreachable-discard-statement-in-if.amber",    "unreachable-discard-statement-in-if",  "A fragment shader with discard keyword and a return"                                                                   },
  62 {       "unreachable-discard-statement.amber",                  "unreachable-discard-statement",                "A fragment shader with unreachable discard statement"                                                                  },
  63 {       "unreachable-loops.amber",                                              "unreachable-loops",                                    "Fragment shader that writes red despite unreachable loops"                                                             },
  64 {       "unreachable-loops-in-switch.amber",                    "unreachable-loops-in-switch",                  "A fragment shader with unreachable loops in a switch"                                                                  },
  65 {       "unreachable-return-in-loop.amber",                             "unreachable-return-in-loop",                   "A fragment shader with an unreachable return in a loop"                                                                },
  66 {       "while-function-always-false.amber",                    "while-function-always-false",                  "A fragment shader with an always false while function"                                                                 },
  67 {       "while-inside-switch.amber",                                    "while-inside-switch",                                  "A fragment shader that uses a while loop inside a switch"                                                              },
  68 {       "write-before-break.amber",                                             "write-before-break",                                   "Fragment shader that writes red before loop break"                                                                             },
  69 {       "write-red-in-loop-nest.amber",                                 "write-red-in-loop-nest",                               "A fragment shader that writes red in a nest of loops"                                                                  },
  70 {       "wrong-color-in-always-false-if.amber",                 "wrong-color-in-always-false-if",               "A fragment shader with wrong color write in false if"                                                                  },