+(define-test %expf.exceptions

+  (:tag :fdlibm)

+  (assert-error 'floating-point-overflow

+		(kernel:%expf 89f0))

+  (assert-true (ext:float-nan-p (kernel:%expf *qnan-single-float*)))

+  (assert-error 'floating-point-invalid-operation

+		(kernel:%expf *snan-single-float*))

+  (assert-equal ext:single-float-positive-infinity

+		(kernel:%expf ext:single-float-positive-infinity))

+  (assert-equal 0f0

+		(kernel:%expf -200f0))

+  (ext:with-float-traps-masked (:overflow)

+    (assert-equal ext:single-float-positive-infinity

+		  (kernel:%expf 89f0)))

+  (ext:with-float-traps-enabled (:underflow)

+    (assert-error 'floating-point-underflow

+		  (kernel:%expf -200f0)))

+

+  (let ((x (scale-float 1f0 -13))

+	(x0 0f0))

+    ;; exp(x) = 1 + x, |x| < 2^-12, with inexact exception unlees x =

+    ;; 0.  The actual threshold is closer to sqrt(2*eps) or about

+    ;; 2.44e-4, about 2^-12

+    (ext:with-float-traps-enabled (:inexact)

+	;; This must not throw an inexact exception because the result

+	;; is exact when the arg is 0.

+	(assert-eql 1f0 (kernel:%expf x0)))

+    (ext:with-float-traps-enabled (:inexact)

+	;; This must throw an inexact exception for non-zero x even

+	;; though the result is exactly x.

+	(assert-error 'floating-point-inexact

+		      (kernel:%expf x)))))

+

+(define-test %logf.exception

+  (:tag :fdlibm)

+  (assert-error 'division-by-zero

+		(kernel:%logf 0f0))

+  (assert-error 'division-by-zero

+		(kernel:%logf -0f0))

+  (assert-error 'floating-point-invalid-operation

+		(kernel:%logf -1f0))

+  (assert-error 'floating-point-invalid-operation

+		(kernel:%logf *snan-single-float*))

+  (assert-true (ext:float-nan-p (kernel:%logf *qnan-single-float*)))

+  (ext:with-float-traps-masked (:divide-by-zero)

+    (assert-equal ext:single-float-negative-infinity

+		  (kernel:%logf 0f0))

+    (assert-equal ext:single-float-negative-infinity

+		  (kernel:%logf -0f0)))

+  (ext:with-float-traps-masked (:invalid)

+    (assert-true (ext:float-nan-p (kernel:%logf -1f0)))

+    (assert-true (ext:float-nan-p (kernel:%logf *snan-single-float*)))))

+

+(define-test %acosf.exceptions

+  (:tag :fdlibm)

+  (assert-error 'floating-point-invalid-operation

+		(kernel:%acosf 2f0))

+  (assert-error 'floating-point-invalid-operation

+		(kernel:%acosf -2f0))

+  (ext:with-float-traps-masked (:invalid)

+    (assert-true (ext:float-nan-p (kernel:%acosf 2f0)))

+    (assert-true (ext:float-nan-p (kernel:%acosf -2f0)))))

+

+(define-test %asinf.exceptions

+  (:tag :fdlibm)

+  (assert-error 'floating-point-invalid-operation

+		(kernel:%asinf 2f0))

+  (assert-error 'floating-point-invalid-operation

+		(kernel:%asinf -2f0))

+  (ext:with-float-traps-masked (:invalid)

+    (assert-true (ext:float-nan-p (kernel:%asinf 2f0)))

+    (assert-true (ext:float-nan-p (kernel:%asinf -2f0)))))

+

+(define-test %atanf.exceptions

+  (:tag :fdlibm)

+  (assert-error 'floating-point-invalid-operation

+		(kernel:%atanf *snan-single-float*))

+  (assert-true (ext:float-nan-p (kernel:%atanf *qnan-single-float*)))

+  (ext:with-float-traps-masked (:invalid)

+    (assert-true (ext:float-nan-p (kernel:%atanf *snan-single-float*))))

+  ;; atan(x) = x for small x, signaling inexact except when x = 0.

+  (let ((x (scale-float 1f0 -30))

+	(x0 0f0))

+    (ext:with-float-traps-enabled (:inexact)

+	;; This must not throw an inexact exception because the result

+	;; is exact when the arg is 0.

+	(assert-eql 0f0 (kernel:%atanf x0)))

+    (ext:with-float-traps-enabled (:inexact)

+	;; This must throw an inexact exception for non-zero x even

+	;; though the result is exactly x.

+	(assert-error 'floating-point-inexact

+		      (kernel:%atanf x)))))

+

+(define-test %log10f.exceptions

+  (:tag :fdlibm)

+  ;; %log10(2^k) = k

+  (dotimes (k 23)

+    (assert-equalp k

+		  (kernel:%log10f (float (expt 10 k) 1f0))))

+  (assert-error 'division-by-zero

+		(kernel:%log10f 0f0))

+  (assert-error 'floating-point-invalid-operation

+		(kernel:%log10f -1f0))

+  (assert-true (ext:float-nan-p (kernel:%log10f *qnan-single-float*)))

+  (assert-equal ext:single-float-positive-infinity

+		(kernel:%log10f ext:single-float-positive-infinity))

+  (ext:with-float-traps-masked (:divide-by-zero)

+    (assert-equal ext:single-float-negative-infinity

+		  (kernel:%log10f 0f0))

+    (assert-equal ext:single-float-negative-infinity

+		  (kernel:%log10f -0f0)))

+  (ext:with-float-traps-masked (:invalid)

+    (assert-true (ext:float-nan-p (kernel:%log10f -1f0)))))

+