anchor.diff:      ?assertEqual([], new()).
   
   value_test() ->
  -    PNCnt1 = [{1,1,0}, {2,13,10}, {3,1,0}, {4,0,1}],
  +    PNCnt1 = [{1, 1, 0}, {2, 13, 10}, {3, 1, 0}, {4, 0, 1}],
       PNCnt2 = [],
  -    PNCnt3 = [{1,3,3},{2,1,1},{3,1,1}],
  +    PNCnt3 = [{1, 3, 3}, {2, 1, 1}, {3, 1, 1}],
       ?assertEqual(4, value(PNCnt1)),
       ?assertEqual(0, value(PNCnt2)),
       ?assertEqual(0, value(PNCnt3)).
  
positive.code: 
  % This is kinda important, I should probably do more about this test.
  update_bin_test() ->
      OldPNCnt = {[{a,1}],[{b,3}]},
      {ok, OldPNBin} = to_binary(?V1_VERS, OldPNCnt),
      {ok, NewPNCnt} = from_binary(OldPNBin),
      ?assertEqual([{b,0,3},{a,1,0}], NewPNCnt).
  
  query_test() ->
      PN = new(),
  
negative.code:     {ok, PNCnt2} = update(increment, 2, PNCnt1),
      {ok, PNCnt3} = update(increment, 1, PNCnt2),
      {ok, PNCnt4} = update(decrement, 1, PNCnt3),
      ?assertEqual([{1, 2, 1}, {2, 1, 0}], PNCnt4).
  
  update_decrement_by_test() ->
      PNCnt0 = new(),
      {ok, PNCnt1} = update({increment, 7}, 1, PNCnt0),
      {ok, PNCnt2} = update({decrement, 5}, 1, PNCnt1),
      ?assertEqual([{1, 7, 5}], PNCnt2).
  
  merge_test() ->
      PNCnt1 = [{<<"1">>, 1, 0},
                {<<"2">>, 2, 0},
                {<<"4">>, 4, 0}],
      PNCnt2 = [{<<"3">>, 3, 0},
                {<<"4">>, 3, 0}],
      ?assertEqual([], merge(new(), new())),
      ?assertEqual([{<<"1">>, 1, 0},
                    {<<"2">>, 2, 0},
                    {<<"4">>, 4, 0},
                    {<<"3">>, 3, 0}], merge(PNCnt1, PNCnt2)).
  
  merge_too_test() ->
      PNCnt1 = [{<<"5">>, 5, 0},
                {<<"7">>, 0, 4}],
      PNCnt2 = [{<<"5">>, 0, 2},
                {<<"6">>, 6, 0},
                {<<"7">>, 7, 0}],
      ?assertEqual([{<<"5">>, 5, 2},
                    {<<"7">>, 7, 4},
                    {<<"6">>, 6, 0}], merge(PNCnt1, PNCnt2)).
  
  equal_test() ->
      PNCnt1 = [{1, 2, 1}, {2, 1, 0}, {3, 0, 1}, {4, 1, 0}],
      PNCnt2 = [{1, 1, 0}, {2, 4, 0}, {3, 1, 0}],
      PNCnt3 = [{4, 1, 0}, {2, 1, 0}, {3, 0, 1}, {1, 2, 1}],
      PNCnt4 = [{4, 1, 0}, {1, 2, 1}, {2, 1, 0}, {3, 0, 1}],
      ?assertNot(equal(PNCnt1, PNCnt2)),
      ?assert(equal(PNCnt3, PNCnt4)),
      ?assert(equal(PNCnt1, PNCnt3)).
  