anchor.diff:           auth_test_oldnopwd/1,
            auth_test_pwderr/1,
            auth_test_nodb/1]).
  --export([conf_test_address_atom/1, conf_test_address_list/1,
  -         conf_test_address_binary/1, conf_test_address_err/1,
  -         conf_test_port_integer/1, conf_test_port_err/1,
  -         conf_test_user_atom/1, conf_test_user_list/1, conf_test_user_err/1,
  -         conf_test_password_atom/1, conf_test_password_list1/1, conf_test_password_list2/1,
  -         conf_test_password_binary1/1, conf_test_password_binary2/1, conf_test_password_err/1,
  -         conf_test_database_atom/1, conf_test_database_list1/1,
  -         conf_test_database_list2/1, conf_test_database_err/1,
  -         conf_test_default_character_set_integer/1,
  -         conf_test_default_character_set_err/1,
  -         conf_test_compress_boolean/1, conf_test_compress_err/1,
  -         conf_test_max_allowed_packet_integer/1,
  -         conf_test_max_allowed_packet_err/1,
  -         conf_test_timeout_integer/1, conf_test_timeout_atom/1, conf_test_timeout_err/1,
  -         conf_test_other/1]).
   
   %% == callback: ct ==
   
  
positive.code:             ct:fail(Reason)
      end.
  
  %% -- conf_* --
  
  conf_test_address_atom(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {address, ct:get_config(hostname)}
          ],
      try test(Config, L)
      catch
          _:Reason ->
              ct:fail(Reason)
      end.
  
  conf_test_address_list(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {address, atom_to_list(ct:get_config(hostname))}
          ],
      try test(Config, L)
      catch
          _:Reason ->
              ct:fail(Reason)
      end.
  
  conf_test_address_binary(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {address, atom_to_binary(ct:get_config(hostname),latin1)}
          ],
      try test(Config, L)
      catch
          _:Reason ->
              ct:fail(Reason)
      end.
  
  conf_test_address_err(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {address, <<>>}
          ],
      try test(Config, L) of
          _ ->
              ct:fail(ebadarg)
      catch
          _:_ ->
              ok
      end.
  
  conf_test_port_integer(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {port, 3306}
          ],
      try test(Config, L)
      catch
          _:Reason ->
              ct:fail(Reason)
      end.
  
  conf_test_port_err(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {port, nobody}
          ],
      try test(Config, L) of
          _ ->
              ct:fail(ebadarg)
      catch
          _:_ ->
              ok
      end.
  
  conf_test_user_atom(Config) ->
      L = [
           {user, test},
           {password, <<"test">>}
          ],
      try test(Config, L) of
          _ ->
              ct:fail(ebadarg)
      catch
          _:_ ->
              ok
      end.
  
  conf_test_user_list(Config) ->
      L = [
           {user, "test"},
           {password, <<"test">>}
          ],
      try test(Config, L)
      catch
          _:Reason ->
              ct:fail(Reason)
      end.
  
  conf_test_user_err(Config) ->
      L = [
           {user, nobody},
           {password, <<"test">>}
          ],
      try test(Config, L) of
          _ ->
              ct:fail(ebadarg)
      catch
          _:_ ->
              ok
      end.
  
  conf_test_password_atom(Config) ->
      L = [
           {user, <<"test">>},
           {password, test}
          ],
      try test(Config, L) of
          _ ->
              ct:fail(ebadarg)
      catch
          _:_ ->
              ok
      end.
  
  conf_test_password_list1(Config) ->
      L = [
           {user, <<"test">>},
           {password, "test"}
          ],
      try test(Config, L)
      catch
          _:Reason ->
              ct:fail(Reason)
      end.
  
  conf_test_password_list2(Config) ->
      L = [
           {user, <<"test_nopwd">>},
           {password, ""}
          ],
      try test(Config, L)
      catch
          _:Reason ->
              ct:fail(Reason)
      end.
  
  conf_test_password_binary1(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>}
          ],
      try test(Config, L)
      catch
          _:Reason ->
              ct:fail(Reason)
      end.
  
  conf_test_password_binary2(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"">>}
          ],
      try test(Config, L)
      catch
          _:Reason ->
              ct:fail(Reason)
      end.
  
  conf_test_password_err(Config) ->
      L = [
           {user, <<"test">>},
           {password, nobody}
          ],
      try test(Config, L) of
          _ ->
              ct:fail(ebadarg)
      catch
          _:_ ->
              ok
      end.
  
  conf_test_database_atom(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {database, binary_to_atom(get_env(database),latin1)}
          ],
      try test(Config, L) of
          _ ->
              ct:fail(ebadarg)
      catch
          _:_ ->
              ok
      end.
  
  conf_test_database_list1(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {database, binary_to_list(get_env(database))}
          ],
      try test(Config, L)
      catch
          _:Reason ->
              ct:fail(Reason)
      end.
  
  conf_test_database_list2(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {database, ""}
          ],
      try test(Config, L)
      catch
          _:Reason ->
              ct:fail(Reason)
      end.
  
  conf_test_database_err(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {database, nowhere}
          ],
      try test(Config, L) of
          _ ->
              ct:fail(ebadarg)
      catch
          _:_ ->
              ok
      end.
  
  conf_test_default_character_set_integer(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {default_character_set, ?CHARSET_utf8_bin}
          ],
      try test(Config, L)
      catch
          _:Reason ->
              ct:fail(Reason)
      end.
  
  conf_test_default_character_set_err(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {default_character_set, false}
          ],
      try test(Config, L) of
          _ ->
              ct:fail(ebadarg)
      catch
          _:_ ->
              ok
      end.
  
  conf_test_compress_boolean(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {compress, true}
          ],
      try test(Config, L)
      catch
          _:Reason ->
              ct:fail(Reason)
      end.
  
  conf_test_compress_err(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {compress, "false"}
          ],
      try test(Config, L) of
          _ ->
              ct:fail(ebadarg)
      catch
          _:_ ->
              ok
      end.
  
  conf_test_max_allowed_packet_integer(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {max_allowed_packet, 4096}
          ],
      try test(Config, L)
      catch
          _:Reason ->
              ct:fail(Reason)
      end.
  
  conf_test_max_allowed_packet_err(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {max_allowed_packet, nobody}
          ],
      try test(Config, L) of
          _ ->
              ct:fail(ebadarg)
      catch
          _:_ ->
              ok
      end.
  
  conf_test_timeout_integer(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {timeout, 10}
          ],
      try test(Config, L)
      catch
          _:Reason ->
              ct:fail(Reason)
      end.
  
  conf_test_timeout_atom(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {timeout, infinity}
          ],
      try test(Config, L)
      catch
          _:Reason ->
              ct:fail(Reason)
      end.
  
  conf_test_timeout_err(Config) ->
      L = [
           {user, <<"test">>},
           {password, <<"test">>},
           {timeout, nobody}
          ],
      try test(Config, L) of
          _ ->
              ct:fail(ebadarg)
      catch
          _:_ ->
              ok
      end.
  
  conf_test_other(Config) ->
      L = [
           {nobody, false}
          ],
      try test(Config, L) of
          _ ->
              ct:fail(ebadarg)
      catch
          _:_ ->
              ok
      end.
  
  %% == internal ==
  
  get_env(Key) ->
      {ok, L} = test(application, get_env, [myer,mysql_pool]),
      test(proplists, get_value, [Key,L]).
  
  set_env(List) ->
      baseline_ct:set_env(List).
  
negative.code:                               %% auth_test_oldnopwd
                                %% auth_test_pwderr
                                auth_test_nodb
                               ]}
              ].
  
  