| --- |
| Author: Zoltán Zsichla |
| Version: 7/198 17-CNL 113 512, Rev. E |
| Date: 2016-06-13 |
| |
| --- |
| = EPTF CLL LGenBase, User Guide |
| :author: Zoltán Zsichla |
| :revnumber: 7/198 17-CNL 113 512, Rev. E |
| :revdate: 2016-06-13 |
| :toc: |
| |
| == About This Document |
| |
| === How to Read This Document |
| |
| This is the User Guide for the LGenBase feature of the Ericsson Performance Test Framework (TitanSim), Core Library (CLL). CLL is developed for the TTCN-3 <<_1, [1]>> Toolset with TITAN <<_2, [2]>>. This document should be read together with the Function Description of the LGenBase feature <<_5, [5]>>. For more information on the CLL consult the User Guide <<_4, [4]>> and the Function Specification <<_3, [3]>> of the TitanSim. |
| |
| == System Requirements |
| |
| In order to use the LGenBase feature the system requirements listed in TitanSim CLL User Guide <<_4, [4]>> should be fulfilled. |
| |
| = LGenBase |
| |
| == Overview |
| |
| The EPTF CLL LGenBase component is a fundamental component providing an implementation for final state machine handling and traffic case management in a load test environment. |
| |
| Using Applibs based on LGenBase the users can easily configure and manage traffic tests. |
| |
| === Burst Calculation |
| |
| Burst calculation functions are used to adjust the rate, the load level to be achieved. For reaching the adequate rate we have to calculate the number of traffic/event to be started in a call generation event and the next call generation time. There are number of predefined burst calculating functions, but user can specify his own function too. The predefined burst functions are `orig`, `imst`, `imst2`, `cs` and `poisson`. The burst calculation methods then can be referred by their names or their indices. |
| |
| Burst calculating functions can be assigned to a traffic case or a weighted scenario in three ways: |
| |
| * First it can set via the initialization of LGenBase component. In this case all of the traffic cases can be set with the same burst calculation method. |
| |
| * The second way for setting burst calculation is via the declaration of a traffic case or weighted scenario. The parameter `scheduler` can be used to assign a burst calculation method to a traffic case. |
| |
| * Users can use the function `f_EPTF_LGenBase_setBurstCalcAlgByIdx()` or `f_EPTF_LGenBase_setBurstCalcAlgByName()` to assign a burst calc method to a traffic case or a weighted scenario. |
| |
| The original EPTF burst calculating function (orig) uses the following algorithm: |
| |
| The trivial formula `idealBurstSize=cpsToReach*cpsUpdateInterval` specifies the number new calls/traffic to be generated at every `(cpsUpdateInterval)`^th^ second. Call generation has two main input parameters that affect the resulting CPS value: `cpsToReach` and `cpsUpdateInterval`. However, the `cpsUpdateInterval` is subject to rouding errors in the scheduler. |
| |
| Therefore, when these values are set, the load generator calculates the parameter `roundedCpsUpdateInterval` as the nearest multiple of the elementary timestep greater than (or equal to) parameter `cpsUpdateInterval`. It calculates a burst size based on this rounded value and parameter `cpsToReach`. |
| |
| However, when the call generation event is scheduled - relative to the snapshot of the actual component timer - the scheduler also rounds the scheduling time to the elementary timestep. Thus the scheduled interval is usually longer than needed (quantization error). |
| |
| To prevent this issue, the actual interval used to schedule a call generation event is calculated by decreasing the rounded update interval with the elementary timestep multiplied by a float value greater than 0.0 and lower than 1.0. This float value gives the probability of accurate scheduling. In case of a multiplication factor of 0.99, 99% of scheduling will be accurate and the remaining 1% is scheduled later than needed. |
| |
| The IMST type burst calculation function (`imst`) uses the following algorithm for calculating the number of traffic/event to be started and the next call generation time: |
| |
| It wakes up every 10 millisec, this will be the next call generation time. At the start it sets `masterCounter` variable to `_0_`. The variable `moduloOperand` equals `_100*1000/rate_` where `_100_` is `OUR_RESOLUTION`, `_1000_` is `TICS_PER_INTERVAL` and rate is the rate to be achieved. Then it increases `masterCounter` variable by one. If `masterCounter` modulo `moduloOperand` equals `_0_` then one plus traffic should be started. It repeats the increase of mastercounter `_1000_` (`TICS_PER_INTERVAL`) times. |
| |
| [source] |
| ---- |
| OUR_RESOLUTION=100; |
| TICS_PER_INTERVAL=1000; |
| masterCounter=0; |
| moduloOperand=OUR_RESOLUTION*TICS_PER_INTERVAL/rate; |
| For(i=masterCounter;i< masterCounter+ TICS_PER_INTERVAL;i++) |
| { |
| If((i mod moduloOperand)==0); |
| { |
| trafficToStart=trafficToStart+1; |
| } |
| } |
| masterCounter=masterCounter+TICS_PER_INTERVAL; |
| ---- |
| |
| The IMST2 type burst calculation function (`imst2`) does the same as the IMST type algorithm a little bit simplified and faster way. |
| |
| The next call generation time is `_10_` millisec too. The variable `moduloOperand` is the same, it equals `OUR_RESOLUTION*TICS_PER_INTERVAL/rate`. The number of traffic should be started is the floor of (`masterCounter+TICS_PER_INTERVAL`) divided by `moduloOperand`. The new `masterCounter` equals (`masterCounter+TICS_PER_INTERVAL`) modulo `moduloOperand`. |
| |
| [source] |
| ---- |
| OUR_RESOLUTION=100; |
| TICS_PER_INTERVAL=1000; |
| masterCounter=0; |
| moduloOperand=OUR_RESOLUTION*TICS_PER_INTERVAL/rate; |
| trafficToStart= |
| int((masterCounter+TICS_PER_INTERVAL)/moduloOperand); |
| moduloOperand= |
| (masterCounter+TICS_PER_INTERVAL)mod moduloOperand |
| ---- |
| |
| === External Templates |
| |
| LGenBase supports loading and caching of parameterised text modules called external templates. LGenBase allows effective parameter substitution into the templates during runtime. LGenBase provides specific set of templates belonging to each traffic case. There are three different template parameter substitution modes: |
| |
| * Dictionary-based substitution |
| * Positional parameter based substitution |
| * Fixed position based substitution |
| |
| [[description_of_files_in_this_feature]] |
| == Description of Files in this Feature |
| |
| The EPTF CLL LGenBase API includes the following files: |
| |
| * LGenBase |
| ** __EPTF_CLL_LGenBase_Definitions.ttcn__: - This TTCN-3 module contains LGenBase type definitions that can be used in all components extending LGenBase. |
| ** __EPTF_CLL_LGenBase_ConfigDefinitions.ttcn__: - This TTCN-3 module contains common type definitions that can be used to describe or process test descriptions from configuration files without importing LGenBase-specific definitions. |
| ** __EPTF_CLL_LGenBase_PhaseDefinitions.ttcn__: - This TTCN-3 module contains phase related type definitions that can be used in all components extending LGenBase. |
| ** __EPTF_CLL_LGenBase_Functions.ttcn__: - This TTCN-3 module contains the implementation of LGenBase functions. |
| ** __EPTF_CLL_LGenBase_ConfigFunctions.ttcn__ - contains functions to manipulate the test configurations, such as traffic cases, scenarios, FSM-s, etc. |
| ** __EPTF_CLL_LGenBase_LoggingDefinitions.ttcn__ - This TTCN-3 module contains logging related type definitions that can be used in all components extending LGenBase. |
| ** __EPTF_CLL_LGenBase_LoggingFunctions.ttcn__ - This TTCN-3 module contains the implementation of logging functions. |
| ** __EPTF_CLL_LGenBase_PhaseFunctions.ttcn__ - contains functions to use phase related scenarios, manipulate phases, etc. |
| ** __EPTF_CLL_LGenBase_EventHandlingFunctions.ttcn__ - contains functions of event dispatching. |
| ** __EPTF_CLL_LGenBase_EventHandlingExternalFunctions.cc__ - contains external functions of event dispatching. |
| ** __EPTF_CLL_LGenBase_ExternalFunctions.ttcn__ - contains the headers of the external functions of event dispatching. |
| ** __EPTF_CLL_LGenBase_StepFunctions.ttcn__ - contains the functions in the test steps registered by the LGenBase. |
| ** __EPTF_CLL_LGenBase_TrafficFunctions.ttcn__ - contains functions to manage traffic, e.g. start, stop traffic cases, scenarios, handle entity |
| ** __EPTF_CLL_LGenBaseTrafficMixer_Definitions.ttcn__ - contains data types to describe traffic cases based on their weight factors. |
| ** __EPTF_CLL_LGenBaseTrafficMixer_Functions.ttcn__ - contains functions to generate traffic cases based on their weight factors. |
| ** __EPTF_CLL_LGenBase_TemplateDefinitions.ttcn__ - contains data types and constants need to handle external templates. |
| ** __EPTF_CLL_LGenBase_TemplateFunctions.ttcn__ - contains functions for handling external templates. |
| * LGenBaseStats |
| ** __EPTF_CLL_LGenBaseStats_Definitions.ttcn__: - This TTCN-3 module contains common type definitions that should be used in all components extending LGenBaseStats. |
| ** __EPTF_CLL_LGenBaseStats_Functions.ttcn__: - This TTCN-3 module contains the implementation of LGenBaseStats functions. |
| * LGenBaseStatsUI |
| ** __EPTF_CLL_LGenBaseStatsUI_Definitions.ttcn__: - This TTCN-3 module contains common type definitions that should be used in all components extending LGenBaseStatsUI. |
| ** __EPTF_CLL_LGenBaseStatsUI_Functions.ttcn__: - This TTCN-3 module contains the implementation of LGenBaseStatsUI functions. |
| |
| == Description of Required Features |
| |
| The LGenBase feature is part of the EPTF Core Load Library (CLL). It relies on some features of the CLL. To use the LGenBase, the user has to obtain the respective files from the following features: |
| |
| * `Base` |
| * `Common` |
| * `FreeBusyQueue` |
| * `RandomNArray` |
| * `HashMap` |
| * `RedBlackTree` |
| * `Scheduler` |
| * `Variable` |
| * `StatHandler` |
| * `TCCUsefulFunctions` |
| |
| For the LGenBaseStats feature: |
| |
| * `Variable` |
| |
| For the LGenBaseStatsUI feature: |
| |
| * `UIHandler` |
| |
| == Installation |
| |
| Since `EPTF_CLL_LGenBase` is used as a part of the TTCN-3 test environment this requires TTCN-3 Test Executor to be installed before any operation of these functions. For more details on the installation of TTCN-3 Test Executor see the relevant section of <<_2, [2]>>. |
| |
| If not otherwise noted in the respective sections, the following are needed to use `EPTF_CLL_LGenBase`: |
| |
| * Copy the files of the features listed in Section <<description_of_files_in_this_feature, Description of Files in this Feature>> to the directory of the test suite or create symbolic links to them. |
| * If you use TITAN plugin for Eclipse, the files of the features must lay in the "CLL dir"\src\"feature" structure. You have to create a path variable with the name of `CoreLibraryPath` pointing to the "CLL dir" directory. |
| * Import the LGenBase demo or write your own application using LGenBase. |
| * Create _Makefile_ or modify the existing one. For more details see the relevant section of <<_2, [2]>>. |
| * Edit the config file according to your needs, see following section <<configuration, Configuration>>. |
| |
| [[configuration]] |
| == Configuration |
| |
| The executable test program behavior is determined via the run-time configuration file. This is a simple text file, which contains various sections. The usual suffix of configuration files is _.cfg_. For further information on the configuration file see <<_2, [2]>>. |
| |
| This LGenBase feature defines TTCN-3 module parameters as defined in <<_2, [2]>>, clause 4. Actual values of these parameters – when no default value or a different from the default actual value wished to be used – shall be given in the `[MODULE_PARAMETERS]` section of the configuration file. |
| |
| This LGenBase feature defines the following module parameters: |
| |
| * `tsp_EPTF_LGenBaseDebug` |
| + |
| This boolean type module parameter is defined in module `EPTF_CLL_LGenBase_Functions`. The feature will log the FSM event handling if the module parameter is true. |
| |
| * `tsp_EPTF_LGenBaseDebugTraffic` |
| + |
| This boolean type module parameter is defined in module `EPTF_CLL_LGenBase_Functions`. The feature will log the traffic management if the module parameter is true. |
| |
| * `tsp_EPTF_LGenBase_roundedCpsUpdateInterval` |
| + |
| This float type module parameter is defined in module `EPTF_CLL_LGenBase_Functions` <<_6, [6]>>. The feature periodically generates traffic. This parameter defines this rate. |
| |
| * `tsp_EPTF_LGenBase_abortStopProcess` |
| + |
| This float type module parameter is defined in module `EPTF_CLL_LGenBase_Functions` <<_6, [6]>>. If the entities didn’t reply to `c_EPTF_LGenBase_inputName_testMgmt_stopTC` or `c_EPTF_LGenBase_inputIdx_testMgmt_abortTC` messages in time described by this module parameter, LGenBase steps to stopped or aborted state. |
| |
| * `tsp_LGenBase_nameSeparator` |
| + |
| This charstring type module parameter is defined in module `EPTF_CLL_LGenBase_Functions` <<_6, [6]>>. This is used to concatenate the name of the entity group, the scenario and the traffic case in unique name of the traffic cases. |
| |
| * `tsp_LGenBase_extTemplLoadList` |
| + |
| This module parameter specifies the list of external template, which is loaded by initializing of the component. It shall be given a list which contains the exteranal templates’ name, file path and a flag to enable/disable automatic `<LF> ─> <CR><LF>` conversion. |
| + |
| [source] |
| { {"foo_templ", "/templates/foo.txt", false}, {"bar_templ", "/templates/bar.txt", true} } |
| + |
| The default value of the module parameter is the `_empty list_`. |
| |
| * `tsp_LGenBase_templParamOpenToken` |
| + |
| This charstring type module parameter specifies the opening string of the template parameters. Empty string is not allowed to define. The default value of the module parameter is: `_‘$(‘_` . |
| |
| * `tsp_LGenBase_templParamCloseToken` |
| + |
| This charstring type module parameter specifies the closing string of the template parameters. Empty string is not allowed to define. The default value of the module parameter is: `_‘)‘_` . |
| |
| * `tsp_LGenBase_enableDefaultArithmeticOperationsInExtTemplate` |
| + |
| This module parameter enables the default arithmetic operations handling during external template parameter substitution. The addition, subtraction, multiplication and division is handled on parameters if the substitution value has a valid number. |
| |
| * `tsp_LGenBase_extTemplRemoveLastNewLine` |
| + |
| This boolean type module parameter can be used to strip the last new line from an external template. Its default value is `_false_`. |
| |
| * `tsp_EPTF_LGenBaseDebugLightList` |
| + |
| The LGenBase activates the DebugLight debugging feature (see also <<_6, [6]>>) on the FSM tables enlisted in this module parameter. |
| |
| * `tsp_LGenBaseStatsUI_columnDescriptorList` |
| + |
| This module parameter describes the contents of each traffic case row on the LGenBaseStatsUI GUI. The `colTitle` field describes the title of the specified column, the `tcColId` describes which data to be displayed in that column, and the `enableIfAvailable` describes whether the column should be writeable, if the data is writeable, or it should be read only in all cases. |
| |
| * `tsp_LGenBaseStatsUI_scColumnDescriptorList` |
| + |
| This module parameter describes the contents of the table in the row of the scenarios. Rather for future use. |
| |
| * `tsp_EPTF_LGenBase_ILog_enableILog` |
| + |
| This boolean type module parameter is defined in module `EPTF_CLL_LGenBase_ILog_Definitions`. It can be used to enable or disable the LGenBase’s ILog feature. Its default value is true, which means that the `ILog` feature is enabled by default. |
| |
| == Usage |
| |
| [[lgenbase-0]] |
| === LGenBase |
| |
| To use the functionalities of the LGenBase feature |
| |
| * extend the `EPTF_LGenBase_CT` with your component |
| |
| * call the `f_EPTF_LGenBase_init` function from the init function of your component |
| |
| * use the public functions of the LGenBase |
| |
| === LGenBaseStats |
| |
| To use the functionalities of the LGenBaseStats feature |
| |
| * extend the `EPTF_LGenBaseStats_CT` with your component |
| |
| * call the `f_EPTF_LGenBaseStats_init` function from the init function of your component |
| |
| * use the variables provided by the LGenBaseStats to display and/or manage the properties of the LGenBase. |
| |
| === LGenBaseStatsUI |
| |
| Extend the `EPTF_LGenBaseStatsUI_CT` with your component. |
| |
| The `f_EPTF_LGenBaseStatsUI_init` function must be called before using the functionalities of the component. |
| |
| Users should create the GUI which will contain the widgets created by the LGenBaseStatsUI. |
| |
| When all the scenarios are ready, the `f_EPTF_LGenBaseStatsUI_prepareGUI` function must be called. That’s all. |
| |
| == DTE handling in LGenBase |
| |
| DTE generated by test steps in FSM will be caught by LGenBase and the event `*"LGenBase: Dynamic_test_case_error_occured!"*` is reported for the entity. The FSM of the entity is deactivated, the entity is disabled. If the reported DTE event is not handled in the FSM, LGenBase reports a traffic error. |
| |
| The error string of the DTE can be retrieved by the function `f_EPTF_LGenBase_get_dte_str` (in integer `pl_eIdx`, in integer `pl_fCtxIdx`). |
| |
| If DTE occurs, then all events are cancelled for the entity in the FSM, test steps that follow the step that caused the DTE are not executed, and the state remains the same as it was when the failing step was started. |
| |
| LGenBase will not report the DTE event for failing test steps that are executed when the DTE event is processed in the FSM (that is the DTE handling part). |
| |
| By default DTE handling is disabled. |
| |
| = Error Messages |
| |
| NOTE: Besides the below described error messages, error messages shown in <<_2, [2]>> or those of other used features or product may also appear. |
| |
| `*"Traffic case is running. The burst calculation method can not be set."*` |
| |
| The burst calculation method can not be set to a running traffic case. |
| |
| `*"This burst calculation method cannot be found."*` |
| |
| The burst calculation method cannot be found in the database. Probably this method was not declared before, or its name is misspelled. |
| |
| `*"This burst calculation method is already defined."*` |
| |
| A burst calculation method has been declared with the same name. |
| |
| `*"Error: attempting to delete fcb. at invalid idx: [idx]"*` |
| |
| The index of the scenario creation callback to be deleted is invalid. |
| |
| `*"Can not schedule traffic case timer event."*` |
| |
| The `f_EPTF_SchedulerComp_scheduleAction` function returned false, the `EPTF_Scheduler_CT` could not schedule the timer to call the `f_EPTF_LGenBase_doTrafficCaseTimerAction`. |
| |
| `*"Invalid input index in finished event."*` |
| |
| The private `f_EPTF_LGenBase_doTrafficCaseTimerAction` function was called with invalid event parameter. |
| |
| `**"* must be *"**` |
| |
| The specified object has been registered in wrong order. Probably other components had registered objects of the same type earlier, however the init function of the LGenBase must be called first. |
| |
| `*"Unhandled burst management type."*` |
| |
| Internal coding error, it must not happen. |
| |
| `*"The behavior type already exists."*` |
| |
| A behavior type with the same name had been registered already. |
| |
| `*"Invalid behavior type: [name]"*` |
| |
| The behavior type had not been registered. |
| |
| `*"The step [name] already exists!"*` |
| |
| A test step with the same name had been registered already. |
| |
| `*"The declared event is a timer timeout event, but the [name] name is not in the list of timers!"*` |
| |
| The event type in the FSM declarator is a timer timeout event, but the specified name is not in the list of timers of the FSM. |
| |
| `*"The declared [name] event behavior name is not valid!"*` |
| |
| The behavior type had not been registered. |
| |
| `*"The declared [name] event input name is not valid!"*` |
| |
| The event had not been registered. |
| |
| `*"The count of the declared states and the states in row#[nr.] of the FSM differ!"*` |
| |
| There are less or more FSM states than the count of the cell rows in the FSM’s specified table row. |
| |
| `*"Invalid step function: [name]"*` |
| |
| The referred step function had not been registered. |
| |
| `*"Invalid step function type:"*` |
| |
| There is a registered function with the same name, but it its type is not `EPTF_LGenBase_TestStepFunction_FT`. |
| |
| `*"Invalid step:"*` |
| |
| The referred test step had not been registered. |
| |
| `*"In case of timer start step the contextArgs must be present."*` |
| |
| The test step is a timer start, but the `contextArgs` is omit. |
| |
| `*"The declared [name] name is not in the list of timers!"*` |
| |
| The referred timer name does not exist in the list of timers of the FSM. |
| |
| `*"In case of timer cancel step the contextArgs must be present."*` |
| |
| The test step is a timer cancel, but the `contextArgs` is omit. |
| |
| `*"In case of timer cancel step the contextArgs must be a name of a timer."*` |
| |
| The test step is a timer cancel, the `contextArgs` is present, but not the `timerName` field is chosen but the `stepContextArgs`. |
| |
| `*"If the contextArgs is present, it must be an integer list. Row#[nr.]"*` |
| |
| The `contextArgs` is present, but not the `stepContextArgs` field is chosen but the `timerName`. |
| |
| `*"Invalid next state calculation function: [name]"*` |
| |
| The referred next state calculation function had not been registered. |
| |
| `*"Invalid next state calculation function type: [name]"*` |
| |
| There is a registered function with the same name, but it its type is not `EPTF_LGenBase_NextStateCalc_FT`. |
| |
| `*"Declared nextstate must be valid"*` |
| |
| The name of the referred state is not present in the list of states of the FSM table. |
| |
| `*"The name of the entity type mustn't be empty."*` |
| |
| The `pl_name` parameter of the `f_EPTF_LGenBase_declareEntityType` function is an empty string. |
| |
| `*"The entity type [name] already exists."*` |
| |
| An entity type with the same name had been registered already. |
| |
| `*"Invalid behavior type: [name]"*` |
| |
| There is no registered behavior type with the specified name. |
| |
| `*"The entity group name mustn't be empty."*` |
| |
| The name field of the `EPTF_LGenBase_EntityGrpDeclarator` is an empty string. |
| |
| `*"The entity type name mustn't be empty."*` |
| |
| The `eType` field of the `EPTF_LGenBase_EntityGrpDeclarator` is an empty string. |
| |
| `*"The entity group [name] already exists."*` |
| |
| An entity group with the same name had been registered already. |
| |
| `*"Invalid entity type [name]"*` |
| |
| There is no registered entity type with the specified name. |
| |
| `*"Invalid count of entities: [count]"*` |
| |
| The specified count is less than `_zero_`. |
| |
| `*"Invalid entity group name: [name]"*` |
| |
| There is no registered entity group with the specified name. |
| |
| `*"Invalid entity group index: [index]"*` |
| |
| The index of the entity group is invalid. |
| |
| `*"Invalid customFinishFunction: [name]"*` |
| |
| There is no registered function with the specified name, or its type is not `EPTF_LGenBase_customFinishFunction_FT`. |
| |
| `*"Invalid group finish action."*` |
| |
| Internal error, it should not happen. |
| |
| `*"Invalid entity finish action."*` |
| |
| Internal error, it should not happen. |
| |
| `*"Invalid customFinishCondition: [name]"*` |
| |
| There is no registered function with the specified name. |
| |
| `*"Invalid customFinishCondition type: [name]"*` |
| |
| There is a registered function with the specified name, but its type is not `EPTF_LGenBase_customFinishCondition_FT`. |
| |
| `*"Invalid custom entity success function: [name]"*` |
| |
| There is no registered function with the specified name. |
| |
| `*"Invalid custom entity success function type: [name]"*` |
| |
| There is a registered function with the specified name, but its type is not `EPTF_LGenBase_evaluateSuccess4EntityAtEntityGroup2_FT`. |
| |
| `*"Invalid FSM name: [name]"*` |
| |
| There is no registered FSM table with the specified name. |
| |
| `*"The traffic case name already exists: [name]"*` |
| |
| A traffic case with the same name had been registered already. |
| |
| `*"FMS name must not be empty."*` |
| |
| The name of the FSM table must be specified and must not be an empty string. |
| |
| `*"Invalid traffic case index: [index]"*` |
| |
| The specified index of the traffic case is invalid. |
| |
| `*"Invalid traffic case name: [name]"*` |
| |
| There is no traffic case with the specified name. |
| |
| `*"Invalid scenario type: [name]"*` |
| |
| There is an inconsistency error in the scenario type. |
| |
| `*"Not weighted scenario!: [name]"*` |
| |
| A function related to a weighted scenario has been called, but the referred scenario is not a weighted scenario. |
| |
| `*"Invalid scenario name: [name]"*` |
| |
| There is no scenario with the specified name in the specified entity group. |
| |
| `*"Invalid scenario index: [name]"*` |
| |
| There is no scenario in the entity group with the specified index. |
| |
| `*"Invalid scenario index within the group: [index]"*` |
| |
| There is no scenario in the entity group with the specified index. |
| |
| `*"Error assigning the traffic case [name] to group [name]"*` |
| |
| There was an error when a traffic case has been created on the specified entity group. |
| |
| `*"collecting traffic weights: TC[index] in weighted SC shall have a weight instead of cpsToReach!"*` |
| |
| There is a non weighted traffic case in a weighted scenario. |
| |
| `*"initializing traffic mix for TC in weighted SC [name]: mixer has not accepted traffic mix"*` |
| |
| There was an error initializing the traffic mix. |
| |
| `*"Error: attempting to delete fcb. at invalid idx:[index]"*` |
| |
| The index of the `EPTF_LGenBase_scenarioCreated_FT` functions in the list of "scenario created" callbacks is invalid. |
| |
| `*"CPS cannot set to weighted TC: [name]"*` |
| |
| Required call per sec rate can not be set to a weighted traffic case. |
| |
| `*"Weight cannot set to normal TC: "*` |
| |
| Weight can be set to a weighted traffic case only. |
| |
| `*"CPS cannot set to non-weighted scenario: [name]"*` |
| |
| Required call per sec rate can be set to a weighted scenario only. |
| |
| `*"Weighted traffic cases can not be paused. Use disable instead."*` |
| |
| Only non-weighted traffic cases can be paused. |
| |
| `*"Entity index"*` |
| |
| Invalid entity index. |
| |
| `*"FSM context index"*` |
| |
| Invalid FSM context index. |
| |
| `*"FSM table index"*` |
| |
| Invalid FSM table index. |
| |
| `*"referred FSM table index"*` |
| |
| Invalid FSM table index. |
| |
| `*"Row index for FSM table[index]"*` |
| |
| Invalid row index in the FSM table. |
| |
| `*"Column index for FSM table[index]"*` |
| |
| Invalid column index in the FSM table. |
| |
| `*"FSM timer index"*` |
| |
| Invalid FSM timer index. |
| |
| `*"Referred FSM context index"*` |
| |
| Invalid FSM context index. |
| |
| `*"FSM timer duration"*` |
| |
| The defined duration is less than zero. |
| |
| `*"Presence of target entity's reference"*` |
| |
| There was no target defined in an event record to be reported to an entity. |
| |
| `*"Special behavior type in event is unknown"*` |
| |
| Invalid behavior type is used. |
| |
| `*"special behaviorType must be known"*` |
| |
| Invalid behavior type is used. |
| |
| `*"Behavior type idx for timeouts must be [index]"*` |
| |
| Invalid behavior type is used. |
| |
| `*"assumes 3 integers in actionId[]"*` |
| |
| Internal error in a private function. |
| |
| `*"expects refContext in TestStepArgs"*` |
| |
| The `refContext` field of the test step args is not present. |
| |
| `*"expects exactly 1 refArgs in refContext in TestStepArgs"*` |
| |
| Starting an FSM timer the step argument must be an integer list with length 1. |
| |
| `*"Event scheduling must be always successful"*` |
| |
| The scheduler could not schedule the timer action. |
| |
| `*"initial state of FSM context"*` |
| |
| There is no defined state in the FSM table with the specified index. |
| |
| `*"FSM context management error"*` |
| |
| Invalid FSM context index or there is no FSM table index in the referred context. |
| |
| `*"Unhandled listener type."*` |
| |
| Internal error. |
| |
| `*"Event/input index"*` |
| |
| Invalid input index for the referred event. |
| |
| `*"Event target field must be omit"*` |
| |
| The target field of a generic event must be omit. |
| |
| `*"The index [index] is invalid. Max: [count]"*` |
| |
| Removing an event listener with invalid index. |
| |
| `*"Event target field must be present"*` |
| |
| The target field of an entity event must be set. |
| |
| `*"Invalid listener. pl_bIdx == [index] , pl_iIdx == [index], pl_eIdx == [index]"*` |
| |
| There was no registered listener listening to the specified event. |
| |
| `*"Length of pl_listenerArgs must be 3"*` |
| |
| Internal error. |
| |
| `*"Table index referred the by FSM context is [index]"*` |
| |
| Invalid FSM table index. Internal error. |
| |
| `*"Referred FSM table row index"*` |
| |
| Invalid FSM table row index. Internal error. |
| |
| `*"state index referred the by FSM context"*` |
| |
| Invalid FSM state index. Internal error. |
| |
| `*"Invalid timer"*` |
| |
| There is no timer with the specified parameters. |
| |
| `*"Invalid timer name: [name]"*` |
| |
| There is no timer in the FSM table with the specified name. |
| |
| `*"Burst PreCalc is empty."*` |
| |
| Internal error. |
| |
| `*"Different FBQ sizes."*` |
| |
| Internal error. |
| |
| `*"The default UIHandler component must not be null."*` |
| |
| The UIHandler component must be a valid component reference. |
| |
| `*"Entity group name [name] contains the separator [separator]"*` |
| |
| The name of the entity group must not contain the separator character defined in `tsp_LGenBase_nameSeparator` module parameter. |
| |
| `*"Scenario name [name] contains the separator [separator]"*` |
| |
| The name of the scenario must not contain the separator character defined in `tsp_LGenBase_nameSeparator` module parameter. |
| |
| `*"Invalid variable name:"*` |
| |
| There is no EPTF Var variable with the specified name. |
| |
| `*"Couldn't store phase list… Possible name collision in phase list…"*` |
| |
| A phase declarator has already been defined with this name. Use another name for declaring a new one. |
| |
| = Warning Messages |
| |
| NOTE: Besides the below described warning messages, warning messages shown in <<_2, [2]>> or those of other used features or product may also appear. |
| |
| `*"The running traffic case [name] can not be restored!"*` |
| |
| A running traffic case can not be restored. |
| |
| `*"Abort the entities of the traffic case [name] has been timed out."*` |
| |
| Not all the entities answered to the aborting message. |
| |
| `*"Stop the entities of the traffic case [name] has been timed out."*` |
| |
| Not all the entities answered to the stopping message. |
| |
| `*"The traffic case is in invalid [state] state!"*` |
| |
| When the timeout period of stopping or aborting a traffic case expired, the traffic case was not in stopping, aborting or finished state. |
| |
| `*"Entity stop response of entity#[index] of traffic case [name] has arrived, but the TC is in [state] state."*` |
| |
| When the specified entity answered to the stopping event, the traffic case was not in stopping state. |
| |
| `*"Entity abort response of entity#[index] of traffic case [name] has arrived, but the TC is in [state] state."*` |
| |
| When the specified entity answered to the aborting event, the traffic case was not in aborting state. |
| |
| `*"Start launch called for tc [name] in state [state]"*` |
| |
| When the start launch command was called, the traffic case was in invalid state. |
| |
| `*"Start launch called for the disabled tc [name]"*` |
| |
| When the start launch command was called, the traffic case was in disabled state. |
| |
| `*"Start launch called for weighted scenario [name] in state [state]"*` |
| |
| When the start launch command was called, the weighted scenario was in invalid state. |
| |
| `*"Start launch called for weighted scenario [name] in state [state]"*` |
| |
| When the start launch command was called, the weighted scenario was in disabled state. |
| |
| `*"Pause called for tc [name] in state [state]"*` |
| |
| The paused command was called, but the traffic case was not in running state. |
| |
| `*"Weighted traffic cases can not be paused. Use disable instead."*` |
| |
| A weighted traffic case can not be paused. |
| |
| `*"Event reporting request to an inactive FSM! Entity == [index] fsmCtxIdx == [index]"*` |
| |
| An event was reported to an inactive FSM. |
| |
| `*"start has been requested for a running FSM timer: [index] timer will be cancelled first!"*` |
| |
| The started FSM timer is already running. |
| |
| `*"Cancelling not running timer:=[index]"*` |
| |
| There was a cancel request to a not running timer. |
| |
| `*"StartStep called but entiy#[index] in traffic case [name], [index] is busy!"*` |
| |
| An entity start was called, but the entity is running or finished. |
| |
| `*"Warning: Path of external template cannot be empty!"*` |
| |
| Empty string is given as template name. |
| |
| `*"Warning: Name of external cannot be empty!"*` |
| |
| Empty string is given as template file path. |
| |
| `*"Warning: Could not read file: [path]"*` |
| |
| Cannot access external template file on file system. |
| |
| `*"Warning: Template set with index: [index] doesn't exist"*` |
| |
| Referred template set does not exist. |
| |
| `*"Warning: Template type declaration with index: [index] doesn't exist"*` |
| |
| Referred template type declaration does not exist. |
| |
| `*"Warning: External template with index: [index] doesn't exist"*` |
| |
| Referred external template does not exist. |
| |
| `*"Warning: External template with name: [name] doesn't exist"*` |
| |
| Referred external template does not exist. |
| |
| `*"Warning: Template set doesn’t have item with index: [index]"*` |
| |
| The referred template item does not exist in template set. |
| |
| `*"Warning: Template type declaration with key [behaviourType, templateName] doesn’t exist"*` |
| |
| The referred template type declaration does not exist. |
| |
| `*"Warning: Assignment not possible, mandatory parameter: [param] is missing from external template"*` |
| |
| Assign a template type to an external template did not succeed because of missing mandatory parameter(s). |
| |
| `*"Warning: Assignment in template set already exists"*` |
| |
| Assign a template type to an external template did not succeed because another assignment of same template type declaration already exist in the template set. |
| |
| `*"Warning: Actual phase is already running in this scenario"*` |
| |
| The phase to be started is already running. LGenBase cannot start or skip a running phase again. |
| |
| `*"Warning: There is already a running phase in this scenario"*` |
| |
| Another phase is already running. LGenBase cannot start or skip a phase, if there is a running phase. Running phase should be stopped before. |
| |
| `*"Warning: No phase is running in this scenario"*` |
| |
| If there is no running phase, it cannot be stopped. |
| |
| = Examples |
| |
| The "demo" directory of the deliverable contains the following examples: |
| |
| * __EPTF_LGenBaseDemo_CallerDefinitions.ttcn__ |
| * __EPTF_LGenBaseDemo_CallerFunctions.ttcn__ |
| * __EPTF_LGenBaseDemo_Definitions.ttcn__ |
| * __EPTF_LGenBaseDemo_Functions.ttcn__ |
| * __EPTF_LGenBaseDemo_ResponderDefinitions.ttcn__ |
| * __EPTF_LGenBaseDemo_ResponderFunctions.ttcn__ |
| * __EPTF_LGenBaseDemo_SiblingFsmDefinitions.ttcn__ |
| * __EPTF_LGenBaseDemo_SiblingFsmFunctions.ttcn__ |
| * __EPTF_LGenBaseDemo_TemplateFunctions.ttcn__ |
| * __EPTF_LGenBaseDemo_TransportDefinitions.ttcn__ |
| * __EPTF_LGenBaseDemo_TransportFunctions.ttcn__ |
| * __EPTF_LGenBaseDemo_msgReRegisterTemplate.txt__ |
| * __EPTF_LGenBaseDemo_msgRegisterTemplate.txt__ |
| |
| == Configuration File |
| |
| The used configuration file (_demo.cfg_) is for the LGenBase example is placed in the demo directory. |
| |
| == Demo Module |
| |
| The demo module (__GenFSM_Demo.ttcn__) illustrates a typical usage of the LGenBase feature and performs some tests. |
| |
| The demo module (__WeightedTraffic_Demo.ttcn__) illustrates some typical usage of weighted scenario. |
| |
| = Terminology |
| |
| *EPTF Core Library (CLL):* + |
| It is that part of the TitanSim software that is totally project independent. (i.e., which is not protocol-, or application-dependent). The Core Library is to be supplied and supported by the TCC organization. Any Core Library development is to be funded centrally by Ericsson. |
| |
| *Application Library (Applib):* + |
| It is that part of the TitanSim software that is although protocol, or application-area dependent, but can be _reused_ across many TitanSim applications. Applibs are dependent on the CLL. |
| |
| *Control Logic:* + |
| It is that part of the TitanSim software that is specific to a particular TitanSim application program. It is usually not directly reusable and is built upon the CLL and several Applibs. |
| |
| *Entities:* + |
| They are "things/objects" that are simulated by the LGen. Such "things" are usually the "users", "calls", "servers", "terminations", or anything whose external behavior is to be simulated by the LGen. Usually an LGen simulates more than one entity. |
| |
| *Entity context:* + |
| It is an indexable generic data record describing an entity. It stores index cross-references to _behavior contexts_ and it directly stores the _FSM contexts_ of the entity. The entity contexts are identified via their indices with respect to the entity context database stored in the `v_LGenBase_entities` component variable. |
| |
| *Behavior context:* + |
| It is an indexable (set of) data record(s) that stores data and state information of a given entity with respect to a given _behavior type._ Storage for behavior contexts is to be provided by the respective Applibs. |
| |
| *Behavior type:* + |
| It is a concept for collectively referring a set of _behavior contexts, FSM inputs, test steps,_ and functions realizing methods conforming to given function signatures prescribed by the LGenBase feature. Behavior types are to be declared dynamically during run-time to the LGenBase by the component-type initialization function of some Applib. Usually an Applib product has only one behavior type, but it is permitted for Applibs to declare more than one behavior types, if necessary. Behavior types are identified by their indices determined by the order of declaration and the declarations are stored in `v_LGenBase_behaviorTypes` |
| |
| *Entity type:* + |
| It is a named list of references to declared _behavior types_. As such, it declares what type of behavior contexts are available on entities of this type. |
| |
| *Entity group:* + |
| A group of entities with the same entity type. The indices of the entities of the group make a continuous interval that does not overlap with the index range of any other entity group. |
| |
| *Test step:* + |
| Test steps are functions whose signature conforms to a given function type. They _must_ not contain TTCN-3 statements with blocking semantics. |
| |
| *Event listener:* + |
| It is a call-back function to be dynamically registered that will be called whenever an _event reporter_ calls `f_EPTF_LGenBase_dispatchEvent` |
| |
| *Reportable event:* + |
| It is a declared notification message of a given _behavior type_ that can be distributed to _event listeners_ by _event reporters_ via `f_EPTF_LGenBase_dispatchEvent` |
| |
| *Event reporter:* + |
| It is an altstep, or function of a given _behavior type_ that eventually calls `f_EPTF_LGenBase_dispatchEvent` |
| |
| *Reported event:* + |
| It is an instance of a _reportable event_ supplied with reported arguments that is actually being distributed via `f_EPTF_LGenBase_dispatchEvent`. |
| |
| *Finite State Machine:* + |
| It is a formal description of _Control Logic_. It is a tabular description of what _test steps_ to call when a given _reported event_ occurs, when the entity is in a given declared _state of the FSM_. After executing these _test steps_ an optional next _FSM state_ can be also defined. |
| |
| *FSM table:* + |
| It is a formal specification of the communication rules of Finite State Machines. These indexable records are stored in `v_LGenBase_fsmTables`. FSM tables realizing _traffic cases_ must obey certain rules. |
| |
| *FSM state:* + |
| It is a locally indexed declaration of a state within an FSM table. |
| |
| *FSM timer:* + |
| It is a locally indexed declaration of a timer within an FSM table. |
| |
| *Traffic case type:* + |
| It is a prototype used as an input for instantiating traffic case instances on a specific entity group. It defines which _FSM table_ to use, which _entity type_ must be used by the _entity group_ where the _traffic case_ is to be deployed |
| |
| *Traffic case:* + |
| It is a behavior, defined by an FSM table, that is executed on a given entity group. All entities of the entity group participate in executing the traffic case. An entity group may have more than one concurrent traffic cases. |
| |
| *Group finish condition:* + |
| It is list of conditions that defines situations when a traffic case is over on group level, that is, no new traffic is launched on that group. Group finish conditions are evaluated whenever any entity of the group reports the event that it has just finished executing a traffic instance of that traffic case. |
| |
| *Group finish actions:* + |
| It is list of action that is executed when any of the group finish conditions has been met. |
| |
| *User finish condition:* + |
| It is list of conditions that defines situations when a _traffic case_ is over for a given entity, that is, the entity is not considered for selection for launching a new traffic, even if the entity returns to its idle _state_. User finish conditions are evaluated whenever any entity of the group reports finishing the traffic case, that is, returning to the "idle" state of the respective FSM context. |
| |
| *User finish actions:* + |
| It is list of action that is executed when any of the _user finish_ conditions has been met. |
| |
| *Scenario* + |
| It is a collection of traffic cases deployed on an entity group. |
| |
| *Named functions:* + |
| They are functions that has an associated name (label), are declared to LGenBase metadata with that label; and can be invoked via their labels. |
| |
| *External templates:* + |
| They are parameterized text modules are stored by LGenBase. Parameter values can be substituted dynamically during run-time. |
| |
| *Template type:* + |
| It is a named declaration of a template assigned to a behavior type. |
| |
| *Template set:* + |
| It is set of templates belonging to a traffic case. It is a list of `<template type, external template>` pairs. |
| |
| = Abbreviations |
| |
| CLL:: Core Library |
| |
| EPTF:: Ericsson Performance Test Framework |
| |
| TitanSim:: Ericsson Performance Test Framework |
| |
| TTCN-3:: Testing and Test Control Notation version 3 See <<_1, [1]>>. |
| |
| = References |
| |
| [[_1]] |
| [1] ETSI ES 201 873-1 v3.2.1 (2007-02) + |
| The Testing and Test Control Notation version 3. http://www.etsi.org/deliver/etsi_es/201800_201899/20187301/03.02.01_60/es_20187301v030201p.pdf[Part 1: Core Language] |
| |
| [[_2]] |
| [2] User Guide for the TITAN TTCN-3 Test Executor |
| |
| [[_3]] |
| [3] EPTF CLL for TTCN-3 toolset with TITAN, Function Specification |
| |
| [[_4]] |
| [4] EPTF CLL for TTCN-3 toolset with TITAN, User Guide |
| |
| [[_5]] |
| [5] EPTF CLL LGenBase, Function Description |
| |
| [[_6]] |
| [6] EPTF CLL for TTCN-3 toolset with TITAN + |
| http://ttcn.ericsson.se/TCC_Releases/Libraries/EPTF_Core_Library_CNL113512/doc/apidoc/html/index.html[Reference Guide] |