Skip site navigation (1)Skip section navigation (2)

FreeBSD Man Pages

Man Page or Keyword Search:
Man Architecture
Apropos Keyword Search (all sections) Output format
home | help
ct(3)			   Erlang Module Definition			 ct(3)

NAME
       ct - Main user interface	for the	Common Test framework.

DESCRIPTION
       Main user interface for the Common Test framework.

       This module implements the command line interface for running tests and
       some basic functions for	common test case issues	such as	 configuration
       and logging.

       Test Suite Support Macros

       The  config  macro  is  defined in ct.hrl. This macro should be used to
       retrieve	information from the Config variable sent to all  test	cases.
       It  is used with	two arguments, where the first is the name of the con-
       figuration variable you wish to retrieve, and the second	is the	Config
       variable	supplied to the	test case.

       Possible	configuration variables	include:

	 * data_dir - Data file	directory.

	 * priv_dir - Scratch file directory.

	 * Whatever  added  by	init_per_suite/1 or init_per_testcase/2	in the
	   test	suite.

DATA TYPES
	 handle() = handle() (see module ct_gen_conn) |	term():

	   The identity	of a specific connection.

	 target_name() = var_name():

	   The name of a target.

	 var_name() = atom():

	   A variable name which is specified  when  ct:require/2  is  called,
	   e.g.	ct:require(mynodename,{node,[telnet]})

EXPORTS
       abort_current_testcase(Reason) -> ok | {error, ErrorReason}

	      Types:

		 Reason	= term()
		 ErrorReason = no_testcase_running | parallel_group

	      When  calling  this  function, the currently executing test case
	      will be aborted. It is the user's	 responsibility	 to  know  for
	      sure  which  test	 case  is currently executing. The function is
	      therefore	only safe to call  from	 a  function  which  has  been
	      called (or synchronously invoked)	by the test case.

	      Reason, the reason for aborting the test case, is	printed	in the
	      test case	log.

       add_config(Callback, Config) -> ok | {error, Reason}

	      Types:

		 Callback = atom()
		 Config	= string()
		 Reason	= term()

	      This function loads  configuration  variables  using  the	 given
	      callback module and configuration	string.	Callback module	should
	      be either	loaded or present in the code part. Loaded  configura-
	      tion  variables can later	be removed using remove_config/2 func-
	      tion.

       break(Comment) -> ok | {error, Reason}

	      Types:

		 Comment = string()
		 Reason	= {multiple_cases_running, TestCases} |	'enable	 break
		 with release_shell option'
		 TestCases = [atom()]

	      This function will cancel	any active timetrap and	pause the exe-
	      cution of	the current test case until the	user  calls  the  con-
	      tinue/0  function. It gives the user the opportunity to interact
	      with the erlang node running the tests, e.g. for debugging  pur-
	      poses  or	 for  manually executing a part	of the test case. If a
	      parallel group is	executing, break/2 should be called instead.

	      A	cancelled timetrap will	not be automatically reactivated after
	      the break, but must be started exlicitly with ct:timetrap/1

	      In  order	 for  the break/continue functionality to work,	Common
	      Test must	release	the shell process controlling stdin.  This  is
	      done  by setting the release_shell start option to true. See the
	      User's Guide for more information.

       break(TestCase, Comment)	-> ok |	{error,	Reason}

	      Types:

		 TestCase = atom()
		 Comment = string()
		 Reason	=  'test  case	not  running'  |  'enable  break  with
		 release_shell option'

	      This  function  works the	same way as break/1, only the TestCase
	      argument makes it	possible to pause a test case executing	 in  a
	      parallel group. The continue/1 function should be	used to	resume
	      execution	of TestCase.

	      See break/1 for more details.

       capture_get() ->	ListOfStrings

	      Types:

		 ListOfStrings = [string()]

	      Equivalent to capture_get([default]).

       capture_get(ExclCategories) -> ListOfStrings

	      Types:

		 ExclCategories	= [atom()]
		 ListOfStrings = [string()]

	      Return and purge the list	of text	strings	 buffered  during  the
	      latest  session of capturing printouts to	stdout.	With ExclCate-
	      gories it's possible to specify log categories  that  should  be
	      ignored  in  ListOfStrings. If ExclCategories = [], no filtering
	      takes place.

	      See also:	capture_start/0, capture_stop/0, log/3.

       capture_start() -> ok

	      Start capturing all text strings printed to stdout during	execu-
	      tion of the test case.

	      See also:	capture_get/1, capture_stop/0.

       capture_stop() -> ok

	      Stop  capturing  text  strings  (a  session  started  with  cap-
	      ture_start/0).

	      See also:	capture_get/1, capture_start/0.

       comment(Comment)	-> void()

	      Types:

		 Comment = term()

	      Print the	given Comment in the comment field in the table	on the
	      test suite result	page.

	      If  called  several times, only the last comment is printed. The
	      test case	return value {comment,Comment} overwrites  the	string
	      set by this function.

       comment(Format, Args) ->	void()

	      Types:

		 Format	= string()
		 Args =	list()

	      Print  the formatted string in the comment field in the table on
	      the test suite result page.

	      The Format and Args arguments are	used in	 call  to  io_lib:for-
	      mat/2  in	 order	to create the comment string. The behaviour of
	      comment/2	is otherwise the same as the comment/1	function  (see
	      above for	details).

       continue() -> ok

	      This  function  must be called in	order to continue after	a test
	      case (not	executing in a parallel	group) has called break/1.

       continue(TestCase) -> ok

	      Types:

		 TestCase = atom()

	      This function must be called in order to continue	after  a  test
	      case has called break/2. If the paused test case,	TestCase, exe-
	      cutes in a parallel group, this  function	 -  rather  than  con-
	      tinue/0 -	must be	used in	order to let the test case proceed.

       decrypt_config_file(EncryptFileName,  TargetFileName)  ->  ok | {error,
       Reason}

	      Types:

		 EncryptFileName = string()
		 TargetFileName	= string()
		 Reason	= term()

	      This function  decrypts  EncryptFileName,	 previously  generated
	      with  encrypt_config_file/2/3.  The  original  file  contents is
	      saved in the target file.	The encryption key, a string, must  be
	      available	 in  a text file named .ct_config.crypt	in the current
	      directory, or the	home directory of the user (it is searched for
	      in that order).

       decrypt_config_file(EncryptFileName, TargetFileName, KeyOrFile) -> ok |
       {error, Reason}

	      Types:

		 EncryptFileName = string()
		 TargetFileName	= string()
		 KeyOrFile = {key, string()} | {file, string()}
		 Reason	= term()

	      This function  decrypts  EncryptFileName,	 previously  generated
	      with  encrypt_config_file/2/3.  The  original  file  contents is
	      saved in the target file.	The key	must have the the  same	 value
	      as that used for encryption.

       encrypt_config_file(SrcFileName,	 EncryptFileName) -> ok	| {error, Rea-
       son}

	      Types:

		 SrcFileName = string()
		 EncryptFileName = string()
		 Reason	= term()

	      This function encrypts the source	 config	 file  with  DES3  and
	      saves  the  result  in  file EncryptFileName. The	key, a string,
	      must be available	in a text file named .ct_config.crypt  in  the
	      current  directory,  or  the  home  directory of the user	(it is
	      searched for in that order).

	      See the Common Test User's Guide	for  information  about	 using
	      encrypted	config files when running tests.

	      See   the	  crypto  application  for  details  on	 DES3  encryp-
	      tion/decryption.

       encrypt_config_file(SrcFileName,	EncryptFileName, KeyOrFile)  ->	 ok  |
       {error, Reason}

	      Types:

		 SrcFileName = string()
		 EncryptFileName = string()
		 KeyOrFile = {key, string()} | {file, string()}
		 Reason	= term()

	      This  function  encrypts	the  source  config file with DES3 and
	      saves the	result in the target file EncryptFileName. The encryp-
	      tion  key	 to  use is either the value in	{key,Key} or the value
	      stored in	the file specified by {file,File}.

	      See the Common Test User's Guide	for  information  about	 using
	      encrypted	config files when running tests.

	      See   the	  crypto  application  for  details  on	 DES3  encryp-
	      tion/decryption.

       fail(Reason) -> void()

	      Types:

		 Reason	= term()

	      Terminate	a test case with the given error Reason.

       fail(Format, Args) -> void()

	      Types:

		 Format	= string()
		 Args =	list()

	      Terminate	a test case with an error message specified by a  for-
	      mat   string  and	 a  list  of  values  (used  as	 arguments  to
	      io_lib:format/2).

       get_config(Required) -> Value

	      Equivalent to get_config(Required, undefined, []).

       get_config(Required, Default) ->	Value

	      Equivalent to get_config(Required, Default, []).

       get_config(Required, Default, Opts) -> ValueOrElement

	      Types:

		 Required = KeyOrName |	{KeyOrName, SubKey} | {KeyOrName, Sub-
		 Key, SubKey}
		 KeyOrName = atom()
		 SubKey	= atom()
		 Default = term()
		 Opts =	[Opt] |	[]
		 Opt = element | all
		 ValueOrElement	= term() | Default

	      Read config data values.

	      This  function  returns  the  matching  value(s)	or config ele-
	      ment(s), given a config variable key or its associated name  (if
	      one has been specified with require/2 or a require statement).

	      Example, given the following config file:

		 {unix,[{telnet,IpAddr},
			{user,[{username,Username},
			       {password,Password}]}]}.

	      ct:get_config(unix,Default)  -_ [{telnet,IpAddr},	{user, [{user-
	      name,Username}, {password,Password}]}]
	      ct:get_config({unix,telnet},Default) -_ IpAddr
	      ct:get_config({unix,user,username},Default) -_ Username
	      ct:get_config({unix,ftp},Default)	-_ Default
	      ct:get_config(unknownkey,Default)	-_ Default

	      If a config variable key has been	associated  with  a  name  (by
	      means of require/2 or a require statement), the name may be used
	      instead of the key to read the value:

	      ct:require(myuser,{unix,user}) -_	ok.
	      ct:get_config(myuser,Default)  -_	 [{username,Username},	{pass-
	      word,Password}]

	      If  a  config variable is	defined	in multiple files and you want
	      to access	all possible values, use the all  option.  The	values
	      will  be returned	in a list and the order	of the elements	corre-
	      sponds to	the order that the  config  files  were	 specified  at
	      startup.

	      If  you  want  config  elements  (key-value  tuples) returned as
	      result instead of	values,	use the	element	option.	 The  returned
	      elements will then be on the form	{Required,Value}

	      See also:	get_config/1, get_config/2, require/1, require/2.

       get_event_mgr_ref() -> EvMgrRef

	      Types:

		 EvMgrRef = atom()

	      Call  this  function in order to get a reference to the CT event
	      manager. The reference can be used to e.g. add a	user  specific
	      event    handler	  while	   tests    are	   running.   Example:
	      gen_event:add_handler(ct:get_event_mgr_ref(), my_ev_h, [])

       get_status() -> TestStatus | {error, Reason} | no_tests_running

	      Types:

		 TestStatus = [StatusElem]
		 StatusElem = {current,	TestCaseInfo} |	{successful,  Success-
		 ful} |	{failed, Failed} | {skipped, Skipped} |	{total,	Total}
		 TestCaseInfo =	{Suite,	TestCase} | [{Suite, TestCase}]
		 Suite = atom()
		 TestCase = atom()
		 Successful = integer()
		 Failed	= integer()
		 Skipped = {UserSkipped, AutoSkipped}
		 UserSkipped = integer()
		 AutoSkipped = integer()
		 Total = integer()
		 Reason	= term()

	      Returns status of	ongoing	test. The returned list	contains  info
	      about  which  test  case is currently executing (a list of cases
	      when a parallel test case	group is executing), as	well as	 coun-
	      ters  for	 successful,  failed, skipped, and total test cases so
	      far.

       get_target_name(Handle) -> {ok, TargetName} | {error, Reason}

	      Types:

		 Handle	= handle()
		 TargetName = target_name()

	      Return the name of the target that the given connection  belongs
	      to.

       get_timetrap_info() -> {Time, Scale}

	      Types:

		 Time =	integer() | infinity
		 Scale = true |	false

	      Read  info  about	 the  timetrap	set for	the current test case.
	      Scale indicates if Common	Test  will  attempt  to	 automatically
	      compensate timetraps for runtime delays introduced by e.g. tools
	      like cover.

       install(Opts) ->	ok | {error, Reason}

	      Types:

		 Opts =	[Opt]
		 Opt = {config,	 ConfigFiles}  |  {event_handler,  Modules}  |
		 {decrypt, KeyOrFile}
		 ConfigFiles = [ConfigFile]
		 ConfigFile = string()
		 Modules = [atom()]
		 KeyOrFile = {key, Key}	| {file, KeyFile}
		 Key = string()
		 KeyFile = string()

	      Install config files and event handlers.

	      Run this function	once before first test.

	      Example:
	      install([{config,["config_node.ctc","config_user.ctc"]}]).

	      Note  that this function is automatically	run by the ct_run pro-
	      gram.

       listenv(Telnet) -> [Env]

	      Types:

		 Telnet	= term()
		 Env = {Key, Value}
		 Key = string()
		 Value = string()

	      Performs the listenv command on the given	telnet connection  and
	      returns the result as a list of Key-Value	pairs.

       log(Format) -> ok

	      Equivalent to log(default, 50, Format, []).

       log(X1, X2) -> ok

	      Types:

		 X1 = Category | Importance | Format
		 X2 = Format | Args

	      Equivalent to log(Category, Importance, Format, Args).

       log(X1, X2, X3) -> ok

	      Types:

		 X1 = Category | Importance
		 X2 = Importance | Format
		 X3 = Format | Args

	      Equivalent to log(Category, Importance, Format, Args).

       log(Category, Importance, Format, Args) -> ok

	      Types:

		 Category = atom()
		 Importance = integer()
		 Format	= string()
		 Args =	list()

	      Printout from a test case	to the log file.

	      This  function  is  meant	 for printing a	string directly	from a
	      test case	to the test case log file.

	      Default Category is default, default Importance  is  ?STD_IMPOR-
	      TANCE, and default value for Args	is [].

	      Please  see  the User's Guide for	details	on Category and	Impor-
	      tance.

       make_priv_dir() -> ok | {error, Reason}

	      Types:

		 Reason	= term()

	      If the test has been started with	the create_priv_dir option set
	      to  manual_per_tc, in order for the test case to use the private
	      directory, it must first create it by calling this function.

       notify(Name, Data) -> ok

	      Types:

		 Name =	atom()
		 Data =	term()

	      Sends a asynchronous notification	of type	Name with  Datato  the
	      common_test  event  manager.  This  can  later  be caught	by any
	      installed	event manager.

	      See also:	gen_event(3).

       pal(Format) -> ok

	      Equivalent to pal(default, 50, Format, []).

       pal(X1, X2) -> ok

	      Types:

		 X1 = Category | Importance | Format
		 X2 = Format | Args

	      Equivalent to pal(Category, Importance, Format, Args).

       pal(X1, X2, X3) -> ok

	      Types:

		 X1 = Category | Importance
		 X2 = Importance | Format
		 X3 = Format | Args

	      Equivalent to pal(Category, Importance, Format, Args).

       pal(Category, Importance, Format, Args) -> ok

	      Types:

		 Category = atom()
		 Importance = integer()
		 Format	= string()
		 Args =	list()

	      Print and	log from a test	case.

	      This function is meant for printing a string from	a  test	 case,
	      both to the test case log	file and to the	console.

	      Default  Category	 is default, default Importance	is ?STD_IMPOR-
	      TANCE, and default value for Args	is [].

	      Please see the User's Guide for details on Category  and	Impor-
	      tance.

       parse_table(Data) -> {Heading, Table}

	      Types:

		 Data =	[string()]
		 Heading = tuple()
		 Table = [tuple()]

	      Parse  the  printout  from  an  SQL  table  and return a list of
	      tuples.

	      The printout to parse would typically be the result of a	select
	      command  in  SQL.	 The returned Table is a list of tuples, where
	      each tuple is a row in the table.

	      Heading is a tuple of strings representing the headings of  each
	      column in	the table.

       print(Format) ->	ok

	      Equivalent to print(default, 50, Format, []).

       print(X1, X2) ->	ok

	      Types:

		 X1 = Category | Importance | Format
		 X2 = Format | Args

	      Equivalent to print(Category, Importance,	Format,	Args).

       print(X1, X2, X3) -> ok

	      Types:

		 X1 = Category | Importance
		 X2 = Importance | Format
		 X3 = Format | Args

	      Equivalent to print(Category, Importance,	Format,	Args).

       print(Category, Importance, Format, Args) -> ok

	      Types:

		 Category = atom()
		 Importance = integer()
		 Format	= string()
		 Args =	list()

	      Printout from a test case	to the console.

	      This function is meant for printing a string from	a test case to
	      the console.

	      Default Category is default, default Importance  is  ?STD_IMPOR-
	      TANCE, and default value for Args	is [].

	      Please  see  the User's Guide for	details	on Category and	Impor-
	      tance.

       reload_config(Required) -> ValueOrElement

	      Types:

		 Required = KeyOrName |	{KeyOrName, SubKey} | {KeyOrName, Sub-
		 Key, SubKey}
		 KeyOrName = atom()
		 SubKey	= atom()
		 ValueOrElement	= term()

	      Reload config file which contains	specified configuration	key.

	      This  function  performs updating	of the configuration data from
	      which the	given configuration variable was read, and returns the
	      (possibly) new value of this variable.

	      Note  that  if  some variables were present in the configuration
	      but are not loaded using this function,  they  will  be  removed
	      from the configuration table together with their aliases.

       remove_config(Callback, Config) -> ok

	      Types:

		 Callback = atom()
		 Config	= string()
		 Reason	= term()

	      This  function  removes  configuration  variables	(together with
	      their aliases) which were	loaded with specified callback	module
	      and configuration	string.

       require(Required) -> ok | {error, Reason}

	      Types:

		 Required = Key	| {Key,	SubKeys} | {Key, SubKey, SubKeys}
		 Key = atom()
		 SubKeys = SubKey | [SubKey]
		 SubKey	= atom()

	      Check if the required configuration is available.	It is possible
	      to specify arbitrarily deep tuples as Required. Note that	it  is
	      only  the	 last element of the tuple which can be	a list of Sub-
	      Keys.

	      Example 1: require the variable myvar:

	      ok = ct:require(myvar).

	      In this case the config file must	at least contain:

	      {myvar,Value}.

	      Example 2: require the key myvar with subkeys sub1 and sub2:

	      ok = ct:require({myvar,[sub1,sub2]}).

	      In this case the config file must	at least contain:

	      {myvar,[{sub1,Value},{sub2,Value}]}.

	      Example 3: require the key myvar with subkey sub1	with subsub1:

	      ok = ct:require({myvar,sub1,sub2}).

	      In this case the config file must	at least contain:

	      {myvar,[{sub1,[{sub2,Value}]}]}.

	      See also:	get_config/1, get_config/2, get_config/3, require/2.

       require(Name, Required) -> ok | {error, Reason}

	      Types:

		 Name =	atom()
		 Required = Key	| {Key,	SubKey}	| {Key,	SubKey,	SubKey}
		 SubKey	= Key
		 Key = atom()

	      Check if the required configuration is available,	and give it  a
	      name.  The  semantics  for Required is the same as in required/1
	      except that it is	not possible to	specify	a list of SubKeys.

	      If the requested data is available, the sub entry	will be	 asso-
	      ciated  with  Name  so that the value of the element can be read
	      with get_config/1,2 provided Name	instead	of the whole  Required
	      term.

	      Example:	Require	 one  node with	a telnet connection and	an ftp
	      connection. Name the node	a:

	      ok = ct:require(a,{machine,node}).

	      All references to	this node may then use the node	name. E.g. you
	      can fetch	a file over ftp	like this:

	      ok = ct:ftp_get(a,RemoteFile,LocalFile).

	      For this to work,	the config file	must at	least contain:

	      {machine,[{node,[{telnet,IpAddr},{ftp,IpAddr}]}]}.

	  Note:
	      The  behaviour of	this function changed radically	in common_test
	      1.6.2. In	order too keep	some  backwards	 compatability	it  is
	      still possible to	do:
	      ct:require(a,{node,[telnet,ftp]}).
	      This  will  associate  the name a	with the top level node	entry.
	      For this to work,	the config file	must at	least contain:
	      {node,[{telnet,IpAddr},{ftp,IpAddr}]}.

	      See also:	get_config/1, get_config/2, get_config/3, require/1.

       run(TestDirs) ->	Result

	      Types:

		 TestDirs = TestDir | [TestDir]

	      Run all test cases in all	suites in the given directories.

	      See also:	run/3.

       run(TestDir, Suite) -> Result

	      Run all test cases in the	given suite.

	      See also:	run/3.

       run(TestDir, Suite, Cases) -> Result

	      Types:

		 TestDir = string()
		 Suite = atom()
		 Cases = atom()	| [atom()]
		 Result	= [TestResult] | {error, Reason}

	      Run the given test case(s).

	      Requires that ct:install/1 has been run first.

	      Suites (*_SUITE.erl) files must be stored	in  TestDir  or	 Test-
	      Dir/test.	All suites will	be compiled when test is run.

       run_test(Opts) -> Result

	      Types:

		 Opts =	[OptTuples]
		 OptTuples  =  {dir,  TestDirs}	 |  {suite,  Suites} | {group,
		 Groups}  |  {testcase,	  Cases}   |   {spec,	TestSpecs}   |
		 {join_specs,  Bool}  |	 {label, Label}	| {config, CfgFiles} |
		 {userconfig,  UserConfig}  |	{allow_user_terms,   Bool}   |
		 {logdir, LogDir} | {silent_connections, Conns}	| {stylesheet,
		 CSSFile} | {cover,  CoverSpecFile}  |	{cover_stop,  Bool}  |
		 {step,	StepOpts} | {event_handler, EventHandlers} | {include,
		 InclDirs} | {auto_compile, Bool} |  {abort_if_missing_suites,
		 Bool}	|  {create_priv_dir,  CreatePrivDir} | {multiply_time-
		 traps,	M} | {scale_timetraps, Bool} | {repeat,	 N}  |	{dura-
		 tion,	DurTime} | {until, StopTime} | {force_stop, ForceStop}
		 | {decrypt,  DecryptKeyOrFile}	 |  {refresh_logs,  LogDir}  |
		 {logopts,  LogOpts}  |	 {verbosity,  VLevels}	| {basic_html,
		 Bool} | {ct_hooks, CTHs}  |  {enable_builtin_hooks,  Bool}  |
		 {release_shell, Bool}
		 TestDirs = [string()] | string()
		 Suites	= [string()] | [atom()]	| string() | atom()
		 Cases = [atom()] | atom()
		 Groups	= GroupNameOrPath | [GroupNameOrPath]
		 GroupNameOrPath = [atom()] | atom() | all
		 TestSpecs = [string()]	| string()
		 Label = string() | atom()
		 CfgFiles = [string()] | string()
		 UserConfig  =	[{CallbackMod,	CfgStrings}]  |	 {CallbackMod,
		 CfgStrings}
		 CallbackMod = atom()
		 CfgStrings = [string()] | string()
		 LogDir	= string()
		 Conns = all | [atom()]
		 CSSFile = string()
		 CoverSpecFile = string()
		 StepOpts = [StepOpt] |	[]
		 StepOpt = config | keep_inactive
		 EventHandlers = EH | [EH]
		 EH = atom() | {atom(),	InitArgs} | {[atom()], InitArgs}
		 InitArgs = [term()]
		 InclDirs = [string()] | string()
		 CreatePrivDir = auto_per_run |	auto_per_tc | manual_per_tc
		 M = integer()
		 N = integer()
		 DurTime = string(HHMMSS)
		 StopTime = string(YYMoMoDDHHMMSS) | string(HHMMSS)
		 ForceStop = skip_rest | Bool
		 DecryptKeyOrFile = {key, DecryptKey} |	{file, DecryptFile}
		 DecryptKey = string()
		 DecryptFile = string()
		 LogOpts = [LogOpt]
		 LogOpt	= no_nl	| no_src
		 VLevels = VLevel | [{Category,	VLevel}]
		 VLevel	= integer()
		 Category = atom()
		 CTHs =	[CTHModule | {CTHModule, CTHInitArgs}]
		 CTHModule = atom()
		 CTHInitArgs = term()
		 Result	= {Ok, Failed, {UserSkipped, AutoSkipped}} |  TestRun-
		 nerPid	| {error, Reason}
		 Ok = integer()
		 Failed	= integer()
		 UserSkipped = integer()
		 AutoSkipped = integer()
		 TestRunnerPid = pid()
		 Reason	= term()

	      Run  tests  as  specified	by the combination of options in Opts.
	      The options are the same as those	used with the ct_run  program.
	      Note  that here a	TestDir	can be used to point out the path to a
	      Suite. Note also that the	option	testcase  corresponds  to  the
	      -case  option  in	the ct_run program. Configuration files	speci-
	      fied in Opts will	be installed automatically at startup.

	      TestRunnerPid is returned	if release_shell == true (see  break/1
	      for details).

	      Reason indicates what type of error has been encountered.

       run_testspec(TestSpec) -> Result

	      Types:

		 TestSpec = [term()]
		 Result	 =  {Ok, Failed, {UserSkipped, AutoSkipped}} | {error,
		 Reason}
		 Ok = integer()
		 Failed	= integer()
		 UserSkipped = integer()
		 AutoSkipped = integer()
		 Reason	= term()

	      Run test specified by TestSpec. The terms	are the	same as	 those
	      used in test specification files.

	      Reason indicates what type of error has been encountered.

       sleep(Time) -> ok

	      Types:

		 Time  =  {hours, Hours} | {minutes, Mins} | {seconds, Secs} |
		 Millisecs | infinity
		 Hours = integer()
		 Mins =	integer()
		 Secs =	integer()
		 Millisecs = integer() | float()

	      This function, similar to	timer:sleep/1, suspends	the test  case
	      for  specified time. However, this function also multiplies Time
	      with the 'multiply_timetraps' value (if set) and	under  certain
	      circumstances   also   scales   up  the  time  automatically  if
	      'scale_timetraps'	is set to true (default	is false).

       start_interactive() -> ok

	      Start CT in interactive mode.

	      From this	mode all test case support functions can  be  executed
	      directly from the	erlang shell. The interactive mode can also be
	      started from the OS command line	with  ct_run  -shell  [-config
	      File...].

	      If  any  functions  using	"required config data" (e.g. telnet or
	      ftp functions) are to be called from the	erlang	shell,	config
	      data must	first be required with ct:require/2.

	      Example:
	      _	ct:require(unix_telnet,	unix).
	      ok
	      _	ct_telnet:open(unix_telnet).
	      {ok,_0.105.0_}
	      _	ct_telnet:cmd(unix_telnet, "ls .").
	      {ok,["ls","file1 ...",...]}

       step(TestDir, Suite, Case) -> Result

	      Types:

		 Case =	atom()

	      Step through a test case with the	debugger.

	      See also:	run/3.

       step(TestDir, Suite, Case, Opts)	-> Result

	      Types:

		 Case =	atom()
		 Opts =	[Opt] |	[]
		 Opt = config |	keep_inactive

	      Step through a test case with the	debugger. If the config	option
	      has been given, breakpoints will be set also on  the  configura-
	      tion functions in	Suite.

	      See also:	run/3.

       stop_interactive() -> ok

	      Exit the interactive mode.

	      See also:	start_interactive/0.

       sync_notify(Name, Data) -> ok

	      Types:

		 Name =	atom()
		 Data =	term()

	      Sends  a	synchronous  notification of type Name with Datato the
	      common_test event	manager. This  can  later  be  caught  by  any
	      installed	event manager.

	      See also:	gen_event(3).

       testcases(TestDir, Suite) -> Testcases |	{error,	Reason}

	      Types:

		 TestDir = string()
		 Suite = atom()
		 Testcases = list()
		 Reason	= term()

	      Returns all test cases in	the specified suite.

       timetrap(Time) -> ok

	      Types:

		 Time  =  {hours, Hours} | {minutes, Mins} | {seconds, Secs} |
		 Millisecs | infinity |	Func
		 Hours = integer()
		 Mins =	integer()
		 Secs =	integer()
		 Millisecs = integer() | float()
		 Func =	{M, F, A} | function()
		 M = atom()
		 F = atom()
		 A = list()

	      Use this function	to set a new timetrap  for  the	 running  test
	      case.  If	 the  argument is Func,	the timetrap will be triggered
	      when this	function returns. Func may  also  return  a  new  Time
	      value,  which  in	 that case will	be the value for the new time-
	      trap.

       userdata(TestDir, Suite)	-> SuiteUserData | {error, Reason}

	      Types:

		 TestDir = string()
		 Suite = atom()
		 SuiteUserData = [term()]
		 Reason	= term()

	      Returns any data specified with the tag userdata in the list  of
	      tuples returned from Suite:suite/0.

       userdata(TestDir,  Suite,  Case::GroupOrCase)  ->  TCUserData | {error,
       Reason}

	      Types:

		 TestDir = string()
		 Suite = atom()
		 GroupOrCase = {group, GroupName} | atom()
		 GroupName = atom()
		 TCUserData = [term()]
		 Reason	= term()

	      Returns any data specified with the tag userdata in the list  of
	      tuples returned from Suite:group(GroupName) or Suite:Case().

AUTHORS
       __

			       common_test 1.10				 ct(3)

NAME | DESCRIPTION | DATA TYPES | EXPORTS | AUTHORS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=ct&manpath=FreeBSD+10.3-RELEASE+and+Ports>

home | help