Add message selector unit tests

Remove regexes altogether since they add complexities:
1. Compiling and running regexes on different OTP versions is
   problematic
2. Holding compiled regexes in rabbit_fifo state is problematic because
   the snapshot can be sent to another node running a different OTP
   version

An alternative is to compile the regex on demand before each scan.

Author: ansd

deps/rabbit/src/rabbit_fifo_filter_jms.erl

@@ -148,12 +148,17 @@ eval0({'not_in', Expr, ValueList}, Headers) ->
 
 eval0({'like', Expr, Pattern, Escape}, Headers) ->
     Value = eval0(Expr, Headers),
-    PatternVal = eval0(Pattern, Headers),
-    EscapeVal = case Escape of
-                    no_escape -> no_escape;
-                    _ -> eval0(Escape, Headers)
-                end,
-    is_like(Value, PatternVal, EscapeVal);
+    case is_binary(Value) of
+        true ->
+            case unicode:characters_to_list(Value) of
+                L when is_list(L) ->
+                    like_match(L, Pattern, Escape);
+                _ ->
+                    undefined
+            end;
+        false ->
+            undefined
+    end;
 
 eval0({'not_like', Expr, Pattern, Escape}, Headers) ->
     case eval0({'like', Expr, Pattern, Escape}, Headers) of
@@ -180,14 +185,29 @@ eval0(_, _) ->
 %% Helper functions
 
 %% "Comparison or arithmetic with an unknown value always yields an unknown value."
-compare(_, undefined, _) -> undefined;
-compare(_, _, undefined) -> undefined;
-compare('=', Left, Right) -> Left == Right;
-compare('<>', Left, Right) -> Left /= Right;
-compare('>', Left, Right) -> Left > Right;
-compare('<', Left, Right) -> Left < Right;
-compare('>=', Left, Right) -> Left >= Right;
-compare('<=', Left, Right) -> Left =< Right.
+compare(_, undefined, _) ->
+    undefined;
+compare(_, _, undefined) ->
+    undefined;
+%% "Only like type values can be compared.
+%% One exception is that it is valid to compare exact numeric values and approximate numeric values.
+%% String and Boolean comparison is restricted to = and <>."
+compare('=', Left, Right) ->
+    Left == Right;
+compare('<>', Left, Right) ->
+    Left /= Right;
+compare('>', Left, Right) when is_number(Left) andalso is_number(Right) ->
+    Left > Right;
+compare('<', Left, Right) when is_number(Left) andalso is_number(Right) ->
+    Left < Right;
+compare('>=', Left, Right) when is_number(Left) andalso is_number(Right) ->
+    Left >= Right;
+compare('<=', Left, Right) when is_number(Left) andalso is_number(Right) ->
+    Left =< Right;
+compare(_, _, _) ->
+    %% "If the comparison of non-like type values is attempted,
+    %% the value of the operation is false."
+    false.
 
 arithmetic(_, undefined, _) ->
     undefined;
@@ -199,15 +219,7 @@ arithmetic('-', Left, Right) when is_number(Left) andalso is_number(Right) ->
     Left - Right;
 arithmetic('*', Left, Right) when is_number(Left) andalso is_number(Right) ->
     Left * Right;
-arithmetic('/', Left, Right) when Right =:= 0 andalso Left > 0 ->
-    infinity;
-arithmetic('/', Left, Right) when Right =:= 0 andalso Left < 0 ->
-    '-infinity';
-arithmetic('/', Left, Right) when Right =:= 0 andalso Left =:= 0 ->
-    'NaN';
-arithmetic('/', Left, Right) when is_integer(Left) andalso is_integer(Right) ->
-    Left div Right;
-arithmetic('/', Left, Right) when is_number(Left) andalso is_number(Right) ->
+arithmetic('/', Left, Right) when is_number(Left) andalso is_number(Right) andalso Right /= 0 ->
     Left / Right;
 arithmetic(_, _, _) ->
     undefined.
@@ -217,59 +229,53 @@ between(Value, From, To)
        From =:= undefined orelse
        To =:= undefined ->
     undefined;
-between(Value, From, To) ->
-    From =< Value andalso Value =< To.
+between(Value, From, To)
+  when is_number(Value) andalso
+       is_number(From) andalso
+       is_number(To) ->
+    From =< Value andalso Value =< To;
+between(_, _, _) ->
+    %% BETWEEN requires arithmetic expressions
+    %% "a string cannot be used in an arithmetic expression"
+    false.
 
 is_in(undefined, _) ->
     undefined;
 is_in(Value, List) ->
     lists:member(Value, List).
 
-is_like(Value, Pattern, Escape)
-  when is_binary(Value) andalso
-       is_binary(Pattern) ->
-    RegexPattern = like_to_regex(Pattern, Escape),
-    case re:run(Value, RegexPattern, [{capture, none}]) of
-        match -> true;
-        nomatch -> false
+like_match([], [], _) ->
+    true;
+like_match(_, [], _) ->
+    false;
+like_match([], [Char | _], _) when Char =/= $% ->
+    false;
+like_match([], [$% | Rest], Escape) ->
+    %% String is empty, pattern starts with % - % can match empty string, continue with rest
+    like_match([], Rest, Escape);
+like_match(S, [Escape, Char | PatRest], Escape) when Escape =/= no_escape ->
+    %% Found escape character, match the next character literally
+    case S of
+        [Char | StrRest] ->
+            like_match(StrRest, PatRest, Escape);
+        _ ->
+            false
     end;
-is_like(_, _, _) ->
-    undefined.
-
-%% Convert LIKE pattern to regex
-%%
-%% TODO compilation should happen when the consumer attaches.
-%% Should this happen within rabbit_jms_selector_parser.yrl?
-like_to_regex(Pattern, Escape) ->
-    {ok, Regex} = convert_like_to_regex(binary_to_list(Pattern), Escape),
-    {ok, MP} = re:compile(<<"^", Regex/binary, "$">>),
-    MP.
-
-convert_like_to_regex(Pattern, Escape) ->
-    convert_like_to_regex(Pattern, [], Escape).
-
-convert_like_to_regex([], Acc, _) ->
-    {ok, iolist_to_binary(lists:reverse(Acc))};
-convert_like_to_regex([Esc, Char | Rest], Acc, Esc) when Esc =/= no_escape ->
-    % Escaped character - take literally
-    convert_like_to_regex(Rest, [escape_regex_char(Char) | Acc], Esc);
-convert_like_to_regex([$% | Rest], Acc, Esc) ->
-    % % means any sequence of characters (including none)
-    convert_like_to_regex(Rest, [".*" | Acc], Esc);
-convert_like_to_regex([$_ | Rest], Acc, Esc) ->
-    % _ means any single character
-    convert_like_to_regex(Rest, [$. | Acc], Esc);
-convert_like_to_regex([Char | Rest], Acc, Esc) ->
-    % Regular character - escape for regex
-    convert_like_to_regex(Rest, [escape_regex_char(Char) | Acc], Esc).
-
-%% Escape special regex characters
-escape_regex_char(Char)
-  when Char =:= $. orelse Char =:= $* orelse Char =:= $+ orelse
-       Char =:= $? orelse Char =:= $^ orelse Char =:= $$ orelse
-       Char =:= $[ orelse Char =:= $] orelse Char =:= $( orelse
-       Char =:= $) orelse Char =:= ${ orelse Char =:= $} orelse
-       Char =:= $| orelse Char =:= $\\ ->
-    [$\\, Char];
-escape_regex_char(Char) ->
-    Char.
+like_match([_ | StrRest], [$_ | PatRest], Escape) ->
+    %% _ matches exactly 1 character
+    like_match(StrRest, PatRest, Escape);
+like_match(S, [$% | PatRest] = Pattern, Escape) ->
+    %% % matches 0 or more characters - try two paths:
+    %% 1. Skip % (match 0 characters)
+    like_match(S, PatRest, Escape) orelse
+    case S of
+        [] ->
+            false;
+        [_ | StrRest] ->
+            %% 2. Match current character and keep % in pattern for next iteration
+            like_match(StrRest, Pattern, Escape)
+    end;
+like_match([Char | StrRest], [Char | PatRest], Escape) ->
+    like_match(StrRest, PatRest, Escape);
+like_match(_, Pattern, _) when is_list(Pattern) ->
+    false.