<!--
Copyright (c) 2019 The Khronos Group Inc.
Use of this source code is governed by an MIT-style license that can be
found in the LICENSE.txt file.
-->

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>WebGL 2 EXT_disjoint_timer_query_webgl2 Conformance Tests</title>
<link rel="stylesheet" href="../../resources/js-test-style.css"/>
<script src="../../js/js-test-pre.js"></script>
<script src="../../js/webgl-test-utils.js"></script>
</head>
<body>
<div id="description"></div>
<canvas id="canvas" style="width: 50px; height: 50px;"> </canvas>
<div id="console"></div>

<script>
"use strict";
description("This test verifies the functionality of the EXT_disjoint_timer_query_webgl2 extension, if it is available.");

var wtu = WebGLTestUtils;
var canvas = document.getElementById("canvas");
var gl = wtu.create3DContext(canvas, null, 2);
var ext = null;
var query = null;
var query2 = null;
var elapsed_query = null;
var timestamp_query1 = null;
var timestamp_query2 = null;
var availability_retry = 500;
var timestamp_counter_bits = 0;

if (!gl) {
    testFailed("WebGL context does not exist");
    finishTest();
} else {
    testPassed("WebGL context exists");

    // Query the extension and store globally so shouldBe can access it
    ext = wtu.getExtensionWithKnownPrefixes(gl, "EXT_disjoint_timer_query_webgl2");
    if (!ext) {
        testPassed("No EXT_disjoint_timer_query_webgl2 support -- this is legal");
        finishTest();
    } else {
        runSanityTests();
        wtu.glErrorShouldBe(gl, gl.NO_ERROR);

        // Clear disjoint value.
        gl.getParameter(ext.GPU_DISJOINT_EXT);
        wtu.glErrorShouldBe(gl, gl.NO_ERROR);

        runElapsedTimeTest();
        wtu.glErrorShouldBe(gl, gl.NO_ERROR);

        timestamp_counter_bits = gl.getQuery(ext.TIMESTAMP_EXT, ext.QUERY_COUNTER_BITS_EXT);
        if (timestamp_counter_bits > 0) {
            runTimeStampTest();
            wtu.glErrorShouldBe(gl, gl.NO_ERROR);
        }
        verifyQueryResultsNotAvailable();
        wtu.glErrorShouldBe(gl, gl.NO_ERROR);

        window.requestAnimationFrame(checkQueryResults);
    }
}

function runSanityTests() {
    debug("");
    debug("Testing other query types");
    query = gl.createQuery();
    gl.beginQuery(gl.ANY_SAMPLES_PASSED, query);
    shouldBeTrue("gl.getQuery(gl.ANY_SAMPLES_PASSED, gl.CURRENT_QUERY) !== null");
    gl.endQuery(gl.ANY_SAMPLES_PASSED);
    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "enabling EXT_disjoint_timer_query_webgl2 should not break other queries");

    debug("");
    debug("Testing timer query expectations");

    shouldBe("ext.QUERY_COUNTER_BITS_EXT", "0x8864");
    shouldBe("ext.TIME_ELAPSED_EXT", "0x88BF");
    shouldBe("ext.TIMESTAMP_EXT", "0x8E28");
    shouldBe("ext.GPU_DISJOINT_EXT", "0x8FBB");

    shouldBe("gl.isQuery(null)", "false");

    shouldBeTrue("gl.getQuery(ext.TIME_ELAPSED_EXT, gl.CURRENT_QUERY) === null");
    wtu.glErrorShouldBe(gl, gl.NO_ERROR);
    shouldBeTrue("gl.getQuery(ext.TIME_ELAPSED_EXT, ext.QUERY_COUNTER_BITS_EXT) >= 30");
    wtu.glErrorShouldBe(gl, gl.NO_ERROR);

    shouldBeTrue("gl.getQuery(ext.TIMESTAMP_EXT, gl.CURRENT_QUERY) === null");
    wtu.glErrorShouldBe(gl, gl.NO_ERROR);

    // Certain drivers set timestamp counter bits to 0 as they don't support timestamps
    shouldBeTrue("gl.getQuery(ext.TIMESTAMP_EXT, ext.QUERY_COUNTER_BITS_EXT) >= 30 || " +
                 "gl.getQuery(ext.TIMESTAMP_EXT, ext.QUERY_COUNTER_BITS_EXT) === 0");
    wtu.glErrorShouldBe(gl, gl.NO_ERROR);

    debug("");
    debug("Testing time elapsed query lifecycle");
    query = gl.createQuery();
    shouldBe("gl.isQuery(query)", "false");
    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "Query creation must succeed.");
    gl.beginQuery(ext.TIMESTAMP_EXT, query);
    wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "Beginning a timestamp query should fail.");
    gl.beginQuery(ext.TIME_ELAPSED_EXT, query);
    shouldBe("gl.isQuery(query)", "true");
    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "Beginning an inactive time elapsed query should succeed.");
    gl.beginQuery(ext.TIME_ELAPSED_EXT, query);
    wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "Attempting to begin an active query should fail.");
    gl.getQueryParameter(query, gl.QUERY_RESULT_AVAILABLE);
    wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "Fetching query result availability of an active query should fail.");
    gl.getQueryParameter(query, gl.QUERY_RESULT_EXT);
    wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "Fetching query result of an active query should fail.");
    shouldBe("gl.getQuery(ext.TIME_ELAPSED_EXT, gl.CURRENT_QUERY)", "query");
    gl.endQuery(ext.TIME_ELAPSED_EXT);
    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "Ending an active time elapsed query should succeed.");
    gl.getQueryParameter(query, gl.QUERY_RESULT_AVAILABLE);
    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "Fetching query result availability after query end should succeed.");
    gl.endQuery(ext.TIME_ELAPSED_EXT);
    wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "Attempting to end an inactive query should fail.");
    ext.queryCounterEXT(query, ext.TIMESTAMP_EXT);
    wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "Should not be able to use time elapsed query to store a timestamp.");
    gl.deleteQuery(query);
    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "Query deletion must succeed.");
    gl.beginQuery(ext.TIME_ELAPSED_EXT, query);
    wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "Beginning a deleted query must fail.");
    gl.getQueryParameter(query, gl.QUERY_RESULT_AVAILABLE);
    wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "Fetching query result availability after query deletion should fail.");
    shouldBe("gl.isQuery(query)", "false");

    debug("");
    debug("Testing timestamp counter");
    query = gl.createQuery();
    shouldThrow("ext.queryCounterEXT(null, ext.TIMESTAMP_EXT)");
    ext.queryCounterEXT(query, ext.TIMESTAMP_EXT);
    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "Timestamp counter queries should work.");
    gl.deleteQuery(query);
    wtu.glErrorShouldBe(gl, gl.NO_ERROR);

    debug("");
    debug("Performing parameter sanity checks");
    gl.getParameter(ext.TIMESTAMP_EXT);
    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "getParameter timestamp calls should work.");
    gl.getParameter(ext.GPU_DISJOINT_EXT);
    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "getParameter disjoint calls should work.");

    debug("");
    debug("Testing current query conditions");
    query = gl.createQuery();
    query2 = gl.createQuery();
    shouldBe("gl.getQuery(ext.TIME_ELAPSED_EXT, gl.CURRENT_QUERY)", "null");
    gl.beginQuery(ext.TIME_ELAPSED_EXT, query);
    shouldBe("gl.getQuery(ext.TIME_ELAPSED_EXT, gl.CURRENT_QUERY)", "query");
    wtu.glErrorShouldBe(gl, gl.NO_ERROR);

    debug("");
    debug("Testing failed begin query should not change the current query.");
    gl.beginQuery(ext.TIME_ELAPSED_EXT, query2);
    wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "Beginning an elapsed query without ending should fail.");
    shouldBe("gl.getQuery(ext.TIME_ELAPSED_EXT, gl.CURRENT_QUERY)", "query");
    wtu.glErrorShouldBe(gl, gl.NO_ERROR);

    debug("");
    debug("Testing beginning a timestamp query is invalid and should not change the elapsed query.");
    gl.beginQuery(ext.TIMESTAMP_EXT, query2)
    wtu.glErrorShouldBe(gl, gl.INVALID_ENUM);
    shouldBe("gl.getQuery(ext.TIME_ELAPSED_EXT, gl.CURRENT_QUERY)", "query");
    wtu.glErrorShouldBe(gl, gl.NO_ERROR);

    debug("");
    debug("Testing timestamp queries end immediately so are never current.");
    ext.queryCounterEXT(query2, ext.TIMESTAMP_EXT);
    shouldBe("gl.getQuery(ext.TIMESTAMP_EXT, gl.CURRENT_QUERY)", "null");
    wtu.glErrorShouldBe(gl, gl.NO_ERROR);

    debug("");
    debug("Testing ending the query should clear the current query.");
    gl.endQuery(ext.TIME_ELAPSED_EXT);
    shouldBe("gl.getQuery(ext.TIME_ELAPSED_EXT, gl.CURRENT_QUERY)", "null");
    wtu.glErrorShouldBe(gl, gl.NO_ERROR);

    debug("");
    debug("Testing beginning a elapsed query using a timestamp query should fail and not affect current query.")
    gl.beginQuery(ext.TIME_ELAPSED_EXT, query2);
    wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "Switching query targets should fail.");
    shouldBe("gl.getQuery(ext.TIME_ELAPSED_EXT, gl.CURRENT_QUERY)", "null");
    wtu.glErrorShouldBe(gl, gl.NO_ERROR);

    gl.deleteQuery(query);
    gl.deleteQuery(query2);

    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "Should be no errors at end of sanity tests");
}

function runElapsedTimeTest() {
    debug("");
    debug("Testing elapsed time query");

    elapsed_query = gl.createQuery();
    gl.beginQuery(ext.TIME_ELAPSED_EXT, elapsed_query);
    gl.clearColor(0, 0, 1, 1);
    gl.clear(gl.COLOR_BUFFER_BIT);
    gl.endQuery(ext.TIME_ELAPSED_EXT);
    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "Time elapsed query should have no errors");
}

function runTimeStampTest() {
    debug("");
    debug("Testing timestamp query");

    timestamp_query1 = gl.createQuery();
    timestamp_query2 = gl.createQuery();
    ext.queryCounterEXT(timestamp_query1, ext.TIMESTAMP_EXT);
    gl.clearColor(1, 0, 0, 1);
    gl.clear(gl.COLOR_BUFFER_BIT);
    ext.queryCounterEXT(timestamp_query2, ext.TIMESTAMP_EXT);
    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "Timestamp queries should have no errors");
}

function verifyQueryResultsNotAvailable() {
    debug("");
    debug("Verifying queries' results don't become available too early");

    // Verify as best as possible that the implementation doesn't
    // allow a query's result to become available the same frame, by
    // spin-looping for some time and ensuring that none of the
    // queries' results become available.
    var startTime = Date.now();
    while (Date.now() - startTime < 2000) {
        gl.finish();
        if (gl.getQueryParameter(elapsed_query, gl.QUERY_RESULT_AVAILABLE)) {
            testFailed("One of the queries' results became available too early");
            return;
        }
        if (timestamp_counter_bits > 0) {
            if (gl.getQueryParameter(timestamp_query1, gl.QUERY_RESULT_AVAILABLE) ||
                gl.getQueryParameter(timestamp_query2, gl.QUERY_RESULT_AVAILABLE)) {
                testFailed("One of the queries' results became available too early");
                return;
            }
        }
    }

    testPassed("Queries' results didn't become available in a spin loop");
}

function checkQueryResults() {
    if (availability_retry > 0) {
        // Make a reasonable attempt to wait for the queries' results to become available.
        if (!gl.getQueryParameter(elapsed_query, gl.QUERY_RESULT_AVAILABLE) ||
            (timestamp_counter_bits > 0 && !gl.getQueryParameter(timestamp_query2, gl.QUERY_RESULT_AVAILABLE))) {
            var error = gl.getError();
            if (error != gl.NO_ERROR) {
                testFailed("getQueryParameter should have no errors: " + wtu.glEnumToString(gl, error));
                debug("");
                finishTest();
                return;
            }
            availability_retry--;
            window.requestAnimationFrame(checkQueryResults);
            return;
        }
    }

    debug("");
    debug("Testing query results");

    // Make sure queries are available.
    shouldBe("gl.getQueryParameter(elapsed_query, gl.QUERY_RESULT_AVAILABLE)", "true");
    if (timestamp_counter_bits > 0) {
        shouldBe("gl.getQueryParameter(timestamp_query1, gl.QUERY_RESULT_AVAILABLE)", "true");
        shouldBe("gl.getQueryParameter(timestamp_query2, gl.QUERY_RESULT_AVAILABLE)", "true");
    }

    var disjoint_value = gl.getParameter(ext.GPU_DISJOINT_EXT);
    if (disjoint_value) {
        // Cannot validate results make sense, but this is okay.
        testPassed("Disjoint triggered.");
    } else {
        var elapsed_result = gl.getQueryParameter(elapsed_query, gl.QUERY_RESULT_EXT);
        if (timestamp_counter_bits > 0) {
            var timestamp_result1 = gl.getQueryParameter(timestamp_query1, gl.QUERY_RESULT_EXT);
            var timestamp_result2 = gl.getQueryParameter(timestamp_query2, gl.QUERY_RESULT_EXT);
        }
        // Do some basic validity checking of the elapsed time query. There's no way it should
        // take more than about half a second for a no-op query.
        var halfSecondInNanos = 0.5 * 1000 * 1000 * 1000;
        if (elapsed_result < 0 || elapsed_result > halfSecondInNanos) {
            testFailed("Time elapsed query returned invalid data: " + elapsed_result);
        } else {
            testPassed("Time elapsed query results were valid.");
        }

        if (timestamp_counter_bits > 0) {
            if (timestamp_result1 <= 0 ||
                timestamp_result2 <= 0 ||
                timestamp_result2 <= timestamp_result1) {
                testFailed("Timestamp queries returned invalid data: timestamp_result1 = " +
                           timestamp_result1 + ", timestamp_result2 = " + timestamp_result2);
            } else {
                testPassed("Timestamp query results were valid.");
            }
        }
    }

    debug("");
    finishTest();
}
</script>
</body>
</html>