xref: /aosp_15_r20/external/deqp/external/vulkancts/modules/vulkan/amber/vktAmberTestCaseUtil.cpp (revision 35238bce31c2a825756842865a792f8cf7f89930)

/*------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2019 Google LLC
 * Copyright (c) 2019 The Khronos Group Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*--------------------------------------------------------------------*/

#include "vktAmberTestCase.hpp"
#include "vktTestGroupUtil.hpp"
#include "vktTestCaseUtil.hpp"
#include "tcuResource.hpp"

namespace vkt
{
namespace cts_amber
{

class AmberIndexFileParser
{
    std::string m_str;
    size_t m_idx;
    size_t m_len;
    static const int m_fieldLen = 256;
    char m_scratch[m_fieldLen];
    char m_filenameField[m_fieldLen];
    char m_testnameField[m_fieldLen];
    char m_descField[m_fieldLen];

    bool isWhitespace(char c)
    {
        if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
        {
            return true;
        }
        return false;
    }

    void skipWhitespace(void)
    {
        while (m_idx < m_len && isWhitespace(m_str[m_idx]))
            m_idx++;
    }

    bool skipCommentLine(void)
    {
        skipWhitespace();
        if (m_str[m_idx] == '#')
        {
            while (m_idx < m_len && m_str[m_idx] != '\n')
                m_idx++;
            return true;
        }
        return false;
    }

    void accept(char c)
    {
        if (m_str[m_idx] == c)
            m_idx++;
    }

    void expect(char c)
    {
        if (m_idx >= m_len || m_str[m_idx] != c)
            TCU_THROW(ResourceError, "Error parsing amber index file");

        m_idx++;
    }

    void captureString(char *field)
    {
        int i = 0;

        while (m_idx < m_len && i < m_fieldLen && m_str[m_idx] != '"')
        {
            field[i] = m_str[m_idx];
            i++;
            m_idx++;
        }

        field[i] = 0;
        m_idx++;
    }

public:
    AmberIndexFileParser(tcu::TestContext &testCtx, const char *filename, const char *category)
    {
        std::string indexFilename("vulkan/amber/");
        indexFilename.append(category);
        indexFilename.append("/");
        indexFilename.append(filename);

        m_str = ShaderSourceProvider::getSource(testCtx.getArchive(), indexFilename.c_str());
        m_len = m_str.length();
        m_idx = 0;
    }

    ~AmberIndexFileParser(void)
    {
    }

    AmberTestCase *parse(const char *category, tcu::TestContext &testCtx)
    {
        // Format:
        // {"filename","test name","description"[,requirement[,requirement[,requirement..]]]}[,]
        // Things inside [] are optional. Whitespace is allowed everywhere.
        //
        // Comments are allowed starting with "#" character.
        //
        // For example, test without requirements might be:
        // {"testname.amber","test name","test description"},

        while (skipCommentLine())
            ;

        if (m_idx < m_len)
        {
            skipWhitespace();
            expect('{');
            skipWhitespace();
            expect('"');
            captureString(m_filenameField);
            skipWhitespace();
            expect(',');
            skipWhitespace();
            expect('"');
            captureString(m_testnameField);
            skipWhitespace();
            expect(',');
            skipWhitespace();
            expect('"');
            captureString(m_descField);
            skipWhitespace();

            std::string testFilename("vulkan/amber/");
            testFilename.append(category);
            testFilename.append("/");
            testFilename.append(m_filenameField);
            AmberTestCase *testCase = new AmberTestCase(testCtx, m_testnameField, m_descField, testFilename);

            while (m_idx < m_len && m_str[m_idx] == ',')
            {
                accept(',');
                skipWhitespace();
                expect('"');
                captureString(m_scratch);
                skipWhitespace();
                testCase->addRequirement(m_scratch);
            }

            expect('}');
            skipWhitespace();
            accept(',');
            skipWhitespace();
            return testCase;
        }
        return 0;
    }
};

void createAmberTestsFromIndexFile(tcu::TestContext &testCtx, tcu::TestCaseGroup *group, const std::string filename,
                                   const char *category)
{
    AmberTestCase *testCase = 0;
    AmberIndexFileParser parser(testCtx, filename.c_str(), category);

    do
    {
        testCase = parser.parse(category, testCtx);
        if (testCase)
        {
            group->addChild(testCase);
        }
    } while (testCase);
}

AmberTestCase *createAmberTestCase(tcu::TestContext &testCtx, const char *name, const char *category,
                                   const std::string &filename, const std::vector<std::string> requirements,
                                   const std::vector<vk::VkImageCreateInfo> imageRequirements,
                                   const std::vector<BufferRequirement> bufferRequirements)
{
    return createAmberTestCase(testCtx, name, "", category, filename, requirements, imageRequirements,
                               bufferRequirements);
}

AmberTestCase *createAmberTestCase(tcu::TestContext &testCtx, const char *name, const char *description,
                                   const char *category, const std::string &filename,
                                   const std::vector<std::string> requirements,
                                   const std::vector<vk::VkImageCreateInfo> imageRequirements,
                                   const std::vector<BufferRequirement> bufferRequirements)

{
    // shader_test files are saved in <path>/external/vulkancts/data/vulkan/amber/<categoryname>/
    std::string readFilename("vulkan/amber/");
    readFilename.append(category);
    readFilename.append("/");
    readFilename.append(filename);

    AmberTestCase *testCase = new AmberTestCase(testCtx, name, description, readFilename);

    for (auto req : requirements)
        testCase->addRequirement(req);

    for (auto req : imageRequirements)
        testCase->addImageRequirement(req);

    for (auto req : bufferRequirements)
        testCase->addBufferRequirement(req);

    return testCase;
}

} // namespace cts_amber
} // namespace vkt