Defining constraints examples

Example: fully random example

OSC2 code: fully random

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


extend top.main:
    tolerance: int

Example: fully directed example

OSC2 code: fully directed

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    my_speed: speed


    keep(my_speed == 50kph) # my_speed is set to 50 kph

Example: constrained random example

OSC2 code: constrained random

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    my_speed: speed


    keep(my_speed in [30..80]kph) # my_speed is restricted to a range

Example: simple Boolean constraint

OSC2 code: simple Boolean constraint

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:


    my_speed: speed with:
        keep(it in [30..80]kph)

Example: simple Boolean constraint with 'in'

OSC2 code: simple Boolean constraint with 'in'

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


enum my_driving_style: [aggressive, assertive, normal, timid]

struct misc:
    dist: length with:
        keep(it in [2..4]m)
    i: int with:
        keep(it in [-1..1])

    ms: my_driving_style with:
        keep(it in [assertive, timid])

Example: compound Boolean constraint example 1

OSC2 code: compound Boolean constraint example 1

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    lawful_driver: bool
    legal_speed: speed
    current_speed: speed


    keep(lawful_driver => (current_speed <= legal_speed))

Example: compound Boolean constraint example 2

OSC2 code: compound Boolean constraint example 2

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:
    x: uint
    y: uint


    # both constraint expressions must evaluate to true
    keep(x <= 3 and x > y)

    # at least one constraint expression must evaluate to true
    keep(x <= 3 or x > y)

    # if the first expression evaluates to true, the second one must
    # also evaluate to true
    keep((x <= 3) => (x > y))

Example: list constraint

OSC2 code: list constraint

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


actor my_car_convoy:
    first_car: vehicle
    cars: list of vehicle

    # the list will have between 2 and 10 items
    # the first item is first_car
    keep(soft cars.size() <= 10)
    keep(soft cars.size() >=  2)
    keep(cars[0] == first_car) # list indexing

Example: hard constraint

OSC2 code: hard constraint

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:


    current_speed: speed with:
        keep(it == 25kph)

Example: soft constraint example 1

OSC2 code: soft constraint example 1

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

scenario sut.scenario1:


    color: car_color with:
        keep(soft it!= green)

Example: soft with compound constraints

OSC2 code: soft with compound constraints

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    a: int
    b: int


    keep(soft a == 1 and b == 0)
    keep(soft a == 10)


    do sut.car.drive(duration: 5s)

Example: using soft when passing parameters

OSC2 code: using soft when passing parameters

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"
    set min_test_time = 0second


scenario top.foo:
  a: int

extend top.main:
  do foo(a: soft 123)

  on @start:
    call logger.log_info("foo.a: $(label(foo).a)")

Example: default constraints

OSC2 code: default constraints

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:

    do sut.car.drive(duration: 5s)


scenario sut.scenario1:
    b: uint
    c: uint

    keep(default b == 10)
    keep(default c == 20)

    keep(b == 1 and c == 2)      # contradiction
    keep(soft b == 1 and c == 2) # b and c get default values

    keep(b > 20) # contradiction
    keep(b > 5)  # b gets 10

    keep(b in [12..18]) # b gets 16
    keep(b == 7) # b gets 7
    keep(b == c) # b and c get 20

    do log_info("### b: $(b); c: $(c)")

Example: default constraint

OSC2 code: default constraint example

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"


scenario vehicle.foo:
    x: int with:
        keep(default it == 0)
    y: int with:
        keep(it!= x)


extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)

Example: soft constraint example 2

OSC2 code: soft constraint example 2

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


scenario vehicle.foo:
    x: int with:
        keep(soft it == 0)
    y: int with:
        keep(it!= x)

Example: remove_default() constraint

OSC2 code: remove_default() constraint

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"

extend top.main:
    do sut.car.drive(duration: 5s)


scenario vehicle.foo:
    x: int with:
        keep(default it == 0)
    y: int with:
        keep(it!= x)
    do drive(duration: 5s)

extend vehicle.foo:
    remove_default(x)
    keep(y == 0)

Example: weighted distribution method example

OSC2 code: weighted distribution method example

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

scenario top.set_values:
    def foo()-> length is empty

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"
    set min_test_time = 0second


extend top.set_values:
    side: av_side # assign left, right in a 20 : 80 ratio
    keep(soft side == weighted(20: left, 80: right))

    top_speed: speed # assign a value from one of three buckets in a 10:30:10 ratio
    keep(soft top_speed == weighted(10: [20..30]kph,
                                    30: [30..70]kph,
                                    10: [70..120]kph))

    dist: length # assign 10m and the return value of foo() in a 50 : 50 ratio
    keep(soft dist == weighted(50: 10m, 50: foo()))

    num_of_wheels: int # assign 4 or 10 wheels in a 50 : 50 ratio
    keep(soft num_of_wheels == weighted(50: 4, 50: 10))


extend top.main:

    do top.set_values()

Example: random distribution method examples

OSC2 code: random distribution method examples

import "$FTX_BASIC/exe_platforms/sumo_ssp/config/sumo_config.osc"

extend test_config:
    set map = "$FTX_PACKAGES/maps/hooder.xodr"
    set min_test_time = 0second


extend top.main:
    top_speed: speed
    keep(soft top_speed == random.normal(55.5, 7) * 1kph)

    top_speed_truncated: speed
    keep(soft top_speed_truncated == random.truncated_normal(10, 120, 55.5, 7) * 1kph)


    dist: length
    keep(soft dist == random.uniform(20, 50.5) * 1m)

    end_speed: speed
    keep(soft end_speed == weighted(
        30: [20..30]kph,
        70: random.truncated_normal(10, 120, 55.5, 7) * 1kph))

Example: user-defined distribution method example

OSC2 code: user-defined distribution method example

import "$FTX/qa/regression/config/av_fake_ssp.osc"


extend random:
    def distribute_int(i: int, j: int) -> int is empty

scenario sut.my_scenario:
    num_of_cars: int
    keep(soft num_of_cars == random.distribute_int(1,5))


extend top.main:
    do sut.my_scenario()