summaryrefslogtreecommitdiff
path: root/test/completion/init.lua
blob: 11d39252e70a278e8e2d9d23c21561b067c6d1fc (plain)
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
local core   = require 'core.completion'
local files  = require 'files'
local catch  = require 'catch'

EXISTS = {'EXISTS'}

local function eq(a, b)
    if a == EXISTS and b ~= nil then
        return true
    end
    local tp1, tp2 = type(a), type(b)
    if tp1 ~= tp2 then
        return false
    end
    if tp1 == 'table' then
        local mark = {}
        for k in pairs(a) do
            if not eq(a[k], b[k]) then
                return false
            end
            mark[k] = true
        end
        for k in pairs(b) do
            if not mark[k] then
                return false
            end
        end
        return true
    end
    return a == b
end

local function include(a, b)
    if a == EXISTS and b ~= nil then
        return true
    end
    local tp1, tp2 = type(a), type(b)
    if tp1 ~= tp2 then
        return false
    end
    if tp1 == 'table' then
        for k in pairs(a) do
            if not eq(a[k], b[k]) then
                return false
            end
        end
        return true
    end
    return a == b
end

rawset(_G, 'TEST', true)

Cared = {
    ['label']               = true,
    ['kind']                = true,
    ['textEdit']            = true,
    ['additionalTextEdits'] = true,
    ['deprecated']          = true,
}

IgnoreFunction = false
ContinueTyping = false

function TEST(script)
    return function (expect)
        ---@diagnostic disable: await-in-sync
        files.removeAll()
        local newScript, catched = catch(script, '?')

        files.setText('', newScript)
        core.clearCache()
        local inputPos = catched['?'][1][1]
        if ContinueTyping then
            local triggerCharacter = script:sub(inputPos - 1, inputPos - 1)
            core.completion('', inputPos, triggerCharacter)
        end
        local triggerCharacter = script:sub(inputPos, inputPos)
        local result = core.completion('', inputPos, triggerCharacter)
        if not expect then
            assert(result == nil)
            return
        end
        assert(result ~= nil)
        result.enableCommon = nil
        for _, item in ipairs(result) do
            if item.id then
                local r = core.resolve(item.id)
                for k, v in pairs(r or {}) do
                    item[k] = v
                end
            end
            for k in pairs(item) do
                if not Cared[k] then
                    item[k] = nil
                end
            end
            if item.description then
                item.description = tostring(item.description)
            end
        end
        if IgnoreFunction then
            for i = #result, 1, -1 do
                local item = result[i]
                if item.label:find '%('
                and not item.label:find 'function' then
                    result[i] = result[#result]
                    result[#result] = nil
                end
            end
        end
        assert(result)
        if expect.include then
            expect.include = nil
            assert(include(expect, result))
        else
            assert(eq(expect, result))
        end
    end
end

require 'completion.common'
require 'completion.continue'