anchor.diff:          false ->
               rpc:call(Node, etorrent_peer_control, unchoke, [PeerPid]),
               timer:sleep(100),
  +            io:format("Try to choke again."),
               choke_in_the_middle(Node, PeerPid)
       end.
   
  
positive.code: %% Tests
  %% ----------------------------------------------------------------------
  groups() ->
      Tests = [down_udp_tracker,
               choked_seed_leech, seed_transmission, leech_transmission,
               seed_leech, partial_downloading, udp_seed_leech, bep9],
  %   [{main_group, [shuffle], Tests}].
      [{main_group, [], Tests}].
  
  
negative.code:     io:format("~n======START SLOW SEED AND LEECHING TEST CASE======~n", []),
      {Ref, Pid} = {make_ref(), self()},
  
      CNode = ?config(choked_seed_node, Config),
      LNode = ?config(leech_node, Config),
      SNode = ?config(seed_node, Config),
      BinIH = ?config(info_hash_bin, Config),
      CTorrentID = wait_torrent_registration(CNode, BinIH),
      STorrentID = wait_torrent_registration(SNode, BinIH),
      io:format("TorrentID on the choked_seed node is ~p.~n", [CTorrentID]),
  
      {ok, LTorrentID} = rpc:call(LNode, etorrent, start,
  		  [?config(http_torrent_file, Config), {Ref, Pid}]),
  
      io:format("TorrentID on the leech node is ~p.~n", [LTorrentID]),
  
      %% Leech peer control process on the slow node.
      LeechId  = rpc:call(LNode, etorrent_ctl, local_peer_id, []),
      CPeerPid = wait_peer_registration(CNode, CTorrentID, LeechId),
      SPeerPid = wait_peer_registration(SNode, STorrentID, LeechId),
      io:format("Peer registered.~n", []),
      rpc:call(SNode, etorrent_peer_control, choke, [SPeerPid]),
  
      wait_torrent(LNode, LTorrentID),
      wait_progress(LNode, LTorrentID, 50),
      io:format("50% were downloaded.~n", []),
  
      true = is_fast_peer(CNode, CPeerPid),
      io:format("Using fast protocol.~n", []),
  
  
      choke_in_the_middle(CNode, CPeerPid),
      io:format("Leecher choked.~n", []),
  
      %% Let the leacher to download the torrent from SNode.
      rpc:call(SNode, etorrent_peer_control, unchoke, [SPeerPid]),
  
      receive
  	{Ref, done} -> ok
  