Skip test case two_nodes_different_otp_version

Test case two_nodes_different_otp_version was introduced in
#14042.

In CI, the code was compiled on OTP 27. The test case then applied the
Ra commands on OTP 27 and OTP 26 at runtime. For that to work the test
transferred the compiled BEAM modules to the OTP 26 node.

Bumping OTP to 28 causes the lower version node (be it OTP 26 or OTP 27)
to error when parsing the atom table chunk of the BEAM file that was
compiled in OTP 28:
```
  corrupt atom table

{error,badfile}
```
That's expected as described in erlang/otp#8913 (comment)
since erlang/otp#8913 changes the atom table chunk
format in the BEAM files.

```
beam_lib:chunks("deps/rabbit/ebin/lqueue.beam", [atoms]).
```
will parse successfully if the file gets loaded on OTP 28 irrespective
of whether the file was compiled with OTP 27 or 28.
However, this file fails to load if it is compiled with 28 and loaded on
27.

There is the `no_long_atoms` option that we could use just for this test
case.
However, given that we have a similar test case
two_nodes_same_otp_version we skip test case two_nodes_different_otp_version
in this commit.

Really, the best solution would be to use different OTP versions in
RabbitMQ mixed version testing in addition to using different RabbitMQ
versions. This way, the test case could just RPC into the different
RabbitMQ nodes and apply the Ra commands there.

Author: ansd

deps/rabbit/test/rabbit_fifo_prop_SUITE.erl

@@ -1111,32 +1111,43 @@ two_nodes_same_otp_version(Config0) ->
 
 %% Run the log on two Erlang nodes with different OTP versions.
 two_nodes_different_otp_version(_Config) ->
-    Node = 'rabbit_fifo_prop@localhost',
-    case net_adm:ping(Node) of
-        pong ->
-            case is_same_otp_version(Node) of
-                true ->
-                    ct:fail("expected CT node and 'rabbit_fifo_prop@localhost' "
-                            "to have different OTP versions");
-                false ->
-                    Prefixes = ["rabbit_fifo", "rabbit_misc", "mc",
-                                "lqueue", "priority_queue", "ra_"],
-                    [begin
-                         Mod = list_to_atom(ModStr),
-                         {Mod, Bin, _File} = code:get_object_code(Mod),
-                         {module, Mod} = erpc:call(Node, code, load_binary, [Mod, ModStr, Bin])
-                     end
-                     || {ModStr, _FileName, _Loaded} <- code:all_available(),
-                        lists:any(fun(Prefix) -> lists:prefix(Prefix, ModStr) end, Prefixes)],
-                    two_nodes(Node)
-            end;
-        pang ->
-            Reason = {node_down, Node},
-            case rabbit_ct_helpers:is_ci() of
-                true ->
-                    ct:fail(Reason);
-                false ->
-                    {skip, Reason}
+    case erlang:system_info(otp_release) of
+        "28" ->
+            %% Compiling a BEAM file on OTP 28 and loading it on OTP 26 or 27
+            %% causes a "corrupt atom table" error.
+            %% https://github.com/erlang/otp/pull/8913#issue-2572291638
+            {skip, "loading BEAM file compiled on OTP 28 on a lower OTP version is unsupported"};
+        _ ->
+            Node = 'rabbit_fifo_prop@localhost',
+            case net_adm:ping(Node) of
+                pong ->
+                    case is_same_otp_version(Node) of
+                        true ->
+                            ct:fail("expected CT node and 'rabbit_fifo_prop@localhost' "
+                                    "to have different OTP versions");
+                        false ->
+                            Prefixes = ["rabbit_fifo", "rabbit_misc", "mc",
+                                        "lqueue", "priority_queue", "ra_"],
+                            [begin
+                                 Mod = list_to_atom(ModStr),
+                                 {Mod, Bin, _File} = code:get_object_code(Mod),
+                                 {module, Mod} = erpc:call(Node, code, load_binary,
+                                                           [Mod, ModStr, Bin])
+                             end
+                             || {ModStr, _FileName, _Loaded} <- code:all_available(),
+                                lists:any(fun(Prefix) ->
+                                                  lists:prefix(Prefix, ModStr)
+                                          end, Prefixes)],
+                            two_nodes(Node)
+                    end;
+                pang ->
+                    Reason = {node_down, Node},
+                    case rabbit_ct_helpers:is_ci() of
+                        true ->
+                            ct:fail(Reason);
+                        false ->
+                            {skip, Reason}
+                    end
             end
     end.