anchor.diff:      {'EXIT',{undef,_}} = (catch Mod:b(10)),
       {'EXIT',{undef,_}} = (catch Mod:never()),
   
  +    code:purge(Mod),
  +    code:delete(Mod),
  +    code:purge(Mod),
       ok.
   
   on_load_update_code(Version) ->
  
positive.code:     {Mod,Code2} = on_load_update_code(2),
      {error,on_load_failure} = code:load_binary(Mod, "", Code2),
      42 = Mod:a(),
      100 = Mod:b(99),
      {'EXIT',{undef,_}} = (catch Mod:never()),
      4 = erlang:trace_pattern({Mod,'_','_'}, false),
  
  
negative.code: 	"-on_load(f/0).\n",
  	"f() -> ok.\n",
  	"c() -> 100.\n"]).
  
  %% Test -on_load while trace feature 'on_load' is enabled (OTP-14612)
  on_load_trace_on_load(Config) ->
      Papa = self(),
      Tracer = spawn_link(fun F() -> receive M -> Papa ! M end, F() end),
      {tracer,[]} = erlang:trace_info(self(),tracer),
      erlang:trace(self(), true, [call, {tracer, Tracer}]),
      erlang:trace_pattern(on_load, true, []),
      on_load_update(Config),
      erlang:trace_pattern(on_load, false, []),
      erlang:trace(self(), false, [call]),
  
      %% WE GET TRACES FOR CALLS TO UNDEFINED FUNCTIONS ???
      %% Remove filter when that is fixed.
      Ms = lists:filter(fun({trace,Papa,call,
                             {error_handler,undefined_function,
                              [on_load_update_code,_,_]}})
                           -> false;
                           (_) -> true
                        end,
                        flush()),
  
      [{trace, Papa, call, {on_load_update_code, a, []}},
       {trace, Papa, call, {on_load_update_code, b, [99]}},
       {trace, Papa, call, {on_load_update_code, c, []}}] = Ms,
  
      exit(Tracer, normal),
      ok.
  
  flush() ->
      receive M -> [M | flush()]
      after 100 -> []
      end.
  
  
  on_load_purge(_Config) ->
      Mod = ?FUNCTION_NAME,
  