RFC 8239 Functions

test rfc8239 config

Execute Tester Command ${rt_handle} command=test_control <additional key=value arguments>

Purpose:
The test rfc8239 config command creates, modifies, and deletes a linerate test. The RFC 8239 tests are used to establish test and evaluation methodology and measurement techniques for physical network equipment in the data center.

Synopsis:

Note: M indicates the argument is `Mandatory`.

     test rfc8239 config
        mode= {create|modify|delete} M
        handle= <test_handle>
        src_port= <port_handle>
        dst_port= <port_handle>
        endpoint_creation= {0|1}
        device_count= <integer>
        mac_addr= {aa:bb:cc:dd:ee:ff}
        port_mac_step= {aa:bb:cc:dd:ee:ff}
        device_mac_step= {aa:bb:cc:dd:ee:ff}
        vlan= <integer>
        port_vlan_step= <integer>
        device_vlan_step= <integer>
        vlan_priority= <1-7>
        ipv4_addr= <a.b.c.d>
        port_ipv4_addr_step= <a.b.c.d>
        device_ipv4_addr_step= <a.b.c.d>
        ipv4_prefix_len= <1-32>
        ipv4_gateway= <a.b.c.d>
        port_ipv4_gateway_step= <a.b.c.d>
        ipv6_addr= <aaaa:bbbb:cccc:dddd:eeee:ffff:gggg:hhhh>
        port_ipv6_addr_step= <aaaa:bbbb:cccc:dddd:eeee:ffff:gggg:hhhh>
        device_ipv6_addr_step= <aaaa:bbbb:cccc:dddd:eeee:ffff:gggg:hhhh>
        ipv6_prefix_len= <0-128>
        ipv6_gateway= <aaaa:bbbb:cccc:dddd:eeee:ffff:gggg:hhhh>
        port_ipv6_gateway_step= <aaaa:bbbb:cccc:dddd:eeee:ffff:gggg:hhhh>
        qos= <string>
        src_endpoints= <handle>
        dst_endpoints= <handle>
        streamblock_handle= <handle>
        traffic_pattern= {pair|mesh|backbone}
        enable_stream_only_gen= {1|0}
        endpoint_map= {one_to_one|one_to_many}
        bidirectional= {0|1}
        iteration_count= {integer}
        test_duration_mode= {seconds|bursts}
        test_duration_seconds= <integer>
        test_duration_bursts= <integer>
        test_type= {lr|mb}
        streamblock_frame_sizes= {true|false}
        frame_size_mode= {custom|random|step|imix}
        frame_size= <integer>
        frame_size_imix= <string>
        frame_size_start= <integer>
        frame_size_end= <integer>
        frame_size_step= <integer>
        frame_size_min= <integer>
        frame_size_max= <integer>
        load_type= {custom|random|step|fixed}
        load_unit= {bits_per_second|frames_per_second|inter_burst_gap|
             kilobits_per_second|megabits_per_second|percent_line_rate }]
        load_list= <list_value>
        load_start= <integer>
        load_end= <integer>
        load_step= <integer>
        load_min= <integer>
        load_max= <integer>
        load_fixed= <integer>
        burst_type= {custom|fixed|step}
        burst_list= <list_value>
        burst_fixed= <integer>
        burst_start= <integer>
        burst_end= <integer>
        burst_step= <integer>
        burst_inter_frame_gap= <integer>
        latency_distribution_list= <integer>
        latency_type= {FILO|FIFO}
        start_traffic_delay= <0-3600>
        stagger_start_delay= <0-65>
        delay_after_transmission= <0-3600>
        enable_learning= {0|1}
        learning_mode= {l2|l3}
        learning_frequency= {learn_once|learn_every_trial|
             learn_every_frame_size|learn_every_iteration}]
        learning_rate= <integer>
        l3_learning_retry_count= <1-100>
        l2_learning_repeat_count= <1-100>
        l2_delay_before_learning= <0-3600>
        l3_delay_before_learning= <0-3600>
        l2_fixed_frame_size= <integer>
        l2_learning_frame_size_mode= {same_as_test|fixed}
        enable_cyclic_resolution= {0|1}
        enable_traffic_verification= {true|false}
        traffic_verification_freq_mode= {verify_every_trial|
                           verify_every_frame_size|verify_every_iteration}]
        traffic_verification_abort_on_fail= {true|false}
        traffic_verification_tx_frame_count= <1-32767>
        traffic_verification_tx_frame_rate= <1-14880952>
        display_load_unit= {bits_per_second|frames_per_second|inter_burst_gap|
                              kilobits_per_second|megabits_per_second|
                              percent_line_rate}]

Arguments:

mode
                Specify the action to be performed on the test port.
                This argument is `Mandatory`. Possible values are create,
                modify, and delete. The values are described below::


                 create - Creates a LineRate test.

                 modify - Modifies the configuration for the created test.

                 delete - Deletes the created test.

src_port
                Defines the source port to be used for stream creation.
                You can use this argument when endpoint_creation is set to 1.

dst_port
                Defines the destination port to be used for stream creation.
                You can use this argument when endpoint_creation is set to 1.

handle
                Specifies the test to be modified or deleted.
                This argument is `Mandatory` for modify mode and delete mode.

endpoint_creation
                Determines whether Spirent HLTAPI creates new endpoints
                on the ports specified by src_port and -dst_port. The endpoints
                are used to create new streams in the test. Possible values are 0
                and 1. When it is set to 1, Spirent HLTAPI creates new endpoints
                on the given source port and destination port. You must specify
                the src_port argument and the -dst_port argument when the value
                is 1. When it is set to 0, you can create streams in two other
                ways. One is to specify src_endpoints and -dst_endpoints, and
                then this command will create a bound stream for the test; the
                other is to provide a list of existing streams
                (streamblock_handle), which the command will use for the test.

device_count
                Defines the number of devices you can create on each port. The
                default value is 1. This argument is only valid when the
                endpoint_creation argument is set to 1.

mac_addr
                The starting MAC address to use when emulating devices.
                You can use this argument when endpoint_creation is set to 1.
                The value should be in MAC address format.

port_mac_step
                Defines the step size to be used for incrementing MAC addresses
                across ports. You can use this argument when endpoint_creation
                is set to 1.

device_mac_step
                Defines the step value to be used for incrementing MAC address
                across devices on one port. You can use this argument when
                endpoint_creation is set to 1. The value should be in MAC
                address format.

vlan
                Specifies the VLAN ID for the first device. You can use this
                option when endpoint_creation is set to 1.

port_vlan_step
                Defines the step value to be used for incrementing VLAN IDs
                across the ports. You can use this argument when
                endpoint_creation is set to 1.

device_vlan_step
                Specifies the step value to be used for incrementing VLAN IDs
                across the devices on one port. You can use this argument when
                endpoint_creation is set to 1.

vlan_priority
                Specifies the VLAN priority for created devices. Possible values
                range from 1 to 7. You can use this argument when
                endpoint_creation is set to 1.

ipv4_addr
                Defines the first IPv4 address when emulating devices.
                You can use this argument when endpoint_creation is set to 1.
                The value should be in IPv4 format.

port_ipv4_addr_step
                Defines the step value to be used for incrementing IPv4 addresses
                across the ports. You can use this argument when
                endpoint_creation is set to 1. The value should be in the IPv4
                format.
                For example, if you specify port_ipv4_addr_step 0.1.0.0,
                ipv4_addr 192.85.1.2, and -device_ipv4_addr_step 0.0.0.1.
                When there are two ports, the IPv4 addresses for emulating hosts
                are listed below::


                 First host block: 192.85.1.2, 192.85.1.3, 192.85.1.4...
                 Second host block: 192.86.1.2, 192.86.1.3, 192.86.1.4...

                The number of hosts in each host block is specified by
                the device_count argument.

device_ipv4_addr_step
                Defines the step value to be used for incrementing IPv4 addresses
                across the devices on one port. You can use this argument when
                endpoint_creation is set to 1.

ipv4_prefix_len
                Specifies the IPv4 prefix length for created devices.
                You can use this argument when endpoint_creation is set to 1.

ipv4_gateway
                Specifies the IPv4 gateway addresses for the first device.
                You can use this argument when endpoint_creation is set to 1.
                The value should be in IPv4 format.

port_ipv4_gateway_step
                Specifies the step value to be used for incrementing IPv4 gateway
                addresses across the ports. You can use this argument when
                endpoint_creation is set to 1. The value should be in IPv4
                format.

ipv6_addr
                Specifies the first IPv6 address when creating devices. You can
                use this argument when endpoint_creation is set to 1. The value
                should be in IPv6 format.

port_ipv6_addr_step
                Specifies the step size to be used for incrementing IPv6
                addresses across the ports. You can use this argument when
                endpoint_creation is set to 1. The value should be in IPv6
                format.

device_ipv6_addr_step
                Defines the step value to be used for incrementing IPv6 addresses
                across the devices on one port. You can use this argument when
                endpoint_creation is set to 1. The value should be in IPv6
                format.

ipv6_prefix_len
                Specifies the prefix length of the IPv6 addresses. You can use
                this argument when endpoint_creation is set to 1. Possible values
                range from 0 to128.

ipv6_gateway
                Defines the starting IPv6 gateway address when emulating devices.
                You can use this argument when endpoint_creation is set to 1.
                The value should be in IPv6 format.

port_ipv6_gateway_step
                Specifies the step size to be used for incrementing IPv6 gateway
                address across the port. You can use this argument when
                endpoint_creation is set to 1. The value should be in IPv6
                format.

qos
                Specifies a list of Quality of Service (QoS) parameters. The
                default value is 0.

src_endpoints
                Specifies the source endpoint used to create traffic. The trial
                will use the traffic binding to the source endpoint
                (src_endpoints) and the destination endpoint (-dst_endpoints) to
                run. When you specify this argument, you must specify the
                dst_endpoints option. You can use this argument when the
                endpoint_creation option is set to 0. This value can be an
                endpoint or a list of endpoints.

dst_endpoints
                Specifies the destination endpoint used to create traffic.
                The trial will use the traffic binding to the source endpoint
                (src_endpoints) and the destination endpoint (-dst_endpoints) to
                run. When you specify this argument, you must specify the
                src_endpoints option. You can use this argument when the
                endpoint_creation option is set to 0. This value can be an
                endpoint or a list of endpoints.

streamblock_handle
                Indicates the existing streams used for the test. The trial will
                use the provided streamblock to do the test. The value of this
                argument can be a stream or a list of streams. You can use this
                argument when the endpoint_creation option is set to 0.

traffic_pattern
                Indicates the traffic pattern to be used for the test. Possible
                values are pair, mesh, and backbone. The patterns are described
                below::


                 pair - Traffic is transmitted between one or more port pairs.
                       The ports to use is specified by the src_endpoints
                       option and the dst_endpoints option.

                 mesh - Every port transmits traffic to every other port and
                       receives traffic from all other ports simultaneously.
                       src_endpoints and -dst_endpoints are the endpoints to be
                       included in the fully meshed network.

                 backbone - Traffic is transmitted in a partially meshed pattern,
                        either unidirectional or bidirectional. src_endpoints and
                        dst_endpoints are the endpoints to be included in
                        the backbone network.

enable_stream_only_gen
                Disables or enables the stream only generation option when
                creating traffic. When it is set to 1, Spirent TestCenter will
                generate a separate stream for each flow instead of generating
                the same stream for all flows. Possible values are 0 and 1.
                The default is 1.

endpoint_map
                Specifies one of the following traffic mapping methods to be
                used within each host block. Possible values are one_to_one
                and one_to_many. The methods are described below::


                 one_to_one - Every endpoint within the source endpoint
                     block transmits traffic to the corresponding destination
                     endpoint within the destination endpoint block.

                 one_to_many - Every endpoint within the source endpoint
                     block transmits traffic to every destination endpoint
                     within the destination endpoint block.

bidirectional
                Determines whether the traffic is unidirectional or bidirectional.
                Possible values are 0 (unidirectional) and 1 (bidirectional).

iteration_count
                Specifies the number of times the test repeats with its initial
                configuration. Each trial is based on the same parameter values.
                Within a trial, certain parameter values vary with each
                iteration, according to the test methodology and setup. At the
                start of the next trial, these parameters revert to their initial
                values. The default value is 1.

test_duration_mode
                Specifies the duration mode for each transmitted stream.
                This option determines whether the test duration is measured
                in seconds or by the number of frames. The default is seconds.
                Possible values are::


                  Value             Description

                  seconds           Each trial lasts for the number of seconds
                                     specified by the test_duration_seconds argument

                  bursts            Each trial lasts for the number of bursts specified
                                     by the test_duration_bursts argument

test_duration_bursts
                Indicates the transmission length in number of frames, when you
                specify test_duration_mode bursts. The default value is 1000.

test_duration_seconds
                Indicates the transmission length in seconds, when you
                specify test_duration_mode seconds. The default value is 60.

test_type
                Indicates the type of test to be done. Possible values are::


                  Value             Description
                  lr                LineRate test.
                                     It provide a maximumrate test for the
                                     performance values for throughput, latency, and jitter
                                     to verify that a DUT is capable of forwarding packets
                                     at line rate under noncongested conditions.

streamblock_frame_sizes
                Specifies whether to use existing streamblock frame size.
                The default value is false.

frame_size_mode
                Specifies how frame sizes are set and varied through
                successive test trials. The default value is custom.
                Possible values are::


                  Value               Description

                  custom              Specifies a list of frame sizes specified
                                       by the frame_size argument.

                  random              Generates random frame sizes within the
                                       range between the minimum size
                                       (frame_size_min)  and the maximum size
                                       (frame_size_max).

                  step                Increases the frame size for each trial from
                                       that  of the previous trial. You should use
                                       frame_size_start, frame_size_end, and
                                       frame_size_step together to generate the
                                       frame size list for the test when the
                                       frame_size_mode is set to step.

                  imix                Specifies a list of frame sizes specified by
                                       the frame_size_imix argument.

                Note: The frame size includes the Cyclic Redundancy Check (CRC).

frame_size
                Defines the frame size (in bytes) list for the test when you
                specify frame_size_mode custom.

frame_size_imix
                Defines a list of Internet Mix (iMIX) frame size distribution
                profiles when you specify frame_size_mode imix. These are preset
                distribution profiles in Spirent TestCenter::


                 Name          Description

                 Default     A simple mix of the three most common frame sizes
                             found on the Internet

                 Spirent     A simple mix of the four most common frame sizes
                             found on the Internet

                 4Point     The default distribution supplemented by a random
                             set of frame sizes

                 TCPv4       A mix of the most common TCPv4 frame sizes found on
                             the Internet

                 IPSEC       A mix of frame sizes that approximates IPsec traffic

                 jmix_upstream   A mix of frame sizes that approximate JMIX
                                 upstream traffic

                 jmix_downstream  A mix of frame sizes that approximate JMIX
                                  downstream traffic

                You can use these preset names directly, or use profile names
                returned by function imix config when creating custom
                distribution profiles.

frame_size_start
                Indicates the frame size (in bytes) for the first test trial. The
                default value is 128. You can specify this argument when
                frame_size_mode is set to step.

frame_size_end
                Specifies the maximum frame size (in bytes) for the test.
                The default value is 256. You can specify
                this argument when frame_size_mode is set to step.

frame_size_step
                Specifies the frame size (in bytes) increment. The default value
                is 128. You can specify this argument when frame_size_mode is
                set to step.

frame_size_min
                Indicates the minimum frame size (in bytes) when you use random
                mode for frame_size_mode. The default is 128.

frame_size_max
                Indicates the maximum frame size (in bytes) when you use random
                mode for frame_size_mode. The default is 256.

load_type
                Specifies the way of varying the load size during the test.
                Possible values are custom, random, step and fixed. The default
                value is custom. The types are described below::


                 custom - The load sizes to use for the test is a list of the load
                         sizes that are specified by the load_list argument.

                 random - The load sizes to use for the test are the random sizes
                          between the minimum size specified by the load_min
                          argument and the maximum size specified by the load_max
                          argument.

                 step - The load sizes increase by the step value (load_step) with
                        each test iteration, beginning with the start value
                        (load_start) and increasing to the end value (load_end).

                 fixed - The load size to use for the test is the fixed size load.
                         This fixed type traffic load can be configured when the
                         test type is MicroBurst (test_type as mb).

load_unit
                Specifies the load unit to use. The default value is
                percent_line_rate. Possible values are::


                  Value                  Description

                  bits_per_second        Number of bits per second

                 frames_per_second       Number of frames per second

                 inter_burst_gap         Interval between two frames

                 kilobits_per_second     Number of kilobits per second

                 megabits_per_second     Number of megabits per second

                 percent_line_rate       Percentage of the line rate

load_list
                Defines the list of load sizes. You can specify this option
                when load_type is set to custom.

load_start
                Indicates the load size for the first trial. The default is 10.
                You can use this argument when you specify load_type step.
                You should use load_start, load_end, and load_step together
                to generate the load value list when you specify load_type step.

load_end
                Specifies the maximum load value for a trial. The default is 50.
                You can use this argument when you specify load_type step.
                Please refer to load_type for more information.

load_step
                Indicates the difference between two load sizes. The default is
                10. You can use this argument when you specify load_type
                step. Please refer to load_type for more information.

load_min
                Specifies the minimum load value for a trial. You can use this
                argument when you specify load_type random. Please refer to
                load_type for more information. The default is 10.

load_max
                Specifies the maximum load value for a trial. You can use this
                argument when you specify load_type random. Please refer to
                load_type for more information. The default is 50.

load_fixed
                Specifies the fixed load value for a trial. You can use this
                argument when you specify load_type as fixed and -test_type
                as mb.

latency_distribution_list
                Specifies a list of latency values (in microseconds)

burst_type
                Specifies the way of varying the burst size during the MicroBurst
                test. Possible values are custom, random, step and fixed. The
                default value is custom. The types are described below::


                 custom - The burst sizes to use for the test is a list of burst
                         sizes that are specified by the burst_list argument.

                 step - The burst sizes increase by the step value (burst_step) with
                        each test iteration, beginning with the start value
                        (burst_start) and increasing to the end value (burst_end).

                 fixed - The burst size to use for the test is the fixed burst size.
                         This fixed type burst size can be configured when the
                         test type is MicroBurst (test_type as mb).

burst_list
                Defines the list of burst sizes. You can specify this option
                when burst_type is set to custom and -test_type as mb.

burst_start
                Indicates the burst size for the first trial. The default is 1.
                You can use this argument when you specify burst_type as step.
                You should use burst_start, burst_end, and burst_step together
                to generate the burst value list when you specify burst_type as step.

burst_end
                Specifies the maximum burst value for a trial. The default is 1.
                You can use this argument when you specify burst_type as step
                and test_type as mb.

burst_step
                Indicates the difference between two burst sizes. The default is
                1. You can use this argument when you specify burst_type as
                step and test_type as mb.

burst_fixed
                Specifies the fixed burst value for a trial. You can use this
                argument when you specify burst_type as fixed and -test_type
                as mb. The default value is 1.

burst_inter_frame_gap
                Specifies the size of the interframe gap, in bytes. You can
                use this argument when you specify test_type as mb. The
                default value is 12.

latency_type
                Specifies the latency calculation methods. The default value
                is LILO. the latency calculation methods. Possible values are::


                  Value             Description
                  FILO              FirstIn Last-Out latency

                  FIFO              FirstIn First-Out latency

start_traffic_delay
                Specifies the delay (in seconds) before test traffic
                is transmitted. This delay occurs after the learning
                period, when test frames are sent to determine
                whether the DUT/SUT correctly forwards frames to
                their destination. Possible values range from 0 to 3600.
                The default value is 2.

stagger_start_delay
                Specifies the delay, measured in microseconds, between each
                transmission. Spirent HLTAPI multiplies the value by 64. For
                example, if you enter 5, the staggered start is 320 microseconds
                between each port starting traffic. A nonzero value causes the
                test ports to transmit test traffic in sequence. A zero value
                causes the test ports to send traffic all at once. Possible
                values range from 0 to 65. The default is 0.

delay_after_transmission
                Specifies the delay after transmission in seconds. Possible
                values range from 0 to 3600. The default value is 15.

enable_learning
                Determines whether enables learning mode or not. Possible
                values are 0 and 1. When it is set to 1, the options related
                to learning are valid. The default is 1.

learning_mode
                Defines Layer 2 learning mode or Layer 3 learning mode.
                The default value is l3.
                Possible values are::


                  Value              Description
                  l2                 Layer 2 learning mode

                  l3                 Layer 3 learning mode

learning_frequency
                Specifies the frequency for sending learning frames.
                The default value is learn_once.
                Possible values are::


                  Value                      Description
                  learn_once                 Sends learning frames once before
                                              the test starts

                  learn_every_trial          Sends learning frames before each
                                              trial begins

                  learn_every_frame_size     Sends learning frames upon each
                                              iteration in frame size

                  learn_every_iteration      Sends learning frames before each
                                              iteration begins

learning_rate
                Specifies the rate, measured in frames per second, at which
                learning frames are sent to the SUT. You must specify
                learning_mode to l2.

l3_learning_retry_count
                Specifies the number of Layer 3 learning retries
                if transmission, learning verification, or link errors
                occur. Possible values range from 1-100. The default is 5.
                You can specify this argument when you specify
                learning_mode l3.

l2_learning_repeat_count
                Specifies the number of Layer 2 learning retries
                if transmission, learning verification, or link errors
                occur. Possible values range from 1-100. The default is 5.
                You can specify this argument when you specify
                learning_mode l2.

l2_delay_before_learning
                Specifies the delay before L2 learning in seconds.
                Possible values range from 0-3600. The default is 2.
                You can specify this argument when you specify
                learning_mode l2.

l3_delay_before_learning
                Specifies the delay before L3 learning in seconds.
                Possible values range from 0-3600. The default is 2.
                You can specify this argument when you specify
                learning_mode l3.

l2_fixed_frame_size
                Specifies the l2 learning frame size. The default
                value is 64. You can use this argument when you
                specify learning_mode l2.

l2_learning_frame_size_mode
                Specifies the mode of learning l2 frame size. The
                default value is fixed. You can use this argument when
                you specify learning_mode l2.

enable_cyclic_resolution
                Enables or disables the Layer 3 cyclic address resolution.
                Possible values are 0 (disable) and 1 (enable).
                Spirent TestCenter sends as many Address Resolution Protocol
                (ARP) /Neighbor Discovery (ND) requests as the number of source
                IP addresses. The intended use for this option is to seed the
                DUT's ARP cache with the source IP and MAC addresses. If this
                option is disabled, only one ARP/ND request is sent. The default
                is 1. You can specify this argument when learning_mode is set to
                l3.

enable_traffic_verification
                When enabled, verification commands will be added to the test
                sequence. Possible values are true and false. The default value
                is false.

traffic_verification_freq_mode
                Specifies when to perform traffic verification during the test.
                The default value is verify_every_iteration. This option is
                available when enable_traffic_verification is set as true.
                Possible values are::


                  Value                      Description
                  verify_every_trial         Verify traffic forwarding at the
                                              beginning of every trial

                  verify_every_frame_size    Verify traffic forwarding after
                                              changing the frame size

                  verify_every_iteration     Verify traffic forwarding at the
                                              beginning of every iteration

traffic_verification_abort_on_fail
                Specifies the test behavior when traffic verification fails.
                Possible values are true and false. When set to true, Spirent
                HLTAPI stops the test if a fail result is detected on any port
                or stream. The default value is true. This option is
                available when enable_traffic_verification is set as true.

traffic_verification_tx_frame_count
                Specifies the number of frames to send from each port for traffic
                verification. Possible values range from 0 to 32767. The default
                value is 100. This option is available when enable_traffic_verification
                is set as true.

traffic_verification_tx_frame_rate
                Specifies the traffic rate in frames per second to use for
                verification. Possible values range from 0 to 14880952. The
                default value is 100. This option is available when
                enable_traffic_verification is set as true.

display_load_unit
                Specifies the unit used in results. The default value is percent_line_rate.
                Possible values are::


                  Value                  Description
                  bits_per_second        Specify results in bps

                  frames_per_second      Specify results in frames/sec

                  inter_burst_gap        Specify results in interburst gap

                  kilobits_per_second    Specify results in Kbps

                  megabits_per_second    Specify results in Mbps

                  percent_line_rate      Specify results as a percentage

Arguments Unsupported by Save as HLTAPI:

None.
Return Values:

Depending on the specific language that HLTAPI uses, the function returns a keyed list/dictionary/hash (See Introduction for more information on return value formats) using the following keys (with corresponding data):

handle    Identifies the created test instance.
status    Success (1) or failure (0) of the operation.
log       An error message (if the operation failed).
Description:

The test rfc8239 config function creates, modifies, or deletes an RFC 8239 test that can be a LineRate test. Use the -mode argument to specify the action to perform. (See the mode argument description for information about the actions.)

Once the RFC 8239 test has been configured, a handle is created, which can be used to modify the created test. (See the mode argument description for more information).

You must specify the mode (create, modify, or delete) argument.

You can use one of the following methods to create a stream used in the created test:

  • You can enable the endpoint_creation parameter that indicates you will use new endpoints to create streams for the test. Then you must use the src_port option and the -dst_port option to specify the source port handle and the destination port handle on which to emulate new streams.
  • You can specify src_endpoints and -dst_endpoints to create a bound stream for the test.
  • You can provide a list of existing streams by specifying streamblock_handle for the test.

For more information about the protocol, see RFC 8239.

Examples:

The following example creates a LineRate= test:

set line_rate_cfg [test rfc8239 config
           mode=                                             create
           test_type=                                        lr
           streamblock_handle=                               streamblock1
           endpoint_creation=                                0
           latency_type=                                     FIFO
           start_traffic_delay=                              3
           stagger_start_delay=                              4
           delay_after_transmission=                         30
           enable_learning=                                  1
           learning_mode=                                    l2
           learning_frequency=                               learn_every_trial
           learning_rate=                                    2000
           l2_delay_before_learning=                         4
           l2_learning_repeat_count=                         8
           l2_fixed_frame_size=                              256
           l2_learning_frame_size_mode=                      fixed
           enable_traffic_verification=                      true
           traffic_verification_freq_mode=                   verify_every_trial
           traffic_verification_abort_on_fail=               true
           traffic_verification_tx_frame_count=              200
           traffic_verification_tx_frame_rate=               2000
           iteration_count=                                  2
           test_duration_mode=                               bursts
           test_duration_bursts=                             1300
           streamblock_frame_sizes=                          false
           frame_size_mode=                                  custom
           frame_size=                                       "64 512"
           load_unit=                                        percent_line_rate
           load_type=                                        custom
           load_list=                                        "10 30" ]

Sample Output:

{status 1} {handle rfc8239linerateconfig2}

The following example creates a MicroBurst test:

set line_rate_cfg [test rfc8239 config
           mode=                                             create
           test_type=                                        mb
           streamblock_handle=                               streamblock1
           endpoint_creation=                                0
           latency_type=                                     FIFO
           start_traffic_delay=                              3
           stagger_start_delay=                              4
           delay_after_transmission=                         30
           enable_learning=                                  1
           learning_mode=                                    l2
           learning_frequency=                               learn_every_trial
           learning_rate=                                    2000
           l2_delay_before_learning=                         4
           l2_learning_repeat_count=                         8
           l2_fixed_frame_size=                              256
           l2_learning_frame_size_mode=                      fixed
           enable_traffic_verification=                      true
           traffic_verification_freq_mode=                   verify_every_trial
           traffic_verification_abort_on_fail=               true
           traffic_verification_tx_frame_count=              200
           traffic_verification_tx_frame_rate=               2000
           iteration_count=                                  1
           test_duration_mode=                               bursts
           test_duration_bursts=                             1300
           streamblock_frame_sizes=                          false
           frame_size_mode=                                  custom
           frame_size=                                       "128"
           load_unit=                                        percent_line_rate
           load_type=                                        custom
           load_list=                                        "30"
           burst_type=                                       step
           burst_start=                                      20
           burst_end=                                        20
           burst_step=                                       20
           burst_inter_frame_gap=                            16 ]

Sample Output:

{status 1} {handle rfc8239microburstconfig2}

The following example modifies a created test:

test rfc8239 config mode=modify
          handle=                            [keylget line_rate_cfg handle]
          test_type=                         lr
          learning_rate=                     1200
          l2_delay_before_learning=          6
          l2_learning_repeat_count=          4
          l2_fixed_frame_size=               512

Sample Output:

{status 1}

test rfc8239 control

Execute Tester Command ${rt_handle} command=test_control <additional key=value arguments>

Purpose:
Controls the RFC 8239 tests.

Synopsis:

Note: M indicates the argument is `Mandatory`.
    test rfc8239 control
        action= {run | insert_breakpoint | remove_breakpoint | stop} M
        wait= {0|1}
        breakpoint= {trial | framesize | load}
        cleanup= {0|1}

Arguments:

action
                Specifies the action to perform for the test. Possible values
                are run and stop. The modes are described below::


                 run                - Starts the test. You can start one test in each type.
                 insert_breakpoint  - Inserts a pause on selected commands. The Command
                                      Sequencer pauses on commands that contain a breakpoint
                                      before running them.
                 remove_breakpoint  - Removes a pause from selected commands.
                 stop               - Stops the test.

wait
                Determines whether this command will return only when the test is
                completed. Possible values are 0 and 1. The default is 1. When it
                is set to 1, the command will return only when the test is
                completed.

breakpoint
                Specifies the command name to pause the sequencer test.
                Possible values are::


                 trial      - Pauses the test at each trial iteration.
                 framesize  - Pauses the test at each frame size iteration.
                 load       - Pauses the test at each load size iteration.

cleanup
                Determines whether the current test instance should be deleted
                after the test is completed. Possible values are 0 and 1. The
                default value is 0. When it is set to 1, the current test
                instance will be deleted after the test is completed.
Return Values:

Depending on the specific language that HLTAPI uses, the function returns a keyed list/dictionary/hash (See Introduction for more information on return value formats) using the following keys (with corresponding data):

status $SUCCESS or $FAILURE log Error message if command returns {status 0}
Description:
The test rfc8239 control function controls the starting and stopping of the test.

Examples:

The following example starts all current configured tests at the same time and does not do the cleanup action when the tests stop:

set ret test rfc8239 control action=run wait 1 -cleanup 0

Sample output for the example shown above:

{status 1}

test rfc8239 info

Execute Tester Command ${rt_handle} command=test_control <additional key=value arguments>

Purpose:
Retrieves statistics for the configured RFC8239 test.

Synopsis:

Note: M indicates the argument is `Mandatory`.

    test rfc8239 info
        test_type= {lr|mb} M
        result_type= {lr_frame_size|lr_load_size|lr_basic|mb_frame_size|mb_load_size|mb_burst_size|mb_stream_block}
        clear_db= {0|1}

Arguments:

test_type
                Specifies the type of the test, whose information will be returned.
                This argument is `Mandatory`. Possible values are lr and mb.

result_type
                Specifies the type of result properties to be returned.
                When the test_type is lr, possible values are lr_frame_size
                lr_load_size, and lr_basic and when test_type is mb, possible
                values are mb_frame_size, mb_load_size, mb_burst_size and
                mb_stream_block.

clear_db
                Specifies to stop and delete the TestCenter IQ database at the
                end of the test. Possible values are 0 and 1. The default is 1.
                If the value is set to 1, test will stop and delete the db.
                If the value is set to 0, test will not stop and delete the db.
Return Values:

Depending on the specific language that HLTAPI uses, the function returns a keyed list/dictionary/hash (See Introduction for more information on return value formats) using the following keys (with corresponding data):

status             SUCCESS or $FAILURE log Error message if command returns {status 0}

statistics list    Specifies the list of RFC 8239 statistics

The following keys are returned when you specify result_type lr_load_size::


  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.test_snapshot_name
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.min_jitter
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value><load value>.test_frame_size
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.test_load_size
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.test_trial_number
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.tx_frame_count
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.avg_latency
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.max_latency
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.max_jitter
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.rx_frame_count
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.avg_jitter
  <rfc8239>.<linerate>.<LineRate_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.min_latency

The following keys are returned when you specify result_type as lr_frame_size::


  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.test_snapshot_name
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.avg_latency
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.test_trial_number
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.offered_fps_load
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.min_jitter
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.test_load_size
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.max_jitter
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.tx_frame_count
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.test_frame_size
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.offered_bps_load
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.rx_frame_count
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.max_latency
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.avg_jitter
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.min_latency
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.offered_pct_load
  <rfc8239>.<linerate>.<LineRate_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.tx_frame_rate

The following keys are returned when you specify result_type as lr_basic::


  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.test_snapshot_name
  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.tx_port_basic_stats_total_frame_count
  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.tx_port_basic_stats_total_octet_count
  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.tx_port_basic_stats_generator_sig_frame_count
  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.tx_port_basic_stats_total_bit_count
  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.rx_port_basic_stats_total_bit_count
  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.rx_port_basic_stats_total_frame_count
  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.rx_port_basic_stats_sig_frame_count
  <rfc8239>.<linerate>.<LineRate_Basic_Summary_Result>.<Iteration value>.<frame size value>.<load value>.rx_port_basic_stats_total_octet_count

The following keys are returned when you specify result_type mb_frame_size::


  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_snapshot_name
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_trial_number
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value><load value>.<burst size value>.test_frame_size
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_load_size
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_burst_size
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_num_ingress_ports
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_num_egress_ports
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.tx_frame_rate
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.tx_frame_count
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.rx_frame_count
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.frame_loss
  <rfc8239>.<microburst>.<MicroBurst_Per_FrameSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.percent_loss

The following keys are returned when you specify result_type as mb_load_size::


  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_snapshot_name
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_trial_number
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_frame_size
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_load_size
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_burst_size
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_num_ingress_ports
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_num_egress_ports
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.tx_frame_rate
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.tx_frame_count
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.rx_frame_count
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.frame_loss
  <rfc8239>.<microburst>.<MicroBurst_Per_LoadSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.percent_loss

The following keys are returned when you specify result_type as mb_burst_size::


  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_snapshot_name
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_trial_number
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_frame_size
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_load_size
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_burst_size
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_num_ingress_ports
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_num_egress_ports
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.tx_frame_rate
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.tx_frame_count
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.rx_frame_count
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.frame_loss
  <rfc8239>.<microburst>.<MicroBurst_Per_BurstSize_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.percent_loss

The following keys are returned when you specify result_type as mb_stream_block::


  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_snapshot_name
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_trial_number
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_frame_size
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_load_size
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_burst_size
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_num_ingress_ports
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.test_num_egress_ports
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.tx_frame_rate
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.tx_frame_count
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.rx_frame_count
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.frame_loss
  <rfc8239>.<microburst>.<MicroBurst_Per_StreamBlock_Result>.<Iteration value>.<frame size value>.<load value>.<burst size value>.percent_loss
Description:

The test rfc8239 info function provides information about the configured tests.

This function returns the requested data and a status value (1 for success). If there is an error, the function returns the status value (0). Function return values are formatted as a keyed list (supported by the Tcl extension software - TclX). Use the TclX function keylget to retrieve data from the keyed list. (See Return Values for a description of each key.)

Examples:

To return LineRate= per load results:

set ret test rfc8239 info test_type=lr result_type lr_load_size

Sample Output:

{status 1} {rfc8239 {{linerate {{LineRate_Per_LoadSize_Result {{T1 {{512 {{30 {
 {test_snapshot_name T1FrameSize:512-Load:30} {test_trial_number 1} {test_frame_size 512}
 {test_load_size 30} {tx_frame_count 1300} {rx_frame_count 1300} {avg_latency -26.937}
 {min_latency -36.52} {max_latency 48.69} {avg_jitter null} {min_jitter null}
 {max_jitter null}}}}}}}}}}}}}

To return LineRate= per frame size results:

set ret test rfc8239 info test_type=lr result_type lr_frame_size

Sample Output:

{status 1} {rfc8239 {{linerate {{LineRate_Per_FrameSize_Result {{T1 {{512 {{30 {
 {test_snapshot_name T1FrameSize:512-Load:30} {test_trial_number 1} {test_frame_size 512}
 {test_load_size 30} {tx_frame_count 1300} {rx_frame_count 1300} {tx_frame_rate 70488}
 {offered_pct_load 30} {offered_fps_load 70488} {offered_bps_load 299996928}
 {avg_latency -35.615} {min_latency -44.27} {max_latency 53.57} {avg_jitter null}
 {min_jitter null} {max_jitter null}}}}}}}}}}}}}

To return LineRate= basic results:

set ret test rfc8239 info test_type=lr result_type lr_basic

Sample Output:

{status 1} {rfc8239 {{linerate {{LineRate_Basic_Summary_Result {{T1 {{512 {{30
{{test_snapshot_name T1FrameSize:512-Load:30} {test_trial_number 1} {test_frame_size 512}
{test_load_size 30} {tx_frame_count 1300} {rx_frame_count 1300} {avg_latency -21.63}
{min_latency -30.44} {max_latency 167.82} {avg_jitter null} {min_jitter null}
{max_jitter null}}}}}}}}}}}}}

To return MicroBurst per frame size results:

set ret test rfc8239 info test_type=mb result_type mb_frame_size

Sample Output:

{status 1} {rfc8239 {{microburst {{MicroBurst_Per_FrameSize_Result {{T1 {{128 {{30 {{20 {
{test_snapshot_name T1NumTxPorts:1NumRxPorts:1-FrameSize:128-Load:30-Burst:20-Frames} {
test_trial_number 1} {test_frame_size 128} {test_load_size 30} {test_burst_size 20}
{test_num_ingress_ports 1} {test_num_egress_ports 1} {tx_frame_rate 253378} {tx_frame_count
26000} {rx_frame_count 26000} {frame_loss 0} {percent_loss 0}}}}}}}}}}}}}}}

To return MicroBurst per load size results:

set ret test rfc8239 info test_type=mb result_type mb_load_size

Sample Output:

{status 1} {rfc8239 {{microburst {{MicroBurst_Per_LoadSize_Result {{T1 {{128 {{30 {{20 {{test_snapshot_name T1NumTxPorts:1NumRxPorts:1-FrameSize:128-Load:30-Burst:20-Frames} {test_trial_number 1} {test_frame_size 128} {test_load_size 30} {test_burst_size 20} {test_num_ingress_ports 1} {test_num_egress_ports 1} {tx_frame_rate 253378} {tx_frame_count 26000} {rx_frame_count 26000} {frame_loss 0} {percent_loss 0}}}}}}}}}}}}}}}

To return MicroBurst per burst size results:

set ret test rfc8239 info test_type=mb result_type mb_burst_size

Sample Output:

{status 1} {rfc8239 {{microburst {{MicroBurst_Per_BurstSize_Result {{T1 {{128 {{30 {{20 {{test_snapshot_name T1NumTxPorts:1NumRxPorts:1-FrameSize:128-Load:30-Burst:20-Frames} {test_trial_number 1} {test_frame_size 128} {test_load_size 30} {test_burst_size 20} {test_num_ingress_ports 1} {test_num_egress_ports 1} {tx_frame_rate 253378} {tx_frame_count 26000} {rx_frame_count 26000} {frame_loss 0} {percent_loss 0}}}}}}}}}}} }}}}

To return MicroBurst per streamblock results:

set ret test rfc8239 info test_type=mb result_type mb_stream_block

Sample Output:

{status 1} {rfc8239 {{microburst {{MicroBurst_Per_StreamBlock_Result {{T1 {{128 {{30 {{20 {{test_snapshot_name T1NumTxPorts:1NumRxPorts:1-FrameSize:128-Load:30-Burst:20-Frames} {test_trial_number 1} {test_frame_size 128} {test_load_size 30} {test_burst_size 20} {test_num_ingress_ports 1} {test_num_egress_ports 1} {tx_frame_rate 253378} {tx_frame_count 26000} {rx_frame_count 26000} {frame_loss 0} {percent_loss 0}}}}}}}}}}}}}}}

End of Procedure Header