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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <string>
#include "base/bind.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "sql/connection.h"
#include "sql/statement.h"
#include "sql/test/sql_test_base.h"
#include "sql/test/test_helpers.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/sqlite/sqlite3.h"
// Test that certain features are/are-not enabled in our SQLite.
namespace {
void CaptureErrorCallback(int* error_pointer, std::string* sql_text,
int error, sql::Statement* stmt) {
*error_pointer = error;
const char* text = stmt ? stmt->GetSQLStatement() : NULL;
*sql_text = text ? text : "no statement available";
}
class SQLiteFeaturesTest : public sql::SQLTestBase {
public:
SQLiteFeaturesTest() : error_(SQLITE_OK) {}
void SetUp() override {
SQLTestBase::SetUp();
// The error delegate will set |error_| and |sql_text_| when any sqlite
// statement operation returns an error code.
db().set_error_callback(
base::Bind(&CaptureErrorCallback, &error_, &sql_text_));
}
void TearDown() override {
// If any error happened the original sql statement can be found in
// |sql_text_|.
EXPECT_EQ(SQLITE_OK, error_) << sql_text_;
SQLTestBase::TearDown();
}
int error() { return error_; }
private:
// The error code of the most recent error.
int error_;
// Original statement which has caused the error.
std::string sql_text_;
};
// Do not include fts1 support, it is not useful, and nobody is
// looking at it.
TEST_F(SQLiteFeaturesTest, NoFTS1) {
ASSERT_EQ(SQLITE_ERROR, db().ExecuteAndReturnErrorCode(
"CREATE VIRTUAL TABLE foo USING fts1(x)"));
}
// Do not include fts2 support, it is not useful, and nobody is
// looking at it.
TEST_F(SQLiteFeaturesTest, NoFTS2) {
ASSERT_EQ(SQLITE_ERROR, db().ExecuteAndReturnErrorCode(
"CREATE VIRTUAL TABLE foo USING fts2(x)"));
}
// fts3 used to be used for history files, and may also be used by WebDatabase
// clients.
TEST_F(SQLiteFeaturesTest, FTS3) {
ASSERT_TRUE(db().Execute("CREATE VIRTUAL TABLE foo USING fts3(x)"));
}
#if !defined(USE_SYSTEM_SQLITE)
// Originally history used fts2, which Chromium patched to treat "foo*" as a
// prefix search, though the icu tokenizer would return it as two tokens {"foo",
// "*"}. Test that fts3 works correctly.
TEST_F(SQLiteFeaturesTest, FTS3_Prefix) {
const char kCreateSql[] =
"CREATE VIRTUAL TABLE foo USING fts3(x, tokenize icu)";
ASSERT_TRUE(db().Execute(kCreateSql));
ASSERT_TRUE(db().Execute("INSERT INTO foo (x) VALUES ('test')"));
sql::Statement s(db().GetUniqueStatement(
"SELECT x FROM foo WHERE x MATCH 'te*'"));
ASSERT_TRUE(s.Step());
EXPECT_EQ("test", s.ColumnString(0));
}
#endif
#if !defined(USE_SYSTEM_SQLITE)
// Verify that Chromium's SQLite is compiled with HAVE_USLEEP defined. With
// HAVE_USLEEP, SQLite uses usleep() with millisecond granularity. Otherwise it
// uses sleep() with second granularity.
TEST_F(SQLiteFeaturesTest, UsesUsleep) {
base::TimeTicks before = base::TimeTicks::Now();
sqlite3_sleep(1);
base::TimeDelta delta = base::TimeTicks::Now() - before;
// It is not impossible for this to be over 1000 if things are compiled the
// right way. But it is very unlikely, most platforms seem to be around
// <TBD>.
LOG(ERROR) << "Milliseconds: " << delta.InMilliseconds();
EXPECT_LT(delta.InMilliseconds(), 1000);
}
#endif
// Ensure that our SQLite version has working foreign key support with cascade
// delete support.
TEST_F(SQLiteFeaturesTest, ForeignKeySupport) {
ASSERT_TRUE(db().Execute("PRAGMA foreign_keys=1"));
ASSERT_TRUE(db().Execute("CREATE TABLE parents (id INTEGER PRIMARY KEY)"));
ASSERT_TRUE(db().Execute(
"CREATE TABLE children ("
" id INTEGER PRIMARY KEY,"
" pid INTEGER NOT NULL REFERENCES parents(id) ON DELETE CASCADE)"));
// Inserting without a matching parent should fail with constraint violation.
// Mask off any extended error codes for USE_SYSTEM_SQLITE.
int insertErr = db().ExecuteAndReturnErrorCode(
"INSERT INTO children VALUES (10, 1)");
EXPECT_EQ(SQLITE_CONSTRAINT, (insertErr&0xff));
size_t rows;
EXPECT_TRUE(sql::test::CountTableRows(&db(), "children", &rows));
EXPECT_EQ(0u, rows);
// Inserting with a matching parent should work.
ASSERT_TRUE(db().Execute("INSERT INTO parents VALUES (1)"));
EXPECT_TRUE(db().Execute("INSERT INTO children VALUES (11, 1)"));
EXPECT_TRUE(db().Execute("INSERT INTO children VALUES (12, 1)"));
EXPECT_TRUE(sql::test::CountTableRows(&db(), "children", &rows));
EXPECT_EQ(2u, rows);
// Deleting the parent should cascade, i.e., delete the children as well.
ASSERT_TRUE(db().Execute("DELETE FROM parents"));
EXPECT_TRUE(sql::test::CountTableRows(&db(), "children", &rows));
EXPECT_EQ(0u, rows);
}
} // namespace
|
