Esiste un framework di simulazione/stub per Common Lisp?

Question

Esiste un framework di simulazione/stub per Common Lisp?

EmacsLispMock sembra ottimo, ma è un framework lisp di Emacs e sto cercando qualcosa da usare da Common Lisp.

Qualche suggerimento?

Answer 1

Il seguente dovrebbe fare quello che stai cercando

(defmacro with-replaced-function (fdef &rest body) 
    (let ((oldf (gensym)) 
     (result (gensym)) 
     (name (car fdef)) 
     (args (cadr fdef)) 
     (rbody (cddr fdef))) 
    `(let ((,oldf (symbol-function ',name))) 
     (setf (symbol-function ',name) (lambda ,args ,@rbody)) 
     (let ((,result (progn ,@body))) 
     (setf (symbol-function ',name) ,oldf) 
     ,result)))) 

(defmacro show (x) 
    `(format t "~a --> ~a~%" 
      ',x ,x)) 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 

(defun foo (x y) (+ x y)) 

(defun bar (x) (foo x (* x 2))) 

(show (bar 42)) 

(show (with-replaced-function (foo (x y) (* x y)) 
           (bar 42))) 

(show (bar 42)) 

La macro salva semplicemente la funzione di essere attualmente indicato dal simbolo e lo sostituisce con l'implementazione stub fornito. Alla fine del blocco la funzione viene ripristinata al valore originale.

Avrebbe probabilmente senso aggiungere una protezione contro le uscite non locali dal corpo.

Nota anche che ovviamente la modifica della definizione di una funzione non funzionerà se le chiamate di funzione sono state indicate da un compilatore. CL ha una dichiarazione speciale NOTINLINE che può essere utilizzata per prevenire questo problema.

Answer 2

Non è necessaria una struttura di derisione/stub in CL.

Basta creare un nuovo CLOS derivato dalla classe di classe con metodi ovverides per ciò che si desidera stub/mock e il gioco è fatto.

Per quanto riguarda lo stub, perché non ridefinire la funzione?

Answer 3

Non è questo il modo più semplice per farlo?

> (defun b() 'original) 
B 
> (setf f #'b) 
#<Compiled-function B #xC2C1546> 
> (defun a() (funcall f)) 
A 
> (a) 
ORIGINAL 
> (setf f #'(lambda() 'stub)) 
#<Anonymous Function #xC2D990E> 
> (a) 
STUB 
> (setf f #'b) 
#<Compiled-function B #xC2C1546> 
> (a) 
ORIGINAL 

Answer 4

Si può cercare di avvolgere funzione di ridefinizione all'interno di una macro

(defmacro with-fun (origfn mockfn &body body) 
    `(let ((it ,origfn)) 
     (setf ,origfn ,mockfn) 
    ,@body 
     (setf ,origfn ,it))) 

Questa è solo un'idea, e si dovrà implementare tale macro. Puoi google per l'implementazione profile che fa esattamente questo, sostituisci una funzione con un'altra e aggiungi informazioni di profilazione. Puoi prendere in prestito alcune idee da lì.

Answer 5

Come fa notare Rainer, il compilatore di file a volte funziona in linea, il che significa che la modifica della definizione della funzione non avrà alcun effetto nei punti in cui la funzione è stata allineata.

Anche la modifica della definizione del nome della funzione non sostituirà l'utilizzo della funzione come oggetto letterale, ad esempio, se si è salvata la # funzione my-stubbed in una variabile da qualche parte.

Tuttavia, in alcune implementazioni chiare è possibile definire wrapper funzione o utilizzare i consigli per ottenere ciò: Ad esempio, Allegro CL ha fwrappers. In SBCL, è possibile utilizzare TRACE con una funzione non standard: break e un hook * debugger-debug * personalizzato, e sono sicuro che altre implementazioni di Lisp avranno qualcosa di simile.

Non penso che nessuno abbia impacchettato questi metodi di stub in una libreria. Potresti essere il primo! (E sarebbe fantastico. Mi piacerebbe usare qualcosa di simile.)

Answer 6

Ho scritto una libreria con una macro molto simile alla risposta di @ 6502 (with-mocked-functions), ma un po 'più generale. Fornisce anche with-added-methods che consente di scrivere metodi di simulazione per un ambito dinamico limitato.Potete trovarlo qui: https://github.com/bytecurry/bytecurry.mocks

Answer 7

Alcuni anni dopo, c'è. Abbiamo cl-mock e mockingbird entrambi in Quicklisp.

(ql:quickload :mockingbird) 

Questo permette anche di verificare se una funzione è stata chiamata, in caso affermativo quante volte e con quali argomenti ed è possibile stub metodi individuali.