anchor.diff:  sanify_basic_test() ->
       %% normal case when everything matches vb map
       [a, b] = do_sanify_chain("B", [{a, 0, active}, {b, 0, replica}],
  -                             [a, b], [], 0, []),
  +                             [a, b], [], 0),
   
       %% yes, the code will keep both masters as long as expected master
       %% is there. Possibly something to fix in future
       [a, b] = do_sanify_chain("B", [{a, 0, active}, {b, 0, active}],
  -                             [a, b], [], 0, []),
  +                             [a, b], [], 0),
   
       %% main chain doesn't match but fast-forward chain does
       [b, c] = do_sanify_chain("B", [{a, 0, dead}, {b, 0, active}, {c, 0, replica}],
  -                             [a, b], [b, c], 0, []),
  +                             [a, b], [b, c], 0),
   
       %% main chain doesn't match but ff chain does. And old master is already deleted
       [b, c] = do_sanify_chain("B", [{b, 0, active}, {c, 0, replica}],
  -                             [a, b], [b, c], 0, []),
  +                             [a, b], [b, c], 0),
   
       %% lets make sure we touch all paths just in case
       %% this runs "there are >1 unexpected master" case
       ignore = do_sanify_chain("B", [{a, 0, active}, {b, 0, active}],
  -                             [c, a, b], [], 0, []),
  +                             [c, a, b], [], 0),
       %% this runs "master is one of replicas" case
       [b] = do_sanify_chain("B", [{b, 0, active}, {c, 0, replica}],
  -                          [a, b], [], 0, []),
  +                          [a, b], [], 0),
       %% and this runs "master is some non-chain member node" case
       [c] = do_sanify_chain("B", [{c, 0, active}],
  -                          [a, b], [], 0, []),
  +                          [a, b], [], 0),
   
       %% lets also test rebalance stopped prior to complete takeover
       [a, b] = do_sanify_chain("B", [{a, 0, dead}, {b, 0, replica},
                                      {c, 0, pending}, {d, 0, replica}],
  -                             [a, b], [c, d], 0, []),
  +                             [a, b], [c, d], 0),
       ok.
   
   sanify_doesnt_lose_replicas_on_stopped_rebalance_test() ->
  
positive.code:         true ->
              {error, unsafe_nodes, UnsafeNodes};
          false ->
              ApplyTimeout = proplists:get_value(apply_config_timeout, Options,
                                                 undefined_timeout),
              ok = janitor_agent:apply_new_bucket_config_with_timeout(Bucket, undefined,
                                                                      Servers,
                                                                      NewBucketConfig,
                                                                      IgnoredVBuckets,
                                                                      ApplyTimeout),
  
              case Zombies =:= [] andalso
                  proplists:get_bool(consider_stopping_rebalance_status, Options) of
                  true ->
                      maybe_stop_rebalance_status();
                  _ -> ok
              end,
  
              case janitor_agent:mark_bucket_warmed(Bucket, Servers) of
                  ok ->
                      ok;
                  {error, BadNodes, _BadReplies} ->
                      {error, marking_as_warmed_failed, BadNodes}
              end
      end.
  
  should_check_for_unsafe_nodes(BCfg, Options) ->
  
negative.code:                                         undefined)
      end.
  
  construct_vbucket_states(VBucket, Chain, States) ->
      NodeStates = [{N, S} || {N, V, S} <- States, V == VBucket],
      ChainStates = lists:map(
                      fun (N) ->
  