#lang racket
(provide  session-tests message-tests io-tests typed-tests
          large-data-test)
(require rackunit
 rackunit/gui
         "../lump.rkt")

(define s (new-session))

(define session-tests
  (test-suite
   "LUMP sessions"
   (test-case 
     "new-session returns a session"
   (check-true (session? s)))
   (test-case 
     "close-session returns void"
   (check-eq? (void) (close-session s)))))

(define message-tests
  (test-suite
   "LUMP messages"
   (test-case
    "new-message returns a message"
    (check-true (message? (new-message 1))))
   (test-case 
    "new-response returns a message"
    (check-true (message? (new-response 2 (new-message 1)))))
   (test-case 
    "id equality"
    (check-equal? (message-id (new-message 23)) 23))
   (test-case 
    "referer equality"
    (check-equal? (message-referer (new-message 1 #:referer 28)) 28))
   (test-case
    "no predefined referer"
    (check-false (message-referer (new-message 1))))
   (test-case
    "flags equality"
    (check-equal? (message-flags (new-message 1 #:flags 77)) 77))
   (test-case
    "argument equality"
    (check-equal? (message-args (new-message 1 23 "String1" "String2"))
                  '(23 "String1" "String2")))))

(define io-tests
  (test-suite
   "LUMP input/output"
   (let* ((snd-msg (new-message 1 #:referer 44 46272627826 "String1" "String2" #("Nested1" "Nested2") 'hello #t))
          (rec-msg (with-input-from-bytes 
                    (with-output-to-bytes 
                     (lambda ()
                       (write-message s snd-msg)))
                    (lambda ()
                      (read-message)))))
     (test-case 
      "transmission id equality"
      (check-equal? (message-id rec-msg) (message-id snd-msg)))
     (test-case
      "transmission referer equality"
      (check-equal? (message-referer rec-msg) (message-referer snd-msg)))
     (test-case
      "transmission argument equality"
      (check-equal? (message-args rec-msg) (message-args snd-msg))))))

(define typed-tests
  (test-suite
   "LUMP typed data"
    (let* ((snd-msg (new-message 1
                                 (typed type:uint8 127)
                                 (typed type:int16 -32768)
                                 (typed type:uint16 65535)
                                 (typed type:int32 -2147483648)
                                 (typed type:uint32 4294967295)
                                 (typed type:int64 -9223372036854775808)
                                 (typed type:uint64 18446744073709551615)))
          (rec-msg (with-input-from-bytes 
                    (with-output-to-bytes 
                     (lambda ()
                       (write-message s snd-msg)))
                    (lambda ()
                      (read-message)))))
      (test-case
       "transmission of typed data types"
       (check-equal? (message-args rec-msg) (map untype (message-args snd-msg)))))))

(define large-data-test
  (test-suite
   "LUMP large data"
   (let* ((snd-msg (apply new-message (build-list 65535 values)))
          (rec-msg (with-input-from-bytes 
                    (with-output-to-bytes 
                     (lambda ()
                       (write-message s snd-msg)))
                    (lambda ()
                      (read-message))))
          (snd-msg2 (new-message 1 (make-bytes  65536)))
          (rec-msg2 (with-input-from-bytes 
                    (with-output-to-bytes 
                     (lambda ()
                       (write-message s snd-msg2)))
                    (lambda ()
                      (read-message)))))
     (test-case
      "transmission of many arguments"
      (check-equal? (message-args rec-msg) (message-args snd-msg)))
     (test-case 
      "transmission of large argument"
      (check-equal? (message-args rec-msg2) (message-args snd-msg2))))))