$('#all-scenarios').addClass('btn-outline-primary').removeClass('btn-primary')
    refreshCards(['FAILED', 'REGRESSED', 'UNKNOWN'])
}

function allScenarioButtonClicked() {
    $('[data-toggle="popover"]').popover('hide')
    $('#all-scenarios').removeClass('btn-outline-primary').addClass('btn-primary')
    $('#failed-scenarios').addClass('btn-outline-danger').removeClass('btn-danger')

        when:
        def cl = new GroovyClassLoader()
        addClass(cl, "@${Managed.name} interface Thing1 {}")
        addClass(cl, "@${Managed.name} interface Thing2 {}")
        addClass(cl, "@${Managed.name} interface Container1 { ${ModelSet.name}<Thing1> getThings() }")
        addClass(cl, "@${Managed.name} interface Container2 { ${ModelSet.name}<Thing2> getThings() }")

        then:

  add_pass(mlir::CreateFunctionalToExecutorDialectConversionPass());
  add_pass(mlir::TFDevice::CreateReplicateToIslandPass(
      /*legacy_graph_export=*/true));
  add_pass(mlir::TFDevice::CreateReplicaIDToDeviceOrdinalPass());
  add_pass(mlir::TFDevice::CreateParallelExecuteToIslandsPass(
      /*legacy_graph_export=*/true));
  add_pass(mlir::TFDevice::CreateLaunchToDeviceAttributePass(

        ClassTestResults classResults = addClass(classId, className, classDisplayName);
        return addTest(classResults.addTest(testName, testDisplayName, duration));
    }

    public ClassTestResults addClass(long classId, String className) {
        return addClass(classId, className, className);
    }

    public ClassTestResults addClass(long classId, String className, String classDisplayName) {

                        }
                    });
                }
                e.addClass(id);
                for (var i = startCol; i < endCol; i++) {
                    slices[i] = id;
                }
            });
        } else {
            row.find("td,th").each(function(index){
                $(this).addClass(slices[index]);
            })
        }
    });

    // Add alternate row styles for tables

        in eager mode.
    *   Callbacks are supported in `MultiWorkerMirroredStrategy`.
    *   Disable `run_eagerly` and distribution strategy if there are symbolic
        tensors added to the model using `add_metric` or `add_loss`.
    *   Loss and gradients should now more reliably be correctly scaled w.r.t.
        the global batch size when using a `tf.distribute.Strategy`.

        HasOneSource | true
        IsASource    | true
    }

    def "does not hold strong reference"() {
        given:
        def cl = new GroovyClassLoader(getClass().classLoader)
        addClass(cl, impl)

        expect:
        detector.cache.size() == 1

        when:
        cl.clearCache()

        then:
        ConcurrentTestUtil.poll(10) {
            System.gc()

        return addTestClass(classId, className, className);
    }

    public ClassTestResults addTestClass(long classId, String className, String classDisplayName) {
        return addPackageForClass(className).addClass(classId, className, classDisplayName);
    }

    private PackageTestResults addPackageForClass(String className) {
        String packageName = StringUtils.substringBeforeLast(className, ".");

            HashCode classFileHash = getHashCode(fileDetails);

            try {
                ClassAnalysis analysis = maybeStripToAbi(analyzer.getClassAnalysis(classFileHash, fileDetails));
                accumulator.addClass(analysis, classFileHash);
            } catch (Exception e) {
                accumulator.fullRebuildNeeded(fileDetails.getName() + " could not be analyzed for incremental compilation. See the debug log for more details");