Debian Codegraph @

packages/stk/stk_unit_tests/stk_util/UnitTestInputUtilities.cpp

raw
1 // ####################### Start Clang Header Tool Managed Headers ########################
2 // clang-format off
3 #include "stk_util/util/concat_variable_name.hpp"
4 #include "stk_util/diag/ParserVarUtil.hpp"
5 #include <gtest/gtest.h>
6 #include <string>
7 // clang-format on
8 // ####################### End Clang Header Tool Managed Headers ########################
9
10 namespace sierra::input_tests{
11
12 struct ParsedVariableTest : public stk::diag::ParsedVariable {
13 ParsedVariableTest(const String& s_) : ParsedVariable(s_) {
14 printf("Component 1 Enum = %i\n",comp1.ComponentEnumVal());
15 printf("Component 2 Enum = %i\n",comp2.ComponentEnumVal());
16 printf("Base Name = '%s'\n", baseName.c_str());
17 }
18 };
19
20 void checkVecX( const ParsedVariableTest& vectorX) {
21 EXPECT_EQ(vectorX.comp1.ComponentEnumVal(),stk::diag::VariableComponent::ComponentEnum::VECTOR_X_COMPONENT);
22 EXPECT_EQ(vectorX.comp2.ComponentEnumVal(),stk::diag::VariableComponent::ComponentEnum::UNSPECIFIED_COMPONENT);
23 EXPECT_TRUE(vectorX.baseName == "vector");
24 EXPECT_EQ(vectorX.name(),"vector(x)");
25 }
26
27 TEST(UnitTestInputUtilities, VectorX) {
28 checkVecX(ParsedVariableTest("vector(X)"));
29 checkVecX(ParsedVariableTest("vector (X)"));
30 checkVecX(ParsedVariableTest("vector( X)"));
31 checkVecX(ParsedVariableTest("vector( X )"));
32 checkVecX(ParsedVariableTest("vector(X )"));
33 checkVecX(ParsedVariableTest("vector(X ) "));
34 }
35
36 TEST(UnitTestInputUtilities, VectorXNoComp) {
37 ParsedVariableTest vectorX("vector_x");
38 EXPECT_EQ(vectorX.comp1.ComponentEnumVal(),stk::diag::VariableComponent::ComponentEnum::ALL_COMPONENTS);
39 EXPECT_EQ(vectorX.comp2.ComponentEnumVal(),stk::diag::VariableComponent::ComponentEnum::ALL_COMPONENTS);
40 EXPECT_TRUE(vectorX.baseName == "vector_x");
41 EXPECT_EQ(vectorX.name(),"vector_x");
42 }
43
44 TEST(UnitTestInputUtilities, VectorAllComp) {
45 ParsedVariableTest vectorAll("vector(:)");
46 EXPECT_EQ(vectorAll.comp1.ComponentEnumVal(),stk::diag::VariableComponent::ComponentEnum::ALL_COMPONENTS);
47 EXPECT_EQ(vectorAll.comp2.ComponentEnumVal(),stk::diag::VariableComponent::ComponentEnum::UNSPECIFIED_COMPONENT);
48 EXPECT_TRUE(vectorAll.baseName == "vector");
49 EXPECT_EQ(vectorAll.name(),"vector(:)");
50 }
51
52 TEST(UnitTestInputUtilities, VectorAllCompAlt) {
53 ParsedVariableTest vectorAll("vector(*)");
54 EXPECT_EQ(vectorAll.comp1.ComponentEnumVal(),stk::diag::VariableComponent::ComponentEnum::ALL_COMPONENTS);
55 EXPECT_EQ(vectorAll.comp2.ComponentEnumVal(),stk::diag::VariableComponent::ComponentEnum::UNSPECIFIED_COMPONENT);
56 EXPECT_TRUE(vectorAll.baseName == "vector");
57 EXPECT_EQ(vectorAll.name(),"vector(*)");
58 }
59
60 TEST(UnitTestInputUtilities, VectorXName) {
61 ParsedVariableTest vectorX("vector_x(1)");
62 EXPECT_EQ(vectorX.comp1.ComponentEnumVal(),stk::diag::VariableComponent::ComponentEnum::INTEGER_COMPONENT);
63 EXPECT_EQ(vectorX.comp2.ComponentEnumVal(),stk::diag::VariableComponent::ComponentEnum::UNSPECIFIED_COMPONENT);
64 EXPECT_TRUE(vectorX.baseName == "vector_x");
65 EXPECT_EQ(vectorX.name(),"vector_x(1)");
66 }
67
68 TEST(UnitTestInputUtilities, NoClosingParen) {
69 EXPECT_ANY_THROW(ParsedVariableTest("vector(X"));
70 }
71 TEST(UnitTestInputUtilities, TooManyParen) {
72 EXPECT_ANY_THROW(ParsedVariableTest("vector(X)(1)"));
73 EXPECT_ANY_THROW(ParsedVariableTest("vector( (X) )"));
74 }
75
76 TEST(UnitTestInputUtilities, StuffAfterParen) {
77 EXPECT_ANY_THROW(ParsedVariableTest("vector(X)_1"));
78 EXPECT_ANY_THROW(ParsedVariableTest("vector(X) _1"));
79 }
80
81 TEST(UnitTestInputUtilities, EmptyRange) {
82 EXPECT_ANY_THROW(ParsedVariableTest("vector()"));
83 EXPECT_ANY_THROW(ParsedVariableTest("vector( )"));
84 }
85
86 TEST(UnitTestInputUtilities, DoubleEmptyRange) {
87 EXPECT_ANY_THROW(ParsedVariableTest("vector(,)"));
88 EXPECT_ANY_THROW(ParsedVariableTest("vector( , )"));
89 EXPECT_ANY_THROW(ParsedVariableTest("vector(, )"));
90 EXPECT_ANY_THROW(ParsedVariableTest("vector( ,)"));
91 }
92
93 TEST(UnitTestInputUtilities, FirstEmptyRange) {
94 EXPECT_ANY_THROW(ParsedVariableTest("vector(,1)"));
95 EXPECT_ANY_THROW(ParsedVariableTest("vector( , 1)"));
96 EXPECT_ANY_THROW(ParsedVariableTest("vector(, 1)"));
97 EXPECT_ANY_THROW(ParsedVariableTest("vector(,1 )"));
98 }
99
100 TEST(UnitTestInputUtilities, SecondEmptyRange) {
101 EXPECT_ANY_THROW(ParsedVariableTest("vector(1,)"));
102 EXPECT_ANY_THROW(ParsedVariableTest("vector(1, )"));
103 EXPECT_ANY_THROW(ParsedVariableTest("vector( 1,)"));
104 EXPECT_ANY_THROW(ParsedVariableTest("vector( 1, )"));
105 }
106
107 void checkSigmaXX1( const ParsedVariableTest& sigmaXX1) {
108 EXPECT_EQ(sigmaXX1.comp1.ComponentEnumVal(),stk::diag::VariableComponent::ComponentEnum::TENSOR_XX_COMPONENT);
109 EXPECT_EQ(sigmaXX1.comp2.ComponentEnumVal(),stk::diag::VariableComponent::ComponentEnum::INTEGER_COMPONENT);
110 EXPECT_TRUE(sigmaXX1.baseName == "sigma");
111 EXPECT_EQ(sigmaXX1.name(), "sigma(xx,1)");
112 }
113 TEST(UnitTestInputUtilities, SigmaXX1) {
114 checkSigmaXX1(ParsedVariableTest("sigma(xx,1)"));
115 checkSigmaXX1(ParsedVariableTest("sigma (xx,1)"));
116 checkSigmaXX1(ParsedVariableTest("sigma ( xx,1)"));
117 checkSigmaXX1(ParsedVariableTest("sigma ( xx, 1)"));
118 checkSigmaXX1(ParsedVariableTest("sigma ( xx , 1 )"));
119 checkSigmaXX1(ParsedVariableTest("sigma(xx 1)"));
120 checkSigmaXX1(ParsedVariableTest("sigma ( xx 1 )"));
121 checkSigmaXX1(ParsedVariableTest("sigma ( xx 1)"));
122 checkSigmaXX1(ParsedVariableTest("sigma (xx 1)"));
123 }
124
125 TEST(UnitTestInputUtilities, TensorComponent) {
126 auto sigxx = ParsedVariableTest("sigma(xx)");
127 EXPECT_EQ(sigxx.baseName, "sigma");
128 EXPECT_EQ(sigxx.comp1.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::TENSOR_XX_COMPONENT);
129 EXPECT_EQ(sigxx.comp2.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::UNSPECIFIED_COMPONENT);
130 auto sigyy = ParsedVariableTest("sigma(yy)");
131 EXPECT_EQ(sigyy.baseName, "sigma");
132 EXPECT_EQ(sigyy.comp1.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::TENSOR_YY_COMPONENT);
133 EXPECT_EQ(sigyy.comp2.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::UNSPECIFIED_COMPONENT);
134 auto sigzz = ParsedVariableTest("sigma(zz)");
135 EXPECT_EQ(sigzz.baseName, "sigma");
136 EXPECT_EQ(sigzz.comp1.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::TENSOR_ZZ_COMPONENT);
137 EXPECT_EQ(sigzz.comp2.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::UNSPECIFIED_COMPONENT);
138 EXPECT_EQ(ParsedVariableTest("sigma(xy)").comp1.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::TENSOR_XY_COMPONENT);
139 EXPECT_EQ(ParsedVariableTest("sigma(xz)").comp1.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::TENSOR_XZ_COMPONENT);
140 EXPECT_EQ(ParsedVariableTest("sigma(yx)").comp1.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::TENSOR_YX_COMPONENT);
141 EXPECT_EQ(ParsedVariableTest("sigma(yZ)").comp1.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::TENSOR_YZ_COMPONENT);
142 EXPECT_EQ(ParsedVariableTest("sigma(zx)").comp1.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::TENSOR_ZX_COMPONENT);
143 EXPECT_EQ(ParsedVariableTest("sigma(Zy)").comp1.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::TENSOR_ZY_COMPONENT);
144 }
145
146 TEST(UnitTestInputUtilities, BadInteger) {
147 EXPECT_ANY_THROW(ParsedVariableTest("vector(0)"));
148 EXPECT_ANY_THROW(ParsedVariableTest("vector(-1)"));
149 EXPECT_ANY_THROW(ParsedVariableTest("sigma(xx,0)"));
150 }
151
152 TEST(UnitTestInputUtilities, TwoComponent) {
153 auto sigxx_1 = ParsedVariableTest("sigma(xx,1)");
154 EXPECT_EQ(sigxx_1.baseName, "sigma");
155 EXPECT_EQ(sigxx_1.comp1.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::TENSOR_XX_COMPONENT);
156 EXPECT_EQ(sigxx_1.comp2.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::INTEGER_COMPONENT);
157 auto sigma_all = ParsedVariableTest("sigma(*,*)");
158 EXPECT_EQ(sigma_all.baseName, "sigma");
159 EXPECT_EQ(sigma_all.comp1.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::ALL_COMPONENTS);
160 EXPECT_EQ(sigma_all.comp2.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::ALL_COMPONENTS);
161 auto sigma_all_int = ParsedVariableTest("sigma(xx,*)");
162 EXPECT_EQ(sigma_all_int.baseName, "sigma");
163 EXPECT_EQ(sigma_all_int.comp1.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::TENSOR_XX_COMPONENT);
164 EXPECT_EQ(sigma_all_int.comp2.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::ALL_COMPONENTS);
165 auto sigma_all_1 = ParsedVariableTest("sigma(*,1)");
166 EXPECT_EQ(sigma_all_1.baseName, "sigma");
167 EXPECT_EQ(sigma_all_1.comp1.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::ALL_COMPONENTS);
168 EXPECT_EQ(sigma_all_1.comp2.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::INTEGER_COMPONENT);
169 }
170
171 TEST(UnitTestInputUtilities, TwoComponentBad) {
172 EXPECT_ANY_THROW(ParsedVariableTest("sigma(xx,1)g"));
173 EXPECT_ANY_THROW(ParsedVariableTest("sigma(xx,xx) "));
174 EXPECT_ANY_THROW(ParsedVariableTest("sigma(xx xx) "));
175 EXPECT_ANY_THROW(ParsedVariableTest("sigma(1 2 3)"));
176 EXPECT_ANY_THROW(ParsedVariableTest("sigma(xx 2 3)"));
177 EXPECT_ANY_THROW(ParsedVariableTest("sigma(xx,1,3)"));
178 EXPECT_ANY_THROW(ParsedVariableTest("sigma(xx,1 3)"));
179 EXPECT_ANY_THROW(ParsedVariableTest("sigma sigma(xx,1 3)"));
180 EXPECT_ANY_THROW(ParsedVariableTest("sigma sigma (xx,1 3)"));
181 EXPECT_ANY_THROW(ParsedVariableTest("sigma sigma"));
182 }
183
184 TEST(UnitTestInputUtilities, InitialSpace) {
185 EXPECT_ANY_THROW(ParsedVariableTest(" sigma(xx,1)"));
186 EXPECT_ANY_THROW(ParsedVariableTest(" sigma(xx)"));
187 }
188
189 TEST(UnitTestInputUtilities, NameWithPercent) {
190 ParsedVariableTest percentName("plane%surf_3");
191 EXPECT_EQ(percentName.baseName, "plane%surf_3");
192 }
193
194 TEST(UnitTestInputUtilities, NameWithDash) {
195 ParsedVariableTest percentName("plane-surf_3");
196 EXPECT_EQ(percentName.baseName, "plane-surf_3");
197 }
198
199 TEST(UnitTestInputUtilities, NameWithArrow) {
200 ParsedVariableTest percentName("plane->surf_3");
201 EXPECT_EQ(percentName.baseName, "plane->surf_3");
202 }
203
204 TEST(UnitTestInputUtilities, NameWithPeriod) {
205 ParsedVariableTest percentName("plane.surf_3");
206 EXPECT_EQ(percentName.baseName, "plane.surf_3");
207 }
208
209 TEST(UnitTestInputUtilities, NameWithColon) {
210 ParsedVariableTest percentName("plane:surf_3");
211 EXPECT_EQ(percentName.baseName, "plane:surf_3");
212 }
213
214 TEST(UnitTestInputUtilities, KeepVarCaseSensitive) {
215 ParsedVariableTest percentName("DisP");
216 EXPECT_EQ(percentName.baseName.s_str(), "DisP");
217 }
218
219 TEST(UnitTestInputUtilities, KeepVarCaseSensitiveWithOneComp) {
220 ParsedVariableTest percentName("DisP(x)");
221 EXPECT_EQ(percentName.baseName.s_str(), "DisP");
222 }
223
224 TEST(UnitTestInputUtilities, KeepVarCaseSensitiveWithTwoComp) {
225 ParsedVariableTest percentName("DisP(x,2)");
226 EXPECT_EQ(percentName.baseName.s_str(), "DisP");
227 }
228
229 TEST(UnitTestInputUtilities, MixedCase) {
230 ParsedVariableTest mixedCase("Vector(X)");
231 EXPECT_EQ(mixedCase.comp1.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::VECTOR_X_COMPONENT);
232 EXPECT_EQ(mixedCase.comp2.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::UNSPECIFIED_COMPONENT);
233 EXPECT_TRUE(mixedCase.baseName == "vector");
234 EXPECT_EQ(mixedCase.name(), "vector(x)");
235 }
236
237 TEST(UnitTestInputUtilities, ExcessiveWhitespace) {
238 EXPECT_ANY_THROW(ParsedVariableTest(" vector ( X ) ")); // Starting Space
239 ParsedVariableTest excessiveWhitespace("vector ( X ) ");
240 EXPECT_EQ(excessiveWhitespace.comp1.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::VECTOR_X_COMPONENT);
241 EXPECT_EQ(excessiveWhitespace.comp2.ComponentEnumVal(), stk::diag::VariableComponent::ComponentEnum::UNSPECIFIED_COMPONENT);
242 EXPECT_TRUE(excessiveWhitespace.baseName == "vector");
243 EXPECT_EQ(excessiveWhitespace.name(), "vector(x)");
244 }
245
246 TEST(UnitTestInputUtilities, InvalidCharactersInComponents) {
247 EXPECT_ANY_THROW(ParsedVariableTest("vector(X@)"));
248 EXPECT_ANY_THROW(ParsedVariableTest("vector(X#)"));
249 EXPECT_ANY_THROW(ParsedVariableTest("vector(X$)"));
250 }
251
252 TEST(UnitTestInputUtilities, EmptyBaseName) {
253 EXPECT_ANY_THROW(ParsedVariableTest("(X)"));
254 }
255
256 TEST(UnitTestInputUtilities, MultipleComponents) {
257 EXPECT_ANY_THROW(ParsedVariableTest("vector(X,Y)"));
258 }
259
260 TEST(UnitTestInputUtilities, InvalidBaseNameCharacters) {
261 EXPECT_ANY_THROW(ParsedVariableTest("vector@name(X)"));
262 EXPECT_ANY_THROW(ParsedVariableTest("vector#name(X)"));
263 EXPECT_ANY_THROW(ParsedVariableTest("vector$name(X)"));
264 }
265
266 }