]> git.tdb.fi Git - libs/gl.git/blob - tests/glsl/glslcompiler.cpp
Add a usage parameter to Buffer
[libs/gl.git] / tests / glsl / glslcompiler.cpp
1 #include <spirv-tools/libspirv.hpp>
2 #include <msp/core/algorithm.h>
3 #include <msp/fs/dir.h>
4 #include <msp/fs/utils.h>
5 #include <msp/gl/glsl/compiler.h>
6 #include <msp/gl/glsl/glsl_error.h>
7 #include <msp/gl/glsl/tokenizer.h>
8 #include <msp/strings/utils.h>
9 #include <msp/test/test.h>
10
11 class GlslCompilerHelper
12 {
13 protected:
14         struct TestCase
15         {
16                 std::string name;
17                 std::string source;
18                 Msp::GL::SL::Compiler::Mode compile_mode;
19                 std::map<std::string, int> spec_values;
20                 std::map<Msp::GL::SL::Stage::Type, std::string> expected_output;
21                 std::string expected_diagnostic;
22                 bool expect_success;
23
24                 TestCase(): expect_success(true) { }
25         };
26
27         std::list<TestCase> test_cases;
28
29         void load_all_test_cases(const Msp::FS::Path &);
30         const TestCase &load_test_case(const std::string &);
31
32         void verify_output(const std::string &, const std::string &);
33         void verify_diagnostic(const std::string &, const std::string &);
34         std::string extract_line(const std::string &, const std::string::const_iterator &);
35         virtual void fail(const std::string &) = 0;
36 };
37
38 class GlslCompilerTest: public Msp::Test::RegisteredTest<GlslCompilerTest>, private GlslCompilerHelper
39 {
40 public:
41         GlslCompilerTest();
42
43         static const char *get_name() { return "GLSL compiler"; }
44
45 private:
46         void run_test_case(const TestCase *);
47         virtual void fail(const std::string &m) { Test::fail(m); }
48 };
49
50 class GlslCompilerIdempotence: public Msp::Test::RegisteredTest<GlslCompilerIdempotence>, private GlslCompilerHelper
51 {
52 public:
53         GlslCompilerIdempotence();
54
55         static const char *get_name() { return "GLSL compiler idempotence"; }
56
57 private:
58         void run_test_case(const TestCase *);
59         virtual void fail(const std::string &m) { Test::fail(m); }
60 };
61
62 class GlslCompilerSpirV: public Msp::Test::RegisteredTest<GlslCompilerSpirV>, private GlslCompilerHelper
63 {
64 private:
65         spvtools::SpirvTools spirv_tools;
66
67 public:
68         GlslCompilerSpirV();
69
70         static const char *get_name() { return "GLSL to SPIR-V compilation"; }
71
72 private:
73         void run_test_case(const TestCase *);
74         void diagnostic(spv_message_level_t, const char *, const spv_position_t &, const char *);
75         virtual void fail(const std::string &m) { Test::fail(m); }
76 };
77
78 using namespace std;
79 using namespace Msp;
80
81 void GlslCompilerHelper::load_all_test_cases(const FS::Path &tests_dir)
82 {
83         vector<string> test_files = FS::list_filtered(tests_dir, "\\.glsl$");
84         sort(test_files);
85         for(const auto &fn: test_files)
86                 load_test_case((tests_dir/fn).str());
87 }
88
89 const GlslCompilerHelper::TestCase &GlslCompilerHelper::load_test_case(const string &fn)
90 {
91         IO::BufferedFile file(fn);
92         TestCase test_case;
93         test_case.name = FS::basename(fn);
94         test_case.compile_mode = GL::SL::Compiler::PROGRAM;
95         string *target = &test_case.source;
96         while(!file.eof())
97         {
98                 string line;
99                 if(!file.getline(line))
100                         break;
101
102                 if(line=="*/")
103                         continue;
104
105                 string::size_type pos = line.find("Expected output:");
106                 if(pos!=string::npos)
107                 {
108                         string stage = strip(line.substr(pos+16));
109                         if(stage=="vertex")
110                                 target = &test_case.expected_output[GL::SL::Stage::VERTEX];
111                         else if(stage=="geometry")
112                                 target = &test_case.expected_output[GL::SL::Stage::GEOMETRY];
113                         else if(stage=="fragment")
114                                 target = &test_case.expected_output[GL::SL::Stage::FRAGMENT];
115                         else
116                                 throw runtime_error("Unknown stage "+stage);
117                         continue;
118                 }
119
120                 pos = line.find("Expected error:");
121                 if(pos==string::npos)
122                         pos = line.find("Expected diagnostic:");
123                 if(pos!=string::npos)
124                 {
125                         target = &test_case.expected_diagnostic;
126                         test_case.expect_success = (line[pos+9]!='e');
127                         continue;
128                 }
129
130                 pos = line.find("Compile mode:");
131                 if(pos!=string::npos)
132                 {
133                         string mode = strip(line.substr(pos+13));
134                         if(mode=="module")
135                                 test_case.compile_mode = GL::SL::Compiler::MODULE;
136                         else if(mode=="program")
137                                 test_case.compile_mode = GL::SL::Compiler::PROGRAM;
138                         else
139                                 throw runtime_error("Unknown compile mode "+mode);
140                         continue;
141                 }
142
143                 pos = line.find("Specialize:");
144                 if(pos!=string::npos)
145                 {
146                         vector<string> parts = split(line.substr(pos+11));
147                         int value = 0;
148                         if(parts[1]=="true")
149                                 value = 1;
150                         else if(parts[1]=="false")
151                                 value = 0;
152                         else
153                                 value = lexical_cast<int>(parts[1]);
154                         test_case.spec_values[parts[0]] = value;
155                         continue;
156                 }
157
158                 *target += line;
159                 *target += '\n';
160         }
161         test_cases.push_back(test_case);
162
163         return test_cases.back();
164 }
165
166 void GlslCompilerHelper::verify_output(const string &output, const string &expected)
167 {
168         GL::SL::Tokenizer tokenizer;
169         tokenizer.begin(output, "<output>");
170
171         GL::SL::Tokenizer expected_tkn;
172         expected_tkn.begin(expected, "<expected>");
173
174         while(1)
175         {
176                 string token = expected_tkn.parse_token();
177
178                 try
179                 {
180                         tokenizer.expect(token);
181                 }
182                 catch(const GL::SL::invalid_shader_source &exc)
183                 {
184                         fail(exc.what());
185                 }
186
187                 if(token.empty())
188                         break;
189         }
190 }
191
192 void GlslCompilerHelper::verify_diagnostic(const string &output, const string &expected)
193 {
194         auto i = output.begin();
195         auto j = expected.begin();
196         bool space = true;
197         while(i!=output.end() && j!=expected.end())
198         {
199                 if(*i==*j)
200                 {
201                         ++i;
202                         ++j;
203                 }
204                 else if(isspace(*i) && isspace(*j))
205                 {
206                         ++i;
207                         ++j;
208                         space = true;
209                 }
210                 else if(space && isspace(*i))
211                         ++i;
212                 else if(space && isspace(*j))
213                         ++j;
214                 else
215                 {
216                         string out_line = extract_line(output, i);
217                         string expect_line = extract_line(expected, j);
218                         fail(format("Incorrect diagnostic line:\n%s\nExpected:\n%s", out_line, expect_line));
219                 }
220         }
221
222         while(i!=output.end() && isspace(*i))
223                 ++i;
224         while(j!=expected.end() && isspace(*j))
225                 ++j;
226
227         if(i!=output.end())
228                 fail(format("Extra diagnostic line: %s", extract_line(output, i)));
229         if(j!=expected.end())
230                 fail(format("Missing diagnostic line: %s", extract_line(expected, j)));
231 }
232
233 string GlslCompilerHelper::extract_line(const string &text, const string::const_iterator &iter)
234 {
235         string::const_iterator begin = iter;
236         for(; (begin!=text.begin() && *begin!='\n'); --begin) ;
237         if(*begin=='\n')
238                 ++begin;
239         string::const_iterator end = iter;
240         for(; (end!=text.end() && *end!='\n'); ++end) ;
241         return string(begin, end);
242 }
243
244
245 GlslCompilerTest::GlslCompilerTest()
246 {
247         load_all_test_cases("glsl");
248         for(const auto &tc: test_cases)
249                 add(&GlslCompilerTest::run_test_case, &tc, tc.name);
250 }
251
252 void GlslCompilerTest::run_test_case(const TestCase *test_case)
253 {
254         GL::SL::Compiler compiler(GL::SL::Features::latest(GL::OPENGL));
255         try
256         {
257                 compiler.set_source(test_case->source, "<test>");
258                 if(test_case->compile_mode==GL::SL::Compiler::PROGRAM)
259                         compiler.specialize(test_case->spec_values);
260                 compiler.compile(test_case->compile_mode);
261         }
262         catch(const GL::SL::invalid_shader_source &exc)
263         {
264                 if(!test_case->expect_success)
265                 {
266                         debug("Errors from compile:");
267                         debug(exc.what());
268                         verify_diagnostic(exc.what(), test_case->expected_diagnostic);
269                         return;
270                 }
271                 throw;
272         }
273
274         if(!test_case->expect_success)
275                 fail("Error expected but none thrown");
276
277         verify_diagnostic(compiler.get_diagnostics(), test_case->expected_diagnostic);
278
279         auto stages = compiler.get_stages();
280         for(auto s: stages)
281         {
282                 auto i = test_case->expected_output.find(s);
283                 if(i==test_case->expected_output.end())
284                         fail(format("Compiler produced extra stage %s", GL::SL::Stage::get_stage_name(s)));
285
286                 string output = compiler.get_stage_glsl(s);
287                 debug(format("Output for stage %s:", GL::SL::Stage::get_stage_name(s)));
288                 auto lines = split_fields(output, '\n');
289                 for(unsigned j=0; j<lines.size(); ++j)
290                         debug(format("%3d: %s", j+1, lines[j]));
291
292                 verify_output(output, i->second);
293         }
294
295         for(const auto &s: test_case->expected_output)
296                 if(find(stages, s.first)==stages.end())
297                         fail(format("Compiler didn't produce stage %s", GL::SL::Stage::get_stage_name(s.first)));
298 }
299
300
301 GlslCompilerIdempotence::GlslCompilerIdempotence()
302 {
303         load_all_test_cases("glsl");
304         for(const auto &tc: test_cases)
305                 if(tc.expect_success)
306                         add(&GlslCompilerIdempotence::run_test_case, &tc, tc.name);
307 }
308
309 void GlslCompilerIdempotence::run_test_case(const TestCase *test_case)
310 {
311         GL::SL::Compiler compiler(GL::SL::Features::latest(GL::OPENGL));
312         compiler.set_source(test_case->source, "<test>");
313         if(test_case->compile_mode==GL::SL::Compiler::PROGRAM)
314                 compiler.specialize(test_case->spec_values);
315         compiler.compile(test_case->compile_mode);
316
317         GL::SL::Compiler compiler2(GL::SL::Features::latest(GL::OPENGL));
318         compiler2.set_source(compiler.get_combined_glsl(), "<loopback>");
319         compiler2.compile(test_case->compile_mode);
320
321         auto stages = compiler.get_stages();
322         auto stages2 = compiler2.get_stages();
323         auto i = stages.begin();
324         auto j = stages2.begin();
325         for(; (i!=stages.end() && j!=stages2.end() && *i==*j); ++i, ++j)
326         {
327                 string output = compiler.get_stage_glsl(*i);
328                 string output2 = compiler2.get_stage_glsl(*j);
329
330                 verify_output(output2, output);
331         }
332
333         if(i!=stages.end())
334                 fail(format("Second pass didn't produce stage %s", GL::SL::Stage::get_stage_name(*i)));
335         if(j!=stages2.end())
336                 fail(format("Second pass produced extra stage %s", GL::SL::Stage::get_stage_name(*j)));
337 }
338
339
340 GlslCompilerSpirV::GlslCompilerSpirV():
341         spirv_tools(SPV_ENV_UNIVERSAL_1_5)
342 {
343         load_all_test_cases("glsl");
344         for(const auto &tc: test_cases)
345                 if(tc.expect_success)
346                         add(&GlslCompilerSpirV::run_test_case, &tc, tc.name);
347
348         using namespace std::placeholders;
349         spirv_tools.SetMessageConsumer(std::bind(std::mem_fn(&GlslCompilerSpirV::diagnostic), this, _1, _2, _3, _4));
350 }
351
352 void GlslCompilerSpirV::run_test_case(const TestCase *test_case)
353 {
354         GL::SL::Compiler compiler(GL::SL::Features::latest(GL::OPENGL));
355         compiler.set_source(test_case->source, "<test>");
356         compiler.compile(GL::SL::Compiler::SPIRV);
357
358         vector<uint32_t> code = compiler.get_combined_spirv();
359         if(!spirv_tools.Validate(code))
360                 fail("Invalid SPIR-V generated");
361 }
362
363 void GlslCompilerSpirV::diagnostic(spv_message_level_t level, const char *, const spv_position_t &, const char *message)
364 {
365         const char *prefix;
366         switch(level)
367         {
368         case SPV_MSG_DEBUG: prefix = "debug: "; break;
369         case SPV_MSG_INFO: prefix = "info: "; break;
370         case SPV_MSG_WARNING: prefix = "warning: "; break;
371         case SPV_MSG_ERROR: prefix = "error: "; break;
372         default: prefix = "";
373         }
374         info(format("%s%s", prefix, message));
375 }