anchor.diff:  %% MR helper funs
   -export([value/1, counter_value/1, set_value/1, map_value/1]).
   %% Other helper funs
  --export([is_crdt/1]).
  +-export([is_crdt/1, is_crdt/2]).
   
   -include("riak_kv_wm_raw.hrl").
   -include("riak_object.hrl").
  
positive.code:             true
      end.
  
  new(B, K, Mod) ->
      CRDT=#crdt{ctype=CType} = to_record(Mod, Mod:new()),
      Bin = to_binary(CRDT),
  
negative.code: %% ===================================================================
  -ifdef(TEST).
  
  is_crdt_test_() ->
      {setup,
       fun() ->
               meck:new(riak_core_bucket),
               meck:new(riak_core_capability, []),
               meck:expect(riak_core_capability, get,
                           fun({riak_kv, crdt}, []) ->
                                   [pncounter,riak_dt_pncounter,riak_dt_orswot,
                                    riak_dt_map];
                              (X, Y) -> meck:passthrough([X, Y]) end),
               ok
       end,
       fun(_) ->
               meck:unload(riak_core_capability),
               meck:unload(riak_core_bucket)
       end,
       [
        ?_test(begin
                   meck:expect(riak_core_bucket, get_bucket,
                               fun(_Bucket) -> [{datatype, foo}] end),
                   Bucket = {<<"counterz">>, <<"crdt">>},
                   BTProps = riak_core_bucket:get_bucket(Bucket),
                   ?assertEqual(foo, proplists:get_value(datatype, BTProps)),
                   ?assertNot(is_crdt(riak_object:new(Bucket, <<"k1">>, hello)))
               end),
        ?_test(begin
                   Bucket = {<<"t">>, <<"bucketjumpy">>},
                   ?assertNot(is_crdt(riak_object:new(Bucket, <<"k1">>, hi)))
               end),
        ?_test(begin
                   meck:expect(riak_core_bucket, get_bucket,
                               fun({<<"maps">>, _Name}) -> [{datatype, map}];
                                  ({<<"sets">>, _Name}) -> [{datatype, set}];
                                  ({<<"counters">>, _Name}) ->
                                       [{datatype, counter}];
                                  ({<<"mappyz">>, _Name}) -> [];
                                  ({X, Y}) -> meck:passthrough([X, Y]) end),
                   Bucket1 = {<<"maps">>, <<"crdt">>},
                   Bucket2 = {<<"sets">>, <<"crdt">>},
                   Bucket3 = {<<"counters">>, <<"crdt">>},
                   Bucket4 = {<<"mappyz">>, <<"crdt">>},
                   BTPropsMap = riak_core_bucket:get_bucket(Bucket1),
                   BTPropsSet = riak_core_bucket:get_bucket(Bucket2),
                   BTPropsCounter = riak_core_bucket:get_bucket(Bucket3),
                   ?assertEqual(map, proplists:get_value(datatype, BTPropsMap)),
                   ?assertEqual(set, proplists:get_value(datatype, BTPropsSet)),
                   ?assertEqual(counter,
                                proplists:get_value(datatype, BTPropsCounter)),
                   [?assert(is_crdt(riak_kv_crdt:new(B, K, Mod)))
                    || {B, K, Mod} <- [{Bucket1, <<"k1">>, riak_dt_map},
                                     {Bucket2, <<"k2">>, riak_dt_orswot},
                                     {Bucket3, <<"k3">>, riak_dt_pncounter}]],
                   ?assertNot(is_crdt(riak_kv_crdt:new(Bucket4, <<"k5">>,
                                                       riak_dt_map))),
                   ?assertNot(is_crdt(riak_object:new(Bucket1, <<"k6">>,
                                                      <<"classic">>)))
               end)]}.
  
  -ifdef(EQC).
  -define(QC_OUT(P),
  