mirror of
https://github.com/neovim/neovim.git
synced 2024-12-20 11:15:14 -07:00
9af2be292d
This expands on the global "don't pay for what you don't use" rules for these special extmark decorations: - inline virtual text, which needs to be processed in plines.c when we calculate the size of text on screen - virtual lines, which are needed when calculating "filler" lines - signs, with text and/or highlights, both of which needs to be processed for the entire line already at the beginning of a line. This adds a count to each node of the marktree, for how many special marks of each kind can be found in the subtree for this node. This makes it possible to quickly skip over these extra checks, when working in regions of the buffer not containing these kind of marks, instead of before where this could just be skipped if the entire _buffer_ didn't contain such marks.
642 lines
19 KiB
Lua
642 lines
19 KiB
Lua
local helpers = require('test.unit.helpers')(after_each)
|
|
local itp = helpers.gen_itp(it)
|
|
|
|
local ffi = helpers.ffi
|
|
local eq = helpers.eq
|
|
local ok = helpers.ok
|
|
|
|
local lib = helpers.cimport('./src/nvim/marktree.h')
|
|
|
|
local function tablelength(t)
|
|
local count = 0
|
|
for _ in pairs(t) do
|
|
count = count + 1
|
|
end
|
|
return count
|
|
end
|
|
|
|
local function pos_leq(a, b)
|
|
return a[1] < b[1] or (a[1] == b[1] and a[2] <= b[2])
|
|
end
|
|
|
|
-- Checks that shadow and tree is consistent, and optionally
|
|
-- return the order
|
|
local function shadoworder(tree, shadow, iter, giveorder)
|
|
ok(iter ~= nil)
|
|
local status = lib.marktree_itr_first(tree, iter)
|
|
local count = 0
|
|
local pos2id, id2pos = {}, {}
|
|
local last
|
|
if not status and next(shadow) == nil then
|
|
return pos2id, id2pos
|
|
end
|
|
repeat
|
|
local mark = lib.marktree_itr_current(iter)
|
|
local id = tonumber(mark.id)
|
|
local spos = shadow[id]
|
|
eq(mark.pos.row, spos[1], mark.id)
|
|
eq(mark.pos.col, spos[2], mark.id)
|
|
if lib.mt_right_test(mark) ~= spos[3] then
|
|
error('invalid gravity for ' .. id .. ':(' .. mark.pos.row .. ', ' .. mark.pos.col .. ')')
|
|
end
|
|
if count > 0 then
|
|
if not pos_leq(last, spos) then
|
|
error('DISORDER')
|
|
end
|
|
end
|
|
count = count + 1
|
|
last = spos
|
|
if giveorder then
|
|
pos2id[count] = id
|
|
id2pos[id] = count
|
|
end
|
|
until not lib.marktree_itr_next(tree, iter)
|
|
local shadowlen = tablelength(shadow)
|
|
if shadowlen ~= count then
|
|
error('missed some keys? (shadow ' .. shadowlen .. ', tree ' .. count .. ')')
|
|
end
|
|
return id2pos, pos2id
|
|
end
|
|
|
|
local function shadowsplice(shadow, start, old_extent, new_extent)
|
|
local old_end = {
|
|
start[1] + old_extent[1],
|
|
(old_extent[1] == 0 and start[2] or 0) + old_extent[2],
|
|
}
|
|
local new_end = {
|
|
start[1] + new_extent[1],
|
|
(new_extent[1] == 0 and start[2] or 0) + new_extent[2],
|
|
}
|
|
local delta = { new_end[1] - old_end[1], new_end[2] - old_end[2] }
|
|
for _, pos in pairs(shadow) do
|
|
if pos_leq(start, pos) then
|
|
if pos_leq(pos, old_end) then
|
|
-- delete region
|
|
if pos[3] then -- right gravity
|
|
pos[1], pos[2] = new_end[1], new_end[2]
|
|
else
|
|
pos[1], pos[2] = start[1], start[2]
|
|
end
|
|
else
|
|
if pos[1] == old_end[1] then
|
|
pos[2] = pos[2] + delta[2]
|
|
end
|
|
pos[1] = pos[1] + delta[1]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function dosplice(tree, shadow, start, old, new)
|
|
lib.marktree_splice(tree, start[1], start[2], old[1], old[2], new[1], new[2])
|
|
shadowsplice(shadow, start, old, new)
|
|
end
|
|
|
|
local ns = 10
|
|
local last_id = nil
|
|
|
|
local function put(tree, row, col, gravity, end_row, end_col, end_gravity)
|
|
last_id = last_id + 1
|
|
local my_id = last_id
|
|
|
|
end_row = end_row or -1
|
|
end_col = end_col or -1
|
|
end_gravity = end_gravity or false
|
|
|
|
lib.marktree_put_test(tree, ns, my_id, row, col, gravity, end_row, end_col, end_gravity, false)
|
|
return my_id
|
|
end
|
|
|
|
local function put_meta(tree, row, col, gravitate, meta)
|
|
last_id = last_id + 1
|
|
local my_id = last_id
|
|
|
|
lib.marktree_put_test(tree, ns, my_id, row, col, gravitate, -1, -1, false, meta)
|
|
return my_id
|
|
end
|
|
|
|
describe('marktree', function()
|
|
before_each(function()
|
|
last_id = 0
|
|
end)
|
|
|
|
itp('works', function()
|
|
local tree = ffi.new('MarkTree[1]') -- zero initialized by luajit
|
|
local shadow = {}
|
|
local iter = ffi.new('MarkTreeIter[1]')
|
|
local iter2 = ffi.new('MarkTreeIter[1]')
|
|
|
|
for i = 1, 100 do
|
|
for j = 1, 100 do
|
|
local gravitate = (i % 2) > 0
|
|
local id = put(tree, j, i, gravitate)
|
|
ok(id > 0)
|
|
eq(nil, shadow[id])
|
|
shadow[id] = { j, i, gravitate }
|
|
end
|
|
-- checking every insert is too slow, but this is ok
|
|
lib.marktree_check(tree)
|
|
end
|
|
|
|
-- ss = lib.mt_inspect_rec(tree)
|
|
-- io.stdout:write(ffi.string(ss))
|
|
-- io.stdout:flush()
|
|
|
|
local id2pos, pos2id = shadoworder(tree, shadow, iter)
|
|
eq({}, pos2id) -- not set if not requested
|
|
eq({}, id2pos)
|
|
|
|
for i, ipos in pairs(shadow) do
|
|
local p = lib.marktree_lookup_ns(tree, ns, i, false, iter)
|
|
eq(ipos[1], p.pos.row)
|
|
eq(ipos[2], p.pos.col)
|
|
local k = lib.marktree_itr_current(iter)
|
|
eq(ipos[1], k.pos.row)
|
|
eq(ipos[2], k.pos.col, ipos[1])
|
|
lib.marktree_itr_next(tree, iter)
|
|
-- TODO(bfredl): use id2pos to check neighbour?
|
|
-- local k2 = lib.marktree_itr_current(iter)
|
|
end
|
|
|
|
for i, ipos in pairs(shadow) do
|
|
lib.marktree_itr_get(tree, ipos[1], ipos[2], iter)
|
|
local k = lib.marktree_itr_current(iter)
|
|
eq(i, tonumber(k.id))
|
|
eq(ipos[1], k.pos.row)
|
|
eq(ipos[2], k.pos.col)
|
|
end
|
|
|
|
ok(lib.marktree_itr_first(tree, iter))
|
|
local del = lib.marktree_itr_current(iter)
|
|
|
|
lib.marktree_del_itr(tree, iter, false)
|
|
shadow[tonumber(del.id)] = nil
|
|
shadoworder(tree, shadow, iter)
|
|
|
|
for _, ci in ipairs({ 0, -1, 1, -2, 2, -10, 10 }) do
|
|
for i = 1, 100 do
|
|
lib.marktree_itr_get(tree, i, 50 + ci, iter)
|
|
local k = lib.marktree_itr_current(iter)
|
|
local id = tonumber(k.id)
|
|
eq(shadow[id][1], k.pos.row)
|
|
eq(shadow[id][2], k.pos.col)
|
|
lib.marktree_del_itr(tree, iter, false)
|
|
shadow[id] = nil
|
|
end
|
|
lib.marktree_check(tree)
|
|
shadoworder(tree, shadow, iter)
|
|
end
|
|
|
|
-- NB: this is quite rudimentary. We rely on
|
|
-- functional tests exercising splicing quite a bit
|
|
lib.marktree_check(tree)
|
|
dosplice(tree, shadow, { 2, 2 }, { 0, 5 }, { 1, 2 })
|
|
lib.marktree_check(tree)
|
|
shadoworder(tree, shadow, iter)
|
|
dosplice(tree, shadow, { 30, 2 }, { 30, 5 }, { 1, 2 })
|
|
lib.marktree_check(tree)
|
|
shadoworder(tree, shadow, iter)
|
|
|
|
dosplice(tree, shadow, { 5, 3 }, { 0, 2 }, { 0, 5 })
|
|
shadoworder(tree, shadow, iter)
|
|
lib.marktree_check(tree)
|
|
|
|
-- build then burn (HOORAY! HOORAY!)
|
|
while next(shadow) do
|
|
lib.marktree_itr_first(tree, iter)
|
|
-- delete every other key for fun and profit
|
|
while true do
|
|
local k = lib.marktree_itr_current(iter)
|
|
lib.marktree_del_itr(tree, iter, false)
|
|
ok(shadow[tonumber(k.id)] ~= nil)
|
|
shadow[tonumber(k.id)] = nil
|
|
local stat = lib.marktree_itr_next(tree, iter)
|
|
if not stat then
|
|
break
|
|
end
|
|
end
|
|
lib.marktree_check(tree)
|
|
shadoworder(tree, shadow, iter2)
|
|
end
|
|
|
|
-- Check iterator validity for 2 specific edge cases:
|
|
-- https://github.com/neovim/neovim/pull/14719
|
|
lib.marktree_clear(tree)
|
|
for i = 1, 20 do
|
|
put(tree, i, i, false)
|
|
end
|
|
|
|
lib.marktree_itr_get(tree, 10, 10, iter)
|
|
lib.marktree_del_itr(tree, iter, false)
|
|
eq(11, iter[0].x.key[iter[0].i].pos.col)
|
|
|
|
lib.marktree_itr_get(tree, 11, 11, iter)
|
|
lib.marktree_del_itr(tree, iter, false)
|
|
eq(12, iter[0].x.key[iter[0].i].pos.col)
|
|
end)
|
|
|
|
itp("'intersect_mov' function works correctly", function()
|
|
local function mov(x, y, w)
|
|
local xa = ffi.new('uint64_t[?]', #x)
|
|
for i, xi in ipairs(x) do
|
|
xa[i - 1] = xi
|
|
end
|
|
local ya = ffi.new('uint64_t[?]', #y)
|
|
for i, yi in ipairs(y) do
|
|
ya[i - 1] = yi
|
|
end
|
|
local wa = ffi.new('uint64_t[?]', #w)
|
|
for i, wi in ipairs(w) do
|
|
wa[i - 1] = wi
|
|
end
|
|
|
|
local dummy_size = #x + #y + #w
|
|
local wouta = ffi.new('uint64_t[?]', dummy_size)
|
|
local douta = ffi.new('uint64_t[?]', dummy_size)
|
|
local wsize = ffi.new('size_t[1]')
|
|
wsize[0] = dummy_size
|
|
local dsize = ffi.new('size_t[1]')
|
|
dsize[0] = dummy_size
|
|
|
|
local status = lib.intersect_mov_test(xa, #x, ya, #y, wa, #w, wouta, wsize, douta, dsize)
|
|
if status == 0 then
|
|
error 'wowza'
|
|
end
|
|
|
|
local wout, dout = {}, {}
|
|
for i = 0, tonumber(wsize[0]) - 1 do
|
|
table.insert(wout, tonumber(wouta[i]))
|
|
end
|
|
for i = 0, tonumber(dsize[0]) - 1 do
|
|
table.insert(dout, tonumber(douta[i]))
|
|
end
|
|
return { wout, dout }
|
|
end
|
|
|
|
eq({ {}, {} }, mov({}, { 2, 3 }, { 2, 3 }))
|
|
eq({ { 2, 3 }, {} }, mov({}, {}, { 2, 3 }))
|
|
eq({ { 2, 3 }, {} }, mov({ 2, 3 }, {}, {}))
|
|
eq({ {}, { 2, 3 } }, mov({}, { 2, 3 }, {}))
|
|
|
|
eq({ { 1, 5 }, {} }, mov({ 1, 2, 5 }, { 2, 3 }, { 3 }))
|
|
eq({ { 1, 2 }, {} }, mov({ 1, 2, 5 }, { 5, 10 }, { 10 }))
|
|
eq({ { 1, 2 }, { 5 } }, mov({ 1, 2 }, { 5, 10 }, { 10 }))
|
|
eq({ { 1, 3, 5, 7, 9 }, { 2, 4, 6, 8, 10 } }, mov({ 1, 3, 5, 7, 9 }, { 2, 4, 6, 8, 10 }, {}))
|
|
eq({ { 1, 3, 5, 7, 9 }, { 2, 6, 10 } }, mov({ 1, 3, 5, 7, 9 }, { 2, 4, 6, 8, 10 }, { 4, 8 }))
|
|
eq({ { 1, 4, 7 }, { 2, 5, 8 } }, mov({ 1, 3, 4, 6, 7, 9 }, { 2, 3, 5, 6, 8, 9 }, {}))
|
|
eq({ { 1, 4, 7 }, {} }, mov({ 1, 3, 4, 6, 7, 9 }, { 2, 3, 5, 6, 8, 9 }, { 2, 5, 8 }))
|
|
eq(
|
|
{ { 0, 1, 4, 7, 10 }, {} },
|
|
mov({ 1, 3, 4, 6, 7, 9 }, { 2, 3, 5, 6, 8, 9 }, { 0, 2, 5, 8, 10 })
|
|
)
|
|
end)
|
|
|
|
local function check_intersections(tree)
|
|
lib.marktree_check(tree)
|
|
-- to debug stuff disable this branch
|
|
if true == true then
|
|
ok(lib.marktree_check_intersections(tree))
|
|
return
|
|
end
|
|
|
|
local str1 = lib.mt_inspect(tree, true, true)
|
|
local dot1 = ffi.string(str1.data, str1.size)
|
|
|
|
local val = lib.marktree_check_intersections(tree)
|
|
if not val then
|
|
local str2 = lib.mt_inspect(tree, true, true)
|
|
local dot2 = ffi.string(str2.data, str2.size)
|
|
print('actual:\n\n' .. 'Xafile.dot' .. '\n\nexpected:\n\n' .. 'Xefile.dot' .. '\n')
|
|
print('nivå', tree[0].root.level)
|
|
io.stdout:flush()
|
|
local afil = io.open('Xafile.dot', 'wb')
|
|
afil:write(dot1)
|
|
afil:close()
|
|
local efil = io.open('Xefile.dot', 'wb')
|
|
efil:write(dot2)
|
|
efil:close()
|
|
ok(false)
|
|
else
|
|
ffi.C.xfree(str1.data)
|
|
end
|
|
end
|
|
|
|
itp('works with intersections', function()
|
|
local tree = ffi.new('MarkTree[1]') -- zero initialized by luajit
|
|
|
|
local ids = {}
|
|
|
|
for i = 1, 80 do
|
|
table.insert(ids, put(tree, 1, i, false, 2, 100 - i, false))
|
|
check_intersections(tree)
|
|
end
|
|
for i = 1, 80 do
|
|
lib.marktree_del_pair_test(tree, ns, ids[i])
|
|
check_intersections(tree)
|
|
end
|
|
ids = {}
|
|
|
|
for i = 1, 80 do
|
|
table.insert(ids, put(tree, 1, i, false, 2, 100 - i, false))
|
|
check_intersections(tree)
|
|
end
|
|
|
|
for i = 1, 10 do
|
|
for j = 1, 8 do
|
|
local ival = (j - 1) * 10 + i
|
|
lib.marktree_del_pair_test(tree, ns, ids[ival])
|
|
check_intersections(tree)
|
|
end
|
|
end
|
|
end)
|
|
|
|
itp('works with intersections with a big tree', function()
|
|
local tree = ffi.new('MarkTree[1]') -- zero initialized by luajit
|
|
|
|
local ids = {}
|
|
|
|
for i = 1, 1000 do
|
|
table.insert(ids, put(tree, 1, i, false, 2, 1000 - i, false))
|
|
if i % 10 == 1 then
|
|
check_intersections(tree)
|
|
end
|
|
end
|
|
|
|
check_intersections(tree)
|
|
eq(2000, tree[0].n_keys)
|
|
ok(tree[0].root.level >= 2)
|
|
|
|
local iter = ffi.new('MarkTreeIter[1]')
|
|
|
|
local k = 0
|
|
for i = 1, 20 do
|
|
for j = 1, 50 do
|
|
k = k + 1
|
|
local ival = (j - 1) * 20 + i
|
|
if false == true then -- if there actually is a failure, this branch will fail out at the actual spot of the error
|
|
lib.marktree_lookup_ns(tree, ns, ids[ival], false, iter)
|
|
lib.marktree_del_itr(tree, iter, false)
|
|
check_intersections(tree)
|
|
|
|
lib.marktree_lookup_ns(tree, ns, ids[ival], true, iter)
|
|
lib.marktree_del_itr(tree, iter, false)
|
|
check_intersections(tree)
|
|
else
|
|
lib.marktree_del_pair_test(tree, ns, ids[ival])
|
|
if k % 5 == 1 then
|
|
check_intersections(tree)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
eq(0, tree[0].n_keys)
|
|
end)
|
|
|
|
itp('works with intersections and marktree_splice', function()
|
|
local tree = ffi.new('MarkTree[1]') -- zero initialized by luajit
|
|
|
|
for i = 1, 1000 do
|
|
put(tree, 1, i, false, 2, 1000 - i, false)
|
|
if i % 10 == 1 then
|
|
check_intersections(tree)
|
|
end
|
|
end
|
|
|
|
check_intersections(tree)
|
|
eq(2000, tree[0].n_keys)
|
|
ok(tree[0].root.level >= 2)
|
|
|
|
for _ = 1, 10 do
|
|
lib.marktree_splice(tree, 0, 0, 0, 100, 0, 0)
|
|
check_intersections(tree)
|
|
end
|
|
end)
|
|
|
|
itp('marktree_move should preserve key order', function()
|
|
local tree = ffi.new('MarkTree[1]') -- zero initialized by luajit
|
|
local iter = ffi.new('MarkTreeIter[1]')
|
|
local ids = {}
|
|
|
|
-- new index and old index look the same, but still have to move because
|
|
-- pos will get updated
|
|
table.insert(ids, put(tree, 1, 1, false, 1, 3, false))
|
|
table.insert(ids, put(tree, 1, 3, false, 1, 3, false))
|
|
table.insert(ids, put(tree, 1, 3, false, 1, 3, false))
|
|
table.insert(ids, put(tree, 1, 3, false, 1, 3, false))
|
|
|
|
lib.marktree_lookup_ns(tree, ns, ids[3], false, iter)
|
|
lib.marktree_move(tree, iter, 1, 2)
|
|
|
|
check_intersections(tree)
|
|
end)
|
|
|
|
itp('works with intersections and marktree_move', function()
|
|
local tree = ffi.new('MarkTree[1]') -- zero initialized by luajit
|
|
|
|
local ids = {}
|
|
|
|
for i = 1, 1000 do
|
|
table.insert(ids, put(tree, 1, i, false, 2, 1000 - i, false))
|
|
if i % 10 == 1 then
|
|
check_intersections(tree)
|
|
end
|
|
end
|
|
|
|
local iter = ffi.new('MarkTreeIter[1]')
|
|
for i = 1, 1000 do
|
|
local which = i % 2
|
|
lib.marktree_lookup_ns(tree, ns, ids[i], which, iter)
|
|
lib.marktree_move(tree, iter, 1 + which, 500 + i)
|
|
if i % 10 == 1 then
|
|
check_intersections(tree)
|
|
end
|
|
end
|
|
end)
|
|
|
|
itp('works with intersections with a even bigger tree', function()
|
|
local tree = ffi.new('MarkTree[1]') -- zero initialized by luajit
|
|
|
|
local ids = {}
|
|
|
|
-- too much overhead on ASAN
|
|
local size_factor = helpers.is_asan() and 3 or 10
|
|
|
|
local at_row = {}
|
|
for i = 1, 10 do
|
|
at_row[i] = {}
|
|
end
|
|
|
|
local size = 1000 * size_factor
|
|
local k = 1
|
|
while k <= size do
|
|
for row1 = 1, 9 do
|
|
for row2 = row1, 10 do -- note row2 can be == row1, leads to empty ranges being tested when k > size/2
|
|
if k > size then
|
|
break
|
|
end
|
|
local id = put(tree, row1, k, false, row2, size - k, false)
|
|
table.insert(ids, id)
|
|
for i = row1 + 1, row2 do
|
|
table.insert(at_row[i], id)
|
|
end
|
|
--if tree[0].root.level == 4 then error("kk"..k) end
|
|
if k % 100 * size_factor == 1 or (k < 2000 and k % 100 == 1) then
|
|
check_intersections(tree)
|
|
end
|
|
k = k + 1
|
|
end
|
|
end
|
|
end
|
|
|
|
eq(2 * size, tree[0].n_keys)
|
|
ok(tree[0].root.level >= 3)
|
|
check_intersections(tree)
|
|
|
|
local iter = ffi.new('MarkTreeIter[1]')
|
|
local pair = ffi.new('MTPair[1]')
|
|
for i = 1, 10 do
|
|
-- use array as set and not {[id]=true} map, to detect duplicates
|
|
local set = {}
|
|
eq(true, ffi.C.marktree_itr_get_overlap(tree, i, 0, iter))
|
|
while ffi.C.marktree_itr_step_overlap(tree, iter, pair) do
|
|
local id = tonumber(pair[0].start.id)
|
|
table.insert(set, id)
|
|
end
|
|
table.sort(set)
|
|
eq(at_row[i], set)
|
|
end
|
|
|
|
k = 0
|
|
for i = 1, 100 do
|
|
for j = 1, (10 * size_factor) do
|
|
k = k + 1
|
|
local ival = (j - 1) * 100 + i
|
|
lib.marktree_del_pair_test(tree, ns, ids[ival])
|
|
-- just a few stickprov, if there is trouble we need to check
|
|
-- everyone using the code in the "big tree" case above
|
|
if k % 100 * size_factor == 0 or (k > 3000 and k % 200 == 0) then
|
|
check_intersections(tree)
|
|
end
|
|
end
|
|
end
|
|
|
|
eq(0, tree[0].n_keys)
|
|
end)
|
|
|
|
itp('works with intersections with a even bigger tree and splice', function()
|
|
local tree = ffi.new('MarkTree[1]') -- zero initialized by luajit
|
|
|
|
-- too much overhead on ASAN
|
|
local size_factor = helpers.is_asan() and 3 or 10
|
|
|
|
local at_row = {}
|
|
for i = 1, 10 do
|
|
at_row[i] = {}
|
|
end
|
|
|
|
local size = 1000 * size_factor
|
|
local k = 1
|
|
while k <= size do
|
|
for row1 = 1, 9 do
|
|
for row2 = row1, 10 do -- note row2 can be == row1, leads to empty ranges being tested when k > size/2
|
|
if k > size then
|
|
break
|
|
end
|
|
local id = put(tree, row1, k, false, row2, size - k, false)
|
|
for i = row1 + 1, row2 do
|
|
table.insert(at_row[i], id)
|
|
end
|
|
--if tree[0].root.level == 4 then error("kk"..k) end
|
|
if k % 100 * size_factor == 1 or (k < 2000 and k % 100 == 1) then
|
|
check_intersections(tree)
|
|
end
|
|
k = k + 1
|
|
end
|
|
end
|
|
end
|
|
|
|
eq(2 * size, tree[0].n_keys)
|
|
ok(tree[0].root.level >= 3)
|
|
check_intersections(tree)
|
|
|
|
for _ = 1, 10 do
|
|
for j = 3, 8 do
|
|
lib.marktree_splice(tree, j, 0, 0, 200, 0, 0)
|
|
check_intersections(tree)
|
|
end
|
|
end
|
|
end)
|
|
|
|
itp('works with meta counts', function()
|
|
local tree = ffi.new('MarkTree[1]') -- zero initialized by luajit
|
|
|
|
-- add
|
|
local shadow = {}
|
|
for i = 1, 100 do
|
|
for j = 1, 100 do
|
|
local gravitate = (i % 2) > 0
|
|
local inline = (j == 3 or j == 50 or j == 51 or j == 55) and i % 11 == 1
|
|
inline = inline or ((j >= 80 and j < 85) and i % 3 == 1)
|
|
local id = put_meta(tree, j, i, gravitate, inline)
|
|
if inline then
|
|
shadow[id] = { j, i, gravitate }
|
|
end
|
|
end
|
|
-- checking every insert is too slow, but this is ok
|
|
lib.marktree_check(tree)
|
|
end
|
|
|
|
lib.marktree_check(tree)
|
|
local iter = ffi.new('MarkTreeIter[1]')
|
|
local filter = ffi.new('uint32_t[4]')
|
|
filter[0] = -1
|
|
ok(lib.marktree_itr_get_filter(tree, 0, 0, 101, 0, filter, iter))
|
|
local seen = {}
|
|
repeat
|
|
local mark = lib.marktree_itr_current(iter)
|
|
eq(nil, seen[mark.id])
|
|
seen[mark.id] = true
|
|
eq(mark.pos.row, shadow[mark.id][1])
|
|
eq(mark.pos.col, shadow[mark.id][2])
|
|
until not lib.marktree_itr_next_filter(tree, iter, 101, 0, filter)
|
|
eq(tablelength(seen), tablelength(shadow))
|
|
|
|
-- delete
|
|
for id = 1, 10000, 2 do
|
|
lib.marktree_lookup_ns(tree, ns, id, false, iter)
|
|
if shadow[id] then
|
|
local mark = lib.marktree_itr_current(iter)
|
|
eq(mark.pos.row, shadow[id][1])
|
|
eq(mark.pos.col, shadow[id][2])
|
|
shadow[id] = nil
|
|
end
|
|
lib.marktree_del_itr(tree, iter, false)
|
|
if id % 100 == 1 then
|
|
lib.marktree_check(tree)
|
|
end
|
|
end
|
|
|
|
-- Splice!
|
|
dosplice(tree, shadow, { 82, 0 }, { 0, 50 }, { 0, 0 })
|
|
lib.marktree_check(tree)
|
|
|
|
dosplice(tree, shadow, { 81, 50 }, { 2, 50 }, { 1, 0 })
|
|
lib.marktree_check(tree)
|
|
|
|
dosplice(tree, shadow, { 2, 50 }, { 1, 50 }, { 0, 10 })
|
|
lib.marktree_check(tree)
|
|
|
|
ok(lib.marktree_itr_get_filter(tree, 0, 0, 101, 0, filter, iter))
|
|
seen = {}
|
|
repeat
|
|
local mark = lib.marktree_itr_current(iter)
|
|
eq(nil, seen[mark.id])
|
|
seen[mark.id] = true
|
|
eq(mark.pos.row, shadow[mark.id][1])
|
|
eq(mark.pos.col, shadow[mark.id][2])
|
|
until not lib.marktree_itr_next_filter(tree, iter, 101, 0, filter)
|
|
eq(tablelength(seen), tablelength(shadow))
|
|
end)
|
|
end)
|