1: %%
    2: %% %CopyrightBegin%
    3: %%
    4: %% Copyright Ericsson AB 1996-2013. All Rights Reserved.
    5: %%
    6: %% The contents of this file are subject to the Erlang Public License,
    7: %% Version 1.1, (the "License"); you may not use this file except in
    8: %% compliance with the License. You should have received a copy of the
    9: %% Erlang Public License along with this software. If not, it can be
   10: %% retrieved online at http://www.erlang.org/.
   11: %%
   12: %% Software distributed under the License is distributed on an "AS IS"
   13: %% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
   14: %% the License for the specific language governing rights and limitations
   15: %% under the License.
   16: %%
   17: %% %CopyrightEnd%
   18: %%
   19: -module(gen_event_SUITE).
   20: 
   21: -include_lib("test_server/include/test_server.hrl").
   22: 
   23: -export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
   24: 	 init_per_group/2,end_per_group/2]).
   25: -export([start/1, add_handler/1, add_sup_handler/1,
   26: 	 delete_handler/1, swap_handler/1, swap_sup_handler/1,
   27: 	 notify/1, sync_notify/1, call/1, info/1, hibernate/1,
   28: 	 call_format_status/1, call_format_status_anon/1,
   29:          error_format_status/1, get_state/1, replace_state/1]).
   30: 
   31: suite() -> [{ct_hooks,[ts_install_cth]}].
   32: 
   33: all() -> 
   34:     [start, {group, test_all}, hibernate,
   35:      call_format_status, call_format_status_anon, error_format_status,
   36:      get_state, replace_state].
   37: 
   38: groups() -> 
   39:     [{test_all, [],
   40:       [add_handler, add_sup_handler, delete_handler,
   41:        swap_handler, swap_sup_handler, notify, sync_notify,
   42:        call, info]}].
   43: 
   44: init_per_suite(Config) ->
   45:     Config.
   46: 
   47: end_per_suite(_Config) ->
   48:     ok.
   49: 
   50: init_per_group(_GroupName, Config) ->
   51:     Config.
   52: 
   53: end_per_group(_GroupName, Config) ->
   54:     Config.
   55: 
   56: 
   57: %% --------------------------------------
   58: %% Start an event manager.
   59: %% --------------------------------------
   60: 
   61: start(doc) -> [];
   62: start(suite) -> [];
   63: start(Config) when is_list(Config) ->
   64:     OldFl = process_flag(trap_exit, true),
   65: 
   66:     ?line dummy_via:reset(),
   67: 
   68:     ?line {ok, Pid0} = gen_event:start(), %anonymous
   69:     ?line [] = gen_event:which_handlers(Pid0),
   70:     ?line ok = gen_event:stop(Pid0),
   71: 
   72:     ?line {ok, Pid1} = gen_event:start_link(), %anonymous
   73:     ?line [] = gen_event:which_handlers(Pid1),
   74:     ?line ok = gen_event:stop(Pid1),
   75: 
   76:     ?line {ok, Pid2} = gen_event:start({local, my_dummy_name}),
   77:     ?line [] = gen_event:which_handlers(my_dummy_name),
   78:     ?line [] = gen_event:which_handlers(Pid2),
   79:     ?line ok = gen_event:stop(my_dummy_name),
   80: 
   81:     ?line {ok, Pid3} = gen_event:start_link({local, my_dummy_name}),
   82:     ?line [] = gen_event:which_handlers(my_dummy_name),
   83:     ?line [] = gen_event:which_handlers(Pid3),
   84:     ?line ok = gen_event:stop(my_dummy_name),
   85: 
   86:     ?line {ok, Pid4} = gen_event:start_link({global, my_dummy_name}),
   87:     ?line [] = gen_event:which_handlers({global, my_dummy_name}),
   88:     ?line [] = gen_event:which_handlers(Pid4),
   89:     ?line ok = gen_event:stop({global, my_dummy_name}),
   90: 
   91:     ?line {ok, Pid5} = gen_event:start_link({via, dummy_via, my_dummy_name}),
   92:     ?line [] = gen_event:which_handlers({via, dummy_via, my_dummy_name}),
   93:     ?line [] = gen_event:which_handlers(Pid5),
   94:     ?line ok = gen_event:stop({via, dummy_via, my_dummy_name}),
   95: 
   96:     ?line {ok, _} = gen_event:start_link({local, my_dummy_name}),
   97:     ?line {error, {already_started, _}} =
   98: 	gen_event:start_link({local, my_dummy_name}),
   99:     ?line {error, {already_started, _}} =
  100: 	gen_event:start({local, my_dummy_name}),
  101:     ?line ok = gen_event:stop(my_dummy_name),
  102: 
  103:     ?line {ok, Pid6} = gen_event:start_link({global, my_dummy_name}),
  104:     ?line {error, {already_started, _}} =
  105: 	gen_event:start_link({global, my_dummy_name}),
  106:     ?line {error, {already_started, _}} =
  107: 	gen_event:start({global, my_dummy_name}),
  108: 
  109:     exit(Pid6, shutdown),
  110:     receive
  111: 	{'EXIT', Pid6, shutdown} -> ok
  112:     after 10000 ->
  113: 	    ?t:fail(exit_gen_event)
  114:     end,
  115: 
  116:     ?line {ok, Pid7} = gen_event:start_link({via, dummy_via, my_dummy_name}),
  117:     ?line {error, {already_started, _}} =
  118: 	gen_event:start_link({via, dummy_via, my_dummy_name}),
  119:     ?line {error, {already_started, _}} =
  120: 	gen_event:start({via, dummy_via, my_dummy_name}),
  121: 
  122:     exit(Pid7, shutdown),
  123:     receive
  124: 	{'EXIT', Pid7, shutdown} -> ok
  125:     after 10000 ->
  126: 	    ?t:fail(exit_gen_event)
  127:     end,
  128: 
  129:     ?t:messages_get(),
  130:     process_flag(trap_exit, OldFl),
  131:     ok.
  132: 
  133: 
  134: hibernate(suite) -> [];
  135: hibernate(Config) when is_list(Config) ->
  136:     ?line {ok,Pid} = gen_event:start({local, my_dummy_handler}),
  137:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy_h, [self()]),
  138:     ?line [dummy_h] = gen_event:which_handlers(my_dummy_handler),
  139:     ?line true = gen_event:call(my_dummy_handler, dummy_h, hibernate),
  140:     ?line receive after 1000 -> ok end,
  141:     ?line {current_function,{erlang,hibernate,3}} = erlang:process_info(Pid,current_function),
  142:     ?line Pid ! wake,
  143:     ?line receive after 1000 -> ok end,
  144:     ?line true = ({current_function,{erlang,hibernate,3}} =/= 
  145: 		  erlang:process_info(Pid,current_function)),    
  146:     ?line later = gen_event:call(my_dummy_handler, dummy_h, hibernate_later),
  147:     ?line true = ({current_function,{erlang,hibernate,3}} =/= 
  148: 		  erlang:process_info(Pid,current_function)),    
  149:     ?line receive after 2000 -> ok end,
  150:     ?line {current_function,{erlang,hibernate,3}} = erlang:process_info(Pid,current_function),
  151:     ?line Pid ! wake,
  152:     ?line receive after 1000 -> ok end,
  153:     ?line true = ({current_function,{erlang,hibernate,3}} =/= 
  154: 		  erlang:process_info(Pid,current_function)),    
  155:     ?line gen_event:notify(my_dummy_handler,hibernate),
  156:     ?line receive after 1000 -> ok end,
  157:     ?line {current_function,{erlang,hibernate,3}} = erlang:process_info(Pid,current_function),
  158:     ?line gen_event:notify(my_dummy_handler,wakeup),
  159:     ?line receive after 1000 -> ok end,
  160:     ?line true = ({current_function,{erlang,hibernate,3}} =/= 
  161: 		  erlang:process_info(Pid,current_function)),    
  162:     ?line gen_event:notify(my_dummy_handler,hibernate),
  163:     ?line receive after 1000 -> ok end,
  164:     ?line {current_function,{erlang,hibernate,3}} = erlang:process_info(Pid,current_function),
  165:     ?line gen_event:sync_notify(my_dummy_handler,wakeup),
  166:     ?line true = ({current_function,{erlang,hibernate,3}} =/= 
  167: 		  erlang:process_info(Pid,current_function)),    
  168:     ?line ok = gen_event:sync_notify(my_dummy_handler,hibernate),
  169:     ?line receive after 1000 -> ok end,
  170:     ?line {current_function,{erlang,hibernate,3}} = erlang:process_info(Pid,current_function),
  171:     ?line Pid ! wake,
  172:     ?line receive after 1000 -> ok end,
  173:     ?line true = ({current_function,{erlang,hibernate,3}} =/= 
  174: 		  erlang:process_info(Pid,current_function)),
  175:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy1_h, [self()]),
  176:     ?line [_,_] = gen_event:which_handlers(my_dummy_handler),
  177:     ?line gen_event:notify(my_dummy_handler,hibernate),
  178:     ?line receive after 1000 -> ok end,
  179:     ?line {current_function,{erlang,hibernate,3}} = erlang:process_info(Pid,current_function),
  180:     ?line gen_event:notify(my_dummy_handler,wakeup),
  181:     ?line receive after 1000 -> ok end,
  182:     ?line {current_function,{erlang,hibernate,3}} = erlang:process_info(Pid,current_function),
  183:     ?line Pid ! wake,
  184:     ?line receive after 1000 -> ok end,
  185:     ?line true = ({current_function,{erlang,hibernate,3}} =/= 
  186: 		  erlang:process_info(Pid,current_function)),
  187:     ?line Pid ! gnurf,
  188:     ?line receive after 1000 -> ok end,
  189:     ?line {current_function,{erlang,hibernate,3}} = erlang:process_info(Pid,current_function),
  190:     ?line Pid ! sleep,
  191:     ?line receive after 1000 -> ok end,
  192:     ?line {current_function,{erlang,hibernate,3}} = erlang:process_info(Pid,current_function),
  193:     ?line Pid ! wake,
  194:     ?line receive after 1000 -> ok end,
  195:     ?line true = ({current_function,{erlang,hibernate,3}} =/= 
  196: 		  erlang:process_info(Pid,current_function)),
  197:     ?line ok = gen_event:stop(my_dummy_handler),
  198:     ?line {ok,Pid2} = gen_event:start({local, my_dummy_handler}),
  199:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy_h, [self(),hibernate]),
  200:     ?line receive after 1000 -> ok end,
  201:     ?line {current_function,{erlang,hibernate,3}} = erlang:process_info(Pid2,current_function),
  202:     ?line sys:suspend(my_dummy_handler),
  203:     ?line receive after 1000 -> ok end,
  204:     ?line {current_function,{erlang,hibernate,3}} = erlang:process_info(Pid2,current_function),
  205:     ?line sys:resume(my_dummy_handler),
  206:     ?line receive after 1000 -> ok end,
  207:     ?line {current_function,{erlang,hibernate,3}} = erlang:process_info(Pid2,current_function),
  208:     ?line Pid2 ! wake,
  209:     ?line receive after 1000 -> ok end,
  210:     ?line true = ({current_function,{erlang,hibernate,3}} =/= 
  211: 		  erlang:process_info(Pid2,current_function)),
  212:    
  213: 
  214:     ?line ok = gen_event:stop(my_dummy_handler),
  215: 
  216:     ok.
  217: 
  218: 
  219: 
  220: add_handler(doc) -> [];
  221: add_handler(suite) -> [];
  222: add_handler(Config) when is_list(Config) ->
  223:     ?line {ok,_} = gen_event:start({local, my_dummy_handler}),
  224:     ?line {error, my_error} =
  225: 	gen_event:add_handler(my_dummy_handler, dummy_h, make_error),
  226:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  227:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy_h, [self()]),
  228:     ?line [dummy_h] = gen_event:which_handlers(my_dummy_handler),
  229: 
  230:     ?line {error, my_error} =
  231: 	gen_event:add_handler(my_dummy_handler, {dummy_h, self()}, make_error),
  232:     ?line [dummy_h] = gen_event:which_handlers(my_dummy_handler),
  233:     ?line ok = gen_event:add_handler(my_dummy_handler, {dummy_h,self()},
  234: 				     [self()]),
  235:     Self = self(),
  236:     ?line [{dummy_h, Self}, dummy_h] =
  237: 	gen_event:which_handlers(my_dummy_handler),
  238:     ?line ok = gen_event:stop(my_dummy_handler),
  239:     ok.
  240: 
  241: add_sup_handler(doc) -> [];
  242: add_sup_handler(suite) -> [];
  243: add_sup_handler(Config) when is_list(Config) ->
  244:     ?line {ok,Pid} = gen_event:start({local, my_dummy_handler}),
  245:     ?line {error, my_error} =
  246: 	gen_event:add_sup_handler(my_dummy_handler, dummy_h, make_error),
  247:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  248:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, dummy_h, [self()]),
  249:     ?line [dummy_h] = gen_event:which_handlers(my_dummy_handler),
  250:     ?line exit(Pid, sup_died),
  251:     ?t:sleep(1000),
  252:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  253: 
  254:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, dummy_h, [self()]),
  255:     ?line [dummy_h] = gen_event:which_handlers(my_dummy_handler),
  256: 
  257:     ?line {error, my_error} =
  258: 	gen_event:add_handler(my_dummy_handler, {dummy_h, self()}, make_error),
  259:     ?line [dummy_h] = gen_event:which_handlers(my_dummy_handler),
  260:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, {dummy_h,self()},
  261: 					 [self()]),
  262:     Self = self(),
  263:     ?line [{dummy_h, Self}, dummy_h] =
  264: 	gen_event:which_handlers(my_dummy_handler),
  265:     ?line ok = gen_event:stop(my_dummy_handler),
  266: 
  267:     ?line receive
  268: 	      {gen_event_EXIT, dummy_h, shutdown} ->
  269: 		  ok
  270: 	  after 1000 ->
  271: 		  ?t:fail({no,{gen_event_EXIT, dummy_h, shutdown}})
  272: 	  end,
  273: 
  274:     ?line receive
  275: 	      {gen_event_EXIT, {dummy_h,Self}, shutdown} ->
  276: 		  ok
  277: 	  after 1000 ->
  278: 		  ?t:fail({no,{gen_event_EXIT, {dummy_h,Self},
  279: 					shutdown}})
  280: 	  end,
  281:     ok.
  282: 
  283: delete_handler(doc) -> [];
  284: delete_handler(suite) -> [];
  285: delete_handler(Config) when is_list(Config) ->
  286:     ?line {ok,_} = gen_event:start({local, my_dummy_handler}),
  287:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy_h, [self()]),
  288:     ?line {error, module_not_found} =
  289: 	gen_event:delete_handler(my_dummy_handler, duuuuuuuuumy, []),
  290:     ?line return_hej =
  291: 	gen_event:delete_handler(my_dummy_handler, dummy_h, return_hej),
  292:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  293:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy_h, [self()]),
  294:     ?line ok =
  295: 	gen_event:delete_handler(my_dummy_handler, dummy_h, []),
  296:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  297: 
  298:     ?line ok = gen_event:add_handler(my_dummy_handler, {dummy_h,1}, [self()]),
  299:     ?line ok = gen_event:add_handler(my_dummy_handler, {dummy_h,2}, [self()]),
  300:     ?line {error, module_not_found} =
  301: 	gen_event:delete_handler(my_dummy_handler, {duuuuuuuuumy,1}, []),
  302:     ?line return_hej =
  303: 	gen_event:delete_handler(my_dummy_handler, {dummy_h,1}, return_hej),
  304:     ?line return_hej =
  305: 	gen_event:delete_handler(my_dummy_handler, {dummy_h,2}, return_hej),
  306:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  307:     ?line ok = gen_event:add_handler(my_dummy_handler, {dummy_h,2}, [self()]),
  308:     ?line ok =
  309: 	gen_event:delete_handler(my_dummy_handler, {dummy_h,2}, []),
  310:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  311: 
  312:     ?line ok = gen_event:stop(my_dummy_handler),
  313:     ok.
  314: 
  315: swap_handler(doc) -> [];
  316: swap_handler(suite) -> [];
  317: swap_handler(Config) when is_list(Config) ->
  318:     ?line {ok,_} = gen_event:start({local, my_dummy_handler}),
  319:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy_h, [self()]),
  320:     ?line {error, non_existing} =
  321: 	gen_event:swap_handler(my_dummy_handler, {faulty_h, swap},
  322: 			       {dummy1_h, []}),
  323:     ?line ok =
  324: 	gen_event:swap_handler(my_dummy_handler, {dummy_h, swap},
  325: 			       {dummy1_h, swap}),
  326:     ?line [dummy1_h] = gen_event:which_handlers(my_dummy_handler),
  327: 
  328:     ?line ok = gen_event:delete_handler(my_dummy_handler, dummy1_h, []),
  329: 
  330:     ?line ok = gen_event:add_handler(my_dummy_handler, {dummy_h,3}, [self()]),
  331:     ?line {error, non_existing} =
  332: 	gen_event:swap_handler(my_dummy_handler, {faulty_h, swap},
  333: 			       {dummy1_h, []}),
  334:     ?line ok =
  335: 	gen_event:swap_handler(my_dummy_handler, {{dummy_h,3}, swap},
  336: 			       {{dummy1_h,4}, swap}),
  337:     ?line [{dummy1_h,4}] = gen_event:which_handlers(my_dummy_handler),
  338: 
  339:     ?line ok = gen_event:delete_handler(my_dummy_handler, {dummy1_h,4}, []),
  340: 
  341:     ?line ok = gen_event:stop(my_dummy_handler),
  342:     ok.
  343: 	
  344: swap_sup_handler(doc) -> [];
  345: swap_sup_handler(suite) -> [];
  346: swap_sup_handler(Config) when is_list(Config) ->
  347:     ?line {ok,_} = gen_event:start({local, my_dummy_handler}),
  348:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, dummy_h, [self()]),
  349:     ?line {error, non_existing} =
  350: 	gen_event:swap_handler(my_dummy_handler, {faulty_h, swap},
  351: 			       {dummy1_h, []}),
  352:     ?line ok =
  353: 	gen_event:swap_handler(my_dummy_handler, {dummy_h, swap},
  354: 			       {dummy1_h, swap}),
  355:     ?line [dummy1_h] = gen_event:which_handlers(my_dummy_handler),
  356: 
  357:     ?line ok = gen_event:delete_handler(my_dummy_handler, dummy1_h, []),
  358:     ?line receive
  359: 	      {gen_event_EXIT, dummy1_h, normal} ->
  360: 		  ok
  361: 	  after 1000 ->
  362: 		  ?t:fail({no,{gen_event_EXIT, dummy1_h, normal}})
  363: 	  end,
  364: 
  365:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, {dummy_h,3},
  366: 					 [self()]),
  367:     ?line {error, non_existing} =
  368: 	gen_event:swap_sup_handler(my_dummy_handler, {faulty_h, swap},
  369: 				   {dummy1_h, []}),
  370:     ?line ok =
  371: 	gen_event:swap_sup_handler(my_dummy_handler, {{dummy_h,3}, swap},
  372: 				   {{dummy1_h,4}, swap}),
  373:     ?line [{dummy1_h,4}] = gen_event:which_handlers(my_dummy_handler),
  374: 
  375:     ?line ok = gen_event:delete_handler(my_dummy_handler, {dummy1_h,4}, []),
  376:     ?line receive
  377: 	      {gen_event_EXIT, {dummy1_h,4}, normal} ->
  378: 		  ok
  379: 	  after 1000 ->
  380: 		  ?t:fail({no,{gen_event_EXIT, {dummy1_h,4}, normal}})
  381: 	  end,
  382: 
  383:     ?line ok = gen_event:stop(my_dummy_handler),
  384:     ok.
  385: 	
  386: notify(doc) -> [];
  387: notify(suite) -> [];
  388: notify(Config) when is_list(Config) ->
  389:     ?line {ok,_} = gen_event:start({local, my_dummy_handler}),
  390:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy_h, [self()]),
  391:     Event = {event, self()},
  392:     ?line [dummy_h] = gen_event:which_handlers(my_dummy_handler),
  393:     ?line ok = gen_event:notify(my_dummy_handler, Event),
  394:     ?line receive
  395: 	      {dummy_h, Event} ->
  396: 		  ok
  397: 	  end,
  398:     ?line ok = gen_event:notify(my_dummy_handler, {swap_event,dummy1_h,swap}),
  399:     ?t:sleep(1000),
  400:     ?line [dummy1_h] = gen_event:which_handlers(my_dummy_handler),
  401:     ?line ok = gen_event:notify(my_dummy_handler, Event),
  402:     ?line receive
  403: 	      {dummy1_h, Event} ->
  404: 		  ok
  405: 	  end,
  406:     ?line ok = gen_event:notify(my_dummy_handler, delete_event),
  407:     ?line receive
  408: 	      {dummy1_h, removed} ->
  409: 		  ok
  410: 	  end,
  411:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  412:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy_h, [self()]),
  413: 
  414:     ?line ok = gen_event:notify(my_dummy_handler, error_event),
  415:     ?line receive
  416: 	      {dummy_h, returned_error} ->
  417: 		  ok
  418: 	  end,
  419:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  420: 
  421:     %% Handler with id, {Mod,Id}
  422: 
  423:     ?line ok = gen_event:add_handler(my_dummy_handler, {dummy_h,5}, [self()]),
  424:     ?line [{dummy_h,5}] = gen_event:which_handlers(my_dummy_handler),
  425:     ?line ok = gen_event:notify(my_dummy_handler, Event),
  426:     ?line receive
  427: 	      {dummy_h, Event} ->
  428: 		  ok
  429: 	  end,
  430:     ?line ok = gen_event:notify(my_dummy_handler,
  431: 				{swap_event, {dummy1_h, 9}, swap}),
  432:     ?t:sleep(1000),
  433:     ?line [{dummy1_h,9}] = gen_event:which_handlers(my_dummy_handler),
  434:     ?line ok = gen_event:notify(my_dummy_handler, Event),
  435:     ?line receive
  436: 	      {dummy1_h, Event} ->
  437: 		  ok
  438: 	  end,
  439:     ?line ok = gen_event:notify(my_dummy_handler, delete_event),
  440:     ?line receive
  441: 	      {dummy1_h, removed} ->
  442: 		  ok
  443: 	  end,
  444:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  445:     ?line ok = gen_event:add_handler(my_dummy_handler, {dummy_h,a}, [self()]),
  446: 
  447:     ?line ok = gen_event:notify(my_dummy_handler, error_event),
  448:     ?line receive
  449: 	      {dummy_h, returned_error} ->
  450: 		  ok
  451: 	  end,
  452:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  453: 
  454:     %% Supervised handler.
  455: 
  456:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, dummy_h, [self()]),
  457:     ?line [dummy_h] = gen_event:which_handlers(my_dummy_handler),
  458:     ?line ok = gen_event:notify(my_dummy_handler, Event),
  459:     ?line receive
  460: 	      {dummy_h, Event} ->
  461: 		  ok
  462: 	  end,
  463: 
  464:     ?line ok = gen_event:notify(my_dummy_handler, do_crash),
  465:     ?line receive
  466: 	      {gen_event_EXIT, dummy_h, {'EXIT',_}} ->
  467: 		  ok
  468: 	  end,
  469: 
  470:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, dummy_h, [self()]),
  471:     ?line ok = gen_event:notify(my_dummy_handler, {swap_event,dummy1_h,swap}),
  472:     ?t:sleep(1000),
  473:     ?line [dummy1_h] = gen_event:which_handlers(my_dummy_handler),
  474: 
  475:     ?line ok = gen_event:notify(my_dummy_handler, do_crash),
  476:     ?line receive
  477: 	      {gen_event_EXIT, dummy1_h, {'EXIT',_}} ->
  478: 		  ok
  479: 	  end,
  480: 
  481:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, dummy_h, [self()]),
  482:     ?line ok = gen_event:notify(my_dummy_handler, {swap_event,dummy1_h,swap}),
  483:     ?t:sleep(1000),
  484:     ?line [dummy1_h] = gen_event:which_handlers(my_dummy_handler),
  485: 
  486:     ?line ok = gen_event:notify(my_dummy_handler, delete_event),
  487:     ?line receive
  488: 	      {dummy1_h, removed} ->
  489: 		  ok
  490: 	  end,
  491: 
  492:     ?line receive
  493: 	      {gen_event_EXIT, dummy1_h, normal} ->
  494: 		  ok
  495: 	  end,
  496: 
  497:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  498: 
  499:     ?line ok = gen_event:stop(my_dummy_handler),
  500:     ok.
  501: 
  502: sync_notify(doc) -> [];
  503: sync_notify(suite) -> [];
  504: sync_notify(Config) when is_list(Config) ->
  505:     ?line {ok,_} = gen_event:start({local, my_dummy_handler}),
  506:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy_h, [self()]),
  507:     Event = {event, self()},
  508:     ?line [dummy_h] = gen_event:which_handlers(my_dummy_handler),
  509:     ?line ok = gen_event:sync_notify(my_dummy_handler, Event),
  510:     ?line receive
  511: 	      {dummy_h, Event} ->
  512: 		  ok
  513: 	  end,
  514:     ?line ok = gen_event:sync_notify(my_dummy_handler,
  515: 				     {swap_event, dummy1_h, swap}),
  516:     ?t:sleep(1000),
  517:     ?line [dummy1_h] = gen_event:which_handlers(my_dummy_handler),
  518:     ?line ok = gen_event:sync_notify(my_dummy_handler, Event),
  519:     ?line receive
  520: 	      {dummy1_h, Event} ->
  521: 		  ok
  522: 	  end,
  523:     ?line ok = gen_event:sync_notify(my_dummy_handler, delete_event),
  524:     ?line receive
  525: 	      {dummy1_h, removed} ->
  526: 		  ok
  527: 	  end,
  528:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  529:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy_h, [self()]),
  530: 
  531:     ?line ok = gen_event:sync_notify(my_dummy_handler, error_event),
  532:     ?line receive
  533: 	      {dummy_h, returned_error} ->
  534: 		  ok
  535: 	  end,
  536:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  537: 
  538:     %% Handler with id, {Mod,Id}
  539: 
  540:     ?line ok = gen_event:add_handler(my_dummy_handler, {dummy_h,5}, [self()]),
  541:     ?line [{dummy_h,5}] = gen_event:which_handlers(my_dummy_handler),
  542:     ?line ok = gen_event:sync_notify(my_dummy_handler, Event),
  543:     ?line receive
  544: 	      {dummy_h, Event} ->
  545: 		  ok
  546: 	  end,
  547:     ?line ok = gen_event:sync_notify(my_dummy_handler,
  548: 				     {swap_event, {dummy1_h, 9}, swap}),
  549:     ?t:sleep(1000),
  550:     ?line [{dummy1_h,9}] = gen_event:which_handlers(my_dummy_handler),
  551:     ?line ok = gen_event:sync_notify(my_dummy_handler, Event),
  552:     ?line receive
  553: 	      {dummy1_h, Event} ->
  554: 		  ok
  555: 	  end,
  556:     ?line ok = gen_event:sync_notify(my_dummy_handler, delete_event),
  557:     ?line receive
  558: 	      {dummy1_h, removed} ->
  559: 		  ok
  560: 	  end,
  561:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  562:     ?line ok = gen_event:add_handler(my_dummy_handler, {dummy_h,a}, [self()]),
  563: 
  564:     ?line ok = gen_event:sync_notify(my_dummy_handler, error_event),
  565:     ?line receive
  566: 	      {dummy_h, returned_error} ->
  567: 		  ok
  568: 	  end,
  569:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  570: 
  571:     %% Supervised handler.
  572: 
  573:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, dummy_h, [self()]),
  574:     ?line [dummy_h] = gen_event:which_handlers(my_dummy_handler),
  575:     ?line ok = gen_event:sync_notify(my_dummy_handler, Event),
  576:     ?line receive
  577: 	      {dummy_h, Event} ->
  578: 		  ok
  579: 	  end,
  580: 
  581:     ?line ok = gen_event:sync_notify(my_dummy_handler, do_crash),
  582:     ?line receive
  583: 	      {gen_event_EXIT, dummy_h, {'EXIT',_}} ->
  584: 		  ok
  585: 	  end,
  586: 
  587:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, dummy_h, [self()]),
  588:     ?line ok = gen_event:sync_notify(my_dummy_handler,
  589: 				     {swap_event,dummy1_h,swap}),
  590:     ?t:sleep(1000),
  591:     ?line [dummy1_h] = gen_event:which_handlers(my_dummy_handler),
  592: 
  593:     ?line ok = gen_event:sync_notify(my_dummy_handler, do_crash),
  594:     ?line receive
  595: 	      {gen_event_EXIT, dummy1_h, {'EXIT',_}} ->
  596: 		  ok
  597: 	  end,
  598: 
  599:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, dummy_h, [self()]),
  600:     ?line ok = gen_event:sync_notify(my_dummy_handler,
  601: 				     {swap_event,dummy1_h,swap}),
  602:     ?t:sleep(1000),
  603:     ?line [dummy1_h] = gen_event:which_handlers(my_dummy_handler),
  604: 
  605:     ?line ok = gen_event:sync_notify(my_dummy_handler, delete_event),
  606:     ?line receive
  607: 	      {dummy1_h, removed} ->
  608: 		  ok
  609: 	  end,
  610: 
  611:     ?line receive
  612: 	      {gen_event_EXIT, dummy1_h, normal} ->
  613: 		  ok
  614: 	  end,
  615: 
  616:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  617: 
  618:     ?line ok = gen_event:stop(my_dummy_handler),
  619:     ok.
  620: 
  621: call(doc) -> [];
  622: call(suite) -> [];
  623: call(Config) when is_list(Config) ->
  624:     ?line {ok,_} = gen_event:start({local, my_dummy_handler}),
  625:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy_h, [self()]),
  626:     ?line ok = gen_event:add_handler(my_dummy_handler, {dummy_h, 1}, [self()]),
  627:     ?line [{dummy_h, 1}, dummy_h] = gen_event:which_handlers(my_dummy_handler),
  628:     ?line {'EXIT',_} = (catch gen_event:call(non_exist, dummy_h, hejsan)),
  629:     ?line {error, bad_module} =
  630: 	gen_event:call(my_dummy_handler, bad_h, hejsan),
  631:     ?line {ok, hejhopp} = gen_event:call(my_dummy_handler, dummy_h, hejsan),
  632:     ?line {ok, hejhopp} = gen_event:call(my_dummy_handler, {dummy_h, 1},
  633: 					 hejsan),
  634:     ?line {ok, hejhopp} = gen_event:call(my_dummy_handler, dummy_h, hejsan,
  635: 					 10000),
  636:     ?line {'EXIT', {timeout, _}} =
  637: 	(catch gen_event:call(my_dummy_handler, dummy_h, hejsan, 0)),
  638:     flush(),
  639:     ?line ok = gen_event:delete_handler(my_dummy_handler, {dummy_h, 1}, []),
  640:     ?line {ok, swapped} = gen_event:call(my_dummy_handler, dummy_h,
  641: 					 {swap_call,dummy1_h,swap}),
  642:     ?line [dummy1_h] = gen_event:which_handlers(my_dummy_handler),
  643:     ?line {error, bad_module} =
  644: 	gen_event:call(my_dummy_handler, dummy_h, hejsan),
  645:     ?line ok = gen_event:call(my_dummy_handler, dummy1_h, delete_call),
  646:     ?line receive
  647: 	      {dummy1_h, removed} ->
  648: 		  ok
  649: 	  end,
  650:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  651:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy_h, [self()]),
  652: 
  653:     ?line {error, {return, faulty}} =
  654: 	gen_event:call(my_dummy_handler, dummy_h, error_call),
  655:     ?line receive
  656: 	      {dummy_h, returned_error} ->
  657: 		  ok
  658: 	  end,
  659:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  660:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy_h, [self()]),
  661: 
  662:     ?line {error, {'EXIT', _}} =
  663: 	gen_event:call(my_dummy_handler, dummy_h, exit_call),
  664: 
  665:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  666: 
  667:     %% Handler with id, {Mod,Id}
  668: 
  669:     ?line ok = gen_event:add_handler(my_dummy_handler, {dummy_h,1}, [self()]),
  670:     ?line [{dummy_h,1}] = gen_event:which_handlers(my_dummy_handler),
  671:     ?line {error, bad_module} =
  672: 	gen_event:call(my_dummy_handler, bad_h, hejsan),
  673:     ?line {ok, hejhopp} = gen_event:call(my_dummy_handler, {dummy_h,1},
  674: 					 hejsan),
  675:     ?line {ok, swapped} = gen_event:call(my_dummy_handler, {dummy_h,1},
  676: 					 {swap_call,{dummy1_h,2},swap}),
  677:     ?line [{dummy1_h,2}] = gen_event:which_handlers(my_dummy_handler),
  678:     ?line {error, bad_module} =
  679: 	gen_event:call(my_dummy_handler, dummy_h, hejsan),
  680:     ?line ok = gen_event:call(my_dummy_handler, {dummy1_h,2}, delete_call),
  681:     ?line receive
  682: 	      {dummy1_h, removed} ->
  683: 		  ok
  684: 	  end,
  685:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  686:     ?line ok = gen_event:add_handler(my_dummy_handler, {dummy_h,3}, [self()]),
  687: 
  688:     ?line {error, {return, faulty}} =
  689: 	gen_event:call(my_dummy_handler, {dummy_h,3}, error_call),
  690:     ?line receive
  691: 	      {dummy_h, returned_error} ->
  692: 		  ok
  693: 	  end,
  694:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  695:     ?line ok = gen_event:add_handler(my_dummy_handler, {dummy_h,4}, [self()]),
  696: 
  697:     ?line {error, {'EXIT', _}} =
  698: 	gen_event:call(my_dummy_handler, {dummy_h,4}, exit_call),
  699: 
  700:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  701: 
  702:     %% Supervised handler.
  703: 
  704:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, dummy_h, [self()]),
  705:     ?line [dummy_h] = gen_event:which_handlers(my_dummy_handler),
  706:     ?line {error, bad_module} =
  707: 	gen_event:call(my_dummy_handler, bad_h, hejsan),
  708:     ?line {ok, hejhopp} = gen_event:call(my_dummy_handler, dummy_h, hejsan),
  709:     ?line {ok, swapped} = gen_event:call(my_dummy_handler, dummy_h,
  710: 					 {swap_call,dummy1_h,swap}),
  711:     ?line [dummy1_h] = gen_event:which_handlers(my_dummy_handler),
  712:     ?line {error, bad_module} =
  713: 	gen_event:call(my_dummy_handler, dummy_h, hejsan),
  714:     ?line ok = gen_event:call(my_dummy_handler, dummy1_h, delete_call),
  715:     ?line receive
  716: 	      {dummy1_h, removed} ->
  717: 		  ok
  718: 	  end,
  719: 
  720:     ?line receive
  721: 	      {gen_event_EXIT, dummy1_h, normal} ->
  722: 		  ok
  723: 	  end,
  724: 
  725:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  726:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, dummy_h, [self()]),
  727: 
  728:     ?line {error, {return, faulty}} =
  729: 	gen_event:call(my_dummy_handler, dummy_h, error_call),
  730:     ?line receive
  731: 	      {dummy_h, returned_error} ->
  732: 		  ok
  733: 	  end,
  734: 
  735:     ?line receive
  736: 	      {gen_event_EXIT, dummy_h, {return,faulty}} ->
  737: 		  ok
  738: 	  after 1000 ->
  739: 		  ?t:fail({no, {gen_event_EXIT, dummy_h, {return,faulty}}})
  740: 	  end,
  741: 
  742:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  743:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, dummy_h, [self()]),
  744: 
  745:     ?line {error, {'EXIT', _}} =
  746: 	gen_event:call(my_dummy_handler, dummy_h, exit_call),
  747: 
  748:     ?line receive
  749: 	      {gen_event_EXIT, dummy_h, {'EXIT',_}} ->
  750: 		  ok
  751: 	  after 1000 ->
  752: 		  ?t:fail({no, {gen_event_EXIT, dummy_h, {'EXIT','_'}}})
  753: 	  end,
  754: 
  755:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  756: 
  757:     ?line ok = gen_event:stop(my_dummy_handler),
  758:     ok.
  759: 
  760: flush() ->
  761:     receive _ -> flush() after 0 -> ok end.
  762: 
  763: info(doc) -> [];
  764: info(suite) -> [];
  765: info(Config) when is_list(Config) ->
  766:     ?line {ok,_} = gen_event:start({local, my_dummy_handler}),
  767:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy_h, [self()]),
  768:     Info = {info, self()},
  769:     ?line [dummy_h] = gen_event:which_handlers(my_dummy_handler),
  770:     ?line my_dummy_handler ! Info,
  771:     ?line receive
  772: 	      {dummy_h, Info} ->
  773: 		  ok
  774: 	  end,
  775:     ?line my_dummy_handler ! {swap_info,dummy1_h,swap},
  776:     ?t:sleep(1000),
  777:     ?line [dummy1_h] = gen_event:which_handlers(my_dummy_handler),
  778:     ?line my_dummy_handler ! Info,
  779:     ?line receive
  780: 	      {dummy1_h, Info} ->
  781: 		  ok
  782: 	  end,
  783:     ?line my_dummy_handler ! delete_info,
  784:     ?line receive
  785: 	      {dummy1_h, removed} ->
  786: 		  ok
  787: 	  end,
  788:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  789:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy_h, [self()]),
  790: 
  791:     ?line my_dummy_handler ! error_info,
  792:     ?line receive
  793: 	      {dummy_h, returned_error} ->
  794: 		  ok
  795: 	  end,
  796:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  797: 
  798:     %% Handler with id, {Mod,Id}
  799: 
  800:     ?line ok = gen_event:add_handler(my_dummy_handler, {dummy_h,1}, [self()]),
  801:     ?line [{dummy_h,1}] = gen_event:which_handlers(my_dummy_handler),
  802:     ?line my_dummy_handler ! Info,
  803:     ?line receive
  804: 	      {dummy_h, Info} ->
  805: 		  ok
  806: 	  end,
  807:     ?line my_dummy_handler ! {swap_info,{dummy1_h,2},swap},
  808:     ?t:sleep(1000),
  809:     ?line [{dummy1_h,2}] = gen_event:which_handlers(my_dummy_handler),
  810:     ?line my_dummy_handler ! Info,
  811:     ?line receive
  812: 	      {dummy1_h, Info} ->
  813: 		  ok
  814: 	  end,
  815:     ?line my_dummy_handler ! delete_info,
  816:     ?line receive
  817: 	      {dummy1_h, removed} ->
  818: 		  ok
  819: 	  end,
  820:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  821:     ?line ok = gen_event:add_handler(my_dummy_handler, {dummy_h,3}, [self()]),
  822: 
  823:     ?line my_dummy_handler ! error_info,
  824:     ?line receive
  825: 	      {dummy_h, returned_error} ->
  826: 		  ok
  827: 	  end,
  828:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  829: 
  830:     %% Supervised handler
  831: 
  832:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, dummy_h, [self()]),
  833:     ?line [dummy_h] = gen_event:which_handlers(my_dummy_handler),
  834:     ?line my_dummy_handler ! Info,
  835:     ?line receive
  836: 	      {dummy_h, Info} ->
  837: 		  ok
  838: 	  end,
  839:     ?line my_dummy_handler ! {swap_info,dummy1_h,swap},
  840:     ?t:sleep(1000),
  841:     ?line [dummy1_h] = gen_event:which_handlers(my_dummy_handler),
  842:     ?line my_dummy_handler ! Info,
  843:     ?line receive
  844: 	      {dummy1_h, Info} ->
  845: 		  ok
  846: 	  end,
  847:     ?line my_dummy_handler ! delete_info,
  848:     ?line receive
  849: 	      {dummy1_h, removed} ->
  850: 		  ok
  851: 	  end,
  852: 
  853:     ?line receive
  854: 	      {gen_event_EXIT, dummy1_h, normal} ->
  855: 		  ok
  856: 	  after 1000 ->
  857: 		  ?t:fail({no, {gen_event_EXIT, dummy1_h, normal}})
  858: 	  end,
  859: 
  860:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  861: 
  862:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, dummy_h, [self()]),
  863: 
  864:     ?line my_dummy_handler ! error_info,
  865:     ?line receive
  866: 	      {dummy_h, returned_error} ->
  867: 		  ok
  868: 	  end,
  869: 
  870:     ?line receive
  871: 	      {gen_event_EXIT, dummy_h, {return,faulty}} ->
  872: 		  ok
  873: 	  after 1000 ->
  874: 		  ?t:fail({no, {gen_event_EXIT, dummy_h, {return,faulty}}})
  875: 	  end,
  876: 
  877:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, dummy_h, [self()]),
  878:     ?line my_dummy_handler ! do_crash,
  879: 
  880:     ?line receive
  881: 	      {gen_event_EXIT, dummy_h, {'EXIT',_}} ->
  882: 		  ok
  883: 	  after 1000 ->
  884: 		  ?t:fail({no, {gen_event_EXIT, dummy_h, {'EXIT','_'}}})
  885: 	  end,
  886: 
  887:     ?line [] = gen_event:which_handlers(my_dummy_handler),
  888: 
  889:     ?line ok = gen_event:stop(my_dummy_handler),
  890:     ok.
  891: 
  892: call_format_status(suite) ->
  893:     [];
  894: call_format_status(doc) ->
  895:     ["Test that sys:get_status/1,2 calls format_status/2"];
  896: call_format_status(Config) when is_list(Config) ->
  897:     ?line {ok, Pid} = gen_event:start({local, my_dummy_handler}),
  898:     %% State here intentionally differs from what we expect from format_status
  899:     State = self(),
  900:     FmtState = "dummy1_h handler state",
  901:     ?line ok = gen_event:add_handler(my_dummy_handler, dummy1_h, [State]),
  902:     ?line Status1 = sys:get_status(Pid),
  903:     ?line Status2 = sys:get_status(Pid, 5000),
  904:     ?line ok = gen_event:stop(Pid),
  905:     ?line {status, Pid, _, [_, _, Pid, [], Data1]} = Status1,
  906:     ?line HandlerInfo1 = proplists:get_value(items, Data1),
  907:     ?line {"Installed handlers", [{_,dummy1_h,_,FmtState,_}]} = HandlerInfo1,
  908:     ?line {status, Pid, _, [_, _, Pid, [], Data2]} = Status2,
  909:     ?line HandlerInfo2 = proplists:get_value(items, Data2),
  910:     ?line {"Installed handlers", [{_,dummy1_h,_,FmtState,_}]} = HandlerInfo2,
  911:     ok.
  912: 
  913: call_format_status_anon(suite) ->
  914:     [];
  915: call_format_status_anon(doc) ->
  916:     ["Test that sys:get_status/1,2 calls format_status/2 for anonymous gen_event processes"];
  917: call_format_status_anon(Config) when is_list(Config) ->
  918:     ?line {ok, Pid} = gen_event:start(),
  919:     %% The 'Name' of the gen_event process will be a pid() here, so
  920:     %% the next line will crash if format_status can't string-ify pids.
  921:     ?line Status1 = sys:get_status(Pid),
  922:     ?line ok = gen_event:stop(Pid),
  923:     Header = "Status for event handler " ++  pid_to_list(Pid),
  924:     ?line {status, Pid, _, [_, _, Pid, [], Data1]} = Status1,
  925:     ?line Header = proplists:get_value(header, Data1),
  926:     ok.
  927: 
  928: 
  929: error_format_status(suite) ->
  930:     [];
  931: error_format_status(doc) ->
  932:     ["Test that a handler error calls format_status/2"];
  933: error_format_status(Config) when is_list(Config) ->
  934:     ?line error_logger_forwarder:register(),
  935:     OldFl = process_flag(trap_exit, true),
  936:     State = self(),
  937:     ?line {ok, Pid} = gen_event:start({local, my_dummy_handler}),
  938:     ?line ok = gen_event:add_sup_handler(my_dummy_handler, dummy1_h, [State]),
  939:     ?line ok = gen_event:notify(my_dummy_handler, do_crash),
  940:     ?line receive
  941: 	      {gen_event_EXIT,dummy1_h,{'EXIT',_}} -> ok
  942: 	  after 5000 ->
  943: 		  ?t:fail(exit_gen_event)
  944: 	  end,
  945:     FmtState = "dummy1_h handler state",
  946:     receive
  947: 	{error,_GroupLeader, {Pid,
  948: 			      "** gen_event handler"++_,
  949: 			      [dummy1_h,my_dummy_handler,do_crash,
  950: 			       FmtState, _]}} ->
  951: 	    ok;
  952: 	Other ->
  953: 	    ?line io:format("Unexpected: ~p", [Other]),
  954: 	    ?line ?t:fail()
  955:     end,
  956:     ?t:messages_get(),
  957:     ?line ok = gen_event:stop(Pid),
  958:     process_flag(trap_exit, OldFl),
  959:     ok.
  960: 
  961: get_state(suite) ->
  962:     [];
  963: get_state(doc) ->
  964:     ["Test that sys:get_state/1,2 return the gen_event state"];
  965: get_state(Config) when is_list(Config) ->
  966:     {ok, Pid} = gen_event:start({local, my_dummy_handler}),
  967:     State1 = self(),
  968:     ok = gen_event:add_handler(my_dummy_handler, dummy1_h, [State1]),
  969:     [{dummy1_h,false,State1}] = sys:get_state(Pid),
  970:     [{dummy1_h,false,State1}] = sys:get_state(Pid, 5000),
  971:     State2 = {?MODULE, self()},
  972:     ok = gen_event:add_handler(my_dummy_handler, {dummy1_h,id}, [State2]),
  973:     Result1 = sys:get_state(Pid),
  974:     [{dummy1_h,false,State1},{dummy1_h,id,State2}] = lists:sort(Result1),
  975:     Result2 = sys:get_state(Pid, 5000),
  976:     [{dummy1_h,false,State1},{dummy1_h,id,State2}] = lists:sort(Result2),
  977:     ok = gen_event:stop(Pid),
  978:     ok.
  979: 
  980: replace_state(suite) ->
  981:     [];
  982: replace_state(doc) ->
  983:     ["Test that replace_state/2,3 replace the gen_event state"];
  984: replace_state(Config) when is_list(Config) ->
  985:     {ok, Pid} = gen_event:start({local, my_dummy_handler}),
  986:     State1 = self(),
  987:     ok = gen_event:add_handler(my_dummy_handler, dummy1_h, [State1]),
  988:     [{dummy1_h,false,State1}] = sys:get_state(Pid),
  989:     NState1 = "replaced",
  990:     Replace1 = fun({dummy1_h,false,_}=S) -> setelement(3,S,NState1) end,
  991:     [{dummy1_h,false,NState1}] = sys:replace_state(Pid, Replace1),
  992:     [{dummy1_h,false,NState1}] = sys:get_state(Pid),
  993:     NState2 = "replaced again",
  994:     Replace2 = fun({dummy1_h,false,_}=S) -> setelement(3,S,NState2) end,
  995:     [{dummy1_h,false,NState2}] = sys:replace_state(Pid, Replace2, 5000),
  996:     [{dummy1_h,false,NState2}] = sys:get_state(Pid),
  997:     %% verify no change in state if replace function crashes
  998:     Replace3 = fun(_) -> exit(fail) end,
  999:     [{dummy1_h,false,NState2}] = sys:replace_state(Pid, Replace3),
 1000:     [{dummy1_h,false,NState2}] = sys:get_state(Pid),
 1001:     ok.