anchor.diff:      timer:sleep(50),
       DhtNodes = pid_groups:find_all(dht_node),
       VerifyFun =
  -        fun (Result1, Result2) ->
  +        fun (Result1, Result2, Interleaved) ->
                   unittest_helper:check_ring_load(440),
                   unittest_helper:check_ring_data(),
                   %% Outcome: at most one slide may succeed.
  -                %% Currently, breakpoints can't be used with the proto scheduler. This possibly
  -                %% can lead to a sequential processing of the slides, i.e. first slide finishes
  -                %% before the second slide starts. Hence, for now, we need to also allow both
  -                %% slides to return OK.
  -                %% TODO: ?assert(not(element(4, Result1) =:= ok andalso element(4, Result2) =:= ok))
  -                Vals = [ok, ongoing_slide, target_id_not_in_range, wrong_pred_succ_node],
  -                ?assert(lists:member(element(4, Result1), Vals)),
  -                ?assert(lists:member(element(4, Result2), Vals))
  +                %% We ensure slide interleaving using breakpoints. When using the proto scheduler
  +                %% we test for interleaving as we cannot use breakpoints.
  +                case Interleaved of
  +                    true ->
  +                        ?assert(not(Result1 =:= ok andalso Result2 =:= ok));
  +                    false ->
  +                        Vals = [ok, ongoing_slide, target_id_not_in_range, wrong_pred_succ_node],
  +                        ?assert(lists:member(Result1, Vals)),
  +                        ?assert(lists:member(Result2, Vals))
  +                end
           end,
       Actions = [
                  {
  
positive.code:         end,
      element(N, Nodes).
  
  -spec get_predspred_pred_node_succ(DhtNode::pid()) -> node_tuple().
  get_predspred_pred_node_succ(DhtNode) ->
      {Pred, Node, Succ} = get_pred_node_succ2(DhtNode, "error fetching nodes"),
      {PredsPred, _Pred2, _Node2} = get_pred_node_succ2(node:pidX(Pred), "error fetching nodes"),
      {PredsPred, Pred, Node, Succ}.
  
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
negative.code:               Tag2 = Slide2#slideconf.name,
                ct:pal("Beginning ~p, ~p", [Tag1, Tag2]),
                ?proto_sched(start),
                PidLocal1 = comm:make_local(node:pidX(Node1)),
                PidLocal2 = comm:make_local(node:pidX(Node2)),
                %% We use breakpoints to assure simultaneous slides.
                %% As these don't work with the proto scheduler, we test the timing of the slides using
                %% a callback function instead. The function sends out messages begin_of_slide and
                %% end_of_slide messages for each slide.
                case proto_sched:infected() of
                    false ->
                        set_breakpoint(PidLocal1, slide1),
                        ?IIF(PidLocal1 =/= PidLocal2, set_breakpoint(PidLocal2, slide2), ok);
                    true  ->
                        proto_sched:register_callback(proto_sched_callback_fun())
                end,
                %% send out slides
                comm:send(node:pidX(Node1), {move, start_slide, Direction1, TargetId1, {slide1, Direction1, Tag1}, self()}),
                comm:send(node:pidX(Node2), {move, start_slide, Direction2, TargetId2, {slide2, Direction2, Tag2}, self()}),
                %% Continue once both slides have reached the gen_component
                case proto_sched:infected() of
                    false ->
                        wait(PidLocal1, slide1),
                        ?IIF(PidLocal1 =/= PidLocal2, wait(PidLocal2, slide2), ok),
                        continue(PidLocal1),
                        ?IIF(PidLocal1 =/= PidLocal2, continue(PidLocal2), ok);
                    true  ->
                        ok
                end,
                %% receive results
                Result1 = fun() -> receive ?SCALARIS_RECV({move, result, _Tag1, Result}, Result) end end(),
                Result2 = fun() -> receive ?SCALARIS_RECV({move, result, _Tag2, Result}, Result) end end(),
                ct:pal("Result1: ~p,~nResult2: ~p", [Result1, Result2]),
                VerifyFun(Result1, Result2, slide_interleaving()),
                ?proto_sched(stop),
                timer:sleep(10)
            end || Slide1 <- SlideVariations1, Slide2 <- SlideVariations2],
      ok.
  