1 : // Copyright 2013 Google Inc. 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 : #include "syzygy/pehacker/variables.h"
16 :
17 : #include "base/logging.h"
18 : #include "gtest/gtest.h"
19 :
20 : namespace pehacker {
21 :
22 : namespace {
23 :
24 : class VariablesTest : public testing::Test {
25 : public:
26 E : VariablesTest() : previous_log_level_(0) {
27 E : }
28 :
29 E : void SetUp() {
30 : // Silence logging.
31 E : previous_log_level_ = logging::GetMinLogLevel();
32 E : logging::SetMinLogLevel(logging::LOG_FATAL);
33 E : }
34 :
35 E : void TearDown() {
36 : // Restore logging to its previous level.
37 E : logging::SetMinLogLevel(previous_log_level_);
38 E : previous_log_level_ = 0;
39 E : }
40 :
41 : int previous_log_level_;
42 : };
43 :
44 : } // namespace
45 :
46 E : TEST_F(VariablesTest, VariableNameIsValid) {
47 E : EXPECT_FALSE(VariableNameIsValid("foo bar"));
48 E : EXPECT_FALSE(VariableNameIsValid("foo-bar"));
49 E : EXPECT_FALSE(VariableNameIsValid("foo@bar"));
50 E : EXPECT_FALSE(VariableNameIsValid("foo!bar"));
51 E : EXPECT_FALSE(VariableNameIsValid("var%"));
52 E : EXPECT_TRUE(VariableNameIsValid("123"));
53 E : EXPECT_TRUE(VariableNameIsValid("foo"));
54 E : EXPECT_TRUE(VariableNameIsValid("foo123"));
55 E : EXPECT_TRUE(VariableNameIsValid("foo_bar"));
56 E : EXPECT_TRUE(VariableNameIsValid("foo_bar_1"));
57 E : EXPECT_TRUE(VariableNameIsValid("__"));
58 E : }
59 :
60 E : TEST_F(VariablesTest, ConvertVariableToString) {
61 E : std::string result;
62 :
63 E : base::DictionaryValue d;
64 E : base::ListValue l;
65 E : base::FundamentalValue f(static_cast<double>(3.14));
66 E : EXPECT_FALSE(ConvertVariableToString(d, &result));
67 E : EXPECT_FALSE(ConvertVariableToString(l, &result));
68 E : EXPECT_FALSE(ConvertVariableToString(f, &result));
69 :
70 E : base::FundamentalValue b(static_cast<bool>(true));
71 E : base::FundamentalValue i(static_cast<int>(42));
72 E : base::StringValue s("string");
73 E : EXPECT_TRUE(ConvertVariableToString(b, &result));
74 E : EXPECT_EQ("1", result);
75 E : EXPECT_TRUE(ConvertVariableToString(i, &result));
76 E : EXPECT_EQ("42", result);
77 E : EXPECT_TRUE(ConvertVariableToString(s, &result));
78 E : EXPECT_EQ("string", result);
79 E : }
80 :
81 E : TEST_F(VariablesTest, ConvertVariableToJson) {
82 E : std::string result;
83 :
84 E : base::DictionaryValue d;
85 E : base::ListValue l;
86 E : base::FundamentalValue f(static_cast<double>(3.14));
87 E : EXPECT_FALSE(ConvertVariableToJson(d, &result));
88 E : EXPECT_FALSE(ConvertVariableToJson(l, &result));
89 E : EXPECT_FALSE(ConvertVariableToJson(f, &result));
90 :
91 E : base::FundamentalValue b(static_cast<bool>(true));
92 E : base::FundamentalValue i(static_cast<int>(42));
93 E : base::StringValue s("string");
94 E : EXPECT_TRUE(ConvertVariableToJson(b, &result));
95 E : EXPECT_EQ("1", result);
96 E : EXPECT_TRUE(ConvertVariableToJson(i, &result));
97 E : EXPECT_EQ("42", result);
98 E : EXPECT_TRUE(ConvertVariableToJson(s, &result));
99 E : EXPECT_EQ("\"string\"", result);
100 E : }
101 :
102 E : TEST_F(VariablesTest, ParseVariableFailsForInvalidNames) {
103 E : base::DictionaryValue d;
104 E : EXPECT_FALSE(ParseVariable("foo bar", "", &d));
105 E : EXPECT_FALSE(ParseVariable("foo-bar", "", &d));
106 E : EXPECT_FALSE(ParseVariable("foo@bar", "", &d));
107 :
108 E : base::StringValue s("");
109 E : EXPECT_FALSE(ParseVariable("foo bar", s, &d));
110 E : EXPECT_FALSE(ParseVariable("foo-bar", s, &d));
111 E : EXPECT_FALSE(ParseVariable("foo@bar", s, &d));
112 E : }
113 :
114 E : TEST_F(VariablesTest, ParseVariableFailsForInvalidStringValues) {
115 E : base::DictionaryValue d;
116 E : EXPECT_FALSE(ParseVariable("var", "[]", &d));
117 E : EXPECT_FALSE(ParseVariable("var", "{}", &d));
118 E : EXPECT_FALSE(ParseVariable("var", "3.14", &d));
119 :
120 E : base::ListValue l;
121 E : base::FundamentalValue f(static_cast<double>(3.14));
122 E : EXPECT_FALSE(ParseVariable("var", d, &d));
123 E : EXPECT_FALSE(ParseVariable("var", l, &d));
124 E : EXPECT_FALSE(ParseVariable("var", f, &d));
125 E : }
126 :
127 E : TEST_F(VariablesTest, ParseVariableFailsCollision) {
128 E : base::DictionaryValue d;
129 E : EXPECT_TRUE(ParseVariable("var", "3", &d));
130 E : EXPECT_FALSE(ParseVariable("var", "4", &d));
131 :
132 E : base::StringValue s("hey");
133 E : EXPECT_FALSE(ParseVariable("var", s, &d));
134 :
135 E : int var = 0;
136 E : EXPECT_TRUE(d.GetInteger("var", &var));
137 E : EXPECT_EQ(3, var);
138 E : }
139 :
140 E : TEST_F(VariablesTest, ParseVariableSucceedsDefault) {
141 E : base::DictionaryValue d;
142 E : EXPECT_TRUE(ParseVariable("var1", "1", &d));
143 E : EXPECT_TRUE(ParseVariable("var2%", "2", &d));
144 E : EXPECT_TRUE(ParseVariable("var1%", "0", &d));
145 :
146 E : int var1 = 0;
147 E : int var2 = 0;
148 E : EXPECT_TRUE(d.GetInteger("var1", &var1));
149 E : EXPECT_TRUE(d.GetInteger("var2", &var2));
150 E : EXPECT_EQ(1, var1);
151 E : EXPECT_EQ(2, var2);
152 E : }
153 :
154 E : TEST_F(VariablesTest, ParseVariableSucceeds) {
155 E : base::DictionaryValue d;
156 E : EXPECT_TRUE(ParseVariable("var1", "true", &d));
157 E : EXPECT_TRUE(ParseVariable("var2", "3", &d));
158 E : EXPECT_TRUE(ParseVariable("var3", "string", &d));
159 E : EXPECT_TRUE(ParseVariable("var4", "\"string\"", &d));
160 E : EXPECT_TRUE(ParseVariable("var5", "", &d));
161 :
162 E : std::string s;
163 E : int i = 0;
164 E : bool b = false;
165 :
166 E : EXPECT_TRUE(d.GetBoolean("var1", &b));
167 E : EXPECT_TRUE(b);
168 :
169 E : EXPECT_TRUE(d.GetInteger("var2", &i));
170 E : EXPECT_EQ(3, i);
171 :
172 E : EXPECT_TRUE(d.GetString("var3", &s));
173 E : EXPECT_EQ("string", s);
174 :
175 E : EXPECT_TRUE(d.GetString("var4", &s));
176 E : EXPECT_EQ("string", s);
177 :
178 E : EXPECT_TRUE(d.GetString("var5", &s));
179 E : EXPECT_TRUE(s.empty());
180 E : }
181 :
182 E : TEST_F(VariablesTest, MergeVariables) {
183 E : base::DictionaryValue dst;
184 E : base::DictionaryValue src;
185 :
186 E : src.SetInteger("var1%", 3);
187 E : src.SetInteger("var2", 45);
188 :
189 E : dst.SetInteger("var1", 42);
190 :
191 E : EXPECT_TRUE(MergeVariables(src, &dst));
192 :
193 E : int i = 0;
194 E : EXPECT_TRUE(dst.GetInteger("var1", &i));
195 E : EXPECT_EQ(42, i);
196 E : EXPECT_TRUE(dst.GetInteger("var2", &i));
197 E : EXPECT_EQ(45, i);
198 :
199 : // This will fail a second time becase var2 is defined.
200 E : EXPECT_FALSE(MergeVariables(src, &dst));
201 :
202 E : EXPECT_TRUE(dst.GetInteger("var1", &i));
203 E : EXPECT_EQ(42, i);
204 E : EXPECT_TRUE(dst.GetInteger("var2", &i));
205 E : EXPECT_EQ(45, i);
206 E : }
207 :
208 E : TEST_F(VariablesTest, ExpandVariables) {
209 E : base::DictionaryValue d;
210 E : d.SetString("var1", "foo");
211 E : d.SetString("var2", "$(var1)bar");
212 E : d.SetString("var3", "$(var4)");
213 E : d.SetString("var4", "$(var3)");
214 :
215 E : std::string s;
216 E : EXPECT_FALSE(ExpandVariables(d, "$", &s)); // Hanging $.
217 E : EXPECT_FALSE(ExpandVariables(d, "$$$", &s)); // Hanging $.
218 E : EXPECT_FALSE(ExpandVariables(d, "$(foo", &s)); // Mismatched parenthesis.
219 E : EXPECT_FALSE(ExpandVariables(d, "$()", &s)); // Empty name.
220 E : EXPECT_FALSE(ExpandVariables(d, "$(var5)", &s)); // Missing variable.
221 E : EXPECT_FALSE(ExpandVariables(d, "$(var4)", &s)); // Circular definition.
222 :
223 E : EXPECT_TRUE(ExpandVariables(d, "$$", &s));
224 E : EXPECT_EQ("$", s);
225 :
226 E : EXPECT_TRUE(ExpandVariables(d, "$$(var1)", &s));
227 E : EXPECT_EQ("$(var1)", s);
228 :
229 E : EXPECT_TRUE(ExpandVariables(d, "$(var2)", &s));
230 E : EXPECT_EQ("foobar", s);
231 :
232 E : EXPECT_TRUE(ExpandVariables(d, "$(var1)-$(var2)", &s));
233 E : EXPECT_EQ("foo-foobar", s);
234 :
235 E : EXPECT_TRUE(ExpandVariables(d, "$$$(var1)", &s));
236 E : EXPECT_EQ("$foo", s);
237 E : }
238 :
239 : } // namespace pehacker
|