+#include <spirv-tools/libspirv.hpp>
#include <msp/core/algorithm.h>
#include <msp/fs/dir.h>
#include <msp/fs/utils.h>
Msp::GL::SL::Compiler::Mode compile_mode;
std::map<std::string, int> spec_values;
std::map<Msp::GL::SL::Stage::Type, std::string> expected_output;
- std::string expected_error;
+ std::string expected_diagnostic;
+ bool expect_success;
+
+ TestCase(): expect_success(true) { }
};
std::list<TestCase> test_cases;
const TestCase &load_test_case(const std::string &);
void verify_output(const std::string &, const std::string &);
- void verify_error(const std::string &, const std::string &);
+ void verify_diagnostic(const std::string &, const std::string &);
std::string extract_line(const std::string &, const std::string::const_iterator &);
virtual void fail(const std::string &) = 0;
};
virtual void fail(const std::string &m) { Test::fail(m); }
};
+class GlslCompilerSpirV: public Msp::Test::RegisteredTest<GlslCompilerSpirV>, private GlslCompilerHelper
+{
+private:
+ spvtools::SpirvTools spirv_tools;
+
+public:
+ GlslCompilerSpirV();
+
+ static const char *get_name() { return "GLSL to SPIR-V compilation"; }
+
+private:
+ void run_test_case(const TestCase *);
+ void diagnostic(spv_message_level_t, const char *, const spv_position_t &, const char *);
+ virtual void fail(const std::string &m) { Test::fail(m); }
+};
+
using namespace std;
using namespace Msp;
void GlslCompilerHelper::load_all_test_cases(const FS::Path &tests_dir)
{
- list<string> test_files = FS::list_filtered(tests_dir, "\\.glsl$");
- test_files.sort();
+ vector<string> test_files = FS::list_filtered(tests_dir, "\\.glsl$");
+ sort(test_files);
for(const auto &fn: test_files)
load_test_case((tests_dir/fn).str());
}
}
pos = line.find("Expected error:");
+ if(pos==string::npos)
+ pos = line.find("Expected diagnostic:");
if(pos!=string::npos)
{
- target = &test_case.expected_error;
+ target = &test_case.expected_diagnostic;
+ test_case.expect_success = (line[pos+9]!='e');
continue;
}
}
}
-void GlslCompilerHelper::verify_error(const string &output, const string &expected)
+void GlslCompilerHelper::verify_diagnostic(const string &output, const string &expected)
{
auto i = output.begin();
auto j = expected.begin();
{
string out_line = extract_line(output, i);
string expect_line = extract_line(expected, j);
- fail(format("Incorrect error line:\n%s\nExpected:\n%s", out_line, expect_line));
+ fail(format("Incorrect diagnostic line:\n%s\nExpected:\n%s", out_line, expect_line));
}
}
++j;
if(i!=output.end())
- fail(format("Extra error line: %s", extract_line(output, i)));
+ fail(format("Extra diagnostic line: %s", extract_line(output, i)));
if(j!=expected.end())
- fail(format("Missing error line: %s", extract_line(expected, j)));
+ fail(format("Missing diagnostic line: %s", extract_line(expected, j)));
}
string GlslCompilerHelper::extract_line(const string &text, const string::const_iterator &iter)
void GlslCompilerTest::run_test_case(const TestCase *test_case)
{
- GL::SL::Compiler compiler(GL::SL::Features::all());
+ GL::SL::Compiler compiler(GL::SL::Features::latest());
try
{
compiler.set_source(test_case->source, "<test>");
}
catch(const GL::SL::invalid_shader_source &exc)
{
- if(!test_case->expected_error.empty())
+ if(!test_case->expect_success)
{
debug("Errors from compile:");
debug(exc.what());
- verify_error(exc.what(), test_case->expected_error);
+ verify_diagnostic(exc.what(), test_case->expected_diagnostic);
return;
}
throw;
}
- if(!test_case->expected_error.empty())
+ if(!test_case->expect_success)
fail("Error expected but none thrown");
+ verify_diagnostic(compiler.get_diagnostics(), test_case->expected_diagnostic);
+
auto stages = compiler.get_stages();
for(auto s: stages)
{
{
load_all_test_cases("glsl");
for(const auto &tc: test_cases)
- if(tc.expected_error.empty())
+ if(tc.expect_success)
add(&GlslCompilerIdempotence::run_test_case, &tc, tc.name);
}
void GlslCompilerIdempotence::run_test_case(const TestCase *test_case)
{
- GL::SL::Compiler compiler(GL::SL::Features::all());
+ GL::SL::Compiler compiler(GL::SL::Features::latest());
compiler.set_source(test_case->source, "<test>");
if(test_case->compile_mode==GL::SL::Compiler::PROGRAM)
compiler.specialize(test_case->spec_values);
compiler.compile(test_case->compile_mode);
- GL::SL::Compiler compiler2(GL::SL::Features::all());
+ GL::SL::Compiler compiler2(GL::SL::Features::latest());
compiler2.set_source(compiler.get_combined_glsl(), "<loopback>");
compiler2.compile(test_case->compile_mode);
if(j!=stages2.end())
fail(format("Second pass produced extra stage %s", GL::SL::Stage::get_stage_name(*j)));
}
+
+
+GlslCompilerSpirV::GlslCompilerSpirV():
+ spirv_tools(SPV_ENV_UNIVERSAL_1_5)
+{
+ load_all_test_cases("glsl");
+ for(const auto &tc: test_cases)
+ if(tc.expect_success)
+ add(&GlslCompilerSpirV::run_test_case, &tc, tc.name);
+
+ using namespace std::placeholders;
+ spirv_tools.SetMessageConsumer(std::bind(std::mem_fn(&GlslCompilerSpirV::diagnostic), this, _1, _2, _3, _4));
+}
+
+void GlslCompilerSpirV::run_test_case(const TestCase *test_case)
+{
+ GL::SL::Compiler compiler(GL::SL::Features::latest());
+ compiler.set_source(test_case->source, "<test>");
+ compiler.compile(GL::SL::Compiler::SPIRV);
+
+ vector<uint32_t> code = compiler.get_combined_spirv();
+ if(!spirv_tools.Validate(code))
+ fail("Invalid SPIR-V generated");
+}
+
+void GlslCompilerSpirV::diagnostic(spv_message_level_t level, const char *, const spv_position_t &, const char *message)
+{
+ const char *prefix;
+ switch(level)
+ {
+ case SPV_MSG_DEBUG: prefix = "debug: "; break;
+ case SPV_MSG_INFO: prefix = "info: "; break;
+ case SPV_MSG_WARNING: prefix = "warning: "; break;
+ case SPV_MSG_ERROR: prefix = "error: "; break;
+ default: prefix = "";
+ }
+ info(format("%s%s", prefix, message));
+}
projects / libs / gl.git / blobdiff