Page MenuHomePhabricator
Differential D63713 Diff 216839 unittests/Support/DataExtractorTest.cpp

Changeset View

Standalone View

View Options

unittests/Support/DataExtractorTest.cpp

1//===- llvm/unittest/Support/DataExtractorTest.cpp - DataExtractor tests --===// 1​//===- llvm/unittest/Support/DataExtractorTest.cpp - DataExtractor tests --===//
2// 2​//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 3​// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information. 4​// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 5​// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6// 6​//
7//===----------------------------------------------------------------------===// 7​//===----------------------------------------------------------------------===//
8 8​
9#include "llvm/Support/DataExtractor.h" 9​#include "llvm/Support/DataExtractor.h"
10​#include "llvm/Testing/Support/Error.h"
probinsonUnsubmitted
Done
Reply

The Error is part of the DataExtractor interface, you should not need to #include this here.

probinson: The Error is part of the DataExtractor interface, you should not need to #include this here.
labathAuthorUnsubmitted
Done
Reply

This is the testing support header which defines stuff that makes things like EXPECT_THAT_ERROR(..., Succeeded()) work.

labath: This is the testing support header which defines stuff that makes things like…
probinsonUnsubmitted
Done
Reply

Doh! I'm due for an eye test.

probinson: Doh! I'm due for an eye test.
10#include "gtest/gtest.h" 11​#include "gtest/gtest.h"
11using namespace llvm; 12​using namespace llvm;
12 13​
13namespace { 14​namespace {
14 15​
15const char numberData[] = "\x80\x90\xFF\xFF\x80\x00\x00\x00"; 16​const char numberData[] = "\x80\x90\xFF\xFF\x80\x00\x00\x00";
16const char stringData[] = "hellohello\0hello"; 17​const char stringData[] = "hellohello\0hello";
17const char leb128data[] = "\xA6\x49"; 18​const char leb128data[] = "\xA6\x49";
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Line(s)120TEST(DataExtractorTest, LEB128_error) {
121 uint64_t Offset = 0; 122​ uint64_t Offset = 0;
122 EXPECT_EQ(0U, DE.getULEB128(&Offset)); 123​ EXPECT_EQ(0U, DE.getULEB128(&Offset));
123 EXPECT_EQ(0U, Offset); 124​ EXPECT_EQ(0U, Offset);
124 125​
125 Offset = 0; 126​ Offset = 0;
126 EXPECT_EQ(0U, DE.getSLEB128(&Offset)); 127​ EXPECT_EQ(0U, DE.getSLEB128(&Offset));
127 EXPECT_EQ(0U, Offset); 128​ EXPECT_EQ(0U, Offset);
128} 129​}
130​
131​TEST(DataExtractorTest, Cursor_tell) {
132​ DataExtractor DE(StringRef("AB"), false, 8);
133​ DataExtractor::Cursor C(0);
134​ // A successful read operation advances the cursor
135​ EXPECT_EQ('A', DE.getU8(C));
136​ EXPECT_EQ(1u, C.tell());
137​
138​ // An unsuccessful one doesn't.
139​ EXPECT_EQ(0u, DE.getU16(C));
140​ EXPECT_EQ(1u, C.tell());
141​
142​ // And neither do any subsequent operations.
143​ EXPECT_EQ(0, DE.getU8(C));
144​ EXPECT_EQ(1u, C.tell());
145​
146​ consumeError(C.takeError());
147​}
148​
149​TEST(DataExtractorTest, Cursor_takeError) {
150​ DataExtractor DE(StringRef("AB"), false, 8);
151​ DataExtractor::Cursor C(0);
152​ // Initially, the cursor is in the "success" state.
153​ EXPECT_THAT_ERROR(C.takeError(), Succeeded());
154​
155​ // It remains "success" after a successful read.
156​ EXPECT_EQ('A', DE.getU8(C));
157​ EXPECT_THAT_ERROR(C.takeError(), Succeeded());
158​
159​ // An unsuccessful read sets the error state.
160​ EXPECT_EQ(0u, DE.getU32(C));
161​ EXPECT_THAT_ERROR(C.takeError(), Failed());
162​
163​ // Once set the error sticks until explicitly cleared.
164​ EXPECT_EQ(0u, DE.getU32(C));
165​ EXPECT_EQ(0, DE.getU8(C));
166​ EXPECT_THAT_ERROR(C.takeError(), Failed());
167​
168​ // At which point reads can be succeed again.
169​ EXPECT_EQ('B', DE.getU8(C));
170​ EXPECT_THAT_ERROR(C.takeError(), Succeeded());
171​}
172​
173​TEST(DataExtractorTest, Cursor_chaining) {
174​ DataExtractor DE(StringRef("ABCD"), false, 8);
175​ DataExtractor::Cursor C(0);
176​
177​ // Multiple reads can be chained without trigerring any assertions.
178​ EXPECT_EQ('A', DE.getU8(C));
179​ EXPECT_EQ('B', DE.getU8(C));
180​ EXPECT_EQ('C', DE.getU8(C));
181​ EXPECT_EQ('D', DE.getU8(C));
182​ // And the error checked at the end.
183​ EXPECT_THAT_ERROR(C.takeError(), Succeeded());
184​}
185​
186​#if defined(GTEST_HAS_DEATH_TEST) && defined(_DEBUG)
187​TEST(DataExtractorDeathTest, Cursor) {
188​ DataExtractor DE(StringRef("AB"), false, 8);
189​
190​ // Even an unused cursor must be checked for errors:
191​ EXPECT_DEATH(DataExtractor::Cursor(0),
192​ "Success values must still be checked prior to being destroyed");
193​
194​ {
195​ auto C = std::make_unique<DataExtractor::Cursor>(0);
196​ EXPECT_EQ(0u, DE.getU32(*C));
197​ // It must also be checked after an unsuccessful operation.
198​ // destruction.
199​ EXPECT_DEATH(C.reset(), "unexpected end of data");
200​ EXPECT_THAT_ERROR(C->takeError(), Failed());
201​ }
202​ {
203​ auto C = std::make_unique<DataExtractor::Cursor>(0);
204​ EXPECT_EQ('A', DE.getU8(*C));
205​ // Same goes for a successful one.
206​ EXPECT_DEATH(
207​ C.reset(),
208​ "Success values must still be checked prior to being destroyed");
209​ EXPECT_THAT_ERROR(C->takeError(), Succeeded());
210​ }
211​ {
212​ auto C = std::make_unique<DataExtractor::Cursor>(0);
213​ EXPECT_EQ('A', DE.getU8(*C));
214​ EXPECT_EQ(0u, DE.getU32(*C));
215​ // Even if a successful operation is followed by an unsuccessful one.
216​ EXPECT_DEATH(C.reset(), "unexpected end of data");
217​ EXPECT_THAT_ERROR(C->takeError(), Failed());
218​ }
219​ {
220​ auto C = std::make_unique<DataExtractor::Cursor>(0);
221​ EXPECT_EQ(0u, DE.getU32(*C));
222​ EXPECT_EQ(0, DE.getU8(*C));
223​ // Even if an unsuccessful operation is followed by one that would normally
224​ // succeed.
225​ EXPECT_DEATH(C.reset(), "unexpected end of data");
dblaikieUnsubmitted
Done
Reply

This produces undefined behavior in the non-death case (the dtor will run twice - importantly it'll run on something that isn't an object of the right type (because that object's already been destroyed)

You could use an Optional<Cursor> to have control over the point of destruction (then "EXPECT_DEATH(opt.reset()..." to observe the unchecked Error).

dblaikie: This produces undefined behavior in the non-death case (the dtor will run twice - importantly…
labathAuthorUnsubmitted
Done
Reply

Done. I've gone with a std::unique_ptr because it makes the construction of the cursor slightly nicer (missing an in_place_t for llvm::Optional).

labath: Done. I've gone with a std::unique_ptr because it makes the construction of the cursor slightly…
226​ EXPECT_THAT_ERROR(C->takeError(), Failed());
227​ }
228​}
229​#endif
230​
231​TEST(DataExtractorTest, getU8_vector) {
232​ DataExtractor DE(StringRef("AB"), false, 8);
233​ DataExtractor::Cursor C(0);
234​ SmallString<2> S;
235​
236​ DE.getU8(C, S, 4);
237​ EXPECT_THAT_ERROR(C.takeError(), Failed());
238​ EXPECT_EQ("", S);
239​
240​ DE.getU8(C, S, 2);
241​ EXPECT_THAT_ERROR(C.takeError(), Succeeded());
242​ EXPECT_EQ("AB", S);
243​}
244​
245​TEST(DataExtractorTest, skip) {
246​ DataExtractor DE(StringRef("AB"), false, 8);
247​ DataExtractor::Cursor C(0);
248​
249​ DE.skip(C, 4);
250​ EXPECT_THAT_ERROR(C.takeError(), Failed());
251​ EXPECT_EQ(0u, C.tell());
252​
253​ DE.skip(C, 2);
254​ EXPECT_THAT_ERROR(C.takeError(), Succeeded());
255​ EXPECT_EQ(2u, C.tell());
256​}
257​
258​TEST(DataExtractorTest, eof) {
259​ DataExtractor DE(StringRef("A"), false, 8);
260​ DataExtractor::Cursor C(0);
261​
262​ EXPECT_FALSE(DE.eof(C));
263​
264​ EXPECT_EQ(0, DE.getU16(C));
265​ EXPECT_FALSE(DE.eof(C));
266​ EXPECT_THAT_ERROR(C.takeError(), Failed());
probinsonUnsubmitted
Done
Reply

Test for eof() in the error case? (attempt to read too far, but eof is still false, if that's the correct contract.)

probinson: Test for eof() in the error case? (attempt to read too far, but eof is still false, if that's…
267​
268​ EXPECT_EQ('A', DE.getU8(C));
269​ EXPECT_TRUE(DE.eof(C));
270​ EXPECT_THAT_ERROR(C.takeError(), Succeeded());
271​}
129} 272​}