Report for "Requirements" requirements collection

Entiry Total Covered Uncovered Partial
Requirements 49 45 4 0
Test purposes 34 32 2  

Inconclusive requirements: 1

92,5
Requirement: 12 Declaring timers
12       Declaring timers
100,0
100,0
Requirement: Timers can be declared in component type
timers can be declared in component type definitions
100,0
100,0
Requirement: Timer value is non-neg float
A timer declaration may have an optional default duration value assigned to it. The timer shall be started with this value if no other value is specified. The timer value shall be a non-negative float value (i.e. greater than or equal to 0.0)
100,0
Requirement: timer array values are non-neg float or minus
timer arrays can also be declared Default duration(s) assignment shall use the array value notation as specified in clause 6.2.7. If the default duration assignment is wished to be skipped for some element(s) of the timer array, it shall explicitly be declared by using the not used symbol ("-")
100,0
100,0
100,0
Requirement: Messages are instances of types declared in the in-out-inout clauses of message port type definition
Messages are instances of types declared in the in/out/inout clauses of message port type definition.
100,0
100,0
100,0
Requirement: Sorts of message insances
Instances of messages can be declared by global, local or in-line templates (see clause 15) or being constructed and passed via variables or template variables parameters or template parameters
100,0
Test purpose: Global template as a message
-- A global template can be sent and received in a message port

ensure that {
    when {
        IUT receives TTCN3 module
        defining component PTC {
            defining port p
        }
        defining component MTC {
            defining port p
        }
        -- contents of T is not specified here
        defining template T
        
        defining test case TC {
            creating component PTC
            and connecting MTC.p with PTC.p
            and starting component PTC
                with function {
                    invoking alt statement {
                        branch p.receive with setverdict(pass)
                        branch timeout with setverdict(fail)
                    }
                }
            -- Sending a global template
            and invoking MTC.p.send(T)
        }
    }
    then {
        IUT accepts the module
        and IUT executes TC
            with verdict pass
    }
}
100,0
Test purpose: Inline template as a message
-- Inline template can be sent and received in a message port

ensure that {
    when {
        IUT receives TTCN3 module
        defining component PTC {
            defining port p
        }
        defining component MTC {
            defining port p
        }
        
        defining test case TC {
            creating component PTC
            and connecting MTC.p with PTC.p
            and starting component PTC
                with function {
                    invoking alt statement {
                        branch p.receive with setverdict(pass)
                        branch timeout with setverdict(fail)
                    }
                }
            -- Sending an inline template
            -- contents of template T is not specified here
            and invoking MTC.p.send(inline template)
        }
    }
    then {
        IUT accepts the module
        and IUT executes TC
            with verdict pass
    }
}
100,0
Test purpose: Local template as a message
-- Local template can be sent and received in a message port

ensure that {
    when {
        IUT receives TTCN3 module
        defining component PTC {
            defining port p
        }
        defining component MTC {
            defining port p
        }
        
        defining test case TC {
            -- contents of template T is not specified here
            defining template T
            creating component PTC
            and connecting MTC.p with PTC.p
            and starting component PTC
                with function {
                    invoking alt statement {
                        branch p.receive with setverdict(pass)
                        branch timeout with setverdict(fail)
                    }
                }
            -- Sending the local template
            and invoking MTC.p.send(T)
        }
    }
    then {
        IUT accepts the module
        and IUT executes TC
            with verdict pass
    }
}
100,0
Test purpose: Parameter as a message
-- Parameter can be sent and received in a message port

ensure that {
    when {
        IUT receives TTCN3 module
        defining component PTC {
            defining port p
        }
        defining component MTC {
            defining port p
        }
        
        defining function F(param) runnning on MTC {
            -- Sending the value of the parameter
            invoking MTC.p.send(param)
        } where {
            type of param is compatible with out type of MTC.p
        }
        
        defining test case TC {
            creating component PTC
            and connecting MTC.p with PTC.p
            and starting component PTC
                with function {
                    invoking alt statement {
                        branch p.receive with setverdict(pass)
                        branch timeout with setverdict(fail)
                    }
                }
            -- Sending the local template
            and invoking F(some value)
        }
    }
    then {
        IUT accepts the module
        and IUT executes TC
            with verdict pass
    }
}
100,0
Test purpose: Template parameter as a message
-- Template parameter can be sent and received in a message port

ensure that {
    when {
        IUT receives TTCN3 module
        defining component PTC {
            defining port p
        }
        defining component MTC {
            defining port p
        }
        
        defining function F(template param) runnning on MTC {
            -- Sending the template of the parameter
            invoking MTC.p.send(param)
        } where {
            type of param is compatible with out type of MTC.p
        }
        
        defining test case TC {
            -- contents of template T is not specified here
            defining template T
            creating component PTC
            and connecting MTC.p with PTC.p
            and starting component PTC
                with function {
                    invoking alt statement {
                        branch p.receive with setverdict(pass)
                        branch timeout with setverdict(fail)
                    }
                }
            -- Sending the local template as function parameter
            and invoking F(T)
        }
    }
    then {
        IUT accepts the module
        and IUT executes TC
            with verdict pass
    }
}
100,0
Test purpose: Template variable as a message
-- Template variable can be sent and received in a message port

ensure that {
    when {
        IUT receives TTCN3 module
        defining component PTC {
            defining port p
        }
        defining component MTC {
            defining port p
        }
        
        defining test case TC {
            -- contents of template T is not specified here
            defining template variable T_var
                initialized by some value
            creating component PTC
            and connecting MTC.p with PTC.p
            and starting component PTC
                with function {
                    invoking alt statement {
                        branch p.receive with setverdict(pass)
                        branch timeout with setverdict(fail)
                    }
                }
            -- Sending the local template variable
            and MTC.p.send(T_var)
        }
    }
    then {
        IUT accepts the module
        and IUT executes TC
            with verdict pass
    }
}
100,0
Test purpose: Variable as a message
-- Variable can be sent and received in a message port

ensure that {
    when {
        IUT receives TTCN3 module
        defining component PTC {
            defining port p
        }
        defining component MTC {
            defining port p
        }
        
        defining test case TC {
            -- contents of template T is not specified here
            defining variable Var
                initialized by some value
            creating component PTC
            and connecting MTC.p with PTC.p
            and starting component PTC
                with function {
                    invoking alt statement {
                        branch p.receive with setverdict(pass)
                        branch timeout with setverdict(fail)
                    }
                }
            -- Sending the local variable
            and MTC.p.send(Var)
        }
    }
    then {
        IUT accepts the module
        and IUT executes TC
            with verdict pass
    }
}
100,0
Requirement: 23 Timer operations
23       Timer operations The running-timers list and the timeout-list are only a conceptual lists and do not restrict the implementation of timers. Other data structures like a set, where the access to timeout events is not restricted by, e.g. the order in which the timeout events have happened, may also be used.
96,2
Requirement: Usage of timers is allowed in test cases, functions, altsteps, module control
TTCN‑3 supports a number of timer operations as given in table 27. These operations may be used in test cases, functions, altsteps and module control.
100,0
Test purpose: Positive syntax test
ensure that {
    when {
        IUT receives TTCN3 module
        defining altstep {
            declaring timer t
            and containing t.start
            and containing t.running
            and containing t.read
            and containing t.timeout
            and containing t.stop
        }
        defining function {
            declaring timer t
            and containing t.start
            and containing t.running
            and containing t.read
            and containing t.timeout
            and containing t.stop
        }
        defining test case {
            declaring timer t
            and containing t.start
            and containing t.running
            and containing t.read
            and containing t.timeout
            and containing t.stop
        }
        defining module control {
            declaring timer t
            and containing t.start
            and containing t.running
            and containing t.read
            and containing t.timeout
            and containing t.stop
        }
    }
    then {
        IUT rejects the module
    }
}
100,0
Test purpose: Timer read is not allowed in component definitions

when {

    A test module contains timer operations in test cases, functions, altsteps and module control

}

ensure {
    .The module compiles successfully
}

 

100,0
Test purpose: Timer running is not allowed in component definitions

ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            defining timer t
            defining boolean field
                initialized with t.running
        }
    }
    then {
        IUT rejects the module
    }
}
100,0
Test purpose: Timer stop is not allowed in module definitions
ensure that {
    when {
        IUT receives TTCN3 module
        containing "all timer.stop" in definitions part
    }
    then {
        IUT rejects the module
    }
}
100,0
Test purpose: Timer timeout operation is not allowed in module definitions
ensure that {
    when {
        IUT receives TTCN3 module
        containing "any timer.timeout" in definitions part
    }
    then {
        IUT rejects the module
    }
}
100,0
Requirement: 23.2 The start timer operation
23.2      The Start timer operation
100,0
100,0
Requirement: Overridden timer value applies only to current instance
The optional timer value parameter shall be used if no default duration is given, or if it is desired to override the default value specified in the timer declaration. When a timer duration is overridden, the new value applies only to the current instance of the timer, any later start operations for this timer, which do not specify a duration, shall use the default duration.
100,0
Requirement: neg timer value causes error verdict
Starting a timer with a negative timer value, e.g. the timer value is the result of an expression, or without a specified timer value shall cause a runtime error.
100,0
Requirement: timer can be restarted by repeated start operation
The start operation may be applied to a running timer, in which case the timer is stopped and re-started. Any entry in a timeout-list for this timer shall be removed from the timeout-list.
100,0
Requirement: timer clock runs from 0 to the value set
The timer clock runs from the float value zero (0.0) up to maximum stated by the duration parameter.
100,0
Requirement: Timer value is non-neg float
Timer value shall be a non‑negative numerical float number (i.e. the value shall be greater or equal 0.0, infinity and not_a_number are disallowed).
100,0
Requirement: Timer with the timer value 0.0 times out immediately.
Starting a timer with the timer value 0.0 means that the timer times out immediately.
100,0
Requirement: 23.3 The Stop timer operation
23.3      The Stop timer operation
100,0
100,0
Requirement: stopped timer is inactive and elapsed time is 0
A stopped timer becomes inactive and its elapsed time is set to the float value zero (0.0).
100,0
Requirement: Stopping inactive timer is ok, but unobservable
Stopping an inactive timer is a valid operation, although it does not have any effect. Stopping an expired timer causes the entry for this timer in the timeout-list to be removed.
100,0
Requirement: all keyword can be used for timers in component or module control
The all keyword may be used to stop all timers that have been started on a component or module control.
100,0
Requirement: 23.4 The Read timer operation
23.4      The Read timer operation
100,0
100,0
Requirement: Read returns elapsed time that is non-neg float
The read operation returns the time that has elapsed since the specified timer was started. The returned value shall be of type float.
100,0
Requirement: Read on an inactive timer returns float zero
Applying the read operation on an inactive timer, i.e. on a timer not listed on the running-timer list, will return the float value zero (0.0).
100,0
Requirement: 23.5 The Running timer operation
23.5      The Running timer operation
100,0
100,0
100,0
Requirement: The any keyword may be used to check if any timer started on a component or module control is running
The any keyword may be used to check if any timer started on a component or module control is running
100,0
Requirement: 23.6 The Timeout operation
23.6      The Timeout operation
100,0
100,0
Requirement: The any keyword used with the timeout operation succeeds if the timeout-list is not empty.
The any keyword used with the timeout operation succeeds if the timeout-list is not empty.
100,0
Test purpose: Any timer ignores timeouts in other components
-- Wait for timeout of an unstarted timer. The waiting must be bounded with waiting of a started timer to prevent indefinite waiting.

-- Create a test with a paralle test component. The PTC starts a timer, the MTC invokes an altstatement with any timer.timeout
ensure that {
    when {
        IUT receives TTCN3 module
        defining component PTC { empty }
        and defining component MTC { empty }
        and defining test case running on MTC {
            creating PTC
            and starting function on PTC {
                defining timers t1(time1) and t2(time2)
                    indicating time1 < time2
                invoking t1.start
                invoking t2.start
                -- to ensure that PTC.done arrives later than potential t1.timeout
                invoking t2.timeout operation
            }
            and containig alt statement {
                -- timers from PTC must not be accessible from MTC
                branch 'any timer.timeout' with setverdict(fail)
                branch triggered by PTC.done with setverdict(pass)
            }
        }
    }
    then {
        IUT accepts the module
        and IUT executes the module
        and IUT execution terminates
            with verdict pass
    }
}



ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            empty
        }
        defining test case running on MTC {
            defining timer t1(time1)
            and defining timer t2(time2)
                indicating time1 < time2
            and starting timer t2
            and containing alt statement {
                -- unstarted timer must not timeout
                branch t1.timeout with setverdict(fail);
                branch t2.timeout with setverdict(pass);
            }
        }
    }
    then {
        IUT accepts the module
        and IUT executes the module
        and IUT execution terminates
            with verdict pass
    }
}

100,0
Test purpose: Wait for timers in scope of the alt
-- Declare a few timers in a component.
-- Define an altstep that waits for any timer and runs on that component.
-- Start a few timers and invoke the altstep.

ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            containing few timers
        }
        defining altstep  A() running on MTC {
            with branch triggered by "any timer.timeout" with setverdict(pass)
        }
        defining test case {
            running on MTC
            and starting the timers of MTC
            and invoking A()
        }
    }
    then {
        IUT accepts the module
        and IUT executes the module
        and IUT execution terminates
            with verdict pass
    }
}

100,0
Test purpose: Wait for timers that are outside of scope
-- Define an altstep with any timer.timeout alternative. Start a timer and invoke the altstep.

ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            empty
        }
        defining altstep  A() {
            with branch triggered by "any timer.timeout" with setverdict(pass)
        }
        defining test case {
            running on MTC
            and defining timer t locally
            and starting timer t
            and invoking A()
        }
    }
    then {
        IUT accepts the module
        and IUT executes the module
        and IUT execution terminates in reasonable time
            with verdict pass
    }
}

100,0
100,0
Requirement: Timeout operational semantics
When a timeout operation is processed, if a timer name is indicated, the timeout-list is searched according to the TTCN‑3 scope rules. If there is a timeout event matching the timer name, that event is removed from the timeout-list, and the timeout operation succeeds.
100,0
Test purpose: Timeout a timer that is already timed out
-- Start a timer. Wait for its timeout. Wait for its timeout once again (bound this wait with another timer to preven indefinite wait).

ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            empty
        }
        defining test case running on MTC {
            defining timer t1 locally
            and defining timer t2 locally
            and starting timer t1
            and invoking t1.timeout
            and starting t2
            and containing alt statement {
                branch t1.timeout with setverdict(fail);
                branch t2.timeout with setverdict(pass);
            }
        }
    }
    then {
        IUT accepts the module
        and IUT executes the module
        and IUT execution terminates
            with verdict pass
    }
}

100,0
Test purpose: Timeout started timer
-- Wait for timeout of several started timers with different maximum times.

ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            empty
        }
        defining test case running on MTC {
            defining timers t1(time1), t2(time2), t3(time3)
                indicating time1 < time2 < time3
            and starting timers t1, t2, t3
            and containing alt statement {
                -- the timer with smallest time must timeout first
                branch t1.timeout with setverdict(pass);
                branch t2.timeout with setverdict(fail);
                branch t3.timeout with setverdict(fail);
            }
        }
    }
    then {
        IUT accepts the module
        and IUT executes the module
        and IUT execution terminates
            with verdict pass
    }
}
100,0
Test purpose: Timeout unstarted timer
-- Wait for timeout of an unstarted timer. The waiting must be bounded with waiting of a started timer to prevent indefinite waiting.

ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            empty
        }
        defining test case running on MTC {
            defining timer t1(time1)
            and defining timer t2(time2)
                indicating time1 < time2
            and starting timer t2
            and containing alt statement {
                -- unstarted timer must not timeout
                branch t1.timeout with setverdict(fail);
                branch t2.timeout with setverdict(pass);
            }
        }
    }
    then {
        IUT accepts the module
        and IUT executes the module
        and IUT execution terminates
            with verdict pass
    }
}

100,0
Requirement: The timeout can be used as alternative in alt
The timeout can be used to determine an alternative in an alt statement
100,0
Requirement: The timeout can be used as a standalone statement
The timeout can be used as stand-alone statement in a behaviour description. In the latter case a timeout operation is considered to be shorthand for an alt statement with the timeout operation as the only alternative
100,0
Requirement: 23.1 Timer mechanism
Only one entry for any particular timer may appear in the timeout-list and running-timer list of the test component or module control for which the timer has been declared. 23.1      The timer mechanism
0,0
Requirement: timer expires and becomes inactive
When a timer expires, the timer becomes immediately inactive.
0,0
Requirement: 23.7 Summary of use of any and all with timers
23.7      Summary of use of any and all with timers

Table 28: Any and All with Timers

Operation

Allowed

Example

 

any

all

                   

start

 

 

 

stop

 

yes

all timer.stop

read

 

 

 

running

yes

 

if (any timer.running) {…}

timeout

yes

 

any timer.timeout

100,0
Test purpose: Allow all timer.stop

ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            empty
        }
        defining test case TC running on MTC {
            defining timer t1
            and defining timer t2
            and starting timer t1
            and starting timer t2
                     where { duration of t2 is longer than that of t1 }
            and invoking { all timer.stop}
            and setverdict(pass) if not t2.running and not t1.runnung
            and setverdict(fail) otherwise
        }
    }
    then {
        IUT accepts the module
        and IUT executes TC
            with verdict pass
    }
}
 

100,0
Test purpose: Allow any timer.running

ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            empty
        }
        defining test case running on MTC {
            defining float variable f_var
            defining timer t1
            and defining timer t2
            and starting timer t1
            and starting t2
            and setverdict(pass) if any timer.running produces true
            and setverdict(fail) otherwise
        }
    }
    then {
        IUT accepts the module
        and IUT executes TC
            with verdict pass
    }
}
 
 

100,0
Test purpose: Allow any timer.timeout

ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            empty
        }
        defining test case TC running on MTC {
            defining timer t1
            and defining timer t2
            and starting timer t1
            and starting timer t2
                     where { duration of t2 is longer than that of t1 }
            and invoking { any timer.timeout}
            and setverdict(pass) if t2.running and not t1.runnung
            and setverdict(fail) otherwise
        }
    }
    then {
        IUT accepts the module
        and IUT executes TC
            with verdict pass
    }
}
 

 
100,0
Test purpose: Disallow all timer.read
ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            empty
        }
        defining test case running on MTC {
            defining float variable f_var
            defining timer t1
            and defining timer t2
            and starting timer t1
            and starting t2
            and assigning { f_var := all timer.read }
                
        }
    }
    then {
        IUT rejects the module
    }
}
 
100,0
Test purpose: Disallow all timer.running
ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            empty
        }
        defining test case running on MTC {
            defining boolean variable b_var
            defining timer t1
            and defining timer t2
            and starting timer t1
            and starting t2
            and assigning { b_var := all timer.running }
                
        }
    }
    then {
        IUT rejects the module
    }
}


 
100,0
Test purpose: Disallow all timer.start
ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            empty
        }
        defining test case running on MTC {
            defining timer t1
            and defining timer t2
            and invoking { all timer.start }
        }
    }
    then {
        IUT rejects the module
    }
}


 
100,0
Test purpose: Disallow all timer.timeout
ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            empty
        }
        defining test case running on MTC {
            defining timer t1
            and defining timer t2
            and starting timer t1
            and starting t2
            and invoking { all timer.timeout() }
        }
    }
    then {
        IUT rejects the module
    }
}


 
100,0
Test purpose: Disallow any timer.read
ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            empty
        }
        defining test case running on MTC {
            defining float variable f_var
            defining timer t1
            and defining timer t2
            and starting timer t1
            and starting t2
            and assigning { f_var := any timer.read }
                
        }
    }
    then {
        IUT rejects the module
    }
}
 
 
100,0
Test purpose: Disallow any timer.start
ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            empty
        }
        defining test case running on MTC {
            defining timer t1
            and defining timer t2
            and invoking { any timer.start }
        }
    }
    then {
        IUT rejects the module
    }
}


 
 
100,0
Test purpose: Disallow any timer.stop
ensure that {
    when {
        IUT receives TTCN3 module
        defining component MTC {
            empty
        }
        defining test case running on MTC {
            defining timer t1
            and defining timer t2
            and starting timer t1
            and starting t2
            and invoking { any timer.stop() }
        }
    }
    then {
        IUT rejects the module
    }
}
100,0
76,2
Requirement: Getverdict and setverdict operations shall only be used in test cases, altsteps and functions.
Verdict operations given in table 29 allow to set and retrieve verdicts. These operations shall only be used in test cases, altsteps and functions
100,0
Requirement: Setverdict locations
Setverdict operations shall only be used in test cases, altsteps and functions.
100,0
Test purpose: Setverdict allowed in altsteps
ensure that {
    when {
        IUT receives TTCN3 module
        defining altstep A() {
            branch with arbitrary trigger: setverdict(pass)
        }
    }
    then {
        IUT accepts the module
    }
}
100,0
Test purpose: Setverdict allowed in test cases
ensure that {
    when {
        IUT receives TTCN3 module
        defining test case TC {
            setverdict(pass)
        }
    }
    then {
        IUT accepts the module
    }
}
100,0
Test purpose: Setverdict in functions allowed
ensure that {
    when {
        IUT receives TTCN3 module
        defining function F {
            setverdict(pass)
        }
    }
    then {
        IUT accepts the module
    }
}
100,0
50,0
Requirement: Global test case verdict
there is a global test case verdict instantiated and handled by the test system that is updated when each test component (i.e. the MTC and each and every PTC) terminates execution (see figure 14). This verdict is not accessible to the getverdict and setverdict operations. The value of this verdict shall be returned by the test case when it terminates execution.
0,0
0,0
0,0
Requirement: Five different values of verdict
The verdict can have five different values: pass, fail, inconc, none and error, i.e. the distinguished values of the verdicttype (see clause 6.1)
100,0
Requirement: Local verdict is initialized with none
When a test component is instantiated, its local verdict object is created and set to the value none.
100,0
100,0
Requirement: Overwriting rules for global verdict
The test case verdict is implicitly updated on the termination of a test component. The effect of this implicit operation shall also follow the overwriting rules listed in table 30.
0,0
Requirement: Error verdict shall not be set with setverdict
The error verdict is special in that it is set by the test system to indicate that a test case (i.e. run-time) error has occurred. It shall not be set by the setverdict operation
100,0
80,0
100,0
Requirement: Optional setverdict parameters
The optional parameters allow to provide information that explain the reasons for assigning the verdict. This information is composed to a string and stored in an implicit charstring variable. On termination of the test component, the actual local verdict is logged together with the implicit charstring variable.
100,0
Requirement: Setverdict allowed verdict values
The setverdict operation shall only be used with the values pass, fail, inconc and none. It shall not be used to assign the value error, this is set by the test system only to indicate run-time errors.
100,0
Requirement: SingleExpression shall resolve to a value of type verdict
SingleExpression shall resolve to a value of type verdict
0,0
Requirement: For FreeText and TemplateInstance, the same rules and restrictions apply as for the parameters of the log statement.
For FreeText and TemplateInstance, the same rules and restrictions apply as for the parameters of the log statement.
100,0
100,0
100,0
Test purpose: Getverdict returns none for uninitialized verdict
-- When test case does not invoke setverdict() directly or indirectly getverdict returns 'none'

ensure that {
    when {
        IUT receives TTCN3 module
        defining test case TC {
            if getverdict returns none
                setverdict pass
            else
                setverdict fail
        }
    }
    then {
        IUT accepts the module
        and IUT executes TC
            with verdict pass
    }
}
100,0

Inconclusive requirements

/Requirements/23 Timer operations/23.6 The Timeout operation//Requirements/23 Timer operations/23.6 The Timeout operation/The any keyword used with the timeout operation succeeds if the timeout-list is not empty./Wait for timers in scope of the alt

Mentioned in files: