aboutsummaryrefslogtreecommitdiffstats
path: root/yql/essentials/sql/v1/highlight/sql_highlighter_ut.cpp
blob: 5fcab7937fceaa61799e0387ba3854613b1d3a46 (plain) (blame)
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
#include "sql_highlighter.h"

#include <library/cpp/json/json_reader.h>
#include <library/cpp/resource/resource.h>
#include <library/cpp/testing/unittest/registar.h>

#include <util/generic/string.h>
#include <util/string/join.h>
#include <util/string/escape.h>

using namespace NSQLHighlight;

struct TTest {
    struct TCase {
        TString Input;
        TString Expected;
    };

    TString Name;
    TVector<TCase> Cases;
};

TVector<TTest> LoadTestSuite() {
    TString text;
    Y_ENSURE(NResource::FindExact("suite.json", &text));
    auto json = NJson::ReadJsonFastTree(text).GetMapSafe();

    TVector<TTest> tests;
    for (auto& [k, v] : json) {
        TVector<TTest::TCase> cases;
        for (auto& c : v.GetArraySafe()) {
            cases.emplace_back(
                std::move(c[0].GetStringSafe()),
                std::move(c[1].GetStringSafe()));
        }
        tests.emplace_back(std::move(k), std::move(cases));
    }
    return tests;
}

char ToChar(EUnitKind kind) {
    switch (kind) {
        case EUnitKind::Keyword:
            return 'K';
        case EUnitKind::Punctuation:
            return 'P';
        case EUnitKind::Identifier:
            return 'I';
        case EUnitKind::QuotedIdentifier:
            return 'Q';
        case EUnitKind::BindParamterIdentifier:
            return 'B';
        case EUnitKind::TypeIdentifier:
            return 'T';
        case EUnitKind::FunctionIdentifier:
            return 'F';
        case EUnitKind::Literal:
            return 'L';
        case EUnitKind::StringLiteral:
            return 'S';
        case EUnitKind::Comment:
            return 'C';
        case EUnitKind::Whitespace:
            return '_';
        case EUnitKind::Error:
            return 'E';
    }
}

TString ToMask(const TVector<TToken>& tokens) {
    TVector<TString> s;
    for (const auto& t : tokens) {
        s.emplace_back(TString(t.Length, ToChar(t.Kind)));
    }
    return JoinSeq("#", s);
}

TString Mask(IHighlighter::TPtr& h, TStringBuf text) {
    return ToMask(Tokenize(*h, text));
}

Y_UNIT_TEST_SUITE(SqlHighlighterTests) {

    Y_UNIT_TEST(Suite) {
        auto h = MakeHighlighter(MakeHighlighting());
        size_t count = 0;
        Cerr << "{" << Endl;
        for (const auto& test : LoadTestSuite()) {
            Cerr << "  \"" << test.Name << "\": [" << Endl;
            for (size_t i = 0; i < test.Cases.size(); ++i) {
                const auto& check = test.Cases[i];
                const auto actual = Mask(h, check.Input);
                Cerr << "    [\"" << EscapeC(check.Input) << "\", \"" << actual << "\"]," << Endl;
                UNIT_ASSERT_VALUES_EQUAL_C(
                    actual,
                    check.Expected,
                    test.Name << " #" << i << ": Input = '" << check.Input << "'");
                count += 1;
            }
            Cerr << "  ]," << Endl;
        }
        Cerr << "}" << Endl;
        Cerr << "Test Cases Executed: " << count << Endl;
    }

} // Y_UNIT_TEST_SUITE(SqlHighlighterTests)