github_mirrors/vectorscan
3
0
Fork 1
mirror of https://github.com/VectorCamp/vectorscan.git synced 2025-09-30 19:47:43 +03:00
Code Issues Packages Projects Releases Wiki Activity

cStyleCasts

Browse Source
This commit is contained in:
gtsoul-tech
2024-05-17 13:57:12 +03:00
parent db92a42681
commit 2fa06dd9ed
19 changed files with 183 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
unit/hyperscan/allocators.cpp
View File

@@ -68,7 +68,7 @@ void two_aligned_free(void *mem) {
return;
}
// Allocated with two_aligned_malloc above.
free((char *)mem - 2);
free(static_cast<char *>(mem) - 2);
}
TEST(CustomAllocator, TwoAlignedCompile) {

12
unit/hyperscan/extparam.cpp
View File

@@ -58,14 +58,14 @@ TEST(ExtParam, LargeMinOffset) {
// ensure it doesn't match.
string corpus = "hatstand" + string(80000, '_') + "teakettle";
err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(0U, c.matches.size());
// Try exactly at the min_offset.
corpus = "hatstand" + string(99983, '_') + "teakettle";
err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(1U, c.matches.size());
ASSERT_EQ(MatchRecord(100000, 0), c.matches[0]);
@@ -97,7 +97,7 @@ TEST(ExtParam, LargeExactOffset) {
// ensure it doesn't match.
string corpus = "hatstand" + string(199982, '_') + "teakettle";
err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(0U, c.matches.size());
@@ -113,7 +113,7 @@ TEST(ExtParam, LargeExactOffset) {
c.clear();
corpus = "hatstand" + string(199984, '_') + "teakettle";
err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(0U, c.matches.size());
@@ -143,14 +143,14 @@ TEST(ExtParam, LargeMinLength) {
// short.
string corpus = string(10000, '_') + "hatstand" + string(80000, '_') + "teakettle";
err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(0U, c.matches.size());
// Now, a match of the right length.
corpus = string(10000, '_') + "hatstand" + string(99983, '_') + "teakettle";
err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(1U, c.matches.size());
ASSERT_EQ(MatchRecord(110000, 0), c.matches[0]);

2
unit/hyperscan/literals.cpp
View File

@@ -87,7 +87,7 @@ protected:
static
int count_cb(unsigned, unsigned long long, unsigned long long, unsigned,
void *ctxt) {
size_t *count = (size_t *)ctxt;
size_t *count = static_cast<size_t *>(ctxt);
(*count)++;
return 0;
}

36
unit/hyperscan/logical_combination.cpp
View File

@@ -60,7 +60,7 @@ TEST(LogicalCombination, SingleComb1) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(16U, c.matches.size());
ASSERT_EQ(MatchRecord(3, 101), c.matches[0]);
@@ -108,7 +108,7 @@ TEST(LogicalCombination, SingleCombQuietSub1) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(8U, c.matches.size());
ASSERT_EQ(MatchRecord(18, 1001), c.matches[0]);
@@ -151,7 +151,7 @@ TEST(LogicalCombination, MultiCombQuietSub1) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(10U, c.matches.size());
ASSERT_EQ(MatchRecord(3, 1003), c.matches[0]);
@@ -198,7 +198,7 @@ TEST(LogicalCombination, MultiHighlanderCombQuietSub1) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(4U, c.matches.size());
ASSERT_EQ(MatchRecord(3, 1003), c.matches[0]);
@@ -237,7 +237,7 @@ TEST(LogicalCombination, MultiQuietCombQuietSub1) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(2U, c.matches.size());
ASSERT_EQ(MatchRecord(3, 1003), c.matches[0]);
@@ -270,7 +270,7 @@ TEST(LogicalCombination, SingleComb2) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(13U, c.matches.size());
ASSERT_EQ(MatchRecord(6, 202), c.matches[0]);
@@ -315,7 +315,7 @@ TEST(LogicalCombination, SingleCombQuietSub2) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(8U, c.matches.size());
ASSERT_EQ(MatchRecord(18, 1002), c.matches[0]);
@@ -354,7 +354,7 @@ TEST(LogicalCombination, SingleComb3) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(17U, c.matches.size());
ASSERT_EQ(MatchRecord(3, 301), c.matches[0]);
@@ -403,7 +403,7 @@ TEST(LogicalCombination, SingleCombQuietSub3) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(8U, c.matches.size());
ASSERT_EQ(MatchRecord(23, 303), c.matches[0]);
@@ -445,7 +445,7 @@ TEST(LogicalCombination, MultiCombDupSub4) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(23U, c.matches.size());
ASSERT_EQ(MatchRecord(6, 202), c.matches[0]);
@@ -503,7 +503,7 @@ TEST(LogicalCombination, MultiCombQuietDupSub4) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(17U, c.matches.size());
ASSERT_EQ(MatchRecord(18, 1002), c.matches[0]);
@@ -564,7 +564,7 @@ TEST(LogicalCombination, MultiCombUniSub5) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(46U, c.matches.size());
ASSERT_EQ(MatchRecord(3, 101), c.matches[0]);
@@ -656,7 +656,7 @@ TEST(LogicalCombination, MultiCombQuietUniSub5) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(30U, c.matches.size());
ASSERT_EQ(MatchRecord(3, 101), c.matches[0]);
@@ -717,7 +717,7 @@ TEST(LogicalCombination, SingleCombPurelyNegative6) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(1U, c.matches.size());
ASSERT_EQ(MatchRecord(53, 1002), c.matches[0]);
@@ -749,7 +749,7 @@ TEST(LogicalCombination, SingleCombQuietPurelyNegative6) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(0U, c.matches.size());
@@ -793,7 +793,7 @@ TEST(LogicalCombination, MultiCombPurelyNegativeUniSub6) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(3U, c.matches.size());
ASSERT_EQ(MatchRecord(106, 202), c.matches[0]);
@@ -841,7 +841,7 @@ TEST(LogicalCombination, MultiCombPurelyNegativeUniSubEOD6) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(8U, c.matches.size());
ASSERT_EQ(MatchRecord(106, 102), c.matches[0]);
@@ -897,7 +897,7 @@ TEST(LogicalCombination, MultiCombStream1) {
int i;
for (i = 0; i < 11; i++) {
err = hs_scan_stream(stream, data[i].c_str(), data[i].size(), 0,
scratch, record_cb, (void *)&c);
scratch, record_cb, reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
}
err = hs_close_stream(stream, scratch, dummy_cb, nullptr);

20
unit/hyperscan/multi.cpp
View File

@@ -59,7 +59,7 @@ TEST(MMAdaptor, norm_cont1) { // UE-901
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(3U, c.matches.size());
ASSERT_EQ(MatchRecord(4, 30), c.matches[0]);
@@ -92,7 +92,7 @@ TEST(MMAdaptor, norm_cont2) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(3U, c.matches.size());
ASSERT_TRUE(c.matches.end() != find(c.matches.begin(), c.matches.end(), MatchRecord(20, 30)));
@@ -125,7 +125,7 @@ TEST(MMAdaptor, norm_halt1) {
c.halt = 1;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SCAN_TERMINATED, err);
ASSERT_EQ(1U, c.matches.size());
ASSERT_EQ(MatchRecord(4, 30), c.matches[0]);
@@ -156,7 +156,7 @@ TEST(MMAdaptor, norm_halt2) { // UE-901
c.halt = 1;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SCAN_TERMINATED, err);
ASSERT_EQ(1U, c.matches.size());
ASSERT_EQ(MatchRecord(20, 30), c.matches[0]);
@@ -187,7 +187,7 @@ TEST(MMAdaptor, high_cont1) { // UE-901
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(2U, c.matches.size());
ASSERT_TRUE(c.matches.end() != find(c.matches.begin(), c.matches.end(), MatchRecord(4, 30)));
@@ -219,7 +219,7 @@ TEST(MMAdaptor, high_cont2) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(2U, c.matches.size());
ASSERT_TRUE(c.matches.end() != find(c.matches.begin(), c.matches.end(), MatchRecord(20, 30)));
@@ -251,7 +251,7 @@ TEST(MMAdaptor, high_halt1) {
c.halt = 1;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SCAN_TERMINATED, err);
ASSERT_EQ(1U, c.matches.size());
ASSERT_EQ(MatchRecord(4, 30), c.matches[0]);
@@ -282,7 +282,7 @@ TEST(MMAdaptor, high_halt2) {
c.halt = 1;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SCAN_TERMINATED, err);
ASSERT_EQ(1U, c.matches.size());
ASSERT_TRUE(MatchRecord(20, 30) == c.matches[0]
@@ -311,7 +311,7 @@ TEST(MPV, UE_2395) {
CallBackContext c;
err = hs_scan(db, data.data(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
unsigned seen = 39;
@@ -358,7 +358,7 @@ TEST(MMRoseLiteralPath, issue_141) {
c.halt = 0;
err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb,
(void *)&c);
reinterpret_cast<void *>(&c));
ASSERT_EQ(HS_SUCCESS, err);
ASSERT_EQ(1U, c.matches.size());
ASSERT_EQ(MatchRecord(19, 0), c.matches[0]);

10
unit/hyperscan/scratch_in_use.cpp
View File

@@ -148,7 +148,7 @@ void runVectoredTest(match_event_handler cb_func) {
static
int rescan_block_cb(unsigned, unsigned long long, unsigned long long, unsigned,
void *ctx) {
RescanContext *rctx = (RescanContext *)ctx;
RescanContext *rctx = reinterpret_cast<RescanContext *>(ctx);
rctx->matches++;
const string data = "___foo___bar_";
@@ -168,7 +168,7 @@ TEST(ScratchInUse, Block) {
static
int rescan_stream_cb(unsigned, unsigned long long, unsigned long long, unsigned,
void *ctx) {
RescanContext *rctx = (RescanContext *)ctx;
RescanContext *rctx = reinterpret_cast<RescanContext *>(ctx);
rctx->matches++;
const string data = "___foo___bar_";
@@ -197,7 +197,7 @@ TEST(ScratchInUse, Streaming) {
static
int rescan_vector_cb(unsigned, unsigned long long, unsigned long long, unsigned,
void *ctx) {
RescanContext *rctx = (RescanContext *)ctx;
RescanContext *rctx = reinterpret_cast<RescanContext *>(ctx);
rctx->matches++;
const string data1 = "___foo_";
@@ -221,7 +221,7 @@ TEST(ScratchInUse, Vectored) {
static
int rescan_realloc_cb(unsigned, unsigned long long, unsigned long long,
unsigned, void *ctx) {
RescanContext *rctx = (RescanContext *)ctx;
RescanContext *rctx = reinterpret_cast<RescanContext *>(ctx);
rctx->matches++;
auto db = makeDatabase("another db", 0, HS_MODE_BLOCK);
@@ -251,7 +251,7 @@ TEST(ScratchInUse, ReallocScratchVector) {
static
int rescan_free_cb(unsigned, unsigned long long, unsigned long long,
unsigned, void *ctx) {
RescanContext *rctx = (RescanContext *)ctx;
RescanContext *rctx = reinterpret_cast<RescanContext *>(ctx);
rctx->matches++;
hs_error_t err = hs_free_scratch(rctx->scratch);

18
unit/hyperscan/test_util.cpp
View File

@@ -41,7 +41,7 @@ using namespace std;
int record_cb(unsigned id, unsigned long long, unsigned long long to,
unsigned, void *ctxt) {
CallBackContext *c = (CallBackContext *)ctxt;
CallBackContext *c = reinterpret_cast<CallBackContext *>(ctxt);
c->matches.emplace_back(to, id);
@@ -189,8 +189,8 @@ void *count_malloc(size_t n) {
}
allocated_count += n;
*(size_t *)pp = n;
void *p = (char *)pp + 16;
*(reinterpret_cast<size_t *>(pp)) = n;
void *p = static_cast<char *>(pp) + 16;
return p;
}
@@ -200,8 +200,8 @@ void count_free(void *p) {
return;
}
void *pp = (char *)p - 16;
size_t n = *(size_t *)pp;
void *pp = static_cast<char *>(p) - 16;
size_t n = *(reinterpret_cast<size_t *>(pp));
allocated_count -= n;
@@ -215,8 +215,8 @@ void *count_malloc_b(size_t n) {
}
allocated_count_b += n;
*(size_t *)pp = n;
void *p = (char *)pp + 32;
*(reinterpret_cast<size_t *>(pp)) = n;
void *p = static_cast<char *>(pp) + 32;
return p;
}
@@ -226,8 +226,8 @@ void count_free_b(void *p) {
return;
}
void *pp = (char *)p - 32;
size_t n = *(size_t *)pp;
void *pp = static_cast<char *>(p) - 32;
size_t n = *(reinterpret_cast<size_t *>(pp));
allocated_count_b -= n;

2
unit/internal/database.cpp
View File

@@ -70,7 +70,7 @@ TEST(CRC, alignments) {
// test the crc32c function at different alignments
for (u8 i = 0; i < 32; i++) {
u32 crc = Crc32c_ComputeBuf(0, (u8 *)a.data() + i, 4000);
u32 crc = Crc32c_ComputeBuf(0, reinterpret_cast<u8 *>(a.data()) + i, 4000);
ASSERT_EQ(crc, 0x94f04377U);
}
}

6
unit/internal/lbr.cpp
View File

@@ -73,7 +73,7 @@ struct LbrTestParams {
static
int onMatch(u64a, u64a, ReportID, void *ctx) {
unsigned *matches = (unsigned *)ctx;
unsigned *matches = reinterpret_cast<unsigned *>(ctx);
(*matches)++;
return MO_CONTINUE_MATCHING;
}
@@ -191,7 +191,7 @@ TEST_P(LbrTest, MatchMin) {
const string corpus = matchingCorpus(params.min);
initQueue();
q.buffer = (const u8 *)corpus.c_str();
q.buffer = reinterpret_cast<const u8 *>(corpus.c_str());
q.length = corpus.length();
u64a end = corpus.length();
@@ -238,7 +238,7 @@ TEST_P(LbrTest, QueueExecToMatch) {
const string corpus = matchingCorpus(params.min);
initQueue();
q.buffer = (const u8 *)corpus.c_str();
q.buffer = reinterpret_cast<const u8 *>(corpus.c_str());
q.length = corpus.length();
u64a end = corpus.length();

2
unit/internal/multi_bit.cpp
View File

@@ -305,7 +305,7 @@ TEST(MultiBit, It3) {
const size_t test_size = 60;
mmbit_holder ba(test_size, 4);
fill_n((u8 *)ba, mmbit_size(test_size) + 4, 0xff);
fill_n(static_cast<u8 *>(ba), mmbit_size(test_size) + 4, 0xff);
mmbit_clear(ba, test_size);

4
unit/internal/pack_bits.cpp
View File

@@ -66,13 +66,13 @@ void pack_bits<u64a>(char *out, const u64a *v, const u32 *bits,
template <>
void unpack_bits<u32>(u32 *v, const char *in, const u32 *bits,
unsigned elements) {
return unpack_bits_32(v, (const u8 *)in, bits, elements);
return unpack_bits_32(v, reinterpret_cast<const u8 *>(in), bits, elements);
}
template <>
void unpack_bits<u64a>(u64a *v, const char *in, const u32 *bits,
unsigned elements) {
return unpack_bits_64(v, (const u8 *)in, bits, elements);
return unpack_bits_64(v, reinterpret_cast<const u8 *>(in), bits, elements);
}
template <typename T>

8
unit/internal/repeat.cpp
View File

@@ -738,7 +738,7 @@ protected:
ptr = new char[sizeof(RepeatInfo) +
sizeof(u64a) * (rsi.patchSize + 2)];
info = (struct RepeatInfo *)ptr;
info = reinterpret_cast<struct RepeatInfo *>(ptr);
info->type = REPEAT_SPARSE_OPTIMAL_P;
info->repeatMin = test_info.repeatMin;
@@ -756,7 +756,7 @@ protected:
info->patchesOffset = rsi.patchesOffset;
u32 repeatMax = info->patchSize;
u64a *table = (u64a *)(ROUNDUP_PTR((ptr + sizeof(RepeatInfo)),
u64a *table = reinterpret_cast<u64a *>(ROUNDUP_PTR((ptr + sizeof(RepeatInfo)),
alignof(u64a)));
for (u32 i = 0; i < repeatMax + 1; i++) {
table[i] = rsi.table[i];
@@ -859,8 +859,8 @@ TEST_P(SparseOptimalTest, TwoTopsNeg) {
}
}
const struct RepeatRingControl *xs = (const struct RepeatRingControl *)
ctrl;
const struct RepeatRingControl *xs = reinterpret_cast<const struct RepeatRingControl *>
(ctrl);
ASSERT_EQ(exit2, repeatNextMatch(info, ctrl, state,
MAX(xs->offset, exit)));
ASSERT_EQ(exit2, repeatNextMatch(info, ctrl, state,

90
unit/internal/rvermicelli.cpp
View File

@@ -39,8 +39,8 @@ TEST(RVermicelli, ExecNoMatch1) {
for (size_t i = 0; i < 16; i++) {
for (size_t j = 0; j < 16; j++) {
const u8 *begin = (const u8 *)t1 + i;
const u8 *end = (const u8 *)t1 + strlen(t1) - j;
const u8 *begin = reinterpret_cast<const u8 *>(t1) + i;
const u8 *end = reinterpret_cast<const u8 *>(t1) + strlen(t1) - j;
const u8 *rv = rvermicelliExec('a', 0, begin, end);
ASSERT_EQ(begin - 1, rv);
@@ -58,12 +58,12 @@ TEST(RVermicelli, Exec1) {
char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb";
for (size_t i = 0; i < 16; i++) {
const u8 *rv = rvermicelliExec('a', 0, (u8 *)t1,
(u8 *)t1 + strlen(t1) - i);
const u8 *rv = rvermicelliExec('a', 0, reinterpret_cast<const u8 *>(t1),
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
ASSERT_EQ((size_t)t1 + 48, (size_t)rv);
rv = rvermicelliExec('A', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1));
rv = rvermicelliExec('A', 1, reinterpret_cast<const u8 *>(t1) + i, reinterpret_cast<const u8 *>(t1) + strlen(t1));
ASSERT_EQ((size_t)t1 + 48, (size_t)rv);
}
@@ -73,12 +73,12 @@ TEST(RVermicelli, Exec2) {
char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbb";
for (size_t i = 0; i < 16; i++) {
const u8 *rv = rvermicelliExec('a', 0, (u8 *)t1,
(u8 *)t1 + strlen(t1) - i);
const u8 *rv = rvermicelliExec('a', 0, reinterpret_cast<const u8 *>(t1),
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
ASSERT_EQ((size_t)t1 + 48, (size_t)rv);
rv = rvermicelliExec('A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1) - i);
rv = rvermicelliExec('A', 1, reinterpret_cast<const u8 *>(t1), reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
ASSERT_EQ((size_t)t1 + 48, (size_t)rv);
}
@@ -88,12 +88,12 @@ TEST(RVermicelli, Exec3) {
char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbaaaaaaaaaaaaaaaaaaaaaaAbbbbbbbbbbbbbbbbbbbbbb";
for (size_t i = 0; i < 16; i++) {
const u8 *rv = rvermicelliExec('a', 0, (u8 *)t1,
(u8 *)t1 + strlen(t1) - i);
const u8 *rv = rvermicelliExec('a', 0, reinterpret_cast<const u8 *>(t1),
reinterpret_cast<const u8 *>(t1)+ strlen(t1) - i);
ASSERT_EQ((size_t)t1 + 47, (size_t)rv);
rv = rvermicelliExec('A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1) - i);
rv = rvermicelliExec('A', 1, reinterpret_cast<const u8 *>(t1), reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
ASSERT_EQ((size_t)t1 + 48, (size_t)rv);
}
@@ -104,11 +104,11 @@ TEST(RVermicelli, Exec4) {
for (size_t i = 0; i < 31; i++) {
t1[16 + i] = 'a';
const u8 *rv = rvermicelliExec('a', 0, (u8 *)t1, (u8 *)t1 + strlen(t1));
const u8 *rv = rvermicelliExec('a', 0, reinterpret_cast<const u8 *>(t1), reinterpret_cast<const u8 *>(t1) + strlen(t1));
ASSERT_EQ((size_t)&t1[16 + i], (size_t)rv);
rv = rvermicelliExec('A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1));
rv = rvermicelliExec('A', 1, reinterpret_cast<const u8 *>(t1), reinterpret_cast<const u8 *>(t1) + strlen(t1));
ASSERT_EQ((size_t)&t1[16 + i], (size_t)rv);
}
@@ -116,7 +116,7 @@ TEST(RVermicelli, Exec4) {
TEST(RNVermicelli, ExecNoMatch1) {
char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
const u8 *buf = (const u8 *)t1;
const u8 *buf = reinterpret_cast<const u8 *>(t1);
for (size_t i = 0; i < 16; i++) {
SCOPED_TRACE(i);
@@ -136,7 +136,7 @@ TEST(RNVermicelli, ExecNoMatch1) {
TEST(RNVermicelli, Exec1) {
char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb";
const u8 *buf = (const u8 *)t1;
const u8 *buf = reinterpret_cast<const u8 *>(t1);
for (size_t i = 0; i < 16; i++) {
SCOPED_TRACE(i);
@@ -152,7 +152,7 @@ TEST(RNVermicelli, Exec1) {
TEST(RNVermicelli, Exec2) {
char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbb";
const u8 *buf = (const u8 *)t1;
const u8 *buf = reinterpret_cast<const u8 *>(t1);
for (size_t i = 0; i < 16; i++) {
SCOPED_TRACE(i);
@@ -168,7 +168,7 @@ TEST(RNVermicelli, Exec2) {
TEST(RNVermicelli, Exec3) {
char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbaaaaaaaaaaaaaaaaaaaaaaAbbbbbbbbbbbbbbbbbbbbbb";
const u8 *buf = (const u8 *)t1;
const u8 *buf = reinterpret_cast<const u8 *>(t1);
for (size_t i = 0; i < 16; i++) {
SCOPED_TRACE(i);
@@ -184,7 +184,7 @@ TEST(RNVermicelli, Exec3) {
TEST(RNVermicelli, Exec4) {
char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
const u8 *buf = (const u8 *)t1;
const u8 *buf = reinterpret_cast<const u8 *>(t1);
for (size_t i = 0; i < 31; i++) {
SCOPED_TRACE(i);
@@ -204,23 +204,23 @@ TEST(RDoubleVermicelli, Exec1) {
char t1[] = "bbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb";
for (size_t i = 0; i < 16; i++) {
const u8 *rv = rvermicelliDoubleExec('a', 'b', 0, (u8 *)t1,
(u8 *)t1 + strlen(t1) - i);
const u8 *rv = rvermicelliDoubleExec('a', 'b', 0, reinterpret_cast<const u8 *>(t1),
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
ASSERT_EQ((size_t)t1 + 50, (size_t)rv);
rv = rvermicelliDoubleExec('A', 'B', 1, (u8 *)t1 + i,
(u8 *)t1 + strlen(t1));
rv = rvermicelliDoubleExec('A', 'B', 1, reinterpret_cast<const u8 *>(t1)+ i,
reinterpret_cast<const u8 *>(t1) + strlen(t1));
ASSERT_EQ((size_t)t1 + 50, (size_t)rv);
rv = rvermicelliDoubleExec('b', 'a', 0, (u8 *)t1 + i,
(u8 *)t1 + strlen(t1));
rv = rvermicelliDoubleExec('b', 'a', 0, reinterpret_cast<const u8 *>(t1) + i,
reinterpret_cast<const u8 *>(t1) + strlen(t1));
ASSERT_EQ((size_t)t1 + 49, (size_t)rv);
rv = rvermicelliDoubleExec('B', 'A', 1, (u8 *)t1 + i,
(u8 *)t1 + strlen(t1));
rv = rvermicelliDoubleExec('B', 'A', 1, reinterpret_cast<const u8 *>(t1) + i,
reinterpret_cast<const u8 *>(t1) + strlen(t1));
ASSERT_EQ((size_t)t1 + 49, (size_t)rv);
}
@@ -230,13 +230,13 @@ TEST(RDoubleVermicelli, Exec2) {
char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbaaaaabbbbbbbbbbbbbbbbbb";
for (size_t i = 0; i < 16; i++) {
const u8 *rv = rvermicelliDoubleExec('a', 'a', 0, (u8 *)t1,
(u8 *)t1 + strlen(t1) - i);
const u8 *rv = rvermicelliDoubleExec('a', 'a', 0, reinterpret_cast<const u8 *>(t1),
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
ASSERT_EQ((size_t)t1 + 52, (size_t)rv);
rv = rvermicelliDoubleExec('A', 'A', 1, (u8 *)t1,
(u8 *)t1 + strlen(t1) - i);
rv = rvermicelliDoubleExec('A', 'A', 1, reinterpret_cast<const u8 *>(t1),
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
ASSERT_EQ((size_t)t1 + 52, (size_t)rv);
}
@@ -247,23 +247,23 @@ TEST(RDoubleVermicelli, Exec3) {
char t1[] = "bbbbbbbbbbbbbbbbbaAaaAAaaaaaaaaaaaaaaaaaabbbbbbbaaaaabbbbbbbbbbbbbbbbbb";
for (size_t i = 0; i < 16; i++) {
const u8 *rv = rvermicelliDoubleExec('A', 'a', 0, (u8 *)t1,
(u8 *)t1 + strlen(t1) - i );
const u8 *rv = rvermicelliDoubleExec('A', 'a', 0, reinterpret_cast<const u8 *>(t1),
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i );
ASSERT_EQ((size_t)t1 + 23, (size_t)rv);
rv = rvermicelliDoubleExec('A', 'A', 1, (u8 *)t1,
(u8 *)t1 + strlen(t1) - i);
rv = rvermicelliDoubleExec('A', 'A', 1, reinterpret_cast<const u8 *>(t1),
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
ASSERT_EQ((size_t)t1 + 52, (size_t)rv);
rv = rvermicelliDoubleExec('A', 'A', 0, (u8 *)t1,
(u8 *)t1 + strlen(t1) - i);
rv = rvermicelliDoubleExec('A', 'A', 0, reinterpret_cast<const u8 *>(t1),
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
ASSERT_EQ((size_t)t1 + 22, (size_t)rv);
rv = rvermicelliDoubleExec('a', 'A', 0, (u8 *)t1,
(u8 *)t1 + strlen(t1) - i);
rv = rvermicelliDoubleExec('a', 'A', 0, reinterpret_cast<const u8 *>(t1),
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
ASSERT_EQ((size_t)t1 + 21, (size_t)rv);
}
@@ -275,11 +275,11 @@ TEST(RDoubleVermicelli, Exec4) {
for (size_t i = 0; i < 31; i++) {
t1[32 + i] = 'a';
t1[32 + i - 1] = 'a';
const u8 *rv = rvermicelliDoubleExec('a', 'a', 0, (u8 *)t1,
(u8 *)t1 + strlen(t1));
const u8 *rv = rvermicelliDoubleExec('a', 'a', 0, reinterpret_cast<const u8 *>(t1),
reinterpret_cast<const u8 *>(t1) + strlen(t1));
ASSERT_EQ((size_t)&t1[32 + i], (size_t)rv);
rv = rvermicelliDoubleExec('A', 'A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1));
rv = rvermicelliDoubleExec('A', 'A', 1, reinterpret_cast<const u8 *>(t1), reinterpret_cast<const u8 *>(t1) + strlen(t1));
ASSERT_EQ((size_t)&t1[32 + i], (size_t)rv);
}
@@ -291,13 +291,13 @@ TEST(RDoubleVermicelli, Exec5) {
for (size_t i = 0; i < 16; i++) {
for (size_t j = 1; j <= 16; j++) {
t1[strlen(t1) - i - j] = 'a';
const u8 *rv = rvermicelliDoubleExec('b', 'a', 0, (u8 *)t1,
(u8 *)t1 + strlen(t1) - i);
const u8 *rv = rvermicelliDoubleExec('b', 'a', 0, reinterpret_cast<const u8 *>(t1),
reinterpret_cast<const u8 *>(t1) + strlen(t1) - i);
ASSERT_EQ((size_t)&t1[strlen(t1) - i - j], (size_t)rv);
rv = rvermicelliDoubleExec('B', 'A', 1, (u8 *)t1,
(u8 *)t1 + strlen(t1) -i );
rv = rvermicelliDoubleExec('B', 'A', 1, reinterpret_cast<const u8 *>(t1),
reinterpret_cast<const u8 *>(t1) + strlen(t1) -i );
ASSERT_EQ((size_t)&t1[strlen(t1) - i - j], (size_t)rv);