anchor.diff:                                                       end, NewVnodes)
                     end, lists:seq(0, 2))).
   
  -equivalent_coverage(Old, {_NewVs, NewFs}, NVal, CHBin) ->
  +equivalent_coverage(OldVNode, NewFilters, NVal, CHBin) ->
       RingSize = chashbin:num_partitions(CHBin),
       PartitionSize = chash:ring_increment(RingSize),
  -    OldFilters = test_vnode_to_filters(Old, NVal, RingSize, PartitionSize),
  +    OldFilters = test_vnode_to_filters(OldVNode, NVal, RingSize, PartitionSize),
  +    equivalent_coverage(OldFilters, NewFilters).
  +
  +equivalent_coverage(OldFilters, NewFilters) ->
       %% This logic relies on the fact that all of the new vnodes must
       %% have an explicit filter list since we're replacing a full vnode
       %% and there is no other vnode which has exactly the same
       %% partitions
  -    NewFilters = lists:foldl(
  -                   fun({_VNode, FilterList}, Acc) -> Acc ++ FilterList end,
  -                   [],
  -                   NewFs),
  -    lists:sort(OldFilters) == lists:sort(NewFilters).
  +    ConsolidatedFilters = lists:foldl(
  +                            fun({_VNode, FilterList}, Acc) -> Acc ++ FilterList end,
  +                            [],
  +                            NewFilters),
  +    lists:sort(OldFilters) == lists:sort(ConsolidatedFilters).
   
   test_vnode_to_filters(Index, NVal, RingSize, PartitionSize) ->
       lists:map(fun(N) -> (((Index div PartitionSize) + (RingSize - N)) rem RingSize) * PartitionSize end,
  
positive.code:     CHash = chash_init(),
      chashbin:create(CHash).
  
  test_replace_traditional2(CHBin) ->
      %% Unlike test_replace_traditional, this function will iterate
      %% through through N request IDs. Seems like an obvious place to
  
negative.code:       fun test_create_subpartition_plan/1,
        fun test_replace_traditional/1,
        fun test_replace_traditional2/1,
        fun test_replace_traditional3/1,
        fun test_replace_subpartition/1]
      }.
  
  