anchor.diff:              ?ct_fail("unknown function ~p:~p/~p~n", [Module, Func, Arity])
       end.
   
  --spec collect_unknown_type_infos/2 :: (list(type_name()), #parse_state{}) -> #parse_state{}.
  -collect_unknown_type_infos(UnknownTypes, ParseState) ->
  +-spec collect_unknown_type_infos/3 :: (list(type_name()), #parse_state{}, non_neg_integer()) -> #parse_state{}.
  +collect_unknown_type_infos(UnknownTypes, ParseState, 0) ->
  +    ct:pal("warning still looking for unknown types: ~p~n", [tester_parse_state:get_unknown_types(ParseState)]),
  +    collect_unknown_type_infos(UnknownTypes, ParseState, 100);
  +collect_unknown_type_infos(UnknownTypes, ParseState, Counter) ->
       ParseState2 = tester_parse_state:reset_unknown_types(ParseState),
       ParseState3 = lists:foldl(fun ({type, Module, TypeName}, InnerParseState) ->
                                           collect_type_info(Module, TypeName, InnerParseState)
  
positive.code:         [] ->
              ParseState2;
          UnknownTypes ->
              collect_unknown_type_infos(UnknownTypes, ParseState2)
      end,
      case tester_parse_state:lookup_type({'fun', Module, Func, Arity}, ParseState3) of
          {value, _} ->
  
negative.code:     {binary, ParseState};
  parse_type({type, _Line, pid, []}, _Module, ParseState) ->
      {pid, ParseState};
  parse_type({type, _Line, tid, []}, _Module, ParseState) ->
      {tid, ParseState};
  parse_type({type, _Line, port, []}, _Module, ParseState) ->
      {port, ParseState};
  parse_type({type, _Line, float, []}, _Module, ParseState) ->
  