aboutsummaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/ec/curves.py29
-rw-r--r--test/ec/test_context.py9
-rw-r--r--test/ec/test_curve.py28
-rw-r--r--test/ec/test_group.py7
-rw-r--r--test/ec/test_key_agreement.py4
-rw-r--r--test/ec/test_mult.py140
-rw-r--r--test/ec/test_op.py32
-rw-r--r--test/ec/test_point.py13
-rw-r--r--test/ec/test_signature.py4
-rw-r--r--test/sca/test_traceset.py1
10 files changed, 162 insertions, 105 deletions
diff --git a/test/ec/curves.py b/test/ec/curves.py
deleted file mode 100644
index c7453c7..0000000
--- a/test/ec/curves.py
+++ /dev/null
@@ -1,29 +0,0 @@
-from pyecsca.ec.curve import EllipticCurve
-from pyecsca.ec.group import AbelianGroup
-from pyecsca.ec.mod import Mod
-from pyecsca.ec.model import ShortWeierstrassModel, MontgomeryModel
-from pyecsca.ec.point import Point, InfinityPoint
-
-
-def get_secp128r1():
- prime = 0xfffffffdffffffffffffffffffffffff
- model = ShortWeierstrassModel()
- coords = model.coordinates["projective"]
- curve = EllipticCurve(model, coords, prime, dict(a=0xfffffffdfffffffffffffffffffffffc,
- b=0xe87579c11079f43dd824993c2cee5ed3))
- return AbelianGroup(curve, Point(coords, X=Mod(0x161ff7528b899b2d0c28607ca52c5b86, prime),
- Y=Mod(0xcf5ac8395bafeb13c02da292dded7a83, prime),
- Z=Mod(1, prime)), InfinityPoint(coords),
- order=0xfffffffe0000000075a30d1b9038a115, cofactor=1)
-
-
-def get_curve25519():
- prime = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed
- model = MontgomeryModel()
- coords = model.coordinates["xz"]
- curve = EllipticCurve(model, coords, prime,
- dict(a=486662, b=1))
- return AbelianGroup(curve, Point(coords, X=Mod(9, prime), Z=Mod(1, prime)),
- InfinityPoint(coords),
- order=0x1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED,
- cofactor=2)
diff --git a/test/ec/test_context.py b/test/ec/test_context.py
index 1073fc0..77160cb 100644
--- a/test/ec/test_context.py
+++ b/test/ec/test_context.py
@@ -5,25 +5,24 @@ from pyecsca.ec.context import (local, DefaultContext, OpResult, NullContext, ge
setcontext,
resetcontext)
from pyecsca.ec.coordinates import AffineCoordinateModel
+from pyecsca.ec.curves import get_curve
from pyecsca.ec.mod import Mod
from pyecsca.ec.mult import LTRMultiplier
from pyecsca.ec.point import Point
-from .curves import get_secp128r1
class OpResultTests(TestCase):
- def test_repr(self):
+ def test_str(self):
for op, char in zip((ast.Add(), ast.Sub(), ast.Mult(), ast.Div()), "+-*/"):
res = OpResult("X1", Mod(0, 5), op, Mod(2, 5), Mod(3, 5))
self.assertEqual(str(res), "X1")
- self.assertEqual(repr(res), "X1 = 2{}3".format(char))
class ContextTests(TestCase):
def setUp(self):
- self.secp128r1 = get_secp128r1()
+ self.secp128r1 = get_curve("secp128r1", "projective")
self.base = self.secp128r1.generator
self.coords = self.secp128r1.curve.coordinate_model
self.mult = LTRMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
@@ -51,7 +50,7 @@ class ContextTests(TestCase):
Point(AffineCoordinateModel(self.secp128r1.curve.model),
x=Mod(1, 5), y=Mod(2, 5)))
- def test_repr(self):
+ def test_str(self):
with local(DefaultContext()) as default:
self.mult.multiply(59, self.base)
str(default)
diff --git a/test/ec/test_curve.py b/test/ec/test_curve.py
index 1adaf47..1f2ca1f 100644
--- a/test/ec/test_curve.py
+++ b/test/ec/test_curve.py
@@ -1,17 +1,19 @@
from unittest import TestCase
+from parameterized import parameterized
+
from pyecsca.ec.curve import EllipticCurve
+from pyecsca.ec.curves import get_curve
from pyecsca.ec.mod import Mod
from pyecsca.ec.model import MontgomeryModel
from pyecsca.ec.point import Point
-from .curves import get_secp128r1, get_curve25519
class CurveTests(TestCase):
def setUp(self):
- self.secp128r1 = get_secp128r1()
+ self.secp128r1 = get_curve("secp128r1", "projective")
self.base = self.secp128r1.generator
- self.curve25519 = get_curve25519()
+ self.curve25519 = get_curve("curve25519", "xz")
def test_init(self):
with self.assertRaises(ValueError):
@@ -39,10 +41,22 @@ class CurveTests(TestCase):
Z=Mod(1, self.secp128r1.curve.prime))
assert not self.secp128r1.curve.is_on_curve(other)
+ @parameterized.expand([
+ ("secp128r1","projective"),
+ ("secp256r1", "projective"),
+ ("secp521r1", "projective"),
+ ("curve25519", "xz"),
+ ("ed25519", "projective"),
+ ("ed448", "projective")
+ ])
+ def test_curve_utils(self, name, coords):
+ group = get_curve(name, coords)
+ try:
+ assert group.curve.is_on_curve(group.generator)
+ except NotImplementedError:
+ pass
+
def test_eq(self):
self.assertEqual(self.secp128r1.curve, self.secp128r1.curve)
self.assertNotEqual(self.secp128r1.curve, self.curve25519.curve)
-
- def test_repr(self):
- self.assertEqual(repr(self.secp128r1.curve),
- "EllipticCurve([a=340282366762482138434845932244680310780, b=308990863222245658030922601041482374867] on ShortWeierstrassModel() using EFDCoordinateModel(\"projective\" on short Weierstrass curves))")
+ self.assertNotEqual(self.secp128r1.curve, None)
diff --git a/test/ec/test_group.py b/test/ec/test_group.py
index e3b3a72..ca0ea91 100644
--- a/test/ec/test_group.py
+++ b/test/ec/test_group.py
@@ -1,14 +1,14 @@
from unittest import TestCase
+from pyecsca.ec.curves import get_curve
from pyecsca.ec.point import InfinityPoint
-from .curves import get_secp128r1, get_curve25519
class AbelianGroupTests(TestCase):
def setUp(self):
- self.secp128r1 = get_secp128r1()
- self.curve25519 = get_curve25519()
+ self.secp128r1 = get_curve("secp128r1", "projective")
+ self.curve25519 = get_curve("curve25519", "xz")
def test_is_neutral(self):
assert self.secp128r1.is_neutral(InfinityPoint(self.secp128r1.curve.coordinate_model))
@@ -16,3 +16,4 @@ class AbelianGroupTests(TestCase):
def test_eq(self):
self.assertEqual(self.secp128r1, self.secp128r1)
self.assertNotEqual(self.secp128r1, self.curve25519)
+ self.assertNotEqual(self.secp128r1, None)
diff --git a/test/ec/test_key_agreement.py b/test/ec/test_key_agreement.py
index f22ee75..ab009e3 100644
--- a/test/ec/test_key_agreement.py
+++ b/test/ec/test_key_agreement.py
@@ -1,14 +1,14 @@
from unittest import TestCase
+from pyecsca.ec.curves import get_curve
from pyecsca.ec.key_agreement import *
from pyecsca.ec.mult import LTRMultiplier
-from .curves import get_secp128r1
class KeyAgreementTests(TestCase):
def setUp(self):
- self.secp128r1 = get_secp128r1()
+ self.secp128r1 = get_curve("secp128r1", "projective")
self.add = self.secp128r1.curve.coordinate_model.formulas["add-2007-bl"]
self.dbl = self.secp128r1.curve.coordinate_model.formulas["dbl-2007-bl"]
self.mult = LTRMultiplier(self.secp128r1, self.add, self.dbl)
diff --git a/test/ec/test_mult.py b/test/ec/test_mult.py
index c72f370..3abc72c 100644
--- a/test/ec/test_mult.py
+++ b/test/ec/test_mult.py
@@ -1,47 +1,67 @@
from unittest import TestCase
+from parameterized import parameterized
+
+from pyecsca.ec.curves import get_curve
from pyecsca.ec.mult import (LTRMultiplier, RTLMultiplier, LadderMultiplier, BinaryNAFMultiplier,
WindowNAFMultiplier, SimpleLadderMultiplier, CoronMultiplier)
from pyecsca.ec.point import InfinityPoint
-from .curves import get_secp128r1, get_curve25519
class ScalarMultiplierTests(TestCase):
def setUp(self):
- self.secp128r1 = get_secp128r1()
+ self.secp128r1 = get_curve("secp128r1", "projective")
self.base = self.secp128r1.generator
self.coords = self.secp128r1.curve.coordinate_model
- self.curve25519 = get_curve25519()
+ self.curve25519 = get_curve("curve25519", "xz")
self.base25519 = self.curve25519.generator
self.coords25519 = self.curve25519.curve.coordinate_model
- def test_rtl(self):
- mult = RTLMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
- self.coords.formulas["dbl-1998-cmo"], self.coords.formulas["z"])
+ def get_formulas(self, coords, *names):
+ return [coords.formulas[name] for name in names if name is not None]
+
+ def assertPointEquality(self, one, other, scale):
+ if scale:
+ self.assertEqual(one, other)
+ else:
+ assert one.equals(other)
+
+ @parameterized.expand([
+ ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
+ ("none", "add-1998-cmo", "dbl-1998-cmo", None)
+ ])
+ def test_rtl(self, name, add, dbl, scale):
+ mult = RTLMultiplier(self.secp128r1, *self.get_formulas(self.coords, add, dbl, scale))
res = mult.multiply(10, self.base)
other = mult.multiply(5, self.base)
other = mult.multiply(2, other)
- self.assertEqual(res, other)
+ self.assertPointEquality(res, other, scale)
self.assertEqual(InfinityPoint(self.coords), mult.multiply(0, self.base))
- def test_ltr(self):
- mult = LTRMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
- self.coords.formulas["dbl-1998-cmo"], self.coords.formulas["z"])
+ @parameterized.expand([
+ ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
+ ("none", "add-1998-cmo", "dbl-1998-cmo", None)
+ ])
+ def test_ltr(self, name, add, dbl, scale):
+ mult = LTRMultiplier(self.secp128r1, *self.get_formulas(self.coords, add, dbl, scale))
res = mult.multiply(10, self.base)
other = mult.multiply(5, self.base)
other = mult.multiply(2, other)
- self.assertEqual(res, other)
+ self.assertPointEquality(res, other, scale)
self.assertEqual(InfinityPoint(self.coords), mult.multiply(0, self.base))
- def test_coron(self):
- mult = CoronMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
- self.coords.formulas["dbl-1998-cmo"], self.coords.formulas["z"])
+ @parameterized.expand([
+ ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
+ ("none", "add-1998-cmo", "dbl-1998-cmo", None)
+ ])
+ def test_coron(self, name, add, dbl, scale):
+ mult = CoronMultiplier(self.secp128r1, *self.get_formulas(self.coords, add, dbl, scale))
res = mult.multiply(10, self.base)
other = mult.multiply(5, self.base)
other = mult.multiply(2, other)
- self.assertEqual(res, other)
+ self.assertPointEquality(res, other, scale)
self.assertEqual(InfinityPoint(self.coords), mult.multiply(0, self.base))
def test_ladder(self):
@@ -54,17 +74,24 @@ class ScalarMultiplierTests(TestCase):
self.assertEqual(res, other)
self.assertEqual(InfinityPoint(self.coords25519), mult.multiply(0, self.base25519))
- def test_simple_ladder(self):
- mult = SimpleLadderMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
- self.coords.formulas["dbl-1998-cmo"],
- self.coords.formulas["z"])
+ @parameterized.expand([
+ ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
+ ("none", "add-1998-cmo", "dbl-1998-cmo", None)
+ ])
+ def test_simple_ladder(self, name, add, dbl, scale):
+ mult = SimpleLadderMultiplier(self.secp128r1,
+ *self.get_formulas(self.coords, add, dbl, scale))
res = mult.multiply(10, self.base)
other = mult.multiply(5, self.base)
other = mult.multiply(2, other)
- self.assertEqual(res, other)
+ self.assertPointEquality(res, other, scale)
self.assertEqual(InfinityPoint(self.coords), mult.multiply(0, self.base))
- def test_ladder_differential(self):
+ @parameterized.expand([
+ ("10", 15),
+ ("2355498743", 2355498743,)
+ ])
+ def test_ladder_differential(self, name, num):
ladder = LadderMultiplier(self.curve25519, self.coords25519.formulas["ladd-1987-m"],
self.coords25519.formulas["dbl-1987-m"],
self.coords25519.formulas["scale"])
@@ -72,45 +99,53 @@ class ScalarMultiplierTests(TestCase):
self.coords25519.formulas["dadd-1987-m"],
self.coords25519.formulas["dbl-1987-m"],
self.coords25519.formulas["scale"])
- res_ladder = ladder.multiply(15, self.base25519)
- res_differential = differential.multiply(15, self.base25519)
+ res_ladder = ladder.multiply(num, self.base25519)
+ res_differential = differential.multiply(num, self.base25519)
self.assertEqual(res_ladder, res_differential)
self.assertEqual(InfinityPoint(self.coords25519), differential.multiply(0, self.base25519))
- def test_binary_naf(self):
- mult = BinaryNAFMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
- self.coords.formulas["dbl-1998-cmo"],
- self.coords.formulas["neg"], self.coords.formulas["z"])
+ @parameterized.expand([
+ ("scaled", "add-1998-cmo", "dbl-1998-cmo", "neg", "z"),
+ ("none", "add-1998-cmo", "dbl-1998-cmo", "neg", None)
+ ])
+ def test_binary_naf(self, name, add, dbl, neg, scale):
+ mult = BinaryNAFMultiplier(self.secp128r1,
+ *self.get_formulas(self.coords, add, dbl, neg, scale))
res = mult.multiply(10, self.base)
other = mult.multiply(5, self.base)
other = mult.multiply(2, other)
- self.assertEqual(res, other)
+ self.assertPointEquality(res, other, scale)
self.assertEqual(InfinityPoint(self.coords), mult.multiply(0, self.base))
- def test_window_naf(self):
- mult = WindowNAFMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
- self.coords.formulas["dbl-1998-cmo"],
- self.coords.formulas["neg"], 3, self.coords.formulas["z"])
+ @parameterized.expand([
+ ("scaled3", "add-1998-cmo", "dbl-1998-cmo", "neg", 3, "z"),
+ ("none3", "add-1998-cmo", "dbl-1998-cmo", "neg", 3, None)
+ ])
+ def test_window_naf(self, name, add, dbl, neg, width, scale):
+ formulas = self.get_formulas(self.coords, add, dbl, neg, scale)
+ mult = WindowNAFMultiplier(self.secp128r1, *formulas[:3], width, *formulas[3:])
res = mult.multiply(10, self.base)
other = mult.multiply(5, self.base)
other = mult.multiply(2, other)
- self.assertEqual(res, other)
+ self.assertPointEquality(res, other, scale)
self.assertEqual(InfinityPoint(self.coords), mult.multiply(0, self.base))
- mult = WindowNAFMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
- self.coords.formulas["dbl-1998-cmo"],
- self.coords.formulas["neg"], 3, self.coords.formulas["z"],
+ mult = WindowNAFMultiplier(self.secp128r1, *formulas[:3], width, *formulas[3:],
precompute_negation=True)
res_precompute = mult.multiply(10, self.base)
- self.assertEqual(res_precompute, res)
+ self.assertPointEquality(res_precompute, res, scale)
- def test_basic_multipliers(self):
+ @parameterized.expand([
+ ("10", 10),
+ ("2355498743", 2355498743,)
+ ])
+ def test_basic_multipliers(self, name, num):
ltr = LTRMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
self.coords.formulas["dbl-1998-cmo"], self.coords.formulas["z"])
- res_ltr = ltr.multiply(10, self.base)
+ res_ltr = ltr.multiply(num, self.base)
rtl = RTLMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
self.coords.formulas["dbl-1998-cmo"], self.coords.formulas["z"])
- res_rtl = rtl.multiply(10, self.base)
+ res_rtl = rtl.multiply(num, self.base)
self.assertEqual(res_ltr, res_rtl)
ltr_always = LTRMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
@@ -119,31 +154,44 @@ class ScalarMultiplierTests(TestCase):
rtl_always = RTLMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
self.coords.formulas["dbl-1998-cmo"], self.coords.formulas["z"],
always=True)
- res_ltr_always = ltr_always.multiply(10, self.base)
- res_rtl_always = rtl_always.multiply(10, self.base)
+ res_ltr_always = ltr_always.multiply(num, self.base)
+ res_rtl_always = rtl_always.multiply(num, self.base)
self.assertEqual(res_ltr, res_ltr_always)
self.assertEqual(res_rtl, res_rtl_always)
bnaf = BinaryNAFMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
self.coords.formulas["dbl-1998-cmo"],
self.coords.formulas["neg"], self.coords.formulas["z"])
- res_bnaf = bnaf.multiply(10, self.base)
+ res_bnaf = bnaf.multiply(num, self.base)
self.assertEqual(res_bnaf, res_ltr)
wnaf = WindowNAFMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
self.coords.formulas["dbl-1998-cmo"],
self.coords.formulas["neg"], 3, self.coords.formulas["z"])
- res_wnaf = wnaf.multiply(10, self.base)
+ res_wnaf = wnaf.multiply(num, self.base)
self.assertEqual(res_wnaf, res_ltr)
ladder = SimpleLadderMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
self.coords.formulas["dbl-1998-cmo"],
self.coords.formulas["z"])
- res_ladder = ladder.multiply(10, self.base)
+ res_ladder = ladder.multiply(num, self.base)
self.assertEqual(res_ladder, res_ltr)
coron = CoronMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
self.coords.formulas["dbl-1998-cmo"],
self.coords.formulas["z"])
- res_coron = coron.multiply(10, self.base)
+ res_coron = coron.multiply(num, self.base)
self.assertEqual(res_coron, res_ltr)
+
+ def test_init_fail(self):
+ with self.assertRaises(ValueError):
+ SimpleLadderMultiplier(self.secp128r1,
+ self.coords25519.formulas["dadd-1987-m"],
+ self.coords25519.formulas["dbl-1987-m"],
+ self.coords25519.formulas["scale"])
+
+ def test_mult_fail(self):
+ mult = LTRMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
+ self.coords.formulas["dbl-1998-cmo"], self.coords.formulas["z"])
+ with self.assertRaises(ValueError):
+ mult.multiply(15)
diff --git a/test/ec/test_op.py b/test/ec/test_op.py
new file mode 100644
index 0000000..13efc53
--- /dev/null
+++ b/test/ec/test_op.py
@@ -0,0 +1,32 @@
+from ast import parse
+from unittest import TestCase
+
+from parameterized import parameterized
+
+from pyecsca.ec.mod import Mod
+from pyecsca.ec.op import CodeOp
+
+
+class OpTests(TestCase):
+
+ @parameterized.expand([
+ ("add", "x = a+b", "x = a+b"),
+ ("sub", "x = a-b", "x = a-b"),
+ ("mul", "y = a*b", "y = a*b"),
+ ("div", "z = a/b", "z = a/b"),
+ ("pow", "b = a**d", "b = a^d")
+ ])
+ def test_str(self, name, module, result):
+ code = parse(module, mode="exec")
+ op = CodeOp(code)
+ self.assertEqual(str(op), result)
+
+ @parameterized.expand([
+ ("add", "x = a+b", {"a": Mod(5, 21), "b": Mod(7, 21)}, Mod(12, 21)),
+ ("sub", "x = a-b", {"a": Mod(7, 21), "b": Mod(5, 21)}, Mod(2, 21))
+ ])
+ def test_call(self, name, module, locals, result):
+ code = parse(module, mode="exec")
+ op = CodeOp(code)
+ res = op(**locals)
+ self.assertEqual(res, result)
diff --git a/test/ec/test_point.py b/test/ec/test_point.py
index c80d4cc..0809edc 100644
--- a/test/ec/test_point.py
+++ b/test/ec/test_point.py
@@ -1,15 +1,15 @@
from unittest import TestCase
from pyecsca.ec.coordinates import AffineCoordinateModel
+from pyecsca.ec.curves import get_curve
from pyecsca.ec.mod import Mod
from pyecsca.ec.model import ShortWeierstrassModel, MontgomeryModel
from pyecsca.ec.point import Point, InfinityPoint
-from .curves import get_secp128r1
class PointTests(TestCase):
def setUp(self):
- self.secp128r1 = get_secp128r1()
+ self.secp128r1 = get_curve("secp128r1", "projective")
self.base = self.secp128r1.generator
self.coords = self.secp128r1.curve.coordinate_model
self.affine = AffineCoordinateModel(ShortWeierstrassModel())
@@ -81,12 +81,3 @@ class PointTests(TestCase):
Z=Mod(1, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa))
assert not pt.equals(different)
self.assertNotEqual(pt, different)
-
- def test_repr(self):
- self.assertEqual(str(self.base),
- "[X=29408993404948928992877151431649155974, Y=275621562871047521857442314737465260675, Z=1]")
- self.assertEqual(repr(self.base),
- "Point([[X=29408993404948928992877151431649155974, Y=275621562871047521857442314737465260675, Z=1]] in EFDCoordinateModel(\"projective\" on short Weierstrass curves))")
- self.assertEqual(str(InfinityPoint(self.coords)), "Infinity")
- self.assertEqual(repr(InfinityPoint(self.coords)),
- "InfinityPoint(EFDCoordinateModel(\"projective\" on short Weierstrass curves))")
diff --git a/test/ec/test_signature.py b/test/ec/test_signature.py
index d9b306a..06b6123 100644
--- a/test/ec/test_signature.py
+++ b/test/ec/test_signature.py
@@ -1,15 +1,15 @@
from hashlib import sha1
from unittest import TestCase
+from pyecsca.ec.curves import get_curve
from pyecsca.ec.mult import LTRMultiplier
from pyecsca.ec.signature import *
-from .curves import get_secp128r1
class SignatureTests(TestCase):
def setUp(self):
- self.secp128r1 = get_secp128r1()
+ self.secp128r1 = get_curve("secp128r1", "projective")
self.add = self.secp128r1.curve.coordinate_model.formulas["add-2007-bl"]
self.dbl = self.secp128r1.curve.coordinate_model.formulas["dbl-2007-bl"]
self.mult = LTRMultiplier(self.secp128r1, self.add, self.dbl)
diff --git a/test/sca/test_traceset.py b/test/sca/test_traceset.py
index f12f205..6d48707 100644
--- a/test/sca/test_traceset.py
+++ b/test/sca/test_traceset.py
@@ -20,6 +20,7 @@ class InspectorTraceSetTests(TestCase):
self.assertIsNotNone(result)
self.assertEqual(result.global_title, "Example trace set")
self.assertEqual(len(result), 10)
+ self.assertEqual(len(list(result)), 10)
self.assertIn("InspectorTraceSet", str(result))
self.assertIs(result[0].trace_set, result)
self.assertEqual(result.sampling_frequency, 12500000)
generated by cgit v1.2.3-70-g09d2 (git 2.51.2) at 2025-11-08 14:22:07 +0000