Changeset 3f2f7df in trunk

Timestamp:

2017-08-10T17:27:02Z (8 years ago)

Author:

Brian Warner <warner@…>

Branches:

master

Children:

aaf167b, d91516a5

Parents:

95ac5494

git-author:

Brian Warner <warner@…> (2017-08-10 01:53:29)

git-committer:

Brian Warner <warner@…> (2017-08-10 17:27:02)

Message:

dictutil: fix bug in str(ValueOrderedDict?), and improve test coverage

It looks like str() was meant to truncate the dict, but a missing i+=1 meant
that it never actually did. I also changed the format to include a clear
"..." in case we truncate it, to avoid confusion with a non-truncated dict of
the same size.

This also improves test coverage in subtract() and
NumDict?.item_with_largest_value().

refs ticket:2891

Location:

src/allmydata

Files:

• test/test_util.py (modified) (4 diffs)
• util/dictutil.py (modified) (1 diff)

src/allmydata/test/test_util.py ¶

@@ -2 +2 @@
 def foo(): pass # keep the line number constant
 
-import os, time, sys, yaml
+import os, time, sys, itertools, random
+import yaml
 from StringIO import StringIO
 from datetime import timedelta
@@ -1465 +1466 @@
         self.failUnlessEqual(d3, {1: "a"})
 
-        d1 = {1: "a", 2: "b"}
-        d2 = {2: "c"}
+        d1 = {1: "a", 2: "b", 3: "c"}
+        d2 = {2: "c", 4: "d"}
         d3 = dictutil.subtract(d1, d2)
-        self.failUnlessEqual(d3, {1: "a"})
+        self.failUnlessEqual(d3, {1: "a", 3: "c"})
 
     def test_utildict(self):
@@ -1557 +1558 @@
         self.failUnlessEqual(d.item_with_largest_value(), ("b", 6))
 
+        # to get full coverage of item_with_largest_value(), we need to
+        # exercise two situations: the first value (in iteritems() order) is
+        # larger than the second, and vice versa. Since iteration is not
+        # deterministic, we need to try a bunch of random dictionaries to
+        # exercise this
+        r = random.Random(0) # consistent seed
+        count = itertools.count()
+        found = set()
+        while count.next() < 1000:
+            a = r.randrange(100)
+            b = r.randrange(100)
+            larger = ("a",a) if a > b else ("b",b)
+            if a == b:
+                continue
+            d0 = dictutil.NumDict()
+            d0.add_num("a", a)
+            d0.add_num("b", b)
+            self.failUnlessEqual(d0, {"a": a, "b": b})
+            items = list(d0.d.iteritems())
+            if items[0][1] > items[1][1]:
+                found.add("first-larger")
+            else:
+                found.add("first-smaller")
+            self.failUnlessEqual(d0.item_with_largest_value(), larger)
+            if found == set(["first-larger", "first-smaller"]):
+                break
+        else:
+            self.fail("unable to exercise all cases of item_with_largest_value")
+
         d = dictutil.NumDict({"a": 1, "b": 2})
         self.failUnlessIn(repr(d), ("{'a': 1, 'b': 2}",
@@ -1628 +1658 @@
         self.failUnlessEqual(d.keys(), ["c", "b", "a"])
         self.failUnlessEqual(repr(d), "<ValueOrderedDict {c: 1, b: 2, a: 3}>")
+        self.failUnlessEqual(str(d), "<ValueOrderedDict {c: 1, b: 2, a: 3}>")
+        # str() is supposed to only show the first 16 entries
+        large_d = dictutil.ValueOrderedDict()
+        for i in range(20):
+            large_d["k%d" % i] = i
+        large_d_repr = ("<ValueOrderedDict {%s, ...}>" %
+                        ", ".join(["k%d: %d" % (i, i) for i in range(16)]))
+        self.failUnlessEqual(str(large_d), large_d_repr)
+
         def eq(a, b):
             return a == b

src/allmydata/util/dictutil.py ¶

@@ -437 +437 @@
             i = 1
             while (n is None) or (i < n):
+                i += 1
                 x = iter.next()
-                s.append(", "); s.append(str(x[0])); s.append(": "); s.append(str(x[1]))
+                s.append(", ");
+                s.append(str(x[0])); s.append(": "); s.append(str(x[1]))
+            # if we get here, we're truncating the repr, so make that clear
+            s.append(", ...")
         except StopIteration:
             pass