racket - 处理队列和队列的测试用例

Question

您好，我想了解 mo 程序到底出了什么问题。我已经为球拍中的队列的入队、出队、顶部和大小编写了代码。我还编写了测试用例来在模块中试用我的程序。当我尝试通过键入以下命令“racket run-tests.rkt | less”来运行测试用例时，我收到以下错误：“default-load-handler: expected only a module' declaration forqueue', but found an extra expression in : #

=== 上下文 === 默认加载/使用编译“

这是我的三个文件和其中的代码

1-队列.rkt

(module queue racket
  (provide make-queue enqueue dequeue top size queue-tests)
  (struct queue (front back size) #:mutable #:transparent)

    (define (make-queue) (queue null null 0))

(define (enqueue q elt)
    (set-queue-back! q (cons elt (queue-back q)))
    (set-queue-size! q (+ (queue-size q) 1))
    )
(define (dequeue q)
    (cond  ((eq? (queue-size q) 0) null)
           ((null? (queue-front q))
            (begin
              (set-queue-front! q (cdr (reverse (queue-back q))))
              (set-queue-back! q null)
              (set-queue-size! q (- (queue-size q) 1))))
           (else
            (begin
              (set-queue-front! q (cdr (queue-front q)))
              (set-queue-size! q (- (queue-size q) 1))))
           )
  )

  (define (top q)
    (cond ((eq? (queue-size q) 0) null)
          ((null? (queue-front q)) (last (queue-back q)))
          (else (car (queue-front q)))))

   (define (size q)
    (queue-size q))

  ; Test cases Here
  (include "test-queue.rkt")
)

2-测试队列.rkt

 #lang racket/base

 (require rackunit)

 (define queue-tests
  (test-suite
    "Tests for the Queue"

    (test-case "Initial Queue Properties"
    (let  ((q (make-queue)))
      (check-equal? (size q) 0 "Queue initially should have size zero.")
      (check-equal? (dequeue q) null "Dequeue on an empty queue returns null")
      (check-equal? (size q) 0 "Dequeue on empty queue leaves size as zero")
      ))

    (test-case "One Element queue ---- Functional test"
       (let ((q (make-queue)))
         (check-equal? (size q) 0 "Stack initially should be of size zero")
         (enqueue q 1)
         (check-equal? (size q) 1 "Added one element to back of queue")
         (check-equal? (top q) 1 "Take a sneak peak at our first element")
         (dequeue q)
         (check-equal? (size 1) 0 "size should now be zero")
         (check-equal? (dequeue q) null "dequeue on empty queue returns null")
         ))

    (test-case "One Element queue --- Internal Test"
       (let  ((q (make-queue)))
         (check-equal? (size q) 0 "queue initially should have size zero.")
         (enqueue q 3)
         (check-equal? (size q) 1 "Added one element.")
         (check-equal? (queue-back q) '(3) "Is the element in the back list?")
         (check-equal? (top s) 3 "Look at our one element.")
         (check-equal? (queue-front q) '(3) "Is the element in the front list?")
         (dequeue s)
         (check-equal? (queue-front q) '() "Is the data empty now?")
         ))

    (test-case "Multi Element queue --- Functional Test"
    (let  ((q (make-queue))
           (elts (list 8 6 7 5 3 0 9))
           )
      (check-equal? (size q) 0 "queue initially should have size zero.")
      (for ((i elts)
            (num (in-range 1 8)))
           (enqueue q i)
           (check-equal? (size q) num "Testing size.")
           (check-equal? (top q) i "Testing top with multiple additions.")
           )
      (for ((i (reverse elts))
            (num (reverse (stream->list (in-range 1 8)))))
           (check-equal? (top q) i "Testing top with multiple deletions")
           (dequeue q)
           (check-equal? (size q) (- num 1) "Testing size.")
           )
      ))

    (test-case "Multi Element queue --- Ebb and Flow Test"
       (let  ((q (make-queue))
              (elts (list 8 6 7 5 3 0 9))
              )
         (check-equal? (size q) 0 "queue initially should have size zero.")
         (for ((i elts)
           (num (in-range 1 8)))
              (enqueue q i)
              (check-equal? (size q) num "Testing size, first flow.")
              (check-equal? (top q) i "Testing top with multiple additions.")
           )
         (for ((i (reverse elts))
               (num (reverse (stream->list (in-range 1 8)))))
              (check-equal? (top q) i "Testing top with multiple deletions")
              (dequeue q)
              (check-equal? (size q) (- num 1) "Testing size, first ebb.")
           )
         (for ((i elts)
               (num (in-range 1 8)))
               (enqueue q i)
               (check-equal? (size q) num "Testing size, second flow.")
               (check-equal? (top q) i "Testing top with multiple additions.")
           )
         (for ((i (reverse elts))
               (num (reverse (stream->list (in-range 1 8)))))
               (check-equal? (top q) i "Testing top with multiple deletions")
               (dequeue q)
               (check-equal? (size q) (- num 1) "Testing size, second ebb.")
           )
      ))

   (test-case "Multi Element queue --- Internal Test"
    (let  ((q (make-queue))
           (elts (list 5 8 8 2 3 0 0))
           (tmp null)
           )
      (for ((i elts)
            (num (in-range 1 8)))
           (enqueue q i)
           (check-equal? (size q) num "Testing size, second flow.")
           (set! tmp (cons i tmp)) ; "push" element to a list
           (check-equal? (queue-front q) tmp "Queue data is in correct form.")
           )
      ))

    ))

3-运行测试.rkt

#lang racket/base

(require "queue.rkt")

(require rackunit/text-ui)

(run-tests queue-tests)

在发现存在的错误方面提供任何帮助将不胜感激。提前致谢。

Answer 1

我相信，您所指的错误可能是由于您的“queue.rkt”文件中的语言级别设置不正确造成的。特别是，所有这三种语言的语言都应设置为

“使用源中声明的语言”。

老实说，我真的不确定您为什么要将其构建为三个独立的模块；我认为这给您带来了额外的困难，但这样做当然应该可以。

编辑：看起来你有问题。特别是，在定义“大小”之后，您有三个近括号。DrRacket 在你跑步时不会为你突出这个问题吗？

编辑 2：哦，糟糕：您正在使用“包含”。不要使用包含。

编辑 3：好的，在这里：我将您的代码重新格式化为一个文件：

(module queue racket

  (require rackunit)

  (provide make-queue enqueue dequeue top size)
  (struct queue (front back size) #:mutable #:transparent)

  (define (make-queue) (queue null null 0))

  (define (enqueue q elt)
    (set-queue-back! q (cons elt (queue-back q)))
    (set-queue-size! q (+ (queue-size q) 1))
    )
  (define (dequeue q)
    (cond  ((eq? (queue-size q) 0) null)
           ((null? (queue-front q))
            (begin
              (set-queue-front! q (cdr (reverse (queue-back q))))
              (set-queue-back! q null)
              (set-queue-size! q (- (queue-size q) 1))))
           (else
            (begin
              (set-queue-front! q (cdr (queue-front q)))
              (set-queue-size! q (- (queue-size q) 1))))
           )
    )

  (define (top q)
    (cond ((eq? (queue-size q) 0) null)
          ((null? (queue-front q)) (last (queue-back q)))
          (else (car (queue-front q)))))

  (define (size q)
    (queue-size q))

  (test-case "Initial Queue Properties"
             (let  ((q (make-queue)))
               (check-equal? (size q) 0 "Queue initially should have size zero.")
               (check-equal? (dequeue q) null "Dequeue on an empty queue returns null")
               (check-equal? (size q) 0 "Dequeue on empty queue leaves size as zero")
               ))

  (test-case "One Element queue ---- Functional test"
             (let ((q (make-queue)))
               (check-equal? (size q) 0 "Stack initially should be of size zero")
               (enqueue q 1)
               (check-equal? (size q) 1 "Added one element to back of queue")
               (check-equal? (top q) 1 "Take a sneak peak at our first element")
               (dequeue q)
               (check-equal? (size 1) 0 "size should now be zero")
               (check-equal? (dequeue q) null "dequeue on empty queue returns null")
               ))

  #;(test-case "One Element queue --- Internal Test"
             (let  ((q (make-queue)))
               (check-equal? (size q) 0 "queue initially should have size zero.")
               (enqueue q 3)
               (check-equal? (size q) 1 "Added one element.")
               (check-equal? (queue-back q) '(3) "Is the element in the back list?")
               (check-equal? (top s) 3 "Look at our one element.")
               (check-equal? (queue-front q) '(3) "Is the element in the front list?")
               (dequeue s)
               (check-equal? (queue-front q) '() "Is the data empty now?")
               ))

  (test-case "Multi Element queue --- Functional Test"
             (let  ((q (make-queue))
                    (elts (list 8 6 7 5 3 0 9))
                    )
               (check-equal? (size q) 0 "queue initially should have size zero.")
               (for ((i elts)
                     (num (in-range 1 8)))
                 (enqueue q i)
                 (check-equal? (size q) num "Testing size.")
                 (check-equal? (top q) i "Testing top with multiple additions.")
                 )
               (for ((i (reverse elts))
                     (num (reverse (stream->list (in-range 1 8)))))
                 (check-equal? (top q) i "Testing top with multiple deletions")
                 (dequeue q)
                 (check-equal? (size q) (- num 1) "Testing size.")
                 )
               ))

  (test-case "Multi Element queue --- Ebb and Flow Test"
             (let  ((q (make-queue))
                    (elts (list 8 6 7 5 3 0 9))
                    )
               (check-equal? (size q) 0 "queue initially should have size zero.")
               (for ((i elts)
                     (num (in-range 1 8)))
                 (enqueue q i)
                 (check-equal? (size q) num "Testing size, first flow.")
                 (check-equal? (top q) i "Testing top with multiple additions.")
                 )
               (for ((i (reverse elts))
                     (num (reverse (stream->list (in-range 1 8)))))
                 (check-equal? (top q) i "Testing top with multiple deletions")
                 (dequeue q)
                 (check-equal? (size q) (- num 1) "Testing size, first ebb.")
                 )
               (for ((i elts)
                     (num (in-range 1 8)))
                 (enqueue q i)
                 (check-equal? (size q) num "Testing size, second flow.")
                 (check-equal? (top q) i "Testing top with multiple additions.")
                 )
               (for ((i (reverse elts))
                     (num (reverse (stream->list (in-range 1 8)))))
                 (check-equal? (top q) i "Testing top with multiple deletions")
                 (dequeue q)
                 (check-equal? (size q) (- num 1) "Testing size, second ebb.")
                 )
               ))

  (test-case "Multi Element queue --- Internal Test"
             (let  ((q (make-queue))
                    (elts (list 5 8 8 2 3 0 0))
                    (tmp null)
                    )
               (for ((i elts)
                     (num (in-range 1 8)))
                 (enqueue q i)
                 (check-equal? (size q) num "Testing size, second flow.")
                 (set! tmp (cons i tmp)) ; "push" element to a list
                 (check-equal? (queue-front q) tmp "Queue data is in correct form.")
                 )
               ))



  )

当我运行此代码时，我在您的一个测试用例中遇到了一个非常简单的错误。

更一般地说，我很吃惊你会编写这么多测试代码而不运行它:)。我个人会编写一个小测试用例然后进行尝试，而不是在发现更基本的问题之前完成所有这些工作。我钦佩你的坚韧，但我认为你需要更多的偏执狂:)

如果您有更多麻烦，请告诉我。

编辑：根据您的要求分成两个文件。

文件 1：queue.rkt

(module queue racket

  (provide make-queue enqueue dequeue top size)
  (struct queue (front back size) #:mutable #:transparent)

  (define (make-queue) (queue null null 0))

  (define (enqueue q elt)
    (set-queue-back! q (cons elt (queue-back q)))
    (set-queue-size! q (+ (queue-size q) 1)))

  (define (dequeue q)
    (cond  ((eq? (queue-size q) 0) null)
           ((null? (queue-front q))
            (begin
              (set-queue-front! q (cdr (reverse (queue-back q))))
              (set-queue-back! q null)
              (set-queue-size! q (- (queue-size q) 1))))
           (else
            (begin
              (set-queue-front! q (cdr (queue-front q)))
              (set-queue-size! q (- (queue-size q) 1))))))

  (define (top q)
    (cond ((eq? (queue-size q) 0) null)
          ((null? (queue-front q)) (last (queue-back q)))
          (else (car (queue-front q)))))

  (define (size q)
    (queue-size q))

  )

文件 2：queue-tests.rkt，在同一目录中：

(module test-queue racket

  (require "queue.rkt"
           rackunit)


  (test-case "Initial Queue Properties"
             (let  ((q (make-queue)))
               (check-equal? (size q) 0 "Queue initially should have size zero.")
               (check-equal? (dequeue q) null "Dequeue on an empty queue returns null")
               (check-equal? (size q) 0 "Dequeue on empty queue leaves size as zero")
               ))

  (test-case "One Element queue ---- Functional test"
             (let ((q (make-queue)))
               (check-equal? (size q) 0 "Stack initially should be of size zero")
               (enqueue q 1)
               (check-equal? (size q) 1 "Added one element to back of queue")
               (check-equal? (top q) 1 "Take a sneak peak at our first element")
               (dequeue q)
               (check-equal? (size 1) 0 "size should now be zero")
               (check-equal? (dequeue q) null "dequeue on empty queue returns null")
               ))

  (test-case "One Element queue --- Internal Test"
             (let  ((q (make-queue)))
               (check-equal? (size q) 0 "queue initially should have size zero.")
               (enqueue q 3)
               (check-equal? (size q) 1 "Added one element.")
               (check-equal? (queue-back q) '(3) "Is the element in the back list?")
               (check-equal? (top s) 3 "Look at our one element.")
               (check-equal? (queue-front q) '(3) "Is the element in the front list?")
               (dequeue s)
               (check-equal? (queue-front q) '() "Is the data empty now?")
               ))

  (test-case "Multi Element queue --- Functional Test"
             (let  ((q (make-queue))
                    (elts (list 8 6 7 5 3 0 9))
                    )
               (check-equal? (size q) 0 "queue initially should have size zero.")
               (for ((i elts)
                     (num (in-range 1 8)))
                 (enqueue q i)
                 (check-equal? (size q) num "Testing size.")
                 (check-equal? (top q) i "Testing top with multiple additions.")
                 )
               (for ((i (reverse elts))
                     (num (reverse (stream->list (in-range 1 8)))))
                 (check-equal? (top q) i "Testing top with multiple deletions")
                 (dequeue q)
                 (check-equal? (size q) (- num 1) "Testing size.")
                 )
               ))

  (test-case "Multi Element queue --- Ebb and Flow Test"
             (let  ((q (make-queue))
                    (elts (list 8 6 7 5 3 0 9))
                    )
               (check-equal? (size q) 0 "queue initially should have size zero.")
               (for ((i elts)
                     (num (in-range 1 8)))
                 (enqueue q i)
                 (check-equal? (size q) num "Testing size, first flow.")
                 (check-equal? (top q) i "Testing top with multiple additions.")
                 )
               (for ((i (reverse elts))
                     (num (reverse (stream->list (in-range 1 8)))))
                 (check-equal? (top q) i "Testing top with multiple deletions")
                 (dequeue q)
                 (check-equal? (size q) (- num 1) "Testing size, first ebb.")
                 )
               (for ((i elts)
                     (num (in-range 1 8)))
                 (enqueue q i)
                 (check-equal? (size q) num "Testing size, second flow.")
                 (check-equal? (top q) i "Testing top with multiple additions.")
                 )
               (for ((i (reverse elts))
                     (num (reverse (stream->list (in-range 1 8)))))
                 (check-equal? (top q) i "Testing top with multiple deletions")
                 (dequeue q)
                 (check-equal? (size q) (- num 1) "Testing size, second ebb.")
                 )
               ))

  (test-case "Multi Element queue --- Internal Test"
             (let  ((q (make-queue))
                    (elts (list 5 8 8 2 3 0 0))
                    (tmp null)
                    )
               (for ((i elts)
                     (num (in-range 1 8)))
                 (enqueue q i)
                 (check-equal? (size q) num "Testing size, second flow.")
                 (set! tmp (cons i tmp)) ; "push" element to a list
                 (check-equal? (queue-front q) tmp "Queue data is in correct form.")
                 )
               )))