diff --git a/include/ss/common.hpp b/include/ss/common.hpp
new file mode 100644
index 0000000..d2d34bd
--- /dev/null
+++ b/include/ss/common.hpp
@@ -0,0 +1,19 @@
+#pragma once
+#include <vector>
+
+namespace ss {
+
+struct none {};
+
+using string_range = std::pair<const char*, const char*>;
+using split_data = std::vector<string_range>;
+
+constexpr inline auto default_delimiter = ",";
+
+template <bool StringError>
+inline void assert_string_error_defined() {
+    static_assert(StringError,
+                  "'string_error' needs to be enabled to use 'error_msg'");
+}
+
+} /* ss */
diff --git a/include/ss/converter.hpp b/include/ss/converter.hpp
index 0a0b837..b66002b 100644
--- a/include/ss/converter.hpp
+++ b/include/ss/converter.hpp
@@ -40,19 +40,13 @@ template <typename T>
 using no_validator_t = typename no_validator<T>::type;
 
 template <typename... Ts>
-struct no_validator_tup {
-    using type = typename apply_trait<no_validator, std::tuple<Ts...>>::type;
-};
+struct no_validator_tup : apply_trait<no_validator, std::tuple<Ts...>> {};
 
 template <typename... Ts>
-struct no_validator_tup<std::tuple<Ts...>> {
-    using type = typename no_validator_tup<Ts...>::type;
-};
+struct no_validator_tup<std::tuple<Ts...>> : no_validator_tup<Ts...> {};
 
 template <typename T>
-struct no_validator_tup<std::tuple<T>> {
-    using type = no_validator_t<T>;
-};
+struct no_validator_tup<std::tuple<T>> : no_validator<T> {};
 
 template <typename... Ts>
 using no_validator_tup_t = typename no_validator_tup<Ts...>::type;
@@ -62,10 +56,7 @@ using no_validator_tup_t = typename no_validator_tup<Ts...>::type;
 ////////////////
 
 template <typename... Ts>
-struct no_void_tup {
-    using type =
-        typename filter_not<std::is_void, no_validator_tup_t<Ts...>>::type;
-};
+struct no_void_tup : filter_not<std::is_void, no_validator_tup_t<Ts...>> {};
 
 template <typename... Ts>
 using no_void_tup_t = filter_not_t<std::is_void, Ts...>;
@@ -76,14 +67,11 @@ using no_void_tup_t = filter_not_t<std::is_void, Ts...>;
 
 // replace 'validators' and remove void from tuple
 template <typename... Ts>
-struct no_void_validator_tup {
-    using type = no_validator_tup_t<no_void_tup_t<Ts...>>;
-};
+struct no_void_validator_tup : no_validator_tup<no_void_tup_t<Ts...>> {};
 
 template <typename... Ts>
-struct no_void_validator_tup<std::tuple<Ts...>> {
-    using type = no_validator_tup_t<no_void_tup_t<Ts...>>;
-};
+struct no_void_validator_tup<std::tuple<Ts...>>
+    : no_validator_tup<no_void_tup_t<Ts...>> {};
 
 template <typename... Ts>
 using no_void_validator_tup_t = typename no_void_validator_tup<Ts...>::type;
@@ -131,12 +119,12 @@ public:
     no_void_validator_tup_t<Ts...> convert(
         line_ptr_type line, const std::string& delim = default_delimiter) {
         split(line, delim);
-        return convert<Ts...>(splitter_.split_input_);
+        return convert<Ts...>(splitter_.split_data_);
     }
 
     // parses already split line, returns 'T' object with extracted values
     template <typename T, typename... Ts>
-    T convert_object(const split_input& elems) {
+    T convert_object(const split_data& elems) {
         return to_object<T>(convert<Ts...>(elems));
     }
 
@@ -151,17 +139,12 @@ public:
     // one argument is given which is a class which has a tied
     // method which returns a tuple, returns that type
     template <typename T, typename... Ts>
-    no_void_validator_tup_t<T, Ts...> convert(const split_input& elems) {
-        if constexpr (sizeof...(Ts) == 0 &&
-                      is_instance_of<T, std::tuple>::value) {
+    no_void_validator_tup_t<T, Ts...> convert(const split_data& elems) {
+        if constexpr (sizeof...(Ts) == 0 && is_instance_of_v<std::tuple, T>) {
             return convert_impl(elems, static_cast<T*>(nullptr));
-
         } else if constexpr (tied_class_v<T, Ts...>) {
-            using arg_ref_tuple =
-                typename std::result_of_t<decltype (&T::tied)(T)>;
-
-            using arg_tuple =
-                typename apply_trait<std::decay, arg_ref_tuple>::type;
+            using arg_ref_tuple = std::result_of_t<decltype (&T::tied)(T)>;
+            using arg_tuple = apply_trait_t<std::decay, arg_ref_tuple>;
 
             return to_object<T>(
                 convert_impl(elems, static_cast<arg_tuple*>(nullptr)));
@@ -173,7 +156,7 @@ public:
     // same as above, but uses cached split line
     template <typename T, typename... Ts>
     no_void_validator_tup_t<T, Ts...> convert() {
-        return convert<T, Ts...>(splitter_.split_input_);
+        return convert<T, Ts...>(splitter_.split_data_);
     }
 
     bool valid() const {
@@ -185,8 +168,7 @@ public:
     }
 
     const std::string& error_msg() const {
-        static_assert(string_error,
-                      "'string_error' needs to be enabled to use 'error_msg'");
+        assert_string_error_defined<string_error>();
         return error_;
     }
 
@@ -196,11 +178,11 @@ public:
 
     // 'splits' string by given delimiter, returns vector of pairs which
     // contain the beginnings and the ends of each column of the string
-    const split_input& split(line_ptr_type line,
-                             const std::string& delim = default_delimiter) {
-        splitter_.split_input_.clear();
+    const split_data& split(line_ptr_type line,
+                            const std::string& delim = default_delimiter) {
+        splitter_.split_data_.clear();
         if (line[0] == '\0') {
-            return splitter_.split_input_;
+            return splitter_.split_data_;
         }
 
         return splitter_.split(line, delim);
@@ -211,11 +193,15 @@ private:
     // resplit
     ////////////////
 
-    const split_input& resplit(line_ptr_type new_line, ssize_t new_size,
-                               const std::string& delim = default_delimiter) {
+    const split_data& resplit(line_ptr_type new_line, ssize_t new_size,
+                              const std::string& delim = default_delimiter) {
         return splitter_.resplit(new_line, new_size, delim);
     }
 
+    size_t size_shifted() {
+        return splitter_.size_shifted();
+    }
+
     ////////////////
     // error
     ////////////////
@@ -248,6 +234,15 @@ private:
         }
     }
 
+    void set_error_multiline_limit_reached() {
+        if constexpr (string_error) {
+            error_.clear();
+            error_.append("multiline limit reached.");
+        } else {
+            error_ = true;
+        }
+    }
+
     void set_error_invalid_conversion(const string_range msg, size_t pos) {
         if constexpr (string_error) {
             error_.clear();
@@ -285,7 +280,7 @@ private:
     ////////////////
 
     template <typename... Ts>
-    no_void_validator_tup_t<Ts...> convert_impl(const split_input& elems) {
+    no_void_validator_tup_t<Ts...> convert_impl(const split_data& elems) {
         clear_error();
 
         if (!splitter_.valid()) {
@@ -306,7 +301,7 @@ private:
     // do not know how to specialize by return type :(
     template <typename... Ts>
     no_void_validator_tup_t<std::tuple<Ts...>> convert_impl(
-        const split_input& elems, const std::tuple<Ts...>*) {
+        const split_data& elems, const std::tuple<Ts...>*) {
         return convert_impl<Ts...>(elems);
     }
 
@@ -345,11 +340,11 @@ private:
 
     template <size_t ArgN, size_t TupN, typename... Ts>
     void extract_multiple(no_void_validator_tup_t<Ts...>& tup,
-                          const split_input& elems) {
+                          const split_data& elems) {
         using elem_t = std::tuple_element_t<ArgN, std::tuple<Ts...>>;
 
         constexpr bool not_void = !std::is_void_v<elem_t>;
-        constexpr bool one_element = count_not<std::is_void, Ts...>::size == 1;
+        constexpr bool one_element = count_not_v<std::is_void, Ts...> == 1;
 
         if constexpr (not_void) {
             if constexpr (one_element) {
@@ -367,8 +362,8 @@ private:
     }
 
     template <typename... Ts>
-    no_void_validator_tup_t<Ts...> extract_tuple(const split_input& elems) {
-        static_assert(!all_of<std::is_void, Ts...>::value,
+    no_void_validator_tup_t<Ts...> extract_tuple(const split_data& elems) {
+        static_assert(!all_of_v<std::is_void, Ts...>,
                       "at least one parameter must be non void");
         no_void_validator_tup_t<Ts...> ret{};
         extract_multiple<0, 0, Ts...>(ret, elems);
@@ -379,7 +374,7 @@ private:
     // members
     ////////////////
 
-    error_type error_;
+    error_type error_{};
     splitter<Matchers...> splitter_;
 
     template <typename...>
diff --git a/include/ss/extract.hpp b/include/ss/extract.hpp
index 60d3fdb..ebf7ef8 100644
--- a/include/ss/extract.hpp
+++ b/include/ss/extract.hpp
@@ -225,8 +225,8 @@ struct unsupported_type {
 
 template <typename T>
 std::enable_if_t<!std::is_integral_v<T> && !std::is_floating_point_v<T> &&
-                     !is_instance_of<T, std::optional>::value &&
-                     !is_instance_of<T, std::variant>::value,
+                     !is_instance_of_v<std::optional, T> &&
+                     !is_instance_of_v<std::variant, T>,
                  bool>
 extract(const char*, const char*, T&) {
     static_assert(error::unsupported_type<T>::value,
@@ -246,7 +246,7 @@ extract(const char* begin, const char* end, T& value) {
 }
 
 template <typename T>
-std::enable_if_t<is_instance_of<T, std::optional>::value, bool> extract(
+std::enable_if_t<is_instance_of_v<std::optional, T>, bool> extract(
     const char* begin, const char* end, T& value) {
     typename T::value_type raw_value;
     if (extract(begin, end, raw_value)) {
@@ -271,7 +271,7 @@ bool extract_variant(const char* begin, const char* end, T& value) {
 }
 
 template <typename T>
-std::enable_if_t<is_instance_of<T, std::variant>::value, bool> extract(
+std::enable_if_t<is_instance_of_v<std::variant, T>, bool> extract(
     const char* begin, const char* end, T& value) {
     return extract_variant<T, 0>(begin, end, value);
 }
diff --git a/include/ss/parser.hpp b/include/ss/parser.hpp
index af740b1..bf0fad6 100644
--- a/include/ss/parser.hpp
+++ b/include/ss/parser.hpp
@@ -13,13 +13,17 @@ namespace ss {
 
 template <typename... Matchers>
 class parser {
-    struct none {};
-
     constexpr static auto string_error = setup<Matchers...>::string_error;
-    constexpr static auto multiline = setup<Matchers...>::multiline;
 
+    using multiline = typename setup<Matchers...>::multiline;
     using error_type = ss::ternary_t<string_error, std::string, bool>;
 
+    constexpr static bool escaped_multiline_enabled =
+        multiline::enabled && setup<Matchers...>::escape::enabled;
+
+    constexpr static bool quoted_multiline_enabled =
+        multiline::enabled && setup<Matchers...>::quote::enabled;
+
 public:
     parser(const std::string& file_name,
            const std::string& delim = ss::default_delimiter)
@@ -48,8 +52,7 @@ public:
     }
 
     const std::string& error_msg() const {
-        static_assert(string_error,
-                      "'string_error' needs to be enabled to use 'error_msg'");
+        assert_string_error_defined<string_error>();
         return error_;
     }
 
@@ -157,11 +160,13 @@ public:
                 if (!parser_.valid()) {
                     return;
                 }
+
                 if constexpr (!std::is_same_v<U, decltype(tuple_output)>) {
                     value = to_object<U>(std::move(tuple_output));
                 } else {
                     value = std::move(tuple_output);
                 }
+
                 parser_.try_invoke(*value, std::forward<Fun>(fun));
             }
         }
@@ -177,6 +182,10 @@ public:
             return value;
         }
 
+        ////////////////
+        // members
+        ////////////////
+
         std::tuple<Ts...> values_;
         parser& parser_;
     };
@@ -321,7 +330,7 @@ private:
               helper_buffer_{other.helper_buffer_}, converter_{std::move(
                                                         other.converter_)},
               next_line_converter_{std::move(other.next_line_converter_)},
-              size_{other.size_},
+              size_{other.size_}, next_line_size_{other.size_},
               helper_size_{other.helper_size_}, delim_{std::move(other.delim_)},
               file_{other.file_}, crlf_{other.crlf_} {
             other.buffer_ = nullptr;
@@ -338,6 +347,7 @@ private:
                 converter_ = std::move(other.converter_);
                 next_line_converter_ = std::move(other.next_line_converter_);
                 size_ = other.size_;
+                next_line_size_ = other.next_line_size_;
                 helper_size_ = other.helper_size_;
                 delim_ = std::move(other.delim_);
                 file_ = other.file_;
@@ -367,17 +377,23 @@ private:
         reader& operator=(const reader& other) = delete;
 
         bool read_next() {
-            ssize_t ssize = getline(&next_line_buffer_, &size_, file_);
+            memset(next_line_buffer_, '\0', next_line_size_);
+            ssize_t ssize =
+                getline(&next_line_buffer_, &next_line_size_, file_);
 
             if (ssize == -1) {
                 return false;
             }
 
             size_t size = remove_eol(next_line_buffer_, ssize);
+            size_t limit = 0;
 
-            if constexpr (multiline && setup<Matchers...>::escape::enabled) {
+            if constexpr (escaped_multiline_enabled) {
                 while (escaped_eol(size)) {
-                    if (!append_line(next_line_buffer_, size)) {
+                    if (multiline_limit_reached(limit)) {
+                        return true;
+                    }
+                    if (!append_next_line_to_buffer(next_line_buffer_, size)) {
                         return false;
                     }
                 }
@@ -385,11 +401,27 @@ private:
 
             next_line_converter_.split(next_line_buffer_, delim_);
 
-            if constexpr (multiline && setup<Matchers...>::quote::enabled) {
+            if constexpr (quoted_multiline_enabled) {
                 while (unterminated_quote()) {
-                    if (!append_line(next_line_buffer_, size)) {
+                    if (multiline_limit_reached(limit)) {
+                        return true;
+                    }
+                    if (!append_next_line_to_buffer(next_line_buffer_, size)) {
                         return false;
                     }
+
+                    if constexpr (escaped_multiline_enabled) {
+                        while (escaped_eol(size)) {
+                            if (multiline_limit_reached(limit)) {
+                                return true;
+                            }
+                            if (!append_next_line_to_buffer(next_line_buffer_,
+                                                            size)) {
+                                return false;
+                            }
+                        }
+                    }
+
                     next_line_converter_.resplit(next_line_buffer_, size);
                 }
             }
@@ -399,9 +431,20 @@ private:
 
         void update() {
             std::swap(buffer_, next_line_buffer_);
+            std::swap(size_, next_line_size_);
             std::swap(converter_, next_line_converter_);
         }
 
+        bool multiline_limit_reached(size_t& limit) {
+            if constexpr (multiline::size > 0) {
+                if (limit++ >= multiline::size) {
+                    next_line_converter_.set_error_multiline_limit_reached();
+                    return true;
+                }
+            }
+            return false;
+        }
+
         bool escaped_eol(size_t size) {
             const char* curr;
             for (curr = next_line_buffer_ + size - 1;
@@ -419,12 +462,15 @@ private:
             return false;
         }
 
-        void undo_remove_eol(size_t& string_end) {
+        void undo_remove_eol(char* buffer, size_t& string_end) {
+            if (next_line_converter_.unterminated_quote()) {
+                string_end -= next_line_converter_.size_shifted();
+            }
             if (crlf_) {
-                std::copy_n("\r\n\0", 3, next_line_buffer_ + string_end);
+                std::copy_n("\r\n\0", 3, buffer + string_end);
                 string_end += 2;
             } else {
-                std::copy_n("\n\0", 2, next_line_buffer_ + string_end);
+                std::copy_n("\n\0", 2, buffer + string_end);
                 string_end += 1;
             }
         }
@@ -444,23 +490,23 @@ private:
 
         void realloc_concat(char*& first, size_t& first_size,
                             const char* const second, size_t second_size) {
-            first = static_cast<char*>(realloc(static_cast<void*>(first),
-                                               first_size + second_size + 2));
-
+            next_line_size_ = first_size + second_size + 2;
+            first = static_cast<char*>(
+                realloc(static_cast<void*>(first), next_line_size_));
             std::copy_n(second, second_size + 1, first + first_size);
             first_size += second_size;
         }
 
-        bool append_line(char*& dst_buffer, size_t& dst_size) {
-            undo_remove_eol(dst_size);
+        bool append_next_line_to_buffer(char*& buffer, size_t& size) {
+            undo_remove_eol(buffer, size);
 
-            ssize_t ssize = getline(&helper_buffer_, &helper_size_, file_);
-            if (ssize == -1) {
+            ssize_t next_ssize = getline(&helper_buffer_, &helper_size_, file_);
+            if (next_ssize == -1) {
                 return false;
             }
 
-            size_t size = remove_eol(helper_buffer_, ssize);
-            realloc_concat(dst_buffer, dst_size, helper_buffer_, size);
+            size_t next_size = remove_eol(helper_buffer_, next_ssize);
+            realloc_concat(buffer, size, helper_buffer_, next_size);
             return true;
         }
 
@@ -475,6 +521,7 @@ private:
         converter<Matchers...> next_line_converter_;
 
         size_t size_{0};
+        size_t next_line_size_{0};
         size_t helper_size_{0};
 
         std::string delim_;
@@ -488,7 +535,7 @@ private:
     ////////////////
 
     std::string file_name_;
-    error_type error_;
+    error_type error_{};
     reader reader_;
     size_t line_number_{0};
     bool eof_{false};
diff --git a/include/ss/setup.hpp b/include/ss/setup.hpp
index c773fca..8f26eb8 100644
--- a/include/ss/setup.hpp
+++ b/include/ss/setup.hpp
@@ -4,6 +4,10 @@
 
 namespace ss {
 
+////////////////
+// matcher
+////////////////
+
 template <char... Cs>
 struct matcher {
 private:
@@ -36,7 +40,7 @@ public:
 };
 
 template <typename FirstMatcher, typename SecondMatcher>
-constexpr bool matches_intersect() {
+inline constexpr bool matches_intersect() {
     for (const auto& first_match : FirstMatcher::matches) {
         for (const auto& second_match : SecondMatcher::matches) {
             if (first_match != '\0' && first_match == second_match) {
@@ -47,6 +51,13 @@ constexpr bool matches_intersect() {
     return false;
 }
 
+template <typename FirstMatcher, typename SecondMatcher1,
+          typename SecondMatcher2>
+inline constexpr bool matches_intersect_union() {
+    return matches_intersect<FirstMatcher, SecondMatcher1>() ||
+           matches_intersect<FirstMatcher, SecondMatcher2>();
+}
+
 template <>
 class matcher<'\0'> {
 public:
@@ -55,31 +66,52 @@ public:
     static bool match(char c) = delete;
 };
 
+////////////////
+// setup
+////////////////
+
+////////////////
+// matcher
+////////////////
+
 template <char C>
 struct quote : matcher<C> {};
 
 template <char... Cs>
 struct trim : matcher<Cs...> {};
 
+template <char... Cs>
+struct trim_left : matcher<Cs...> {};
+
+template <char... Cs>
+struct trim_right : matcher<Cs...> {};
+
 template <char... Cs>
 struct escape : matcher<Cs...> {};
 
 template <typename T, template <char...> class Template>
-struct is_instance_of_matcher {
-    constexpr static bool value = false;
-};
+struct is_instance_of_matcher : std::false_type {};
 
 template <char... Ts, template <char...> class Template>
-struct is_instance_of_matcher<Template<Ts...>, Template> {
-    constexpr static bool value = true;
-};
+struct is_instance_of_matcher<Template<Ts...>, Template> : std::true_type {};
+
+template <typename T, template <char...> class Template>
+using is_instance_of_matcher_t =
+    typename is_instance_of_matcher<T, Template>::type;
 
 template <template <char...> class Matcher, typename... Ts>
 struct get_matcher;
 
 template <template <char...> class Matcher, typename T, typename... Ts>
 struct get_matcher<Matcher, T, Ts...> {
-    using type = ternary_t<is_instance_of_matcher<T, Matcher>::value, T,
+
+    template <typename U>
+    struct is_matcher : is_instance_of_matcher<U, Matcher> {};
+
+    static_assert(count_v<is_matcher, T, Ts...> <= 1,
+                  "the same matcher is cannot"
+                  "be defined multiple times");
+    using type = ternary_t<is_matcher<T>::value, T,
                            typename get_matcher<Matcher, Ts...>::type>;
 };
 
@@ -91,39 +123,119 @@ struct get_matcher<Matcher> {
 template <template <char...> class Matcher, typename... Ts>
 using get_matcher_t = typename get_matcher<Matcher, Ts...>::type;
 
-class multiline;
+////////////////
+// multiline
+////////////////
+
+template <size_t S, bool B = true>
+struct multiline_restricted {
+    constexpr static auto size = S;
+    constexpr static auto enabled = B;
+};
+
+using multiline = multiline_restricted<0>;
+
+template <typename T>
+struct is_instance_of_multiline : std::false_type {};
+
+template <size_t S, bool B>
+struct is_instance_of_multiline<multiline_restricted<S, B>> : std::true_type {};
+
+template <typename T>
+using is_instance_of_multiline_t = typename is_instance_of_multiline<T>::type;
+
+template <typename... Ts>
+struct get_multiline;
+
+template <typename T, typename... Ts>
+struct get_multiline<T, Ts...> {
+    using type = ternary_t<is_instance_of_multiline<T>::value, T,
+                           typename get_multiline<Ts...>::type>;
+};
+
+template <>
+struct get_multiline<> {
+    using type = multiline_restricted<0, false>;
+};
+
+template <typename... Ts>
+using get_multiline_t = typename get_multiline<Ts...>::type;
+
+////////////////
+// string_error
+////////////////
+
 class string_error;
 
+////////////////
+// setup implementation
+////////////////
+
 template <typename... Ts>
 struct setup {
 private:
     template <typename T>
-    struct is_multiline : std::is_same<T, multiline> {};
-
-    constexpr static auto count_multiline = count<is_multiline, Ts...>::size;
+    struct is_matcher
+        : std::disjunction<is_instance_of_matcher_t<T, quote>,
+                           is_instance_of_matcher_t<T, escape>,
+                           is_instance_of_matcher_t<T, trim>,
+                           is_instance_of_matcher_t<T, trim_left>,
+                           is_instance_of_matcher_t<T, trim_right>> {};
 
     template <typename T>
     struct is_string_error : std::is_same<T, string_error> {};
 
-    constexpr static auto count_string_error =
-        count<is_string_error, Ts...>::size;
+    constexpr static auto count_matcher = count_v<is_matcher, Ts...>;
+    constexpr static auto count_multiline =
+        count_v<is_instance_of_multiline, Ts...>;
+    constexpr static auto count_string_error = count_v<is_string_error, Ts...>;
+
+    constexpr static auto number_of_valid_setup_types =
+        count_matcher + count_multiline + count_string_error;
+
+    using trim_left_only = get_matcher_t<trim_left, Ts...>;
+    using trim_right_only = get_matcher_t<trim_right, Ts...>;
+    using trim_all = get_matcher_t<trim, Ts...>;
 
 public:
     using quote = get_matcher_t<quote, Ts...>;
-    using trim = get_matcher_t<trim, Ts...>;
     using escape = get_matcher_t<escape, Ts...>;
-    constexpr static bool multiline = (count_multiline == 1);
+
+    using trim_left = ternary_t<trim_all::enabled, trim_all, trim_left_only>;
+    using trim_right = ternary_t<trim_all::enabled, trim_all, trim_right_only>;
+
+    using multiline = get_multiline_t<Ts...>;
     constexpr static bool string_error = (count_string_error == 1);
 
+private:
+#define ASSERT_MSG "cannot have the same match character in multiple matchers"
+    static_assert(!matches_intersect<escape, quote>(), ASSERT_MSG);
+
+    constexpr static auto quote_trim_intersect =
+        matches_intersect_union<quote, trim_left, trim_right>();
+    static_assert(!quote_trim_intersect, ASSERT_MSG);
+
+    constexpr static auto escape_trim_intersect =
+        matches_intersect_union<escape, trim_left, trim_right>();
+    static_assert(!escape_trim_intersect, ASSERT_MSG);
+
+#undef ASSERT_MSG
+
     static_assert(
-        !multiline || (multiline && (quote::enabled || escape::enabled)),
+        !multiline::enabled ||
+            (multiline::enabled && (quote::enabled || escape::enabled)),
         "to enable multiline either quote or escape need to be enabled");
 
-#define ASSERT_MSG "cannot have the same match character in multiple matchers"
-    static_assert(!matches_intersect<quote, trim>(), ASSERT_MSG);
-    static_assert(!matches_intersect<trim, escape>(), ASSERT_MSG);
-    static_assert(!matches_intersect<escape, quote>(), ASSERT_MSG);
-#undef ASSERT_MSG
+    static_assert(!(trim_all::enabled && trim_left_only::enabled) &&
+                      !(trim_all::enabled && trim_right_only::enabled),
+                  "ambiguous trim setup");
+
+    static_assert(count_multiline <= 1, "mutliline defined multiple times");
+    static_assert(count_string_error <= 1,
+                  "string_error defined multiple times");
+
+    static_assert(number_of_valid_setup_types == sizeof...(Ts),
+                  "one or multiple invalid setup parameters defined");
 };
 
 template <typename... Ts>
diff --git a/include/ss/splitter.hpp b/include/ss/splitter.hpp
index 483d85d..96ca082 100644
--- a/include/ss/splitter.hpp
+++ b/include/ss/splitter.hpp
@@ -1,4 +1,5 @@
 #pragma once
+#include "common.hpp"
 #include "setup.hpp"
 #include "type_traits.hpp"
 #include <algorithm>
@@ -10,17 +11,14 @@
 
 namespace ss {
 
-// TODO move to common or something
-using string_range = std::pair<const char*, const char*>;
-using split_input = std::vector<string_range>;
-constexpr static auto default_delimiter = ",";
-
 template <typename... Ts>
 class splitter {
 private:
     using quote = typename setup<Ts...>::quote;
-    using trim = typename setup<Ts...>::trim;
+    using trim_left = typename setup<Ts...>::trim_left;
+    using trim_right = typename setup<Ts...>::trim_right;
     using escape = typename setup<Ts...>::escape;
+    using multiline = typename setup<Ts...>::multiline;
 
     constexpr static auto string_error = setup<Ts...>::string_error;
     constexpr static auto is_const_line = !quote::enabled && !escape::enabled;
@@ -39,8 +37,7 @@ public:
     }
 
     const std::string& error_msg() const {
-        static_assert(string_error,
-                      "'string_error' needs to be enabled to use 'error_msg'");
+        assert_string_error_defined<string_error>();
         return error_;
     }
 
@@ -48,10 +45,12 @@ public:
         return unterminated_quote_;
     }
 
-    const split_input& split(line_ptr_type new_line,
-                             const std::string& delimiter = default_delimiter) {
-        split_input_.clear();
-        return resplit(new_line, -1, delimiter);
+    const split_data& split(line_ptr_type new_line,
+                            const std::string& delimiter = default_delimiter) {
+        split_data_.clear();
+        line_ = new_line;
+        begin_ = line_;
+        return split_impl_select_delim(delimiter);
     }
 
 private:
@@ -59,35 +58,50 @@ private:
     // resplit
     ////////////////
 
+    // number of characters the end of line is shifted backwards
+    size_t size_shifted() const {
+        return escaped_;
+    }
+
     void adjust_ranges(const char* old_line) {
-        for (auto& [begin, end] : split_input_) {
+        for (auto& [begin, end] : split_data_) {
             begin = begin - old_line + line_;
             end = end - old_line + line_;
         }
     }
 
-    const split_input& resplit(
+    const split_data& resplit(
         line_ptr_type new_line, ssize_t new_size,
         const std::string& delimiter = default_delimiter) {
-        line_ = new_line;
 
         // resplitting, continue from last slice
-        if (!split_input_.empty() && unterminated_quote()) {
-            const auto& last = std::prev(split_input_.end());
-            const auto [old_line, old_begin] = *last;
-            size_t begin = old_begin - old_line - 1;
-            split_input_.pop_back();
-            adjust_ranges(old_line);
-
-            // safety measure
-            if (new_size != -1 && static_cast<size_t>(new_size) < begin) {
-                set_error_invalid_resplit();
-                return split_input_;
-            }
-
-            begin_ = line_ + begin;
+        if (!quote::enabled || !multiline::enabled || split_data_.empty() ||
+            !unterminated_quote()) {
+            set_error_invalid_resplit();
+            return split_data_;
         }
 
+        const auto [old_line, old_begin] = *std::prev(split_data_.end());
+        size_t begin = old_begin - old_line - 1;
+
+        // safety measure
+        if (new_size != -1 && static_cast<size_t>(new_size) < begin) {
+            set_error_invalid_resplit();
+            return split_data_;
+        }
+
+        // if unterminated quote, the last element is junk
+        split_data_.pop_back();
+
+        line_ = new_line;
+        adjust_ranges(old_line);
+
+        begin_ = line_ + begin;
+        end_ = line_ - old_line + end_ - escaped_;
+        curr_ = end_;
+
+        resplitting_ = true;
+
         return split_impl_select_delim(delimiter);
     }
 
@@ -122,6 +136,15 @@ private:
         }
     }
 
+    void set_error_unterminated_escape() {
+        if constexpr (string_error) {
+            error_.clear();
+            error_.append("unterminated escape at the end of the line");
+        } else {
+            error_ = true;
+        }
+    }
+
     void set_error_unterminated_quote() {
         unterminated_quote_ = true;
         if constexpr (string_error) {
@@ -163,9 +186,17 @@ private:
         return delim.size();
     }
 
-    void trim_if_enabled(line_ptr_type& curr) {
-        if constexpr (trim::enabled) {
-            while (trim::match(*curr)) {
+    void trim_left_if_enabled(line_ptr_type& curr) {
+        if constexpr (trim_left::enabled) {
+            while (trim_left::match(*curr)) {
+                ++curr;
+            }
+        }
+    }
+
+    void trim_right_if_enabled(line_ptr_type& curr) {
+        if constexpr (trim_right::enabled) {
+            while (trim_right::match(*curr)) {
                 ++curr;
             }
         }
@@ -176,7 +207,7 @@ private:
                                              const Delim& delim) {
         line_ptr_type end = begin;
 
-        trim_if_enabled(end);
+        trim_right_if_enabled(end);
 
         // just spacing
         if (*end == '\0') {
@@ -190,7 +221,7 @@ private:
         }
 
         end += delimiter_size(delim);
-        trim_if_enabled(end);
+        trim_left_if_enabled(end);
 
         // delimiter
         return {end - begin, true};
@@ -200,25 +231,14 @@ private:
     // shifting
     ////////////////
 
-    void shift_and_set_current() {
-        if constexpr (!is_const_line) {
-            if (escaped_ > 0) {
-                std::copy_n(curr_ + escaped_, end_ - curr_ - escaped_, curr_);
-                curr_ = end_ - escaped_;
-                return;
-            }
-        }
-        curr_ = end_;
-    }
-
-    void shift_and_push() {
-        shift_and_set_current();
-        split_input_.emplace_back(begin_, curr_);
-    }
-
     void shift_if_escaped(line_ptr_type& curr) {
         if constexpr (escape::enabled) {
             if (escape::match(*curr)) {
+                if (curr[1] == '\0') {
+                    set_error_unterminated_escape();
+                    done_ = true;
+                    return;
+                }
                 shift_and_jump_escape();
             }
         }
@@ -237,17 +257,33 @@ private:
         begin_ = end_ + n;
     }
 
+    void shift_and_push() {
+        shift_and_set_current();
+        split_data_.emplace_back(begin_, curr_);
+    }
+
+    void shift_and_set_current() {
+        if constexpr (!is_const_line) {
+            if (escaped_ > 0) {
+                std::copy_n(curr_ + escaped_, end_ - curr_ - escaped_, curr_);
+                curr_ = end_ - escaped_;
+                return;
+            }
+        }
+        curr_ = end_;
+    }
+
     ////////////////
     // split impl
     ////////////////
 
-    const split_input& split_impl_select_delim(
+    const split_data& split_impl_select_delim(
         const std::string& delimiter = default_delimiter) {
         clear_error();
         switch (delimiter.size()) {
         case 0:
             set_error_empty_delimiter();
-            return split_input_;
+            return split_data_;
         case 1:
             return split_impl(delimiter[0]);
         default:
@@ -256,18 +292,14 @@ private:
     }
 
     template <typename Delim>
-    const split_input& split_impl(const Delim& delim) {
+    const split_data& split_impl(const Delim& delim) {
 
-        if (split_input_.empty()) {
-            begin_ = line_;
-        }
-
-        trim_if_enabled(begin_);
+        trim_left_if_enabled(begin_);
 
         for (done_ = false; !done_; read(delim))
             ;
 
-        return split_input_;
+        return split_data_;
     }
 
     ////////////////
@@ -278,6 +310,14 @@ private:
     void read(const Delim& delim) {
         escaped_ = 0;
         if constexpr (quote::enabled) {
+            if constexpr (multiline::enabled) {
+                if (resplitting_) {
+                    resplitting_ = false;
+                    ++begin_;
+                    read_quoted(delim);
+                    return;
+                }
+            }
             if (quote::match(*begin_)) {
                 curr_ = end_ = ++begin_;
                 read_quoted(delim);
@@ -319,23 +359,38 @@ private:
                 if (!quote::match(*end_)) {
                     if constexpr (escape::enabled) {
                         if (escape::match(*end_)) {
+                            if (end_[1] == '\0') {
+                                // eol, unterminated escape
+                                // eg: ... "hel\\0
+                                set_error_unterminated_escape();
+                                done_ = true;
+                                break;
+                            }
+                            // not eol
+
                             shift_and_jump_escape();
                             ++end_;
                             continue;
                         }
                     }
+                    // not escaped
 
-                    // unterminated quote error
+                    // eol, unterminated quote error
                     // eg: ..."hell\0 -> quote not terminated
                     if (*end_ == '\0') {
+                        shift_and_set_current();
                         set_error_unterminated_quote();
-                        split_input_.emplace_back(line_, begin_);
+                        split_data_.emplace_back(line_, begin_);
                         done_ = true;
                         break;
                     }
+                    // not eol
+
                     ++end_;
                     continue;
                 }
+                // quote found
+                // ...
 
                 auto [width, valid] = match_delimiter(end_ + 1, delim);
 
@@ -344,6 +399,7 @@ private:
                     shift_push_and_start_next(width + 1);
                     break;
                 }
+                // not delimiter
 
                 // double quote
                 // eg: ...,"hel""lo",... -> hel"lo
@@ -352,8 +408,8 @@ private:
                     ++end_;
                     continue;
                 }
+                // not double quote
 
-                // not a delimiter
                 if (width == 0) {
                     // eol
                     // eg: ...,"hello"   \0 -> hello
@@ -363,7 +419,7 @@ private:
                     // mismatched quote
                     // eg: ...,"hel"lo,... -> error
                     set_error_mismatched_quote(end_ - line_);
-                    split_input_.emplace_back(line_, begin_);
+                    split_data_.emplace_back(line_, begin_);
                 }
                 done_ = true;
                 break;
@@ -375,17 +431,18 @@ private:
     // members
     ////////////////
 
-    static_assert(std::is_same_v<error_type, bool> ||
-                  std::is_same_v<error_type, std::string>);
-    error_type error_;
+public:
+    error_type error_{};
     bool unterminated_quote_{false};
+    bool done_{true};
+    bool resplitting_{false};
+    size_t escaped_{0};
+    split_data split_data_;
+
     line_ptr_type begin_;
     line_ptr_type curr_;
     line_ptr_type end_;
     line_ptr_type line_;
-    bool done_;
-    size_t escaped_{0};
-    split_input split_input_;
 
     template <typename...>
     friend class converter;
diff --git a/include/ss/type_traits.hpp b/include/ss/type_traits.hpp
index 73913da..2fd75ad 100644
--- a/include/ss/type_traits.hpp
+++ b/include/ss/type_traits.hpp
@@ -103,6 +103,9 @@ struct apply_trait<Trait, std::tuple<T>> {
     using type = std::tuple<typename Trait<T>::type>;
 };
 
+template <template <typename...> class Trait, typename... Ts>
+using apply_trait_t = typename apply_trait<Trait, Ts...>::type;
+
 ////////////////
 // apply optional trait
 ////////////////
@@ -143,6 +146,9 @@ struct apply_optional_trait<Trait, std::tuple<T>> {
         std::tuple<typename optional_trait<typename Trait<T>::type, T>::type>;
 };
 
+template <template <typename...> class Trait, typename... Ts>
+using apply_trait_optional_t = apply_optional_trait<Trait, Ts...>;
+
 ////////////////
 // filter false_type
 ////////////////
@@ -192,6 +198,9 @@ struct negate_impl {
     using type = std::integral_constant<bool, !Trait<Ts...>::value>;
 };
 
+template <template <typename...> class Trait>
+using negate_impl_t = typename negate_impl<Trait>::type;
+
 ////////////////
 // filter by trait
 ////////////////
@@ -235,20 +244,23 @@ struct count;
 
 template <template <typename...> class Trait, typename T, typename... Ts>
 struct count<Trait, T, Ts...> {
-    static constexpr size_t size =
+    static constexpr size_t value =
         std::tuple_size<filter_if_t<Trait, T, Ts...>>::value;
 };
 
 template <template <typename...> class Trait, typename T>
 struct count<Trait, T> {
-    static constexpr size_t size = Trait<T>::value;
+    static constexpr size_t value = Trait<T>::value;
 };
 
 template <template <typename...> class Trait>
 struct count<Trait> {
-    static constexpr size_t size = 0;
+    static constexpr size_t value = 0;
 };
 
+template <template <typename...> class Trait, typename... Ts>
+constexpr size_t count_v = count<Trait, Ts...>::value;
+
 ////////////////
 // count not
 ////////////////
@@ -258,34 +270,40 @@ struct count_not;
 
 template <template <typename...> class Trait, typename T, typename... Ts>
 struct count_not<Trait, T, Ts...> {
-    static constexpr size_t size =
+    static constexpr size_t value =
         std::tuple_size<filter_not_t<Trait, T, Ts...>>::value;
 };
 
 template <template <typename...> class Trait, typename T>
 struct count_not<Trait, T> {
-    static constexpr size_t size = !Trait<T>::value;
+    static constexpr size_t value = !Trait<T>::value;
 };
 
 template <template <typename...> class Trait>
 struct count_not<Trait> {
-    static constexpr size_t size = 0;
+    static constexpr size_t value = 0;
 };
 
+template <template <typename...> class Trait, typename... Ts>
+constexpr size_t count_not_v = count_not<Trait, Ts...>::value;
+
 ////////////////
 // all of
 ////////////////
 
 template <template <typename...> class Trait, typename... Ts>
 struct all_of {
-    static constexpr bool value = count<Trait, Ts...>::size == sizeof...(Ts);
+    static constexpr bool value = count_v<Trait, Ts...> == sizeof...(Ts);
 };
 
 template <template <typename...> class Trait, typename... Ts>
 struct all_of<Trait, std::tuple<Ts...>> {
-    static constexpr bool value = count<Trait, Ts...>::size == sizeof...(Ts);
+    static constexpr bool value = count_v<Trait, Ts...> == sizeof...(Ts);
 };
 
+template <template <typename...> class Trait, typename... Ts>
+constexpr bool all_of_v = all_of<Trait, Ts...>::value;
+
 ////////////////
 // any of
 ////////////////
@@ -293,43 +311,52 @@ struct all_of<Trait, std::tuple<Ts...>> {
 template <template <typename...> class Trait, typename... Ts>
 struct any_of {
     static_assert(sizeof...(Ts) > 0);
-    static constexpr bool value = count<Trait, Ts...>::size > 0;
+    static constexpr bool value = count_v<Trait, Ts...> > 0;
 };
 
 template <template <typename...> class Trait, typename... Ts>
 struct any_of<Trait, std::tuple<Ts...>> {
     static_assert(sizeof...(Ts) > 0);
-    static constexpr bool value = count<Trait, Ts...>::size > 0;
+    static constexpr bool value = count_v<Trait, Ts...> > 0;
 };
 
+template <template <typename...> class Trait, typename... Ts>
+constexpr bool any_of_v = any_of<Trait, Ts...>::value;
+
 ////////////////
 // none  of
 ////////////////
 
 template <template <typename...> class Trait, typename... Ts>
 struct none_of {
-    static constexpr bool value = count<Trait, Ts...>::size == 0;
+    static constexpr bool value = count_v<Trait, Ts...> == 0;
 };
 
 template <template <typename...> class Trait, typename... Ts>
 struct none_of<Trait, std::tuple<Ts...>> {
-    static constexpr bool value = count<Trait, Ts...>::size == 0;
+    static constexpr bool value = count_v<Trait, Ts...> == 0;
 };
 
+template <template <typename...> class Trait, typename... Ts>
+constexpr bool none_of_v = none_of<Trait, Ts...>::value;
+
 ////////////////
 // is instance of
 ////////////////
 
-template <typename T, template <typename...> class Template>
+template <template <typename...> class Template, typename T>
 struct is_instance_of {
     constexpr static bool value = false;
 };
 
-template <typename... Ts, template <typename...> class Template>
-struct is_instance_of<Template<Ts...>, Template> {
+template <template <typename...> class Template, typename... Ts>
+struct is_instance_of<Template, Template<Ts...>> {
     constexpr static bool value = true;
 };
 
+template <template <typename...> class Template, typename... Ts>
+constexpr bool is_instance_of_v = is_instance_of<Template, Ts...>::value;
+
 ////////////////
 // ternary
 ////////////////
@@ -354,17 +381,21 @@ using ternary_t = typename ternary<B, T, U>::type;
 // tuple to struct
 ////////////////
 
-template <class S, std::size_t... Is, class Tup>
-S to_object(std::index_sequence<Is...>, Tup&& tup) {
-    return {std::get<Is>(std::forward<Tup>(tup))...};
+template <class T, std::size_t... Is, class U>
+T to_object_impl(std::index_sequence<Is...>, U&& data) {
+    return {std::get<Is>(std::forward<U>(data))...};
 }
 
-// TODO Tup may not be a tuple ...
-template <class S, class Tup>
-S to_object(Tup&& tup) {
-    using T = std::remove_reference_t<Tup>;
-    return to_object<S>(std::make_index_sequence<std::tuple_size<T>{}>{},
-                        std::forward<Tup>(tup));
+template <class T, class U>
+T to_object(U&& data) {
+    using NoRefU = std::remove_reference_t<U>;
+    if constexpr (is_instance_of_v<std::tuple, NoRefU>) {
+        return to_object_impl<
+            T>(std::make_index_sequence<std::tuple_size<NoRefU>{}>{},
+               std::forward<U>(data));
+    } else {
+        return T{std::forward<U>(data)};
+    }
 }
 
 } /* trait */
diff --git a/test/test_converter.cpp b/test/test_converter.cpp
index 044c85d..434eeb8 100644
--- a/test/test_converter.cpp
+++ b/test/test_converter.cpp
@@ -14,10 +14,10 @@ TEST_CASE("converter test split") {
                 {"x", {"x"}, ","}} // clang-format on
     ) {
         auto split = c.split(s, delim);
-        CHECK(split.size() == expected.size());
+        CHECK_EQ(split.size(), expected.size());
         for (size_t i = 0; i < split.size(); ++i) {
             auto s = std::string(split[i].first, split[i].second);
-            CHECK(s == expected[i]);
+            CHECK_EQ(s, expected[i]);
         }
     }
 }
@@ -28,68 +28,68 @@ TEST_CASE("converter test valid conversions") {
     {
         auto tup = c.convert<int>("5");
         REQUIRE(c.valid());
-        CHECK(tup == 5);
+        CHECK_EQ(tup, 5);
     }
     {
         auto tup = c.convert<int, void>("5,junk");
         REQUIRE(c.valid());
-        CHECK(tup == 5);
+        CHECK_EQ(tup, 5);
     }
     {
         auto tup = c.convert<void, int>("junk,5");
         REQUIRE(c.valid());
-        CHECK(tup == 5);
+        CHECK_EQ(tup, 5);
     }
     {
         auto tup = c.convert<int, void, void>("5\njunk\njunk", "\n");
         REQUIRE(c.valid());
-        CHECK(tup == 5);
+        CHECK_EQ(tup, 5);
     }
     {
         auto tup = c.convert<void, int, void>("junk 5 junk", " ");
         REQUIRE(c.valid());
-        CHECK(tup == 5);
+        CHECK_EQ(tup, 5);
     }
     {
         auto tup = c.convert<void, void, int>("junk\tjunk\t5", "\t");
         REQUIRE(c.valid());
-        CHECK(tup == 5);
+        CHECK_EQ(tup, 5);
     }
     {
         auto tup =
             c.convert<void, void, std::optional<int>>("junk\tjunk\t5", "\t");
         REQUIRE(c.valid());
         REQUIRE(tup.has_value());
-        CHECK(tup == 5);
+        CHECK_EQ(tup, 5);
     }
     {
         auto tup = c.convert<int, double, void>("5,6.6,junk");
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple(5, 6.6));
+        CHECK_EQ(tup, std::make_tuple(5, 6.6));
     }
     {
         auto tup = c.convert<int, void, double>("5,junk,6.6");
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple(5, 6.6));
+        CHECK_EQ(tup, std::make_tuple(5, 6.6));
     }
     {
         auto tup = c.convert<void, int, double>("junk;5;6.6", ";");
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple(5, 6.6));
+        CHECK_EQ(tup, std::make_tuple(5, 6.6));
     }
     {
         auto tup =
             c.convert<void, std::optional<int>, double>("junk;5;6.6", ";");
         REQUIRE(c.valid());
         REQUIRE(std::get<0>(tup).has_value());
-        CHECK(tup == std::make_tuple(5, 6.6));
+        CHECK_EQ(tup, std::make_tuple(5, 6.6));
     }
     {
         auto tup =
             c.convert<void, std::optional<int>, double>("junk;5.4;6.6", ";");
         REQUIRE(c.valid());
-        REQUIRE(!std::get<0>(tup).has_value());
-        CHECK(tup == std::make_tuple(std::optional<int>{}, 6.6));
+        REQUIRE_FALSE(std::get<0>(tup).has_value());
+        CHECK_EQ(tup, std::make_tuple(std::optional<int>{}, 6.6));
     }
     {
         auto tup =
@@ -97,7 +97,7 @@ TEST_CASE("converter test valid conversions") {
                                                                ";");
         REQUIRE(c.valid());
         REQUIRE(std::holds_alternative<int>(std::get<0>(tup)));
-        CHECK(tup == std::make_tuple(std::variant<int, double>{5}, 6.6));
+        CHECK_EQ(tup, std::make_tuple(std::variant<int, double>{5}, 6.6));
     }
     {
         auto tup =
@@ -105,7 +105,7 @@ TEST_CASE("converter test valid conversions") {
                                                                ";");
         REQUIRE(c.valid());
         REQUIRE(std::holds_alternative<double>(std::get<0>(tup)));
-        CHECK(tup == std::make_tuple(std::variant<int, double>{5.5}, 6.6));
+        CHECK_EQ(tup, std::make_tuple(std::variant<int, double>{5.5}, 6.6));
     }
 }
 
@@ -113,64 +113,64 @@ TEST_CASE("converter test invalid conversions") {
     ss::converter c;
 
     c.convert<int>("");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<int>("10", "");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<int, void>("");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<int, void>(",junk");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<void, int>("junk,");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<int>("x");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<int, void>("x");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<int, void>("x,junk");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<void, int>("junk,x");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<void, std::variant<int, double>, double>("junk;.5.5;6", ";");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 }
 
 TEST_CASE("converter test ss:ax restriction (all except)") {
     ss::converter c;
 
     c.convert<ss::ax<int, 0>>("0");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<ss::ax<int, 0, 1, 2>>("1");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<void, char, ss::ax<int, 0, 1, 2>>("junk,c,1");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<ss::ax<int, 1>, char>("1,c");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
     {
         int tup = c.convert<ss::ax<int, 1>>("3");
         REQUIRE(c.valid());
-        CHECK(tup == 3);
+        CHECK_EQ(tup, 3);
     }
     {
         std::tuple<char, int> tup = c.convert<char, ss::ax<int, 1>>("c,3");
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple('c', 3));
+        CHECK_EQ(tup, std::make_tuple('c', 3));
     }
     {
         std::tuple<int, char> tup = c.convert<ss::ax<int, 1>, char>("3,c");
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple(3, 'c'));
+        CHECK_EQ(tup, std::make_tuple(3, 'c'));
     }
 }
 
@@ -178,33 +178,33 @@ TEST_CASE("converter test ss:nx restriction (none except)") {
     ss::converter c;
 
     c.convert<ss::nx<int, 1>>("3");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<char, ss::nx<int, 1, 2, 69>>("c,3");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<ss::nx<int, 1>, char>("3,c");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     {
         auto tup = c.convert<ss::nx<int, 3>>("3");
         REQUIRE(c.valid());
-        CHECK(tup == 3);
+        CHECK_EQ(tup, 3);
     }
     {
         auto tup = c.convert<ss::nx<int, 0, 1, 2>>("2");
         REQUIRE(c.valid());
-        CHECK(tup == 2);
+        CHECK_EQ(tup, 2);
     }
     {
         auto tup = c.convert<char, void, ss::nx<int, 0, 1, 2>>("c,junk,1");
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple('c', 1));
+        CHECK_EQ(tup, std::make_tuple('c', 1));
     }
     {
         auto tup = c.convert<ss::nx<int, 1>, char>("1,c");
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple(1, 'c'));
+        CHECK_EQ(tup, std::make_tuple(1, 'c'));
     }
 }
 
@@ -212,33 +212,33 @@ TEST_CASE("converter test ss:ir restriction (in range)") {
     ss::converter c;
 
     c.convert<ss::ir<int, 0, 2>>("3");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<char, ss::ir<int, 4, 69>>("c,3");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<ss::ir<int, 1, 2>, char>("3,c");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     {
         auto tup = c.convert<ss::ir<int, 1, 5>>("3");
         REQUIRE(c.valid());
-        CHECK(tup == 3);
+        CHECK_EQ(tup, 3);
     }
     {
         auto tup = c.convert<ss::ir<int, 0, 2>>("2");
         REQUIRE(c.valid());
-        CHECK(tup == 2);
+        CHECK_EQ(tup, 2);
     }
     {
         auto tup = c.convert<char, void, ss::ir<int, 0, 1>>("c,junk,1");
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple('c', 1));
+        CHECK_EQ(tup, std::make_tuple('c', 1));
     }
     {
         auto tup = c.convert<ss::ir<int, 1, 20>, char>("1,c");
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple(1, 'c'));
+        CHECK_EQ(tup, std::make_tuple(1, 'c'));
     }
 }
 
@@ -246,33 +246,33 @@ TEST_CASE("converter test ss:oor restriction (out of range)") {
     ss::converter c;
 
     c.convert<ss::oor<int, 1, 5>>("3");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<ss::oor<int, 0, 2>>("2");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<char, ss::oor<int, 0, 1>, void>("c,1,junk");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<ss::oor<int, 1, 20>, char>("1,c");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     {
         auto tup = c.convert<ss::oor<int, 0, 2>>("3");
         REQUIRE(c.valid());
-        CHECK(tup == 3);
+        CHECK_EQ(tup, 3);
     }
 
     {
         auto tup = c.convert<char, void, ss::oor<int, 4, 69>>("c,junk,3");
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple('c', 3));
+        CHECK_EQ(tup, std::make_tuple('c', 3));
     }
 
     {
         auto tup = c.convert<ss::oor<int, 1, 2>, char>("3,c");
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple(3, 'c'));
+        CHECK_EQ(tup, std::make_tuple(3, 'c'));
     }
 }
 
@@ -293,34 +293,34 @@ TEST_CASE("converter test ss:ne restriction (not empty)") {
     ss::converter c;
 
     c.convert<ss::ne<std::string>>("");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<int, ss::ne<std::string>>("3,");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<ss::ne<std::string>, int>(",3");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<void, ss::ne<std::string>, int>("junk,,3");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<ss::ne<std::vector<int>>>("");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     {
         auto tup = c.convert<ss::ne<std::string>>("s");
         REQUIRE(c.valid());
-        CHECK(tup == "s");
+        CHECK_EQ(tup, "s");
     }
     {
         auto tup = c.convert<std::optional<int>, ss::ne<std::string>>("1,s");
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple(1, "s"));
+        CHECK_EQ(tup, std::make_tuple(1, "s"));
     }
     {
         auto tup = c.convert<ss::ne<std::vector<int>>>("{1 2 3}");
         REQUIRE(c.valid());
-        CHECK(tup == extracted_vector);
+        CHECK_EQ(tup, extracted_vector);
     }
 }
 
@@ -329,65 +329,65 @@ TEST_CASE(
     ss::converter c;
 
     c.convert<ss::lt<int, 3>>("3");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<ss::lt<int, 2>>("3");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<ss::gt<int, 3>>("3");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<ss::gt<int, 4>>("3");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<ss::lte<int, 2>>("3");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     c.convert<ss::gte<int, 4>>("3");
-    REQUIRE(!c.valid());
+    REQUIRE_FALSE(c.valid());
 
     {
         auto tup = c.convert<ss::lt<int, 4>>("3");
         REQUIRE(c.valid());
-        CHECK(tup == 3);
+        CHECK_EQ(tup, 3);
     }
 
     {
         auto tup = c.convert<ss::gt<int, 2>>("3");
         REQUIRE(c.valid());
-        CHECK(tup == 3);
+        CHECK_EQ(tup, 3);
     }
 
     {
         auto tup = c.convert<ss::lte<int, 4>>("3");
         REQUIRE(c.valid());
-        CHECK(tup == 3);
+        CHECK_EQ(tup, 3);
     }
 
     {
         auto tup = c.convert<ss::lte<int, 3>>("3");
         REQUIRE(c.valid());
-        CHECK(tup == 3);
+        CHECK_EQ(tup, 3);
     }
 
     {
         auto tup = c.convert<ss::gte<int, 2>>("3");
         REQUIRE(c.valid());
-        CHECK(tup == 3);
+        CHECK_EQ(tup, 3);
     }
 
     {
         auto tup = c.convert<ss::gte<int, 3>>("3");
         REQUIRE(c.valid());
-        CHECK(tup == 3);
+        CHECK_EQ(tup, 3);
     }
 }
 
 TEST_CASE("converter test error mode") {
     ss::converter<ss::string_error> c;
     c.convert<int>("junk");
-    CHECK(!c.valid());
-    CHECK(!c.error_msg().empty());
+    CHECK_FALSE(c.valid());
+    CHECK_FALSE(c.error_msg().empty());
 }
 
 TEST_CASE("converter test converter with quotes spacing and escaping") {
@@ -397,7 +397,7 @@ TEST_CASE("converter test converter with quotes spacing and escaping") {
         auto tup = c.convert<std::string, std::string, std::string>(
             R"("just","some","strings")");
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple("\"just\"", "\"some\"", "\"strings\""));
+        CHECK_EQ(tup, std::make_tuple("\"just\"", "\"some\"", "\"strings\""));
     }
 
     {
@@ -406,7 +406,7 @@ TEST_CASE("converter test converter with quotes spacing and escaping") {
         auto tup = c.convert<std::string, std::string, double, char>(
             buff(R"("just",some,"12.3","a")"));
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple("just", "some", 12.3, 'a'));
+        CHECK_EQ(tup, std::make_tuple("just", "some", 12.3, 'a'));
     }
 
     {
@@ -415,7 +415,7 @@ TEST_CASE("converter test converter with quotes spacing and escaping") {
         auto tup = c.convert<std::string, std::string, double, char>(
             buff(R"(    just  ,  some   ,  12.3 ,a     )"));
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple("just", "some", 12.3, 'a'));
+        CHECK_EQ(tup, std::make_tuple("just", "some", 12.3, 'a'));
     }
 
     {
@@ -424,7 +424,7 @@ TEST_CASE("converter test converter with quotes spacing and escaping") {
         auto tup =
             c.convert<std::string, std::string>(buff(R"(ju\,st,strings)"));
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple("ju,st", "strings"));
+        CHECK_EQ(tup, std::make_tuple("ju,st", "strings"));
     }
 
     {
@@ -433,7 +433,7 @@ TEST_CASE("converter test converter with quotes spacing and escaping") {
         auto tup = c.convert<std::string, std::string, double, std::string>(
             buff(R"(  ju\,st  ,  "so,me"  ,   12.34     ,   "str""ings")"));
         REQUIRE(c.valid());
-        CHECK(tup == std::make_tuple("ju,st", "so,me", 12.34, "str\"ings"));
+        CHECK_EQ(tup, std::make_tuple("ju,st", "so,me", 12.34, "str\"ings"));
     }
 }
 
@@ -446,17 +446,44 @@ TEST_CASE("converter test invalid split conversions") {
         // mismatched quote
         auto tup = c.convert<std::string, std::string, double, char>(
             buff(R"(  "just  , some ,   "12.3","a"  )"));
-        CHECK(!c.valid());
-        CHECK(!c.unterminated_quote());
-        CHECK(!c.error_msg().empty());
+        CHECK_FALSE(c.valid());
+        CHECK_FALSE(c.unterminated_quote());
+        CHECK_FALSE(c.error_msg().empty());
     }
 
     {
         // unterminated quote
         auto tup = c.convert<std::string, std::string, double, std::string>(
             buff(R"(  ju\,st  ,  "so,me"  ,   12.34     ,   "str""ings)"));
-        CHECK(!c.valid());
+        CHECK_FALSE(c.valid());
         CHECK(c.unterminated_quote());
-        CHECK(!c.error_msg().empty());
+        CHECK_FALSE(c.error_msg().empty());
+    }
+
+    {
+        // unterminated escape
+        auto tup = c.convert<std::string, std::string, double, std::string>(
+            buff(R"(just,some,2,strings\)"));
+        CHECK_FALSE(c.valid());
+        CHECK_FALSE(c.unterminated_quote());
+        CHECK_FALSE(c.error_msg().empty());
+    }
+
+    {
+        // unterminated escape while quoting
+        auto tup = c.convert<std::string, std::string, double, std::string>(
+            buff(R"(just,some,2,"strings\)"));
+        CHECK_FALSE(c.valid());
+        CHECK_FALSE(c.unterminated_quote());
+        CHECK_FALSE(c.error_msg().empty());
+    }
+
+    {
+        // unterminated escaped quote
+        auto tup = c.convert<std::string, std::string, double, std::string>(
+            buff(R"(just,some,2,"strings\")"));
+        CHECK_FALSE(c.valid());
+        CHECK(c.unterminated_quote());
+        CHECK_FALSE(c.error_msg().empty());
     }
 }
diff --git a/test/test_extractions.cpp b/test/test_extractions.cpp
index 118a1a7..cb092d0 100644
--- a/test/test_extractions.cpp
+++ b/test/test_extractions.cpp
@@ -8,7 +8,7 @@
         std::string s = #input;                                                \
         auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size());            \
         REQUIRE(t.has_value());                                                \
-        CHECK(std::abs(t.value() - type(input)) < eps);                        \
+        CHECK_LT(std::abs(t.value() - type(input)), eps);                      \
     }                                                                          \
     {                                                                          \
         /* check negative too */                                               \
@@ -16,7 +16,7 @@
         auto s = std::string("-") + #input;                                    \
         auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size());            \
         REQUIRE(t.has_value());                                                \
-        CHECK(std::abs(t.value() - type(-input)) < eps);                       \
+        CHECK_LT(std::abs(t.value() - type(-input)), eps);                     \
     }
 
 TEST_CASE("testing extract functions for floating point values") {
@@ -41,7 +41,7 @@ TEST_CASE("testing extract functions for floating point values") {
         std::string s = #input;                                                \
         auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size());            \
         REQUIRE(t.has_value());                                                \
-        CHECK(t.value() == type(input));                                       \
+        CHECK_EQ(t.value(), type(input));                                      \
     }                                                                          \
     {                                                                          \
         /* check negative too */                                               \
@@ -49,7 +49,7 @@ TEST_CASE("testing extract functions for floating point values") {
             auto s = std::string("-") + #input;                                \
             auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size());        \
             REQUIRE(t.has_value());                                            \
-            CHECK(t.value() == type(-input));                                  \
+            CHECK_EQ(t.value(), type(-input));                                 \
         }                                                                      \
     }
 
@@ -74,7 +74,7 @@ TEST_CASE("extract test functions for decimal values") {
     {                                                                          \
         std::string s = input;                                                 \
         auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size());            \
-        CHECK(!t.has_value());                                                 \
+        CHECK_FALSE(t.has_value());                                            \
     }
 
 TEST_CASE("extract test functions for numbers with invalid inputs") {
@@ -106,7 +106,7 @@ TEST_CASE("extract test functions for numbers with invalid inputs") {
             }                                                                  \
         }                                                                      \
         t = ss::to_num<type>(s.c_str(), s.c_str() + s.size());                 \
-        CHECK(!t.has_value());                                                 \
+        CHECK_FALSE(t.has_value());                                            \
     }                                                                          \
     {                                                                          \
         std::string s = std::to_string(std::numeric_limits<type>::min());      \
@@ -122,7 +122,7 @@ TEST_CASE("extract test functions for numbers with invalid inputs") {
             }                                                                  \
         }                                                                      \
         t = ss::to_num<type>(s.c_str(), s.c_str() + s.size());                 \
-        CHECK(!t.has_value());                                                 \
+        CHECK_FALSE(t.has_value());                                            \
     }
 
 TEST_CASE("extract test functions for numbers with out of range inputs") {
@@ -143,12 +143,12 @@ TEST_CASE("extract test functions for boolean values") {
                                {false, "false"}}) {
         bool v;
         REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
-        CHECK(v == b);
+        CHECK_EQ(v, b);
     }
 
     for (const std::string& s : {"2", "tru", "truee", "xxx", ""}) {
         bool v;
-        REQUIRE(!ss::extract(s.c_str(), s.c_str() + s.size(), v));
+        CHECK_FALSE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
     }
 }
 
@@ -157,12 +157,12 @@ TEST_CASE("extract test functions for char values") {
          {std::pair<char, std::string>{'a', "a"}, {'x', "x"}, {' ', " "}}) {
         char v;
         REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
-        CHECK(v == c);
+        CHECK_EQ(v, c);
     }
 
     for (const std::string& s : {"aa", "xxx", ""}) {
         char v;
-        REQUIRE(!ss::extract(s.c_str(), s.c_str() + s.size(), v));
+        CHECK_FALSE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
     }
 }
 
@@ -174,7 +174,7 @@ TEST_CASE("extract test functions for std::optional") {
         std::optional<int> v;
         REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
         REQUIRE(v.has_value());
-        CHECK(*v == i);
+        CHECK_EQ(*v, i);
     }
 
     for (const auto& [c, s] :
@@ -184,19 +184,19 @@ TEST_CASE("extract test functions for std::optional") {
         std::optional<char> v;
         REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
         REQUIRE(v.has_value());
-        CHECK(*v == c);
+        CHECK_EQ(*v, c);
     }
 
     for (const std::string& s : {"aa", "xxx", ""}) {
         std::optional<int> v;
         REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
-        REQUIRE(!v.has_value());
+        CHECK_FALSE(v.has_value());
     }
 
     for (const std::string& s : {"aa", "xxx", ""}) {
         std::optional<char> v;
         REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
-        REQUIRE(!v.has_value());
+        CHECK_FALSE(v.has_value());
     }
 }
 
@@ -204,7 +204,7 @@ TEST_CASE("extract test functions for std::optional") {
     {                                                                          \
         auto ptr = std::get_if<type>(&var);                                    \
         REQUIRE(ptr);                                                          \
-        REQUIRE(el == *ptr);                                                   \
+        REQUIRE_EQ(el, *ptr);                                                  \
     }
 
 #define CHECK_NOT_VARIANT(var, type) CHECK(!std::holds_alternative<type>(var));
@@ -288,21 +288,21 @@ TEST_CASE("extract test functions for std::variant") {
         }
         {
             std::variant<int, double> var;
-            REQUIRE(!ss::extract(s.c_str(), s.c_str() + s.size(), var));
+            REQUIRE_FALSE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
 
             REQUIRE_VARIANT(var, int{}, int);
             CHECK_NOT_VARIANT(var, double);
         }
         {
             std::variant<double, int> var;
-            REQUIRE(!ss::extract(s.c_str(), s.c_str() + s.size(), var));
+            REQUIRE_FALSE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
 
             REQUIRE_VARIANT(var, double{}, double);
             CHECK_NOT_VARIANT(var, int);
         }
         {
             std::variant<int> var;
-            REQUIRE(!ss::extract(s.c_str(), s.c_str() + s.size(), var));
+            REQUIRE_FALSE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
 
             REQUIRE_VARIANT(var, int{}, int);
         }
diff --git a/test/test_helpers.hpp b/test/test_helpers.hpp
index f9317cc..03f2750 100644
--- a/test/test_helpers.hpp
+++ b/test/test_helpers.hpp
@@ -8,10 +8,9 @@
 #include <doctest.h>
 #endif
 
-class buffer {
+struct buffer {
     char* data_{nullptr};
 
-public:
     char* operator()(const char* data) {
         if (data_) {
             delete[] data_;
@@ -34,6 +33,11 @@ public:
         }
     }
 
+    char* append_overwrite_last(const char* data, size_t size) {
+        data_[strlen(data_) - size] = '\0';
+        return append(data);
+    }
+
     ~buffer() {
         if (data_) {
             delete[] data_;
diff --git a/test/test_parser.cpp b/test/test_parser.cpp
index 5a09105..af8b183 100644
--- a/test/test_parser.cpp
+++ b/test/test_parser.cpp
@@ -66,12 +66,13 @@ TEST_CASE("parser test various cases") {
             i.emplace_back(ss::to_object<X>(a));
         }
 
-        CHECK(std::equal(i.begin(), i.end(), data.begin()));
+        CHECK_EQ(i, data);
     }
 
     {
         ss::parser p{f.name, ","};
         std::vector<X> i;
+        std::vector<X> expected = {std::begin(data) + 1, std::end(data)};
 
         p.ignore_next();
         while (!p.eof()) {
@@ -80,7 +81,7 @@ TEST_CASE("parser test various cases") {
             i.emplace_back(ss::to_object<X>(a));
         }
 
-        CHECK(std::equal(i.begin(), i.end(), data.begin() + 1));
+        CHECK_EQ(i, expected);
     }
 
     {
@@ -91,7 +92,7 @@ TEST_CASE("parser test various cases") {
             i.push_back(p.get_object<X, int, double, std::string>());
         }
 
-        CHECK(std::equal(i.begin(), i.end(), data.begin()));
+        CHECK_EQ(i, data);
     }
 
     {
@@ -103,7 +104,7 @@ TEST_CASE("parser test various cases") {
             i.push_back(p.get_object<X, tup>());
         }
 
-        CHECK(std::equal(i.begin(), i.end(), data.begin()));
+        CHECK_EQ(i, data);
     }
 
     {
@@ -114,7 +115,7 @@ TEST_CASE("parser test various cases") {
             i.push_back(p.get_next<X>());
         }
 
-        CHECK(std::equal(i.begin(), i.end(), data.begin()));
+        CHECK_EQ(i, data);
     }
 
     {
@@ -129,10 +130,17 @@ TEST_CASE("parser test various cases") {
                 i.push_back(a);
             }
         }
-        std::vector<X> expected = data;
-        std::remove_if(expected.begin(), expected.end(),
-                       [](const X& x) { return x.i == excluded; });
-        CHECK(std::equal(i.begin(), i.end(), expected.begin()));
+
+        std::vector<X> expected;
+        for (auto& x : data) {
+            if (x.i != excluded) {
+                expected.push_back(x);
+            }
+        }
+
+        std::copy_if(data.begin(), data.end(), expected.begin(),
+                     [](const X& x) { return x.i != excluded; });
+        CHECK_EQ(i, expected);
     }
 
     {
@@ -146,7 +154,7 @@ TEST_CASE("parser test various cases") {
             }
         }
         std::vector<X> expected = {{3, 4, "y"}};
-        CHECK(std::equal(i.begin(), i.end(), expected.begin()));
+        CHECK_EQ(i, expected);
     }
 
     {
@@ -194,7 +202,7 @@ TEST_CASE("parser test composite conversion") {
     auto expect_error = [](auto error) { CHECK(!error.empty()); };
 
     REQUIRE(p.valid());
-    REQUIRE(!p.eof());
+    REQUIRE_FALSE(p.eof());
 
     {
         constexpr static auto expectedData = std::tuple{10, 'a', 11.1};
@@ -203,17 +211,17 @@ TEST_CASE("parser test composite conversion") {
             p.try_next<int, int, double>(fail)
                 .or_else<test_struct>(fail)
                 .or_else<int, char, double>(
-                    [](auto&& data) { CHECK(data == expectedData); })
+                    [](auto&& data) { CHECK_EQ(data, expectedData); })
                 .on_error(fail)
                 .or_else<test_tuple>(fail)
                 .values();
 
         REQUIRE(p.valid());
-        REQUIRE(!d1);
-        REQUIRE(!d2);
+        REQUIRE_FALSE(d1);
+        REQUIRE_FALSE(d2);
         REQUIRE(d3);
-        REQUIRE(!d4);
-        CHECK(*d3 == expectedData);
+        REQUIRE_FALSE(d4);
+        CHECK_EQ(*d3, expectedData);
     }
 
     {
@@ -222,7 +230,7 @@ TEST_CASE("parser test composite conversion") {
 
         auto [d1, d2, d3, d4] =
             p.try_next<int, int, double>([](auto& i1, auto i2, double d) {
-                 CHECK(std::tie(i1, i2, d) == expectedData);
+                 CHECK_EQ(std::tie(i1, i2, d), expectedData);
              })
                 .on_error(fail)
                 .or_object<test_struct, int, double, char>(fail)
@@ -234,10 +242,10 @@ TEST_CASE("parser test composite conversion") {
 
         REQUIRE(p.valid());
         REQUIRE(d1);
-        REQUIRE(!d2);
-        REQUIRE(!d3);
-        REQUIRE(!d4);
-        CHECK(*d1 == expectedData);
+        REQUIRE_FALSE(d2);
+        REQUIRE_FALSE(d3);
+        REQUIRE_FALSE(d4);
+        CHECK_EQ(*d1, expectedData);
     }
 
     {
@@ -252,12 +260,12 @@ TEST_CASE("parser test composite conversion") {
                 .or_else<int, char, double>(fail)
                 .values();
 
-        REQUIRE(!p.valid());
-        REQUIRE(!d1);
-        REQUIRE(!d2);
-        REQUIRE(!d3);
-        REQUIRE(!d4);
-        REQUIRE(!d5);
+        REQUIRE_FALSE(p.valid());
+        REQUIRE_FALSE(d1);
+        REQUIRE_FALSE(d2);
+        REQUIRE_FALSE(d3);
+        REQUIRE_FALSE(d4);
+        REQUIRE_FALSE(d5);
     }
 
     {
@@ -265,14 +273,14 @@ TEST_CASE("parser test composite conversion") {
 
         auto [d1, d2] =
             p.try_next<int, double>([](auto& i, auto& d) {
-                 REQUIRE(std::tie(i, d) == std::tuple{10, 11.1});
+                 REQUIRE_EQ(std::tie(i, d), std::tuple{10, 11.1});
              })
                 .or_else<int, double>([](auto&, auto&) { FAIL(""); })
                 .values();
 
         REQUIRE(p.valid());
         REQUIRE(d1);
-        REQUIRE(!d2);
+        REQUIRE_FALSE(d2);
     }
 
     {
@@ -283,9 +291,9 @@ TEST_CASE("parser test composite conversion") {
                             .values();
 
         REQUIRE(p.valid());
-        REQUIRE(!d1);
+        REQUIRE_FALSE(d1);
         REQUIRE(d2);
-        CHECK(d2->tied() == std::tuple{1, 11.1, 'a'});
+        CHECK_EQ(d2->tied(), std::tuple{1, 11.1, 'a'});
     }
 
     {
@@ -300,12 +308,12 @@ TEST_CASE("parser test composite conversion") {
                 .on_error(expect_error)
                 .values();
 
-        REQUIRE(!p.valid());
-        REQUIRE(!d1);
-        REQUIRE(!d2);
-        REQUIRE(!d3);
-        REQUIRE(!d4);
-        REQUIRE(!d5);
+        REQUIRE_FALSE(p.valid());
+        REQUIRE_FALSE(d1);
+        REQUIRE_FALSE(d2);
+        REQUIRE_FALSE(d3);
+        REQUIRE_FALSE(d4);
+        REQUIRE_FALSE(d5);
     }
 
     {
@@ -319,12 +327,12 @@ TEST_CASE("parser test composite conversion") {
 
         REQUIRE(p.valid());
         REQUIRE(d1);
-        REQUIRE(!d2);
-        CHECK(*d1 == std::tuple{10, std::nullopt});
+        REQUIRE_FALSE(d2);
+        CHECK_EQ(*d1, std::tuple{10, std::nullopt});
     }
 
     {
-        REQUIRE(!p.eof());
+        REQUIRE_FALSE(p.eof());
 
         auto [d1, d2] = p.try_next<int, std::variant<int, std::string>>()
                             .on_error(fail)
@@ -334,8 +342,8 @@ TEST_CASE("parser test composite conversion") {
 
         REQUIRE(p.valid());
         REQUIRE(d1);
-        REQUIRE(!d2);
-        CHECK(*d1 == std::tuple{11, std::variant<int, std::string>{"junk"}});
+        REQUIRE_FALSE(d2);
+        CHECK_EQ(*d1, std::tuple{11, std::variant<int, std::string>{"junk"}});
     }
 
     {
@@ -346,12 +354,12 @@ TEST_CASE("parser test composite conversion") {
                             .values();
         REQUIRE(p.valid());
         REQUIRE(d1);
-        REQUIRE(!d2);
-        CHECK(d1->tied() == std::tuple{10, 11.1, 'c'});
+        REQUIRE_FALSE(d2);
+        CHECK_EQ(d1->tied(), std::tuple{10, 11.1, 'c'});
     }
 
     {
-        REQUIRE(!p.eof());
+        REQUIRE_FALSE(p.eof());
 
         auto [d1, d2, d3, d4] =
             p.try_next<int, int>([] { return false; })
@@ -361,11 +369,11 @@ TEST_CASE("parser test composite conversion") {
                 .values();
 
         REQUIRE(p.valid());
-        REQUIRE(!d1);
-        REQUIRE(!d2);
+        REQUIRE_FALSE(d1);
+        REQUIRE_FALSE(d2);
         REQUIRE(d3);
-        REQUIRE(!d4);
-        CHECK(d3.value() == std::tuple{10, 20});
+        REQUIRE_FALSE(d4);
+        CHECK_EQ(d3.value(), std::tuple{10, 20});
     }
 
     {
@@ -379,11 +387,11 @@ TEST_CASE("parser test composite conversion") {
                 .values();
 
         REQUIRE(p.valid());
-        REQUIRE(!d1);
-        REQUIRE(!d2);
+        REQUIRE_FALSE(d1);
+        REQUIRE_FALSE(d2);
         REQUIRE(d3);
-        REQUIRE(!d4);
-        CHECK(d3->tied() == std::tuple{10, 22.2, 'f'});
+        REQUIRE_FALSE(d4);
+        CHECK_EQ(d3->tied(), std::tuple{10, 22.2, 'f'});
     }
 
     CHECK(p.eof());
@@ -446,7 +454,7 @@ TEST_CASE("parser test the moving of parsed values") {
 
         ss::parser p{f.name, ","};
         auto x = p.get_next<my_string>();
-        CHECK(move_called < 3);
+        CHECK_LT(move_called, 3);
         move_called_one_col = move_called;
         move_called = 0;
     }
@@ -461,21 +469,21 @@ TEST_CASE("parser test the moving of parsed values") {
 
         ss::parser p{f.name, ","};
         auto x = p.get_next<my_string, my_string, my_string>();
-        CHECK(move_called <= 3 * move_called_one_col);
+        CHECK_LE(move_called, 3 * move_called_one_col);
         move_called = 0;
     }
 
     {
         ss::parser p{f.name, ","};
         auto x = p.get_object<xyz, my_string, my_string, my_string>();
-        CHECK(move_called <= 6 * move_called_one_col);
+        CHECK_LE(move_called, 6 * move_called_one_col);
         move_called = 0;
     }
 
     {
         ss::parser p{f.name, ","};
         auto x = p.get_next<xyz>();
-        CHECK(move_called <= 6 * move_called_one_col);
+        CHECK_LE(move_called, 6 * move_called_one_col);
         move_called = 0;
     }
 }
@@ -503,10 +511,10 @@ TEST_CASE("parser test error mode") {
 
     ss::parser<ss::string_error> p(f.name, ",");
 
-    REQUIRE(!p.eof());
+    REQUIRE_FALSE(p.eof());
     p.get_next<int>();
-    CHECK(!p.valid());
-    CHECK(!p.error_msg().empty());
+    CHECK_FALSE(p.valid());
+    CHECK_FALSE(p.error_msg().empty());
 }
 
 std::string no_quote(const std::string& s) {
@@ -516,7 +524,7 @@ std::string no_quote(const std::string& s) {
     return s;
 }
 
-TEST_CASE("parser test csv on multiple lines with quotes") {
+TEST_CASE("parser test csv on multiple lines with quotes zzz") {
     unique_file_name f;
     std::vector<X> data = {{1, 2, "\"x\nx\nx\""}, {3, 4, "\"y\ny\ny\""},
                            {5, 6, "\"z\nz\""},    {7, 8, "\"u\"\"\""},
@@ -537,7 +545,7 @@ TEST_CASE("parser test csv on multiple lines with quotes") {
         i.emplace_back(ss::to_object<X>(a));
     }
 
-    CHECK(std::equal(i.begin(), i.end(), data.begin()));
+    CHECK_EQ(i, data);
 
     ss::parser<ss::quote<'"'>> p_no_multiline{f.name, ","};
     while (!p.eof()) {
@@ -553,8 +561,8 @@ std::string no_escape(std::string& s) {
 
 TEST_CASE("parser test csv on multiple lines with escapes") {
     unique_file_name f;
-    std::vector<X> data = {{1, 2, "x\\\nx\\\nx"}, {3, 4, "y\\\ny\\\ny"},
-                           {5, 6, "z\\\nz"},      {7, 8, "u"},
+    std::vector<X> data = {{1, 2, "x\\\nx\\\nx"}, {5, 6, "z\\\nz\\\nz"},
+                           {7, 8, "u"},           {3, 4, "y\\\ny\\\ny"},
                            {9, 10, "v\\\\"},      {11, 12, "w\\\n"}};
 
     make_and_write(f.name, data);
@@ -573,11 +581,72 @@ TEST_CASE("parser test csv on multiple lines with escapes") {
         i.emplace_back(ss::to_object<X>(a));
     }
 
-    CHECK(std::equal(i.begin(), i.end(), data.begin()));
+    CHECK_EQ(i, data);
 
     ss::parser<ss::escape<'\\'>> p_no_multiline{f.name, ","};
     while (!p.eof()) {
         auto a = p_no_multiline.get_next<int, double, std::string>();
-        CHECK(!p.valid());
+        CHECK_FALSE(p.valid());
     }
 }
+
+TEST_CASE("parser test csv on multiple lines with quotes and escapes") {
+    unique_file_name f;
+    {
+        std::ofstream out{f.name};
+        out << "1,2,\"just\\\n\nstrings\"" << std::endl;
+        out << "3,4,\"just\nsome\\\n\n\\\nstrings\"" << std::endl;
+        out << "5,6,\"just\\\n\\\n\n\nstrings" << std::endl;
+        out << "7,8,\"just strings\"" << std::endl;
+        out << "9,10,just strings" << std::endl;
+    }
+
+    ss::parser<ss::multiline, ss::escape<'\\'>, ss::quote<'"'>> p{f.name};
+    std::vector<X> i;
+
+    while (!p.eof()) {
+        auto a = p.get_next<int, double, std::string>();
+        if (p.valid()) {
+            i.emplace_back(ss::to_object<X>(a));
+        }
+    }
+
+    std::vector<X> data = {{1, 2, "just\n\nstrings"},
+                           {3, 4, "just\nsome\n\n\nstrings"},
+                           {9, 10, "just strings"}};
+
+    CHECK_EQ(i, data);
+}
+
+TEST_CASE("parser test multiline restricted") {
+    unique_file_name f;
+    {
+        std::ofstream out{f.name};
+        out << "1,2,\"just\n\nstrings\"" << std::endl;
+        out << "3,4,\"ju\n\n\nnk\"" << std::endl;
+        out << "5,6,just\\\n\\\nstrings" << std::endl;
+        out << "7,8,ju\\\n\\\n\\\nnk" << std::endl;
+        out << "9,10,\"just\\\n\nstrings\"" << std::endl;
+        out << "11,12,\"ju\\\n|\n\n\n\n\nk\"" << std::endl;
+        out << "13,14,\"ju\\\n\\\n15,16\"\\\n\\\\\n\nnk\"" << std::endl;
+        out << "17,18,\"ju\\\n\\\n\\\n\\\\\n\nnk\"" << std::endl;
+        out << "19,20,just strings" << std::endl;
+    }
+
+    ss::parser<ss::multiline_restricted<2>, ss::quote<'"'>, ss::escape<'\\'>>
+        p{f.name, ","};
+    std::vector<X> i;
+
+    while (!p.eof()) {
+        auto a = p.get_next<int, double, std::string>();
+        if (p.valid()) {
+            i.emplace_back(ss::to_object<X>(a));
+        }
+    }
+
+    std::vector<X> data = {{1, 2, "just\n\nstrings"},
+                           {5, 6, "just\n\nstrings"},
+                           {9, 10, "just\n\nstrings"},
+                           {19, 20, "just strings"}};
+    CHECK_EQ(i, data);
+}
diff --git a/test/test_splitter.cpp b/test/test_splitter.cpp
index 1b1a380..14caded 100644
--- a/test/test_splitter.cpp
+++ b/test/test_splitter.cpp
@@ -17,7 +17,7 @@ struct set_combinations_size {
     }
 };
 
-std::vector<std::string> words(const ss::split_input& input) {
+std::vector<std::string> words(const ss::split_data& input) {
     std::vector<std::string> ret;
     for (const auto& [begin, end] : input) {
         ret.emplace_back(begin, end);
@@ -88,6 +88,30 @@ auto spaced(const case_type& input, const std::string& s1,
     return ret;
 }
 
+auto spaced_left(const case_type& input, const std::string& s) {
+    case_type ret = input;
+    for (const auto& i : input) {
+        ret.push_back(concat(i));
+        ret.push_back(concat(s, i));
+        ret.push_back(concat(s, s, i));
+        ret.push_back(concat(s, s, s, i));
+    }
+
+    return ret;
+}
+
+auto spaced_right(const case_type& input, const std::string& s) {
+    case_type ret = input;
+    for (const auto& i : input) {
+        ret.push_back(concat(i));
+        ret.push_back(concat(i, s));
+        ret.push_back(concat(i, s, s));
+        ret.push_back(concat(i, s, s, s));
+    }
+
+    return ret;
+}
+
 std::vector<std::string> combinations(const std::vector<std::string>& v,
                                       const std::string& delim, size_t n) {
     if (n <= 1) {
@@ -169,7 +193,7 @@ void test_combinations(matches_type& matches, std::vector<std::string> delims) {
         for (size_t i = 0; i < lines.size(); ++i) {
             auto vec = s.split(buff(lines[i].c_str()), delim);
             CHECK(s.valid());
-            CHECK(words(vec) == expectations[i]);
+            CHECK_EQ(words(vec), expectations[i]);
         }
     }
 }
@@ -482,25 +506,25 @@ TEST_CASE("splitter test error mode") {
         // empty delimiter
         ss::splitter<ss::string_error> s;
         s.split(buff("just,some,strings"), "");
-        CHECK(!s.valid());
-        CHECK(!s.unterminated_quote());
-        CHECK(!s.error_msg().empty());
+        CHECK_FALSE(s.valid());
+        CHECK_FALSE(s.unterminated_quote());
+        CHECK_FALSE(s.error_msg().empty());
     }
 
     {
         // unterminated quote
         ss::splitter<ss::string_error, ss::quote<'"'>> s;
         s.split(buff("\"just"));
-        CHECK(!s.valid());
+        CHECK_FALSE(s.valid());
         CHECK(s.unterminated_quote());
-        CHECK(!s.error_msg().empty());
+        CHECK_FALSE(s.error_msg().empty());
     }
 }
 
 template <typename Splitter>
 auto expect_unterminated_quote(Splitter& s, const std::string& line) {
     auto vec = s.split(buff(line.c_str()));
-    CHECK(!s.valid());
+    CHECK_FALSE(s.valid());
     CHECK(s.unterminated_quote());
     return vec;
 }
@@ -514,166 +538,234 @@ public:
     auto resplit(char* new_line, size_t new_line_size) {
         return splitter.resplit(new_line, new_line_size);
     }
+
+    size_t size_shifted() {
+        return splitter.size_shifted();
+    }
 };
 } /* ss */
 
-TEST_CASE("splitter test unterminated quote") {
+TEST_CASE("splitter test resplit unterminated quote") {
+
     {
-        ss::converter<ss::quote<'"'>> c;
+        ss::converter<ss::quote<'"'>, ss::multiline, ss::escape<'\\'>> c;
+        auto& s = c.splitter;
+        auto vec = expect_unterminated_quote(s, R"("x)");
+        CHECK_EQ(vec.size(), 1);
+        REQUIRE(s.unterminated_quote());
+
+        {
+            auto new_line =
+                buff.append_overwrite_last(R"(a\x)", c.size_shifted());
+
+            vec = c.resplit(new_line, strlen(new_line));
+            CHECK(s.unterminated_quote());
+            CHECK_EQ(vec.size(), 1);
+        }
+
+        {
+            auto new_line =
+                buff.append_overwrite_last(R"(")", c.size_shifted());
+
+            vec = c.resplit(new_line, strlen(new_line));
+            REQUIRE(s.valid());
+            CHECK_FALSE(s.unterminated_quote());
+            REQUIRE_EQ(vec.size(), 1);
+            CHECK_EQ(words(vec)[0], "xax");
+        }
+    }
+
+    {
+        ss::converter<ss::quote<'"'>, ss::multiline> c;
         auto& s = c.splitter;
         auto vec = expect_unterminated_quote(s, "\"just");
-        CHECK(vec.size() == 1);
+        CHECK_EQ(vec.size(), 1);
 
         auto new_line = buff.append(R"(",strings)");
         vec = c.resplit(new_line, strlen(new_line));
         CHECK(s.valid());
-        CHECK(!s.unterminated_quote());
+        CHECK_FALSE(s.unterminated_quote());
         std::vector<std::string> expected{"just", "strings"};
-        CHECK(words(vec) == expected);
+        CHECK_EQ(words(vec), expected);
     }
 
     {
-        ss::converter<ss::quote<'"'>> c;
+        ss::converter<ss::quote<'"'>, ss::multiline> c;
         auto& s = c.splitter;
         auto vec = expect_unterminated_quote(s, "just,some,\"random");
         std::vector<std::string> expected{"just", "some", "just,some,\""};
-        CHECK(words(vec) == expected);
+        CHECK_EQ(words(vec), expected);
 
         auto new_line = buff.append(R"(",strings)");
         vec = c.resplit(new_line, strlen(new_line));
         CHECK(s.valid());
-        CHECK(!s.unterminated_quote());
+        CHECK_FALSE(s.unterminated_quote());
         expected = {"just", "some", "random", "strings"};
-        CHECK(words(vec) == expected);
+        CHECK_EQ(words(vec), expected);
     }
 
     {
-        ss::converter<ss::quote<'"'>> c;
+        ss::converter<ss::quote<'"'>, ss::multiline> c;
         auto& s = c.splitter;
         auto vec = expect_unterminated_quote(s, R"("just","some","ran"")");
         std::vector<std::string> expected{"just", "some", R"("just","some",")"};
-        CHECK(words(vec) == expected);
+        CHECK_EQ(words(vec), expected);
 
-        auto new_line = buff.append(R"(,dom","strings")");
+        auto new_line =
+            buff.append_overwrite_last(R"(,dom","strings")", c.size_shifted());
         vec = c.resplit(new_line, strlen(new_line));
         CHECK(s.valid());
-        CHECK(!s.unterminated_quote());
+        CHECK_FALSE(s.unterminated_quote());
         expected = {"just", "some", "ran\",dom", "strings"};
-        CHECK(words(vec) == expected);
+        CHECK_EQ(words(vec), expected);
     }
 
     {
-        ss::converter<ss::quote<'"'>> c;
+        ss::converter<ss::quote<'"'>, ss::multiline> c;
         auto& s = c.splitter;
         auto vec = expect_unterminated_quote(s, R"("just","some","ran)");
         std::vector<std::string> expected{"just", "some", R"("just","some",")"};
-        CHECK(words(vec) == expected);
+        CHECK_EQ(words(vec), expected);
+        REQUIRE(s.unterminated_quote());
 
         {
             auto new_line = buff.append(R"(,dom)");
             vec = c.resplit(new_line, strlen(new_line));
-            CHECK(!s.valid());
+            CHECK_FALSE(s.valid());
             CHECK(s.unterminated_quote());
-            CHECK(words(vec) == expected);
+            CHECK_EQ(words(vec), expected);
         }
 
         {
             auto new_line = buff.append(R"(",strings)");
             vec = c.resplit(new_line, strlen(new_line));
             CHECK(s.valid());
-            CHECK(!s.unterminated_quote());
+            CHECK_FALSE(s.unterminated_quote());
             expected = {"just", "some", "ran,dom", "strings"};
-            CHECK(words(vec) == expected);
+            CHECK_EQ(words(vec), expected);
         }
     }
 
     {
-        ss::converter<ss::quote<'"'>, ss::escape<'\\'>> c;
+        ss::converter<ss::quote<'"'>, ss::escape<'\\'>, ss::multiline> c;
         auto& s = c.splitter;
         auto vec = expect_unterminated_quote(s, R"("just\"some","ra)");
         std::vector<std::string> expected{"just\"some"};
         auto w = words(vec);
         w.pop_back();
-        CHECK(w == expected);
+        CHECK_EQ(w, expected);
+        REQUIRE(s.unterminated_quote());
         {
             auto new_line = buff.append(R"(n,dom",str\"ings)");
             vec = c.resplit(new_line, strlen(new_line));
             CHECK(s.valid());
-            CHECK(!s.unterminated_quote());
+            CHECK_FALSE(s.unterminated_quote());
             expected = {"just\"some", "ran,dom", "str\"ings"};
-            CHECK(words(vec) == expected);
+            CHECK_EQ(words(vec), expected);
         }
     }
 
     {
-        ss::converter<ss::quote<'"'>, ss::escape<'\\'>> c;
+        ss::converter<ss::quote<'"'>, ss::escape<'\\'>, ss::multiline> c;
+        auto& s = c.splitter;
+        auto vec =
+            expect_unterminated_quote(s, "3,4,"
+                                         "\"just0\\\n1\\\n22\\\n33333x\\\n4");
+
+        std::vector<std::string> expected{"3", "4"};
+        auto w = words(vec);
+        w.pop_back();
+        CHECK_EQ(w, expected);
+        REQUIRE(s.unterminated_quote());
+        {
+            auto new_line =
+                buff.append_overwrite_last("\nx5strings\"", c.size_shifted());
+            vec = c.resplit(new_line, strlen(new_line));
+            CHECK(s.valid());
+            CHECK_FALSE(s.unterminated_quote());
+            expected = {"3", "4", "just0\n1\n22\n33333x\n4\nx5strings"};
+            CHECK_EQ(words(vec), expected);
+        }
+    }
+    {
+        ss::converter<ss::quote<'"'>, ss::escape<'\\'>, ss::multiline> c;
         auto& s = c.splitter;
         auto vec = expect_unterminated_quote(s, R"("just\"some","ra"")");
         std::vector<std::string> expected{"just\"some"};
         auto w = words(vec);
         w.pop_back();
-        CHECK(w == expected);
+        CHECK_EQ(w, expected);
+        REQUIRE(s.unterminated_quote());
         {
-            auto new_line = buff.append(R"(n,dom",str\"ings)");
+            auto new_line = buff.append_overwrite_last(R"(n,dom",str\"ings)",
+                                                       c.size_shifted());
             vec = c.resplit(new_line, strlen(new_line));
             CHECK(s.valid());
-            CHECK(!s.unterminated_quote());
+            CHECK_FALSE(s.unterminated_quote());
             expected = {"just\"some", "ra\"n,dom", "str\"ings"};
-            CHECK(words(vec) == expected);
+            CHECK_EQ(words(vec), expected);
         }
     }
 
     {
-        ss::converter<ss::quote<'"'>, ss::escape<'\\'>> c;
+        ss::converter<ss::quote<'"'>, ss::escape<'\\'>, ss::multiline> c;
         auto& s = c.splitter;
-        auto vec = expect_unterminated_quote(s, R"("just\"some","ra\")");
+        auto vec = expect_unterminated_quote(s, R"("just\"some","r\a\a\\\a\")");
         std::vector<std::string> expected{"just\"some"};
         auto w = words(vec);
         w.pop_back();
-        CHECK(w == expected);
+        CHECK_EQ(w, expected);
+        REQUIRE(s.unterminated_quote());
         {
-            auto new_line = buff.append(R"(n,dom",str\"ings)");
+            auto new_line = buff.append_overwrite_last(R"(n,dom",str\"ings)",
+                                                       c.size_shifted());
             vec = c.resplit(new_line, strlen(new_line));
             CHECK(s.valid());
-            CHECK(!s.unterminated_quote());
-            expected = {"just\"some", "ra\"n,dom", "str\"ings"};
-            CHECK(words(vec) == expected);
+            CHECK_FALSE(s.unterminated_quote());
+            expected = {"just\"some", "raa\\a\"n,dom", "str\"ings"};
+            CHECK_EQ(words(vec), expected);
         }
     }
 
     {
-        ss::converter<ss::quote<'"'>, ss::trim<' '>> c;
+        ss::converter<ss::quote<'"'>, ss::trim<' '>, ss::multiline> c;
         auto& s = c.splitter;
         auto vec = expect_unterminated_quote(s, R"(  "just" ,some,  "ra )");
         std::vector<std::string> expected{"just", "some"};
         auto w = words(vec);
         w.pop_back();
-        CHECK(w == expected);
+        CHECK_EQ(w, expected);
+        REQUIRE(s.unterminated_quote());
         {
             auto new_line = buff.append(R"( n,dom"  , strings   )");
             vec = c.resplit(new_line, strlen(new_line));
             CHECK(s.valid());
-            CHECK(!s.unterminated_quote());
+            CHECK_FALSE(s.unterminated_quote());
             expected = {"just", "some", "ra  n,dom", "strings"};
-            CHECK(words(vec) == expected);
+            CHECK_EQ(words(vec), expected);
         }
     }
 
     {
-        ss::converter<ss::quote<'"'>, ss::trim<' '>, ss::escape<'\\'>> c;
+        ss::converter<ss::quote<'"'>, ss::trim<' '>, ss::escape<'\\'>,
+                      ss::multiline>
+            c;
         auto& s = c.splitter;
         auto vec = expect_unterminated_quote(s, R"(  "ju\"st" ,some,  "ra \")");
         std::vector<std::string> expected{"ju\"st", "some"};
         auto w = words(vec);
         w.pop_back();
-        CHECK(w == expected);
+        CHECK_EQ(w, expected);
+        REQUIRE(s.unterminated_quote());
         {
-            auto new_line = buff.append(R"( n,dom"  , strings   )");
+            auto new_line =
+                buff.append_overwrite_last(R"( n,dom"  , strings   )",
+                                           c.size_shifted());
             vec = c.resplit(new_line, strlen(new_line));
             CHECK(s.valid());
-            CHECK(!s.unterminated_quote());
+            CHECK_FALSE(s.unterminated_quote());
             expected = {"ju\"st", "some", "ra \" n,dom", "strings"};
-            CHECK(words(vec) == expected);
+            CHECK_EQ(words(vec), expected);
         }
     }
 }
@@ -686,26 +778,139 @@ TEST_CASE("splitter test invalid splits") {
 
     // empty delimiter
     s.split(buff("some,random,strings"), "");
-    CHECK(!s.valid());
-    CHECK(!s.unterminated_quote());
-    CHECK(!s.error_msg().empty());
+    CHECK_FALSE(s.valid());
+    CHECK_FALSE(s.unterminated_quote());
+    CHECK_FALSE(s.error_msg().empty());
 
     // mismatched delimiter
     s.split(buff(R"(some,"random,"strings")"));
-    CHECK(!s.valid());
-    CHECK(!s.unterminated_quote());
-    CHECK(!s.error_msg().empty());
+    CHECK_FALSE(s.valid());
+    CHECK_FALSE(s.unterminated_quote());
+    CHECK_FALSE(s.error_msg().empty());
+
+    // unterminated escape
+    s.split(buff(R"(some,random,strings\)"));
+    CHECK_FALSE(s.valid());
+    CHECK_FALSE(s.unterminated_quote());
+    CHECK_FALSE(s.error_msg().empty());
+
+    // unterminated escape
+    s.split(buff(R"(some,random,"strings\)"));
+    CHECK_FALSE(s.valid());
+    CHECK_FALSE(s.unterminated_quote());
+    CHECK_FALSE(s.error_msg().empty());
 
     // unterminated quote
     s.split(buff("some,random,\"strings"));
-    CHECK(!s.valid());
+    CHECK_FALSE(s.valid());
     CHECK(s.unterminated_quote());
-    CHECK(!s.error_msg().empty());
+    CHECK_FALSE(s.error_msg().empty());
 
     // invalid resplit
     char new_line[] = "some";
     auto a = c.resplit(new_line, strlen(new_line));
-    CHECK(!s.valid());
-    CHECK(!s.unterminated_quote());
-    CHECK(!s.error_msg().empty());
+    CHECK_FALSE(s.valid());
+    CHECK_FALSE(s.unterminated_quote());
+    CHECK_FALSE(s.error_msg().empty());
+}
+
+TEST_CASE("splitter test with trim_left") {
+    auto guard = set_combinations_size(3);
+    case_type case1 = spaced_left({R"(x )"}, " ");
+    case_type case2 = spaced_left({R"(yy )"}, " ");
+    case_type case3 = spaced_left({R"(y y )"}, " ");
+    case_type case4 = spaced_left({R"()"}, " ");
+
+    std::vector<std::string> delims = {",", "::", "\t", "\n"};
+
+    {
+        matches_type p{{case1, "x "},
+                       {case2, "yy "},
+                       {case3, "y y "},
+                       {case4, ""}};
+        test_combinations<ss::trim_left<' '>>(p, delims);
+    }
+
+    case_type case5 = spaced_left({"z "}, "\t");
+    case_type case6 = spaced_left({"ab\t "}, " \t");
+    case_type case7 = spaced_left({"a\tb "}, " \t");
+    case_type case8 = spaced_left({"a \t b "}, " \t");
+
+    {
+        matches_type p{{case1, "x "},    {case2, "yy "},    {case3, "y y "},
+                       {case4, ""},      {case5, "z "},     {case6, "ab\t "},
+                       {case7, "a\tb "}, {case8, "a \t b "}};
+        test_combinations<ss::trim_left<' ', '\t'>>(p, {",", "::", "\n"});
+    }
+}
+
+TEST_CASE("splitter test with trim_right") {
+    auto guard = set_combinations_size(3);
+    case_type case1 = spaced_right({R"( x)"}, " ");
+    case_type case2 = spaced_right({R"( yy)"}, " ");
+    case_type case3 = spaced_right({R"( y y)"}, " ");
+    case_type case4 = spaced_right({R"()"}, " ");
+
+    std::vector<std::string> delims = {",", "::", "\t", "\n"};
+
+    {
+        matches_type p{{case1, " x"},
+                       {case2, " yy"},
+                       {case3, " y y"},
+                       {case4, ""}};
+        test_combinations<ss::trim_right<' '>>(p, delims);
+    }
+
+    case_type case5 = spaced_right({" z"}, "\t");
+    case_type case6 = spaced_right({"\t ab"}, " \t");
+    case_type case7 = spaced_right({"\ta\tb"}, " \t");
+    case_type case8 = spaced_right({" \t a \t b"}, " \t");
+
+    {
+        matches_type p{{case1, " x"},     {case2, " yy"},
+                       {case3, " y y"},   {case4, ""},
+                       {case5, " z"},     {case6, "\t ab"},
+                       {case7, "\ta\tb"}, {case8, " \t a \t b"}};
+        test_combinations<ss::trim_right<' ', '\t'>>(p, {",", "::", "\n"});
+    }
+}
+
+TEST_CASE("splitter test with trim_right and trim_left") {
+    auto guard = set_combinations_size(3);
+    case_type case1 = spaced_right({R"(-x)"}, "-");
+    case_type case2 = spaced_left({R"(yy_)"}, "_");
+    case_type case3 = spaced_right({R"(-y y)"}, "-");
+    case_type case4 = spaced_left({R"()"}, "-");
+    case_type case5 = spaced_left({R"()"}, "_");
+    case_type case6 = {"___---", "_-", "______-"};
+
+    std::vector<std::string> delims = {",", "::", "\t", "\n"};
+
+    {
+        matches_type p{{case1, "-x"}, {case2, "yy_"}, {case3, "-y y"},
+                       {case4, ""},   {case5, ""},    {case6, ""}};
+        test_combinations<ss::trim_left<'_'>, ss::trim_right<'-'>>(p, delims);
+    }
+}
+
+TEST_CASE("splitter test with quote and escape, trim_left and trim_right") {
+    auto guard = set_combinations_size(3);
+    case_type case1 = spaced_left({R"("\"")", R"(\")", R"("""")"}, "_");
+    case_type case2 =
+        spaced_left({R"("x\"x")", R"(x\"x)", R"(x"x)", R"("x""x")"}, "_");
+    case_type case3 = spaced_left({R"("")", R"()"}, "_");
+    case_type case4 = spaced_left({R"("x")", R"(x)"}, "_");
+    case_type case5 =
+        spaced_right({R"("\"\"")", R"("""""")", R"("\"""")", R"("""\"")"}, "-");
+    case_type case6 = spaced_right({R"("\\")", R"(\\)"}, "-");
+    case_type case7 = spaced_right({R"("xxxxxxxxxx")", R"(xxxxxxxxxx)"}, "-");
+
+    std::vector<std::string> delims = {"::", "\n"};
+
+    {
+        matches_type p{{case1, "\""},   {case2, "x\"x"}, {case3, ""},
+                       {case5, "\"\""}, {case6, "\\"},   {case7, "xxxxxxxxxx"}};
+        test_combinations<ss::quote<'"'>, ss::escape<'\\'>, ss::trim_left<'_'>,
+                          ss::trim_right<'-'>>(p, delims);
+    }
 }