1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef SQL_TEST_SCOPED_ERROR_EXPECTER_H_
#define SQL_TEST_SCOPED_ERROR_EXPECTER_H_
#include <set>
#include "sql/database.h"
// This is not strictly necessary for the operation of ScopedErrorExpecter, but
// the class is not useful without the SQLite error codes.
#include "third_party/sqlite/sqlite3.h"
namespace sql {
namespace test {
// sql::Database and sql::Statement treat most SQLite errors as fatal in debug
// mode. The goal is to catch SQL errors before code is shipped to production.
// That fatal check makes it hard to write tests for error-handling code. This
// scoper lists errors to expect and treat as non-fatal. Errors are expected
// globally (on all connections).
//
// Since errors can be very context-dependent, the class is pedantic - specific
// errors must be expected, and every expected error must be seen.
//
// NOTE(shess): There are still fatal error cases this does not address. If
// your test is handling database errors and you're hitting a case not handled,
// contact me.
class ScopedErrorExpecter {
public:
ScopedErrorExpecter();
ScopedErrorExpecter(const ScopedErrorExpecter&) = delete;
ScopedErrorExpecter& operator=(const ScopedErrorExpecter&) = delete;
~ScopedErrorExpecter();
// Add an error to expect. Extended error codes can be specified
// individually, or the base code can be specified to expect errors for the
// entire group (SQLITE_IOERR_* versus SQLITE_IOERR).
void ExpectError(int err);
// Return |true| if the all of the expected errors were encountered. Failure
// to call this results in an EXPECT failure when the instance is destructed.
[[nodiscard]] bool SawExpectedErrors();
private:
// The target of the callback passed to Database::SetErrorExpecter(). If
// |err| matches an error passed to ExpectError(), records |err| and returns
// |true|; this indicates that the enclosing test expected this error and the
// caller should continue as it would in production. Otherwise returns
// |false| and adds a failure to the current test.
bool ErrorSeen(int err);
// Callback passed to Database::SetErrorExpecter().
Database::ScopedErrorExpecterCallback callback_;
// Record whether SawExpectedErrors() has been called.
bool checked_;
// Errors to expect.
std::set<int> errors_expected_;
// Expected errors which have been encountered.
std::set<int> errors_seen_;
};
} // namespace test
} // namespace sql
#endif // SQL_TEST_SCOPED_ERROR_EXPECTER_H_
|
