[gnunet-scheme] 03/06: tests/distributed-hash-table: Randomise keys and values.

[gnunet]

This is an automated email from the git hooks/post-receive script.

maxime-devos pushed a commit to branch master
in repository gnunet-scheme.

commit 25ded09e08ed8fbdff22108cf26d1d9e4942738e
Author: Maxime Devos <maximedevos@telenet.be>
AuthorDate: Sat Jan 29 19:28:08 2022 +0000

    tests/distributed-hash-table: Randomise keys and values.
    
    This makes tests somewhat more interesting.
    
    * tests/distributed-hash-table.scm
      (make-slice/read-write*): New procedure.
      (make-a-datum, "datum-key", "datum-key, read-only is sufficient")
      ("datum key must be readable", "datum-value, maximal length")
      ("datum-value", test-datum-overly-large)
      ("copy-datum: equal and independent")
      ("copy-search-result: equal and independent")
      ("search-result-get-path, slice")
      ("search-result-put-path, slice"
      ("search-result get-path must be readable")
      ("search-result put-path must be readable")
      (test-malformed-path): Use 'make-slice/read-write*' instead of
      'make-slice/read-write' where appropriate.
---
 tests/distributed-hash-table.scm | 55 +++++++++++++++++++++-------------------
 1 file changed, 29 insertions(+), 26 deletions(-)

diff --git a/tests/distributed-hash-table.scm b/tests/distributed-hash-table.scm
index 79e1831..942a6b5 100644
--- a/tests/distributed-hash-table.scm
+++ b/tests/distributed-hash-table.scm
@@ -23,6 +23,7 @@
        (gnu gnunet dht client)
        (gnu gnunet dht struct)
        (gnu gnunet utils bv-slice)
+       (gnu gnunet utils hat-let)
        (gnu gnunet netstruct syntactic)
        (gnu gnunet hashcode struct)
        (gnu gnunet block)
@@ -107,9 +108,17 @@
 (test-error "way too small" (bound-replication-level (- 
%minimum-replication-level #e1e20)))
 (test-error "non-numeric" (bound-replication-level 'what))
 
+(define (make-slice/read-write* size)
+  "Like @code{make-slice/read-write*}, but fill the slice with random data."
+  (define s (make-slice/read-write size))
+  (let^ ((/o/ loop (i 0))
+        (? (>= i size) s))
+       (slice-u8-set! s i (random 256))
+       (loop (+ i 1))))
+
 (define* (make-a-datum #:key
                       (type 0)
-                      (key (make-slice/read-write (sizeof /hashcode:512 '())))
+                      (key (make-slice/read-write* (sizeof /hashcode:512 '())))
                       (value (make-slice/read-write 0))
                       (expiration 0))
   (make-datum type key value #:expiration expiration))
@@ -148,10 +157,10 @@
     (datum-type (make-a-datum #:type type))))
 
 (datum-key-test "datum-key"
-               (make-slice/read-write (sizeof /hashcode:512 '())))
+               (make-slice/read-write* (sizeof /hashcode:512 '())))
 (datum-key-test "datum-key, read-only is sufficient"
                (slice/read-only
-                (make-slice/read-write
+                (make-slice/read-write*
                  (sizeof /hashcode:512 '()))))
 
 (test-missing-caps
@@ -159,14 +168,14 @@
  'key
  CAP_WRITE
  CAP_READ
- (make-a-datum #:key (slice/write-only (make-slice/read-write
+ (make-a-datum #:key (slice/write-only (make-slice/read-write*
                                        (sizeof /hashcode:512 '())))))
 
 ;; AFAIK a zero length value is allowed, albeit somewhat pointless?
 (datum-value-test "datum-value, length 0" (make-slice/read-write 0))
 (datum-value-test "datum-value, maximal length"
-                 (make-slice/read-write %max-datum-value-length))
-(datum-value-test "datum-value" (make-slice/read-write 900))
+                 (make-slice/read-write* %max-datum-value-length))
+(datum-value-test "datum-value" (make-slice/read-write* 900))
 
 (define (test-datum-overly-large test-case type type/integer length)
   (test-equal test-case
@@ -175,7 +184,7 @@
               (list (condition-who c)
                     (overly-large-datum-type c)
                     (overly-large-datum-length  c))))
-      (make-a-datum #:type type #:value (make-slice/read-write length)))))
+      (make-a-datum #:type type #:value (make-slice/read-write* length)))))
 
 (test-datum-overly-large
  "datum-value, too large (1, numeric type)" 19 19
@@ -245,12 +254,10 @@
   ;; A least in Guile 3.0.5, all bytevectors of length 0 are eq?,
   ;; so let the value be non-empty such that datum-independent?
   ;; can return #true.
-  (let* ((old-key (make-slice/read-write (sizeof /hashcode:512 '())))
-        (old-value (make-slice/read-write 70))
-        (old (make-a-datum #:value old-value #:expiration 777)))
-    (slice-u32-set! old-key 9 #xcabba9e (endianness big))
-    (slice-u32-set! old-value 5 #xcabba9e (endianness big))
-    (let ((new (copy-datum old)))
+  (let* ((old-key (make-slice/read-write* (sizeof /hashcode:512 '())))
+        (old-value (make-slice/read-write* 70))
+        (old (make-a-datum #:key old-key #:value old-value #:expiration 777)))
+     (let ((new (copy-datum old)))
       (and (datum=? old new)
           (datum-independent? old new)))))
 
@@ -259,14 +266,10 @@
 
 ;; Detected a bug: the datum was not copied
 (test-assert "copy-search-result: equal and independent"
-  (let* ((old-key (make-slice/read-write (sizeof /hashcode:512 '())))
-        (old-value (make-slice/read-write 70))
-        (old-get-path (make-slice/read-write (path-length->size 5)))
-        (old-put-path (make-slice/read-write (path-length->size 9))))
-    (slice-u32-set! old-key 9 #xcabba9e (endianness big))
-    (slice-u32-set! old-value 5 #xcabba9e (endianness big))
-    (slice-u32-set! old-get-path 0 #xcabba9e (endianness big))
-    (slice-u32-set! old-put-path 1 #xcabba9e (endianness big))
+  (let* ((old-key (make-slice/read-write* (sizeof /hashcode:512 '())))
+        (old-value (make-slice/read-write* 70))
+        (old-get-path (make-slice/read-write* (path-length->size 5)))
+        (old-put-path (make-slice/read-write* (path-length->size 9))))
     (let* ((old-datum (make-a-datum #:value old-value #:expiration 555))
           (old (datum->search-result old-datum #:get-path old-get-path
                                      #:put-path old-put-path))
@@ -288,11 +291,11 @@
 ;; These detected a bug: the capabilities were not restricted!
 ;; TODO: can there be a get path without a put path?
 (search-result-get-path-slice-test
- "search-result-get-path, slice" (make-slice/read-write (path-length->size 7)))
+ "search-result-get-path, slice" (make-slice/read-write* (path-length->size 
7)))
 (search-result-get-path-slice-test
  "search-result-get-path, empty" (make-slice/read-write 0))
 (search-result-put-path-slice-test
- "search-result-put-path, slice" (make-slice/read-write (path-length->size 7)))
+ "search-result-put-path, slice" (make-slice/read-write* (path-length->size 
7)))
 (search-result-put-path-slice-test
  "search-result-put-path, empty" (make-slice/read-write 0))
 (test-equal "search-result-get-path, none"
@@ -309,7 +312,7 @@
  CAP_READ
  (datum->search-result
   (make-a-datum) #:get-path
-  (slice/write-only (make-slice/read-write (path-length->size 7)))))
+  (slice/write-only (make-slice/read-write* (path-length->size 7)))))
 
 (test-missing-caps
  "search-result get-path must be readable"
@@ -318,7 +321,7 @@
  CAP_READ
  (datum->search-result
   (make-a-datum) #:put-path
-  (slice/write-only (make-slice/read-write (path-length->size 7)))))
+  (slice/write-only (make-slice/read-write* (path-length->size 7)))))
 
 (define (test-malformed-path test-case what keyword)
   (test-assert test-case
@@ -336,7 +339,7 @@
                                 (malformed-path-size c))))
                  (datum->search-result
                   (make-a-datum) keyword
-                  (make-slice/read-write size)))
+                  (make-slice/read-write* size)))
                (list 'datum->search-result what size)))))))
 
 (test-malformed-path

-- 
To stop receiving notification emails like this one, please contact
gnunet@gnunet.org.