anchor.diff:              {group, pncounter_group}
              ].
   
  -groups() ->
  -    [
  +groups() -> [
           {gcounter_group, [sequence, {repeat, ?NUM_REPEATS}],
            [
             crdt_gcounter_inc,
             crdt_gcounter_read_your_write,
             crdt_gcounter_read_monotonic,
  -          crdt_gcounter_concurrent_read_monotonic
  +          crdt_gcounter_read_monotonic2,
  +          crdt_gcounter_concurrent_read_monotonic,
  +          crdt_gcounter_ordered_concurrent_read
            ]},
           {pncounter_group, [sequence, {repeat, ?NUM_REPEATS}],
            [
  
positive.code:     spawn_writers(UnitTestPid, Parallel, Count, WriteFun),
      wait_writers_completion(Parallel),
  
      %% kill readers
      [exit(R, kill) || R <- Readers],
      check_monotonic_reader_failure(),
  
      ok.
  
  tester_type_check_crdt(_Config) ->
      Count = 10,
  
negative.code: 
      ok.
  
  crdt_gcounter_read_monotonic2(_Config) ->
      %% starts random number of (strong and eventual) writers
      %% start multiple reader, which submit reads sequentially
      %% values read should increase monotonic
      Key = randoms:getRandomString(),
      UnitTestPid = self(),
  
      ReaderCount = randoms:rand_uniform(2, 50),
      ct:pal("Start ~p readers", [ReaderCount]),
      Reader = [spawn(fun() ->
                          Loop =
                              fun(F) ->
                                  receive
                                      {read, Pids, Prev} ->
                                          {ok, Result} = gcounter_on_cseq:read_state(Key),
                                          case gcounter:lteq(Prev, Result) of
                                              true -> ok;
                                              false ->
                                                  ct:pal("~n~w ~nis not smaller or equals than ~n~w", [Prev, Result]),
                                                  UnitTestPid ! {compare_failed, Prev, Result}
                                          end,
                                          NextReader = lists:nth(randoms:rand_uniform(1, length(Pids)+1), Pids),
                                          NextReader ! {read, Pids, Result}
                                  end,
                                  F(F)
                              end,
                          Loop(Loop)
                      end)
                || _ <- lists:seq(1, ReaderCount)],
      {ok, Init} = gcounter_on_cseq:read_state(Key),
      hd(Reader) ! {read, Reader, Init},
  
      %% do all the writes
      Parallel = randoms:rand_uniform(1, 50),
      Count = 10000 div Parallel,
      WriteFun = fun
  