move tests under tests/ dir

Author: iliabylich

api.cpp

@@ -20,44 +20,3 @@ namespace lib_ruby_parser
                 into_blob<ParserOptions, ParserOptionsBlob>(std::move(options))));
     }
 }
-
-#ifdef TEST_ENV
-
-#include "test_helper.hpp"
-
-namespace lib_ruby_parser
-{
-    static void test_parse(void)
-    {
-        annotate_test;
-
-        ParserOptions options(
-            String::Copied("(eval)"),
-            MaybeDecoder(Decoder(nullptr, nullptr)),
-            MaybeTokenRewriter(TokenRewriter(nullptr)),
-            true);
-
-        ByteList input = ByteList::Copied("2 + 3", 5);
-
-        ParserResult result = parse(
-            std::move(input),
-            std::move(options));
-
-        assert_eq(result.ast->tag, Node::Tag::SEND);
-        assert_eq(result.tokens.len, 4); // tINT tPLUS tINT EOF
-        assert_eq(result.comments.len, 0);
-        assert_eq(result.magic_comments.len, 0);
-        assert_byte_list(result.input.bytes, "2 + 3");
-    }
-
-    void run_test_group_api(void)
-    {
-        const test_fn_t tests[] = {
-            test_parse,
-        };
-
-        run_tests_as_group("api", tests, sizeof(tests) / sizeof(test_fn_t));
-    }
-}
-
-#endif

api.hpp

@@ -9,10 +9,6 @@ namespace lib_ruby_parser
     /// Parses given `input` according to `option`.
     /// This is the main entrypoint API.
     ParserResult parse(ByteList input, ParserOptions options);
-
-#ifdef TEST_ENV
-    void run_test_group_api(void);
-#endif
 } // namespace lib_ruby_parser
 
 #endif // LIB_RUBY_PARSER_API_HPP

bytes.cpp

@@ -27,71 +27,3 @@ namespace lib_ruby_parser
 
     Bytes::Bytes(ByteList raw_) : raw(std::move(raw_)) {}
 } // namespace lib_ruby_parser
-
-#ifdef TEST_ENV
-
-#include "test_helper.hpp"
-#include <cstdlib>
-#include <iostream>
-
-namespace lib_ruby_parser
-{
-    extern "C"
-    {
-        ByteListBlob lib_ruby_parser__test__make_byte_list(char i1, char i2, char i3);
-    }
-
-    static void test_byte_list_fields(void)
-    {
-        annotate_test;
-
-        ByteList byte_list = from_blob<ByteListBlob, ByteList>(
-            lib_ruby_parser__test__make_byte_list('1', '2', '3'));
-        assert_byte_list(byte_list, "123");
-
-        ByteList moved = std::move(byte_list);
-    }
-
-    static void test_byte_list_constructors(void)
-    {
-        annotate_test;
-
-        char *owned = static_cast<char *>(malloc(4));
-        owned[0] = '1';
-        owned[1] = '2';
-        owned[2] = '3';
-        owned[3] = '4';
-        ByteList byte_list_owned = ByteList::Owned(owned, 4);
-        assert_byte_list(byte_list_owned, "1234");
-
-        ByteList byte_list_coped = ByteList::Copied("56789", 5);
-        assert_byte_list(byte_list_coped, "56789");
-    }
-
-    extern "C"
-    {
-        BytesBlob lib_ruby_parser__test__make_bytes(char i1, char i2, char i3);
-    }
-    static void test_bytes_fields(void)
-    {
-        annotate_test;
-
-        Bytes bytes = from_blob<BytesBlob, Bytes>(
-            lib_ruby_parser__test__make_bytes('a', 'b', 'c'));
-        assert_byte_list(bytes.raw, "abc");
-    }
-
-    void run_test_group_bytes(void)
-    {
-        const test_fn_t tests[] = {
-            test_byte_list_fields,
-            test_byte_list_constructors,
-            test_bytes_fields,
-        };
-
-        run_tests_as_group("bytes", tests, sizeof(tests) / sizeof(test_fn_t));
-    }
-
-}
-
-#endif

bytes.hpp

@@ -48,11 +48,6 @@ namespace lib_ruby_parser
         Bytes(Bytes &&) = default;
         Bytes &operator=(Bytes &&) = default;
     };
-
-#ifdef TEST_ENV
-    void run_test_group_bytes(void);
-#endif
-
 } // namespace lib_ruby_parser
 
 #endif // LIB_RUBY_PARSER_BYTES_HPP

comment.cpp

@@ -15,78 +15,3 @@ namespace lib_ruby_parser
 
     LIST_IMPL(CommentList, Comment, LIB_RUBY_PARSER_drop_comment_list);
 } // namespace lib_ruby_parser
-
-#ifdef TEST_ENV
-
-#include "test_helper.hpp"
-
-namespace lib_ruby_parser
-{
-    extern "C"
-    {
-        CommentType lib_ruby_parser__test__make_comment_type_document(void);
-        CommentType lib_ruby_parser__test__make_comment_type_inline(void);
-        CommentType lib_ruby_parser__test__make_comment_type_unknown(void);
-    }
-    static void test_comment_type_options(void)
-    {
-        annotate_test;
-
-        CommentType comment_type;
-
-        comment_type = lib_ruby_parser__test__make_comment_type_document();
-        assert_eq(comment_type, CommentType::DOCUMENT);
-
-        comment_type = lib_ruby_parser__test__make_comment_type_inline();
-        assert_eq(comment_type, CommentType::INLINE);
-
-        comment_type = lib_ruby_parser__test__make_comment_type_unknown();
-        assert_eq(comment_type, CommentType::UNKNOWN);
-    }
-
-    extern "C"
-    {
-        CommentBlob lib_ruby_parser__test__make_comment(LocBlob location, CommentTypeBlob kind);
-    }
-    static void test_comment_fields(void)
-    {
-        annotate_test;
-
-        Comment comment = from_blob<CommentBlob, Comment>(
-            lib_ruby_parser__test__make_comment(
-                into_blob<Loc, LocBlob>(Loc(1, 2)),
-                into_blob<CommentType, CommentTypeBlob>(CommentType::INLINE)));
-
-        assert_comment(comment, Loc(1, 2), CommentType::INLINE);
-    }
-
-    extern "C"
-    {
-        CommentListBlob lib_ruby_parser__test__make_comment_list(CommentBlob comment);
-    }
-    static void test_comment_list_fields(void)
-    {
-        annotate_test;
-
-        CommentList comment_list = from_blob<CommentListBlob, CommentList>(
-            lib_ruby_parser__test__make_comment_list(
-                lib_ruby_parser__test__make_comment(
-                    into_blob<Loc, LocBlob>(Loc(1, 2)),
-                    into_blob<CommentType, CommentTypeBlob>(CommentType::INLINE))));
-        assert_eq(comment_list.len, 1);
-        assert_comment(comment_list.ptr[0], Loc(1, 2), CommentType::INLINE);
-    }
-
-    void run_test_group_comment(void)
-    {
-        const test_fn_t tests[] = {
-            test_comment_type_options,
-            test_comment_fields,
-            test_comment_list_fields,
-        };
-
-        run_tests_as_group("comment", tests, sizeof(tests) / sizeof(test_fn_t));
-    }
-}
-
-#endif

comment.hpp

@@ -52,10 +52,6 @@ namespace lib_ruby_parser
         CommentList(CommentList &&);
         CommentList &operator=(CommentList &&);
     };
-
-#ifdef TEST_ENV
-    void run_test_group_comment(void);
-#endif
 } // namespace lib_ruby_parser
 
 #endif // LIB_RUBY_PARSER_COMMENT_HPP

decoded_input.cpp

@@ -12,38 +12,3 @@ namespace lib_ruby_parser
                                                   lines(std::move(lines_)),
                                                   bytes(std::move(bytes_)) {}
 }
-
-#ifdef TEST_ENV
-
-#include "test_helper.hpp"
-
-namespace lib_ruby_parser
-{
-    extern "C"
-    {
-        DecodedInputBlob lib_ruby_parser__test__make_decoded_input(void);
-    }
-    static void test_decoded_input(void)
-    {
-        annotate_test;
-
-        DecodedInput decoded_input = from_blob<DecodedInputBlob, DecodedInput>(
-            lib_ruby_parser__test__make_decoded_input());
-
-        assert_string_eq(decoded_input.name, "(eval)");
-        assert_eq(decoded_input.lines.len, 1);
-        assert_source_line(decoded_input.lines.ptr[0], 10, 20, false);
-        assert_byte_list(decoded_input.bytes, "2 + 2");
-    }
-
-    void run_test_group_decoded_input(void)
-    {
-        const test_fn_t tests[] = {
-            test_decoded_input,
-        };
-
-        run_tests_as_group("decoded_input", tests, sizeof(tests) / sizeof(test_fn_t));
-    }
-}
-
-#endif

decoded_input.hpp

@@ -24,10 +24,6 @@ namespace lib_ruby_parser
         DecodedInput(DecodedInput &&) = default;
         DecodedInput &operator=(DecodedInput &&) = default;
     };
-
-#ifdef TEST_ENV
-    void run_test_group_decoded_input(void);
-#endif
 } // namespace lib_ruby_parser
 
 #endif // LIB_RUBY_PARSER_DECODED_INPUT_HPP