chromium/third_party/angle/src/tests/test_utils/compiler_test.cpp

//
// Copyright 2015 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// compiler_test.cpp:
//     utilities for compiler unit tests.

#include "tests/test_utils/compiler_test.h"

#include "angle_gl.h"
#include "compiler/translator/Compiler.h"
#include "compiler/translator/FunctionLookup.h"
#include "compiler/translator/tree_util/IntermTraverse.h"

namespace sh
{

namespace
{
constexpr char kBinaryBlob[] =;
bool IsBinaryBlob(const std::string &code)
{}

ImmutableString GetSymbolTableMangledName(TIntermAggregate *node)
{}

class FunctionCallFinder : public TIntermTraverser
{};

}  // anonymous namespace

bool compileTestShader(GLenum type,
                       ShShaderSpec spec,
                       ShShaderOutput output,
                       const std::string &shaderString,
                       ShBuiltInResources *resources,
                       const ShCompileOptions &compileOptions,
                       std::string *translatedCode,
                       std::string *infoLog)
{}

bool compileTestShader(GLenum type,
                       ShShaderSpec spec,
                       ShShaderOutput output,
                       const std::string &shaderString,
                       const ShCompileOptions &compileOptions,
                       std::string *translatedCode,
                       std::string *infoLog)
{}

MatchOutputCodeTest::MatchOutputCodeTest(GLenum shaderType, ShShaderOutput outputType)
    :{}

void MatchOutputCodeTest::setDefaultCompileOptions(const ShCompileOptions &defaultCompileOptions)
{}

void MatchOutputCodeTest::addOutputType(const ShShaderOutput outputType)
{}

ShBuiltInResources *MatchOutputCodeTest::getResources()
{}

void MatchOutputCodeTest::compile(const std::string &shaderString)
{}

void MatchOutputCodeTest::compile(const std::string &shaderString,
                                  const ShCompileOptions &compileOptions)
{}

bool MatchOutputCodeTest::compileWithSettings(ShShaderOutput output,
                                              const std::string &shaderString,
                                              const ShCompileOptions &compileOptions,
                                              std::string *translatedCode,
                                              std::string *infoLog)
{}

bool MatchOutputCodeTest::foundInCodeRegex(ShShaderOutput output,
                                           const std::regex &regexToFind,
                                           std::smatch *match) const
{}

bool MatchOutputCodeTest::foundInCode(ShShaderOutput output, const char *stringToFind) const
{}

bool MatchOutputCodeTest::foundInCodeInOrder(ShShaderOutput output,
                                             std::vector<const char *> stringsToFind)
{}

bool MatchOutputCodeTest::foundInCode(ShShaderOutput output,
                                      const char *stringToFind,
                                      const int expectedOccurrences) const
{}

bool MatchOutputCodeTest::foundInCode(const char *stringToFind) const
{}

bool MatchOutputCodeTest::foundInCodeRegex(const std::regex &regexToFind, std::smatch *match) const
{}

bool MatchOutputCodeTest::foundInCode(const char *stringToFind, const int expectedOccurrences) const
{}

bool MatchOutputCodeTest::foundInCodeInOrder(std::vector<const char *> stringsToFind)
{}

bool MatchOutputCodeTest::notFoundInCode(const char *stringToFind) const
{}

const TIntermAggregate *FindFunctionCallNode(TIntermNode *root, const TString &functionMangledName)
{}

}  // namespace sh