summaryrefslogtreecommitdiffstats
path: root/test/test_ip6.py
diff options
context:
space:
mode:
authorAndrew Yourtchenko <ayourtch@gmail.com>2020-08-26 14:33:54 +0000
committerOle Trøan <otroan@employees.org>2020-08-27 08:03:38 +0000
commita3b7c554c669afc627f9a1e32666211bb6fb6b25 (patch)
tree625a8fd262f823d0bd79ec779430a6df905368df /test/test_ip6.py
parentd135487aff499b3450fd8d3013b6af52d80e96a1 (diff)
tests: "force solo" testcase support
Some of the tests are time-sensitive, and at present require a non-trivial modification in order to run at high concurrency. Without these modifications, they intermittently fail, and require the test retries. Rather than setting them to the extended tests and forgetting about them, put them into a "solo" set, which gets run in a single-threaded mode after the rest of the tests are done. Mark a few of the tests that showed errors during TEST_JOBS=48 as forced-solo. Also, give a better diagnostic if the testcase misses a docstring needed to represent it in the diagnostic outputs. Type: fix Change-Id: I33fe62eb17edc1885bd2c3523892051d52da6546 Signed-off-by: Andrew Yourtchenko <ayourtch@gmail.com>
Diffstat (limited to 'test/test_ip6.py')
-rw-r--r--test/test_ip6.py4
1 files changed, 4 insertions, 0 deletions
diff --git a/test/test_ip6.py b/test/test_ip6.py
index f8a2dc24e42..36ef5777207 100644
--- a/test/test_ip6.py
+++ b/test/test_ip6.py
@@ -165,6 +165,10 @@ class TestIPv6(TestIPv6ND):
""" IPv6 Test Case """
@classmethod
+ def force_solo(cls):
+ return True
+
+ @classmethod
def setUpClass(cls):
super(TestIPv6, cls).setUpClass()
a id='n187' href='#n187'>187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 
module policer {

    yang-version 1;
    namespace "urn:opendaylight:params:xml:ns:yang:policer";
    prefix "policer";

    description
        "VPP specific configuration of policer messages. Mapped to policer API:
         https://git.fd.io/vpp/tree/src/vnet/policer/policer.api

         Partially based on
         https://tools.ietf.org/html/draft-asechoud-netmod-qos-model-02";

    reference
        "https://docs.fd.io/vpp/17.04/clicmd_src_vnet_policer.html";

    revision "2017-03-15" {
        description "Initial revision of policer model";
    }

    import ietf-inet-types {
      prefix inet;
    }

    typedef policer-ref {
        type leafref {
            path "/policers/policer/name";
        }
        description
            "This type is used by data models that need to reference
            configured policer.";
    }

    typedef color-classfier {
        type enumeration {
            enum conform-color;
            enum exceed-color;
        }
        default conform-color;
    }

    typedef meter-type {
        type enumeration {
            enum 1r2c;
            enum 1r3c;
            enum 2r3c-2698;
            enum 2r3c-4115;
            enum 2r3c-mef5cf1;
        }
        default 1r2c;
    }

    typedef policer-round-type {
        type enumeration {
            enum closest;
            enum up;
            enum down;
        }
        default closest;
    }

    typedef policer-rate-type {
        type enumeration {
            enum kbps;
            enum pps;
        }
        default kbps;
    }

    // adapted from draft-asechoud-netmod-qos-model-02
    identity meter-action-type {
      description
        "action type in a meter";
    }

    identity meter-action-drop {
      base meter-action-type;
      description
        "drop action type in a meter";
    }

    identity meter-action-mark-dscp {
      base meter-action-type;
      description
        "dscp mark and transmit action type in a meter";
    }

    identity meter-action-transmit {
      base meter-action-type;
      description
        "transmit action type in a meter";
    }

    typedef vpp-dscp-type {
        description
            "DSCP field values supported by VPP";
        type enumeration {
            enum CS0 {
                value 0;
            }
            enum CS1 {
                value 8;
            }
            enum AF11 {
                value 10;
            }
            enum AF12 {
                value 12;
            }
            enum AF13 {
                value 14;
            }
            enum CS2 {
                value 16;
            }
            enum AF21 {
                value 18;
            }
            enum AF22 {
                value 20;
            }
            enum AF23 {
                value 22;
            }
            enum CS3 {
                value 24;
            }
            enum AF31 {
                value 26;
            }
            enum AF32 {
                value 28;
            }
            enum AF33 {
                value 30;
            }
            enum CS4 {
                value 32;
            }
            enum AF41 {
                value 34;
            }
            enum AF42 {
                value 36;
            }
            enum AF43 {
                value 38;
            }
            enum CS5 {
                value 40;
            }
            enum EF {
                value 46;
            }
            enum CS6 {
                value 48;
            }
            enum CS7 {
                value 50;
            }
        }
        default CS0;
    }

    typedef dscp-type {
        type union {
            type vpp-dscp-type;
            type inet:dscp;
        }
    }

    grouping meter-action-params {
      description
        "meter action parameters";
      leaf meter-action-type {
        mandatory true;
        type identityref {
          base meter-action-type;
        }
        description
          "meter action type";
      }
      leaf dscp {
        when "../meter-action-type = meter-action-mark-dscp";
        type dscp-type;
        description
          "dscp marking";
      }
    }

    grouping policer-base-attributes {
        leaf cir {
            type uint32;
        }
        leaf eir {
            type uint32;
        }
        leaf cb {
            type uint64;
            description "Committed Burst";
        }
        leaf eb {
            type uint64;
            description "Excess or Peak Bursnatt";
        }
        leaf rate-type {
            type policer-rate-type;
        }
        leaf round-type {
            type policer-round-type;
        }
        leaf type {
            type meter-type;
            description "policer algorithm";
        }
        leaf color-aware {
            type boolean;
        }
        container conform-action {
            presence "Defines conform action";
            uses meter-action-params;
        }
        container exceed-action {
            presence "Defines exceed action";
            uses meter-action-params;
        }
        container violate-action {
            presence "Defines violate action";
            uses meter-action-params;
        }
    }

    grouping policer-operational-attributes {
        leaf single-rate {
            type boolean;
        }
        leaf scale {
            type uint32;
        }
        leaf cir-tokens-per-period {
            type uint32;
        }
        leaf pir_tokens-per-period {
            type uint32;
        }
        leaf current-limit {
            type uint32;
        }
        leaf current-bucket {
            type uint32;
        }
        leaf extended-limit {
            type uint32;
        }
        leaf extended-bucket {
            type uint32;
        }
        leaf last-update-time {
            type uint64;
        }
    }

    container policers {
        list policer {
            key name;
            leaf name {
                type string {
                    length 1..63;
                }
            }
            uses policer-base-attributes;
        }
    }

    container policers-state {
        list policer {
            key name;
            leaf name {
                type string {
                    length 1..63;
                }
            }
            uses policer-base-attributes;
            uses policer-operational-attributes;
        }
    }
}