anchor.diff:      BinKey = list_to_binary(Key),
       ok = case riakc_pb_socket:get(Conn, Bucket, BinKey) of
           {ok, O} ->
  -            O2 = riakc_obj:update_value(O, PropList),
  +            O2 = riakc_obj:update_value(O, ConvertedPropList),
               riakc_pb_socket:put(Conn, O2);
           {error, _} ->
  -            O = riakc_obj:new(Bucket, BinKey, PropList, <<"application/x-erlang-term">>),
  +            O = riakc_obj:new(Bucket, BinKey, ConvertedPropList, <<"application/x-erlang-term">>),
               riakc_pb_socket:put(Conn, O)
       end,
       {ok, Record:set(id, lists:concat([Type, "-", Key]))}.
  
positive.code:     case Max of
          all -> lists:nthtail(Skip, Sorted);
          Max when Skip < length(Sorted) ->
              lists:sublist(Sorted, Skip + 1, Max);                                                                                             
          _ ->  
              []  
  
      end.
  
  % this is a stub just to make the tests runable
  
negative.code: find(Conn, Type, Conditions, Max, Skip, Sort, SortOrder) ->
      Bucket = type_to_bucket_name(Type),
      {ok, Keys} = case Conditions of
          [] ->
              riakc_pb_socket:list_keys(Conn, Bucket);
          _ ->
              {ok, {search_results, KeysExt, _, _}} = riakc_pb_socket:search(
                  Conn, Bucket, build_search_query(Conditions)),
              ConvertedKeysExt = decode_search_from_riak(KeysExt),
              {ok, lists:map(fun ({_,X})->
                               Id = proplists:get_value(id, X),
                               list_to_binary(Id)
                             end, ConvertedKeysExt)}
      end,
      Records = find_acc(Conn, atom_to_list(Type) ++ "-", Keys, []),
      Sorted = if
  