#pragma once #include "LibLsp/JsonRpc/MessageIssue.h" #include "LibLsp/JsonRpc/stream.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace test { inline int& Failures() { static int failures = 0; return failures; } inline int& SkippedTests() { static int skipped = 0; return skipped; } inline std::string& TestFilterStorage() { static std::string pattern; return pattern; } inline void InitTestFilter(int argc, char** argv) { std::string pattern; char const* env = std::getenv("LSPCPP_TEST_FILTER"); if (env != nullptr) { pattern = env; } for (int i = 1; i < argc; ++i) { char const* arg = argv[i]; char const* prefix = "--filter="; size_t const prefix_len = std::strlen(prefix); if (std::strncmp(arg, prefix, prefix_len) == 0) { pattern = arg + prefix_len; break; } } TestFilterStorage() = std::move(pattern); } inline bool ShouldRunTest(char const* test_name) { std::string const& pattern = TestFilterStorage(); if (pattern.empty()) { return true; } return std::strstr(test_name, pattern.c_str()) != nullptr; } inline void Expect(bool condition, char const* message) { if (!condition) { std::cerr << message << std::endl; ++Failures(); } } class DummyLog : public lsp::Log { public: void log(Level, std::wstring&& msg) override { std::wcerr << msg << std::endl; } void log(Level, const std::wstring& msg) override { std::wcerr << msg << std::endl; } void log(Level, std::string&& msg) override { std::cerr << msg << std::endl; } void log(Level, const std::string& msg) override { std::cerr << msg << std::endl; } }; class CollectingIssueHandler : public MessageIssueHandler { public: void handle(std::vector&&) override { } void handle(MessageIssue&& issue) override { issues.push_back(std::move(issue)); } std::vector issues; }; class StringIStream : public lsp::istream { public: explicit StringIStream(std::string data) : data_(std::move(data)) { } void set_bad(bool value = true) { bad_ = value; } void set_fail(bool value = true) { fail_ = value; } int get() override { if (bad_) { return EOF; } if (pos_ >= data_.size()) { eof_ = true; return EOF; } return static_cast(data_[pos_++]); } lsp::istream& read(char* str, std::streamsize count) override { for (std::streamsize i = 0; i < count; ++i) { int const c = get(); if (c == EOF) { break; } str[i] = static_cast(c); } return *this; } bool fail() override { return fail_; } bool bad() override { return bad_; } bool eof() override { return eof_; } bool good() override { return !fail_ && !bad_ && !eof_; } void clear() override { fail_ = false; bad_ = false; eof_ = false; } std::string what() override { return what_; } private: std::string data_; size_t pos_ = 0; bool fail_ = false; bool bad_ = false; bool eof_ = false; std::string what_; }; class FeedableIStream : public lsp::istream { public: void append(std::string const& data) { { std::lock_guard lock(mutex_); for (char c : data) { data_.push_back(c); } } cv_.notify_all(); } void interrupt() override { { std::lock_guard lock(mutex_); interrupted_ = true; } cv_.notify_all(); } int get() override { std::unique_lock lock(mutex_); cv_.wait( lock, [&]() { return interrupted_ || !data_.empty(); }); if (data_.empty()) { eof_ = true; return EOF; } auto const c = static_cast(data_.front()); data_.pop_front(); return c; } lsp::istream& read(char* str, std::streamsize count) override { for (std::streamsize i = 0; i < count; ++i) { int const c = get(); if (c == EOF) { break; } str[i] = static_cast(c); } return *this; } bool fail() override { return false; } bool bad() override { return false; } bool eof() override { std::lock_guard lock(mutex_); return eof_; } bool good() override { return !eof(); } void clear() override { std::lock_guard lock(mutex_); eof_ = false; } std::string what() override { return {}; } private: std::mutex mutex_; std::condition_variable cv_; std::deque data_; bool interrupted_ = false; bool eof_ = false; }; class StringOStream : public lsp::ostream { public: void set_bad(bool value = true) { bad_ = value; } std::string const& data() const { return data_; } std::string snapshot() const { std::lock_guard lock(mutex_); return data_; } lsp::ostream& write(std::string const& value) override { if (!bad_) { std::lock_guard lock(mutex_); data_ += value; } return *this; } lsp::ostream& write(std::streamsize value) override { return write(std::to_string(value)); } lsp::ostream& flush() override { return *this; } bool fail() override { return fail_; } bool bad() override { return bad_; } bool eof() override { return false; } bool good() override { return !fail_ && !bad_; } void clear() override { fail_ = false; bad_ = false; } std::string what() override { return what_; } private: mutable std::mutex mutex_; std::string data_; bool fail_ = false; bool bad_ = false; std::string what_; }; inline std::string MakeLspFrame(std::string const& body) { return "Content-Length: " + std::to_string(body.size()) + "\r\n\r\n" + body; } inline int ParseContentLength(std::string const& framed) { auto const header_end = framed.find("\r\n\r\n"); if (header_end == std::string::npos) { return -1; } auto const colon = framed.find(':'); if (colon == std::string::npos) { return -1; } return std::atoi(framed.substr(colon + 1, header_end - colon - 1).c_str()); } inline std::string WaitForOutputContaining( std::shared_ptr const& output_stream, std::string const& needle, int attempts = 100, std::chrono::milliseconds delay = std::chrono::milliseconds(10)) { std::string output; for (int i = 0; i < attempts; ++i) { output = output_stream->snapshot(); if (output.find(needle) != std::string::npos) { break; } std::this_thread::sleep_for(delay); } return output; } inline bool JsonEqual( rapidjson::Value const& lhs, rapidjson::Value const& rhs, std::string* diff_path = nullptr) { if (lhs.GetType() != rhs.GetType()) { if (diff_path != nullptr) { *diff_path = "type mismatch"; } return false; } switch (lhs.GetType()) { case rapidjson::kObjectType: { if (lhs.MemberCount() != rhs.MemberCount()) { if (diff_path != nullptr) { *diff_path = "object member count mismatch"; } return false; } for (auto const& member : lhs.GetObject()) { auto it = rhs.FindMember(member.name); if (it == rhs.MemberEnd()) { if (diff_path != nullptr) { *diff_path = std::string("missing key: ") + member.name.GetString(); } return false; } std::string child_path; if (!JsonEqual(member.value, it->value, diff_path != nullptr ? &child_path : nullptr)) { if (diff_path != nullptr) { *diff_path = std::string(member.name.GetString()) + (child_path.empty() ? "" : "." + child_path); } return false; } } return true; } case rapidjson::kArrayType: { if (lhs.Size() != rhs.Size()) { if (diff_path != nullptr) { *diff_path = "array length mismatch"; } return false; } for (rapidjson::SizeType i = 0; i < lhs.Size(); ++i) { std::string child_path; if (!JsonEqual(lhs[i], rhs[i], diff_path != nullptr ? &child_path : nullptr)) { if (diff_path != nullptr) { *diff_path = std::to_string(i) + (child_path.empty() ? "" : "." + child_path); } return false; } } return true; } case rapidjson::kStringType: return std::strcmp(lhs.GetString(), rhs.GetString()) == 0; case rapidjson::kNumberType: return lhs.GetDouble() == rhs.GetDouble(); case rapidjson::kTrueType: case rapidjson::kFalseType: case rapidjson::kNullType: return true; default: return false; } } inline bool JsonEqual(char const* actual_json, char const* expected_json, std::string* diff = nullptr) { rapidjson::Document actual; rapidjson::Document expected; actual.Parse(actual_json); expected.Parse(expected_json); if (actual.HasParseError() || expected.HasParseError()) { if (diff != nullptr) { *diff = "json parse error"; } return false; } return JsonEqual(actual, expected, diff); } inline void ExpectJsonEqual(char const* actual, char const* expected, char const* message) { std::string diff; if (!JsonEqual(actual, expected, &diff)) { std::cerr << message; if (!diff.empty()) { std::cerr << " (first diff at: " << diff << ")"; } std::cerr << "\nexpected: " << expected << "\nactual: " << actual << std::endl; ++Failures(); } } inline void ExpectJsonEqual(std::string const& actual, std::string const& expected, char const* message) { ExpectJsonEqual(actual.c_str(), expected.c_str(), message); } inline bool UpdateFixturesEnabled() { char const* env = std::getenv("LSPCPP_UPDATE_FIXTURES"); return env != nullptr && env[0] != '\0'; } inline std::string ReadTextFile(std::vector const& candidates) { for (auto const& candidate : candidates) { std::ifstream input(candidate.c_str()); if (!input) { continue; } std::ostringstream buffer; buffer << input.rdbuf(); return buffer.str(); } return {}; } inline std::vector FixturePathCandidates(char const* name) { std::string const suffix = std::string("tests/fixtures/lsp/") + name; return { suffix, "../" + suffix, "../../" + suffix, "../../../" + suffix, }; } inline std::string ReadFixture(char const* name) { std::string const json = ReadTextFile(FixturePathCandidates(name)); Expect(!json.empty(), "protocol golden fixture must be readable"); return json; } inline bool WriteFixture(char const* name, std::string const& content) { if (!UpdateFixturesEnabled()) { return false; } for (auto const& candidate : FixturePathCandidates(name)) { std::ofstream output(candidate.c_str()); if (!output) { continue; } output << content; return true; } std::string const primary = std::string("tests/fixtures/lsp/") + name; std::ofstream output(primary.c_str()); if (!output) { return false; } output << content; return true; } inline void ExpectJsonFixture(std::string const& actual, char const* fixture_name, char const* message) { if (UpdateFixturesEnabled()) { WriteFixture(fixture_name, actual); return; } ExpectJsonEqual(actual, ReadFixture(fixture_name), message); } inline std::vector ExtractLspFrameBodies(std::string const& output) { std::vector bodies; size_t pos = 0; while (pos < output.size()) { size_t const header_end = output.find("\r\n\r\n", pos); if (header_end == std::string::npos) { break; } size_t const length_start = output.find("Content-Length:", pos); if (length_start == std::string::npos || length_start > header_end) { break; } size_t const value_start = length_start + std::string("Content-Length:").size(); int const length = std::atoi(output.substr(value_start, header_end - value_start).c_str()); size_t const body_start = header_end + 4; if (length < 0 || body_start + static_cast(length) > output.size()) { break; } bodies.push_back(output.substr(body_start, static_cast(length))); pos = body_start + static_cast(length); } return bodies; } } // namespace test #define RUN_TEST(fn) \ do { \ if (test::ShouldRunTest(#fn)) { \ (fn)(); \ } else { \ ++test::SkippedTests(); \ } \ } while (0)