CoCalc -- message

GitHub Repository: PojavLauncherTeam/shaderc
Path: blob/main/libshaderc_util/src/message_test.cc
¹⁵⁶⁰ views
1
// Copyright 2015 The Shaderc Authors. All rights reserved.
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//     http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
// Some of the tests here check code paths that are not checked by
16
// integration tests.
17
// Generally, these would be conditions not generated by the Glslang
18
// compiler.  It's easier to write these unit tests than to inject
19
// a dependency on a fake compiler.
20
#include "libshaderc_util/message.h"
21

22
#include <gtest/gtest.h>
23

24
using shaderc_util::MessageType;
25
using shaderc_util::ParseGlslangOutput;
26
using shaderc_util::string_piece;
27

28
namespace {
29

30
TEST(ParseGlslangOutputTest, EmptyMessageBody) {
31
  string_piece segment_number;
32
  string_piece line_number;
33
  string_piece rest;
34
  EXPECT_EQ(MessageType::Unknown,
35
            ParseGlslangOutput("WARNING: ", false, false, &segment_number,
36
                               &line_number, &rest));
37
  EXPECT_EQ(MessageType::Unknown,
38
            ParseGlslangOutput("ERROR: ", false, false, &segment_number,
39
                               &line_number, &rest));
40
}
41

42
TEST(ParseGlslangOutputTest, GlobalError) {
43
  string_piece segment_number;
44
  string_piece line_number;
45
  string_piece rest;
46
  EXPECT_EQ(
47
      MessageType::GlobalError,
48
      ParseGlslangOutput("ERROR: too many functions: got 1666473 of them",
49
                         false, false, &segment_number, &line_number, &rest));
50
  EXPECT_EQ("too many functions: got 1666473 of them", rest.str());
51

52
  EXPECT_EQ(
53
      MessageType::GlobalError,
54
      ParseGlslangOutput(
55
          "ERROR: #version: versions before 150 do not allow a profile token",
56
          false, false, &segment_number, &line_number, &rest));
57
  EXPECT_EQ("#version: versions before 150 do not allow a profile token",
58
            rest.str());
59
}
60

61
TEST(ParseGlslangOutputTest, GlobalWarning) {
62
  string_piece segment_number;
63
  string_piece line_number;
64
  string_piece rest;
65
  EXPECT_EQ(MessageType::GlobalWarning,
66
            ParseGlslangOutput("Warning, version 1000 is unknown.", false,
67
                               false, &segment_number, &line_number, &rest));
68
  EXPECT_EQ("version 1000 is unknown.", rest.str());
69
}
70

71
TEST(ParseGlslangOutputTest, InvalidSuffixAfterSegmentNumber) {
72
  string_piece segment_number;
73
  string_piece line_number;
74
  string_piece rest;
75
  EXPECT_EQ(MessageType::GlobalWarning,
76
            ParseGlslangOutput("WARNING: 12a", false, false, &segment_number,
77
                               &line_number, &rest));
78
  EXPECT_EQ(MessageType::GlobalError,
79
            ParseGlslangOutput("WARNING: 12a", true, false, &segment_number,
80
                               &line_number, &rest));
81
  EXPECT_EQ(MessageType::GlobalError,
82
            ParseGlslangOutput("ERROR: 42!", false, false, &segment_number,
83
                               &line_number, &rest));
84
}
85

86
TEST(ParseGlslangOutputTest, OnlyANumber) {
87
  string_piece source_name;
88
  string_piece line_number;
89
  string_piece rest;
90
  EXPECT_EQ(MessageType::GlobalWarning,
91
            ParseGlslangOutput("WARNING: 12", false, false, &source_name,
92
                               &line_number, &rest));
93
  EXPECT_TRUE(source_name.empty());
94
  EXPECT_TRUE(line_number.empty());
95
  EXPECT_EQ("12", rest.str());
96

97
  EXPECT_EQ(MessageType::GlobalError,
98
            ParseGlslangOutput("WARNING: 12", true, false, &source_name,
99
                               &line_number, &rest));
100
  EXPECT_TRUE(source_name.empty());
101
  EXPECT_TRUE(line_number.empty());
102
  EXPECT_EQ("12", rest.str());
103

104
  EXPECT_EQ(MessageType::GlobalError,
105
            ParseGlslangOutput("ERROR: 42", false, false, &source_name,
106
                               &line_number, &rest));
107
  EXPECT_TRUE(source_name.empty());
108
  EXPECT_TRUE(line_number.empty());
109
  EXPECT_EQ("42", rest.str());
110
}
111

112
TEST(ParseGlslangOutputTest, InvalidSuffixAfterSegmentNumberColon) {
113
  string_piece segment_number;
114
  string_piece line_number;
115
  string_piece rest;
116
  EXPECT_EQ(MessageType::GlobalWarning,
117
            ParseGlslangOutput("WARNING: 12:0", false, false, &segment_number,
118
                               &line_number, &rest));
119
  EXPECT_EQ(MessageType::GlobalError,
120
            ParseGlslangOutput("ERROR: 42:1234", false, false, &segment_number,
121
                               &line_number, &rest));
122
}
123

124
TEST(ParseGlslangOutputTest, CompletelyUnrecognized) {
125
  string_piece segment_number;
126
  string_piece line_number;
127
  string_piece rest;
128
  EXPECT_EQ(MessageType::Unknown,
129
            ParseGlslangOutput("hello world!", false, false, &segment_number,
130
                               &line_number, &rest));
131
}
132

133
TEST(ParseGlslangOutputTest, LocationSpecification) {
134
  string_piece segment_number;
135
  string_piece line_number;
136
  string_piece rest;
137

138
  // Glslang reading from strings can give string segment numbers as
139
  // the filename part.
140
  EXPECT_EQ(
141
      MessageType::Error,
142
      ParseGlslangOutput("ERROR: 0:2: '#' : invalid directive: foo", false,
143
                         false, &segment_number, &line_number, &rest));
144
  EXPECT_EQ("0", segment_number.str());
145
  EXPECT_EQ("2", line_number.str());
146
  EXPECT_EQ("'#' : invalid directive: foo", rest.str());
147

148
  EXPECT_EQ(
149
      MessageType::Warning,
150
      ParseGlslangOutput("WARNING: 15:36: The following extension must be "
151
                         "enabled to use this feature:",
152
                         false, false, &segment_number, &line_number, &rest));
153
  EXPECT_EQ("15", segment_number.str());
154
  EXPECT_EQ("36", line_number.str());
155
  EXPECT_EQ("The following extension must be enabled to use this feature:",
156
            rest.str());
157
}
158

159
TEST(ParseGlslangOutputTest, FileName_BaseAndExtension) {
160
  string_piece source_name;
161
  string_piece line_number;
162
  string_piece rest;
163

164
  EXPECT_EQ(MessageType::Error,
165
            ParseGlslangOutput("ERROR: shader.vert:5: something wrong", false,
166
                               false, &source_name, &line_number, &rest));
167
  EXPECT_EQ("shader.vert", source_name.str());
168
  EXPECT_EQ("5", line_number.str());
169
  EXPECT_EQ("something wrong", rest.str());
170
}
171

172
TEST(ParseGlslangOutputTest, FileName_BaseOnly) {
173
  string_piece source_name;
174
  string_piece line_number;
175
  string_piece rest;
176

177
  EXPECT_EQ(MessageType::Warning,
178
            ParseGlslangOutput("WARNING: file:42: something wrong", false,
179
                               false, &source_name, &line_number, &rest));
180
  EXPECT_EQ("file", source_name.str());
181
  EXPECT_EQ("42", line_number.str());
182
  EXPECT_EQ("something wrong", rest.str());
183
}
184

185
TEST(ParseGlslangOutputTest, FileName_HexNumber) {
186
  string_piece source_name;
187
  string_piece line_number;
188
  string_piece rest;
189

190
  EXPECT_EQ(MessageType::Warning,
191
            ParseGlslangOutput("WARNING: 0xdeedbeef:0: wa:ha:ha", false, false,
192
                               &source_name, &line_number, &rest));
193
  EXPECT_EQ("0xdeedbeef", source_name.str());
194
  EXPECT_EQ("0", line_number.str());
195
  EXPECT_EQ("wa:ha:ha", rest.str());
196
}
197

198
TEST(ParseGlslangOutputTest, FileName_ContainsColons) {
199
  string_piece source_name;
200
  string_piece line_number;
201
  string_piece rest;
202

203
  EXPECT_EQ(MessageType::Warning,
204
            ParseGlslangOutput("WARNING:  foo:bar:0: wa:ha:ha", false, false,
205
                               &source_name, &line_number, &rest));
206
  EXPECT_EQ("foo:bar", source_name.str());
207
  EXPECT_EQ("0", line_number.str());
208
  EXPECT_EQ("wa:ha:ha", rest.str());
209
}
210

211
TEST(ParseGlslangOutputTest, NoFile) {
212
  string_piece source_name;
213
  string_piece line_number;
214
  string_piece rest;
215

216
  EXPECT_EQ(MessageType::Warning,
217
            ParseGlslangOutput("WARNING:  :12: abc", false, false, &source_name,
218
                               &line_number, &rest));
219
  EXPECT_EQ("", source_name.str());
220
  EXPECT_EQ("12", line_number.str());
221
  EXPECT_EQ("abc", rest.str());
222
}
223

224
TEST(ParseGlslangOutputTest, NoLineNumber_InferredAsGlobalNoLocation) {
225
  string_piece source_name;
226
  string_piece line_number;
227
  string_piece rest;
228

229
  // No solution since there is no room for digits.
230
  EXPECT_EQ(MessageType::GlobalWarning,
231
            ParseGlslangOutput("WARNING:  foo:: abc", false, false,
232
                               &source_name, &line_number, &rest));
233
  EXPECT_EQ("", source_name.str());
234
  EXPECT_EQ("", line_number.str());
235
  EXPECT_EQ("foo:: abc", rest.str());
236
}
237

238
TEST(ParseGlslangOutputTest, NoSpaceAfterColon_InferredAsGlobalNoLocation) {
239
  string_piece source_name;
240
  string_piece line_number;
241
  string_piece rest;
242

243
  // No solution since there is no space after the line-number-and-colon.
244
  EXPECT_EQ(MessageType::GlobalWarning,
245
            ParseGlslangOutput("WARNING:  foo:12:abc", false, false,
246
                               &source_name, &line_number, &rest));
247
  EXPECT_EQ("", source_name.str());
248
  EXPECT_EQ("", line_number.str());
249
  EXPECT_EQ("foo:12:abc", rest.str());
250
}
251

252
TEST(ParseGlslangOutputTest, WindowsPath) {
253
  string_piece source_name;
254
  string_piece line_number;
255
  string_piece rest;
256

257
  EXPECT_EQ(
258
      MessageType::Error,
259
      ParseGlslangOutput(R"(ERROR: C:\path\to\shader.glsl:5: something wrong)",
260
                         false, false, &source_name, &line_number, &rest));
261
  EXPECT_EQ(R"(C:\path\to\shader.glsl)", source_name.str());
262
  EXPECT_EQ("5", line_number.str());
263
  EXPECT_EQ("something wrong", rest.str());
264

265
  EXPECT_EQ(
266
      MessageType::Warning,
267
      ParseGlslangOutput(R"(WARNING: \\path\without\drive.vert:42: BOOM!)",
268
                         false, false, &source_name, &line_number, &rest));
269
  EXPECT_EQ(R"(\\path\without\drive.vert)", source_name.str());
270
  EXPECT_EQ("42", line_number.str());
271
  EXPECT_EQ("BOOM!", rest.str());
272

273
  EXPECT_EQ(MessageType::Warning,
274
            ParseGlslangOutput(R"(WARNING: X:\123.456\789:0: wa:ha:ha)", false,
275
                               false, &source_name, &line_number, &rest));
276
  EXPECT_EQ(R"(X:\123.456\789)", source_name.str());
277
  EXPECT_EQ("0", line_number.str());
278
  EXPECT_EQ("wa:ha:ha", rest.str());
279
}
280

281
}  // anonymous namespace
282

283
Product

Resources

Company
