[libcxx] [test] Fix Clang -Wunused-local-typedef warnings.

[STL_MSFT]

Summary

[libcxx] [test] Fix Clang -Wunused-local-typedef warnings.

[STL_MSFT]

Ping?

[EricWF]

LGTM. @STL_MSFT This seems like you could commit it without review. You're a professional STL developer after all, if you can't get this right may God have mercy on your users.

[STL_MSFT]

Yeah, I just wanted to check that you didn't mean to actually use these typedefs for something. Thanks!

test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp

 void
 test()
 {
     test(std::complex<T>(INFINITY, 1), std::complex<T>(0, -INFINITY));
 }
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         std::complex<double> r = acos(testcases[i]);
         if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             is_about(r.real(), pi/2);

test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp

 void
 test()
 {
     test(std::complex<T>(INFINITY, 1), std::complex<T>(INFINITY, 0));
 }
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         std::complex<double> r = acosh(testcases[i]);
         if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(!std::signbit(r.real()));

test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp

 void
 test()
 {
     test(std::complex<T>(0, 0), std::complex<T>(0, 0));
 }
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         std::complex<double> r = asin(testcases[i]);
         if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));

test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp

 void
 test()
 {
     test(std::complex<T>(0, 0), std::complex<T>(0, 0));
 }
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         std::complex<double> r = asinh(testcases[i]);
         if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));

test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp

 void
 test()
 {
     test(std::complex<T>(0, 0), std::complex<T>(0, 0));
 }
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         std::complex<double> r = atanh(testcases[i]);
         if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));

test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp

 void
 test()
 {
     test(std::complex<T>(0, 0), std::complex<T>(1, 0));
 }
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         std::complex<double> r = cos(testcases[i]);
         std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
         std::complex<double> z = cosh(t1);
         if (std::isnan(real(r)))
             assert(std::isnan(real(z)));

test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp

 void
 test()
 {
     test(std::complex<T>(0, 0), std::complex<T>(1, 0));
 }
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         std::complex<double> r = cosh(testcases[i]);
         if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(r.real() == 1);
             assert(r.imag() == 0);

test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp

 void
 test()
 {
     test(std::complex<T>(0, 0), std::complex<T>(0, 0));
 }
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         std::complex<double> r = sin(testcases[i]);
         std::complex<double> t1(-imag(testcases[i]), real(testcases[i]));
         std::complex<double> t2 = sinh(t1);
         std::complex<double> z(imag(t2), -real(t2));
         if (std::isnan(real(r)))

test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp

 void
 test()
 {
     test(std::complex<T>(0, 0), std::complex<T>(0, 0));
 }
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         std::complex<double> r = sinh(testcases[i]);
         if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(r.real() == 0);
             assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));

test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp

 void
 test()
 {
     test(std::complex<T>(0, 0), std::complex<T>(0, 0));
 }
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         std::complex<double> r = tanh(testcases[i]);
         if (testcases[i].real() == 0 && testcases[i].imag() == 0)
         {
             assert(r.real() == 0);
             assert(std::signbit(r.real()) == std::signbit(testcases[i].real()));

test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp

 {
     return x * x;
 }
 
 void
 test1()
 {
     typedef std::lognormal_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d(-1./8192, 0.015625);
     const int N = 1000000;
     std::vector<D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
         D::result_type v = d(g);
test1()
     assert(std::abs((skew - x_skew) / x_skew) < 0.05);
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.25);
 }
 
 void
 test2()
 {
     typedef std::lognormal_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d(-1./32, 0.25);
     const int N = 1000000;
     std::vector<D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
         D::result_type v = d(g);
test2()
     assert(std::abs((skew - x_skew) / x_skew) < 0.01);
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
 }
 
 void
 test3()
 {
     typedef std::lognormal_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d(-1./8, 0.5);
     const int N = 1000000;
     std::vector<D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
         D::result_type v = d(g);
test3()
     assert(std::abs((skew - x_skew) / x_skew) < 0.02);
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.05);
 }
 
 void
 test4()
 {
     typedef std::lognormal_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d;
     const int N = 1000000;
     std::vector<D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
         D::result_type v = d(g);
test4()
     assert(std::abs((skew - x_skew) / x_skew) < 0.08);
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.4);
 }
 
 void
 test5()
 {
     typedef std::lognormal_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d(-0.78125, 1.25);
     const int N = 1000000;
     std::vector<D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
         D::result_type v = d(g);

test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp

 {
     return x * x;
 }
 
 int main()
 {
     {
         typedef std::student_t_distribution<> D;
-        typedef D::param_type P;
         typedef std::minstd_rand G;
         G g;
         D d(5.5);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
             u.push_back(d(g));
         double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
int main()
         double x_kurtosis = 6 / (d.n() - 4);
         assert(std::abs(mean - x_mean) < 0.01);
         assert(std::abs((var - x_var) / x_var) < 0.01);
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.2);
     }
     {
         typedef std::student_t_distribution<> D;
-        typedef D::param_type P;
         typedef std::minstd_rand G;
         G g;
         D d(10);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
             u.push_back(d(g));
         double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
int main()
         double x_kurtosis = 6 / (d.n() - 4);
         assert(std::abs(mean - x_mean) < 0.01);
         assert(std::abs((var - x_var) / x_var) < 0.01);
         assert(std::abs(skew - x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.04);
     }
     {
         typedef std::student_t_distribution<> D;
-        typedef D::param_type P;
         typedef std::minstd_rand G;
         G g;
         D d(100);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
             u.push_back(d(g));
         double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();

test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp

 {
     return x * x;
 }
 
 void
 test1()
 {
     typedef std::extreme_value_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d(0.5, 2);
     const int N = 1000000;
     std::vector<D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
         D::result_type v = d(g);
test1()
     assert(std::abs((skew - x_skew) / x_skew) < 0.01);
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
 }
 
 void
 test2()
 {
     typedef std::extreme_value_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d(1, 2);
     const int N = 1000000;
     std::vector<D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
         D::result_type v = d(g);
test2()
     assert(std::abs((skew - x_skew) / x_skew) < 0.01);
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
 }
 
 void
 test3()
 {
     typedef std::extreme_value_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d(1.5, 3);
     const int N = 1000000;
     std::vector<D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
         D::result_type v = d(g);
test3()
     assert(std::abs((skew - x_skew) / x_skew) < 0.01);
     assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
 }
 
 void
 test4()
 {
     typedef std::extreme_value_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d(3, 4);
     const int N = 1000000;
     std::vector<D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
         D::result_type v = d(g);

test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp

 {
     return x * x;
 }
 
 int main()
 {
     {
         typedef std::gamma_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(0.5, 2);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
int main()
         double x_kurtosis = 6 / d.alpha();
         assert(std::abs((mean - x_mean) / x_mean) < 0.01);
         assert(std::abs((var - x_var) / x_var) < 0.01);
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
     {
         typedef std::gamma_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(1, .5);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
int main()
         double x_kurtosis = 6 / d.alpha();
         assert(std::abs((mean - x_mean) / x_mean) < 0.01);
         assert(std::abs((var - x_var) / x_var) < 0.01);
         assert(std::abs((skew - x_skew) / x_skew) < 0.01);
         assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
     }
     {
         typedef std::gamma_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(2, 3);
         const int N = 1000000;
         std::vector<D::result_type> u;
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);

test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp

 {
     return a + m*(sqr(x) - sqr(b))/2 + c*(x-b);
 }
 
 void
 test1()
 {
     typedef std::piecewise_linear_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937_64 G;
     G g;
     double b[] = {10, 14, 16, 17};
     double p[] = {0, 1, 1, 0};
     const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
     D d(b, b+Np+1, p);
     const int N = 1000000;
     std::vector<D::result_type> u;
for (size_t i = 0; i < N; ++i)
         assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
     }
 }
 
 void
 test2()
 {
     typedef std::piecewise_linear_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937_64 G;
     G g;
     double b[] = {10, 14, 16, 17};
     double p[] = {0, 0, 1, 0};
     const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
     D d(b, b+Np+1, p);
     const int N = 1000000;
     std::vector<D::result_type> u;
for (size_t i = 0; i < N; ++i)
         assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
     }
 }
 
 void
 test3()
 {
     typedef std::piecewise_linear_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937_64 G;
     G g;
     double b[] = {10, 14, 16, 17};
     double p[] = {1, 0, 0, 0};
     const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
     D d(b, b+Np+1, p);
     const size_t N = 1000000;
     std::vector<D::result_type> u;
for (size_t i = 0; i < N; ++i)
         assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
     }
 }
 
 void
 test4()
 {
     typedef std::piecewise_linear_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937_64 G;
     G g;
     double b[] = {10, 14, 16};
     double p[] = {0, 1, 0};
     const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
     D d(b, b+Np+1, p);
     const int N = 1000000;
     std::vector<D::result_type> u;
for (size_t i = 0; i < N; ++i)
         assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
     }
 }
 
 void
 test5()
 {
     typedef std::piecewise_linear_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937_64 G;
     G g;
     double b[] = {10, 14};
     double p[] = {1, 1};
     const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
     D d(b, b+Np+1, p);
     const int N = 1000000;
     std::vector<D::result_type> u;
for (size_t i = 0; i < N; ++i)
         assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
     }
 }
 
 void
 test6()
 {
     typedef std::piecewise_linear_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937_64 G;
     G g;
     double b[] = {10, 14, 16, 17};
     double p[] = {25, 62.5, 12.5, 0};
     const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
     D d(b, b+Np+1, p);
     const int N = 1000000;
     std::vector<D::result_type> u;

test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp

 #include <thread>
 #include <cstdlib>
 #include <cassert>
 
 int main()
 {
     typedef std::chrono::system_clock Clock;
     typedef Clock::time_point time_point;
-    typedef Clock::duration duration;
     std::chrono::milliseconds ms(500);
     time_point t0 = Clock::now();
     std::this_thread::sleep_until(t0 + ms);
     time_point t1 = Clock::now();
     std::chrono::nanoseconds ns = (t1 - t0) - ms;
     std::chrono::nanoseconds err = 5 * ms / 100;
     // The time slept is within 5% of 500ms
     assert(std::abs(ns.count()) < err.count());
 }