diff --git a/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp b/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
index 3ab9d54..f889837 100644
--- a/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
+++ b/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
@@ -15,16 +15,64 @@
 // template<class _URNG> result_type operator()(_URNG& g);
 
 #include <random>
+#include <cassert>
+#include <vector>
+#include <algorithm>
+
+double
+f(double x, double a, double b)
+{
+    return 1/3.1415926535897932 * std::atan((x - a)/b) + .5;
+}
 
 int main()
 {
-    typedef std::cauchy_distribution<> D;
-    typedef D::param_type P;
-    typedef std::mt19937 G;
-    G g;
-    D d(0.5, 2);
-    D::result_type v = d(g);
-
-// If anyone can figure out a better test than this,
-// it would be more than welcome!
+    {
+        typedef std::cauchy_distribution<> D;
+        typedef D::param_type P;
+        typedef std::mt19937 G;
+        G g;
+        const double a = 10;
+        const double b = .5;
+        D d(a, b);
+        const int N = 1000000;
+        std::vector<D::result_type> u;
+        for (int i = 0; i < N; ++i)
+            u.push_back(d(g));
+        std::sort(u.begin(), u.end());
+        for (int i = 0; i < N; ++i)
+            assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
+    }
+    {
+        typedef std::cauchy_distribution<> D;
+        typedef D::param_type P;
+        typedef std::mt19937 G;
+        G g;
+        const double a = -1.5;
+        const double b = 1;
+        D d(a, b);
+        const int N = 1000000;
+        std::vector<D::result_type> u;
+        for (int i = 0; i < N; ++i)
+            u.push_back(d(g));
+        std::sort(u.begin(), u.end());
+        for (int i = 0; i < N; ++i)
+            assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
+    }
+    {
+        typedef std::cauchy_distribution<> D;
+        typedef D::param_type P;
+        typedef std::mt19937 G;
+        G g;
+        const double a = .5;
+        const double b = 2;
+        D d(a, b);
+        const int N = 1000000;
+        std::vector<D::result_type> u;
+        for (int i = 0; i < N; ++i)
+            u.push_back(d(g));
+        std::sort(u.begin(), u.end());
+        for (int i = 0; i < N; ++i)
+            assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
+    }
 }
diff --git a/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp b/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp
index c9cdad4..c4cfaef 100644
--- a/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp
+++ b/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp
@@ -15,17 +15,68 @@
 // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
 
 #include <random>
+#include <cassert>
+#include <vector>
+#include <algorithm>
+
+double
+f(double x, double a, double b)
+{
+    return 1/3.1415926535897932 * std::atan((x - a)/b) + .5;
+}
+
 
 int main()
 {
-    typedef std::cauchy_distribution<> D;
-    typedef D::param_type P;
-    typedef std::mt19937 G;
-    G g;
-    D d(0.5, 2);
-    P p(3, 4);
-    D::result_type v = d(g, p);
-
-// If anyone can figure out a better test than this,
-// it would be more than welcome!
+    {
+        typedef std::cauchy_distribution<> D;
+        typedef D::param_type P;
+        typedef std::mt19937 G;
+        G g;
+        const double a = 10;
+        const double b = .5;
+        D d;
+        P p(a, b);
+        const int N = 1000000;
+        std::vector<D::result_type> u;
+        for (int i = 0; i < N; ++i)
+            u.push_back(d(g, p));
+        std::sort(u.begin(), u.end());
+        for (int i = 0; i < N; ++i)
+            assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
+    }
+    {
+        typedef std::cauchy_distribution<> D;
+        typedef D::param_type P;
+        typedef std::mt19937 G;
+        G g;
+        const double a = -1.5;
+        const double b = 1;
+        D d;
+        P p(a, b);
+        const int N = 1000000;
+        std::vector<D::result_type> u;
+        for (int i = 0; i < N; ++i)
+            u.push_back(d(g, p));
+        std::sort(u.begin(), u.end());
+        for (int i = 0; i < N; ++i)
+            assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
+    }
+    {
+        typedef std::cauchy_distribution<> D;
+        typedef D::param_type P;
+        typedef std::mt19937 G;
+        G g;
+        const double a = .5;
+        const double b = 2;
+        D d;
+        P p(a, b);
+        const int N = 1000000;
+        std::vector<D::result_type> u;
+        for (int i = 0; i < N; ++i)
+            u.push_back(d(g, p));
+        std::sort(u.begin(), u.end());
+        for (int i = 0; i < N; ++i)
+            assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
+    }
 }