anchor.diff:                  error_badepoch ->
                       %% TODO: same TODO as the above error_badepoch case.
                       error_badepoch;
  -                error_overwritten ->
  -                    error({impossible, ?MODULE, ?LINE, left_off_here})
  -            end;
  -        Else ->
  -            %% TODO: corner case
  -            io:format(user, "WTF? Else = ~p\n", [Else]),
  -            Else
  +                Else ->
  +                    error({left_off_here, ?MODULE, ?LINE, Else})
  +            end
       end.
   
   read_page(#proj{epoch=Epoch} = P, LPN) ->
  
positive.code:             %%       in the Acc?  Or should the client assume that if
              %%       scan_forward() doesn't mention a page that
              scan_forward(P, LPN + 1, MaxPages - 1, ok, true, Acc);
          error_overwritten ->
              error({impossible, ?MODULE, ?LINE, overwritten_reply_to_read});
          error_unwritten ->
              %% Halt, allow recursion to create our return value.
              scan_forward(P, LPN, 0, ok, false, Acc)
      end.
  
  flu_pid(X) when is_pid(X) ->
  
negative.code:         [{LPN1,Pg1}, {LPN2,Pg2}, {LPN3,Pg3}, {LPN4,Pg4}, {LPN5,Pg5}] = LPN_Pgs,
          {ok, 4, true, [{LPN2,Pg2}, {LPN3,Pg3}]} = scan_forward(P1, 2, 2),
          {ok, 6, false, [{LPN3,Pg3}, {LPN4,Pg4}, {LPN5,Pg5}]} = scan_forward(P1, 3, 10),
  
          %% Let's smoke read-repair: regular write failure
          Epoch = P1#proj.epoch,
          Pg6 = <<424242:(PageSize*8)>>,
  
          %% Simulate a failed write to the chain.
          [F6a, F6b, F6c] = Chain6 = project_to_chain(6, P1),
          NotHead6 = [F6b, F6c],
          ok = write_single_page_to_chain([F6a], Epoch, 6, Pg6, 1),
  
          %% Does the chain look as expected?
          {ok, Pg6} = corfurl_flu:read(flu_pid(F6a), Epoch, 6),
          [error_unwritten = corfurl_flu:read(flu_pid(X), Epoch, 6) ||
              X <- NotHead6],
  
          %% Read repair should fix it.
          {ok, Pg6} = read_page(P1, 6),
          [{ok, Pg6} = corfurl_flu:read(flu_pid(X), Epoch, 6) || X <- Chain6],
  
          %% Let's smoke read-repair: failed fill
          [F7a, F7b, F7c] = Chain7 = project_to_chain(7, P1),
          NotHead7 = [F7b, F7c],
          ok = corfurl_flu:fill(flu_pid(F7a), Epoch, 7),
  
          %% Does the chain look as expected?
          error_trimmed = corfurl_flu:read(flu_pid(F7a), Epoch, 7),
          [error_unwritten = corfurl_flu:read(flu_pid(X), Epoch, 7) ||
              X <- NotHead7],
  
          %% Read repair should fix it.
          error_trimmed = read_page(P1, 7),
          [error_trimmed = corfurl_flu:read(flu_pid(X), Epoch, 7) || X <- Chain7],
  
  
          ok
      after
  