[Jenkins] auto-formatting by clang-format version 6.0.0 (tags/google/…

…stable/2017-11-14)
stan-dev · Feb 5, 2020 · b09d1a0 · b09d1a0
1 parent e102e5f
commit b09d1a0
Show file tree

Hide file tree

Showing 14 changed files with 162 additions and 70 deletions.
diff --git a/test/unit/math/rev/core/thread_stack_instance_test.cpp b/test/unit/math/rev/core/thread_stack_instance_test.cpp
@@ -91,13 +91,16 @@ TEST(thread_stack_instance, child_instances) {
 
   auto thread_tester = [&]() -> void {
     ChainableStack thread_instance;
-    EXPECT_TRUE(main_ad_stack->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size()
+    EXPECT_TRUE(
+        main_ad_stack->var_stack_.size()
+            + stan::math::ChainableStack::instance_->var_nochain_stack_.size()
 #ifdef STAN_THREADS
-                >
+        >
 #else
-                ==
+        ==
 #endif
-                ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size());
+        ChainableStack::instance_->var_stack_.size()
+            + stan::math::ChainableStack::instance_->var_nochain_stack_.size());
   };
 
   std::thread other_work(thread_tester);

diff --git a/test/unit/math/rev/err/check_bounded_test.cpp b/test/unit/math/rev/err/check_bounded_test.cpp
@@ -15,13 +15,16 @@ TEST(AgradRevErrorHandlingScalar, CheckBoundedVarCheckVectorized) {
   for (int i = 0; i < N; ++i)
     a.push_back(var(i));
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(5U, stack_size);
   EXPECT_NO_THROW(check_bounded(function, "a", a, -1.0, 6.0));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(5U, stack_size_after_call);
   stan::math::recover_memory();
 }
@@ -145,13 +148,16 @@ TEST(AgradRevErrorHandlingScalar, CheckBoundedVarCheckUnivariate) {
   const char* function = "check_bounded";
   var a(5.0);
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(1U, stack_size);
   EXPECT_NO_THROW(check_bounded(function, "a", a, 4.0, 6.0));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(1U, stack_size_after_call);
 
   stan::math::recover_memory();

diff --git a/test/unit/math/rev/err/check_consistent_size_test.cpp b/test/unit/math/rev/err/check_consistent_size_test.cpp
@@ -15,13 +15,16 @@ TEST(AgradRevErrorHandlingScalar, CheckConsistentSizeVarCheckVectorized) {
   for (int i = 0; i < N; ++i)
     a.push_back(var(i));
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(5U, stack_size);
   EXPECT_NO_THROW(check_consistent_size(function, "a", a, 5U));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(5U, stack_size_after_call);
   stan::math::recover_memory();
 }

diff --git a/test/unit/math/rev/err/check_consistent_sizes_test.cpp b/test/unit/math/rev/err/check_consistent_sizes_test.cpp
@@ -17,13 +17,16 @@ TEST(AgradRevErrorHandlingScalar, CheckConsistentSizesVarCheckVectorized) {
     a.push_back(var(i));
   }
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(10U, stack_size);
   EXPECT_NO_THROW(check_consistent_sizes(function, "a", a, "b", b));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(10U, stack_size_after_call);
   stan::math::recover_memory();
 }

diff --git a/test/unit/math/rev/err/check_finite_test.cpp b/test/unit/math/rev/err/check_finite_test.cpp
@@ -15,19 +15,23 @@ TEST(AgradRevErrorHandlingScalar, CheckFiniteVarCheckVectorized) {
   for (int i = 0; i < N; ++i)
     a.push_back(var(i));
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(5U, stack_size);
   EXPECT_NO_THROW(check_finite(function, "a", a));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(5U, stack_size_after_call);
 
   a[1] = std::numeric_limits<double>::infinity();
   EXPECT_THROW(check_finite(function, "a", a), std::domain_error);
   stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(6U, stack_size_after_call);
 
   stan::math::recover_memory();
@@ -65,19 +69,23 @@ TEST(AgradRevErrorHandlingScalar, CheckFiniteVarCheckUnivariate) {
   const char* function = "check_finite";
   var a(5.0);
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(1U, stack_size);
   EXPECT_NO_THROW(check_finite(function, "a", a));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(1U, stack_size_after_call);
 
   a = std::numeric_limits<double>::infinity();
   EXPECT_THROW(check_finite(function, "a", a), std::domain_error);
   stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(2U, stack_size_after_call);
 
   stan::math::recover_memory();

diff --git a/test/unit/math/rev/err/check_greater_or_equal_test.cpp b/test/unit/math/rev/err/check_greater_or_equal_test.cpp
@@ -15,19 +15,23 @@ TEST(AgradRevErrorHandlingScalar, CheckGreateOrEqualVarCheckVectorized) {
   for (int i = 0; i < N; ++i)
     a.push_back(var(i));
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(5U, stack_size);
   EXPECT_NO_THROW(check_greater_or_equal(function, "a", a, -1.0));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(5U, stack_size_after_call);
 
   EXPECT_THROW(check_greater_or_equal(function, "a", a, 2.0),
                std::domain_error);
   stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(5U, stack_size_after_call);
 
   stan::math::recover_memory();
@@ -192,19 +196,23 @@ TEST(AgradRevErrorHandlingScalar, CheckGreaterOrEqualVarCheckUnivariate) {
   const char* function = "check_greater_or_equal";
   var a(5.0);
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(1U, stack_size);
   EXPECT_NO_THROW(check_greater_or_equal(function, "a", a, 2.0));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(1U, stack_size_after_call);
 
   EXPECT_THROW(check_greater_or_equal(function, "a", a, 10.0),
                std::domain_error);
   stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(1U, stack_size_after_call);
 
   stan::math::recover_memory();

diff --git a/test/unit/math/rev/err/check_greater_test.cpp b/test/unit/math/rev/err/check_greater_test.cpp
@@ -14,18 +14,22 @@ TEST(AgradRevErrorHandlingScalar, CheckGreaterVarCheckVectorized) {
   for (int i = 0; i < N; ++i)
     a.push_back(var(i));
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(5U, stack_size);
   EXPECT_NO_THROW(check_greater(function, "a", a, -1.0));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(5U, stack_size_after_call);
 
   EXPECT_THROW(check_greater(function, "a", a, 2.0), std::domain_error);
   stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(5U, stack_size_after_call);
 
   stan::math::recover_memory();
@@ -182,18 +186,22 @@ TEST(AgradRevErrorHandlingScalar, CheckGreaterVarCheckUnivariate) {
   const char* function = "check_greater";
   var a(5.0);
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(1U, stack_size);
   EXPECT_NO_THROW(check_greater(function, "a", a, 2.0));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(1U, stack_size_after_call);
 
   EXPECT_THROW(check_greater(function, "a", a, 10.0), std::domain_error);
   stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(1U, stack_size_after_call);
 
   stan::math::recover_memory();

diff --git a/test/unit/math/rev/err/check_less_or_equal_test.cpp b/test/unit/math/rev/err/check_less_or_equal_test.cpp
@@ -14,18 +14,22 @@ TEST(AgradRevErrorHandlingScalar, CheckLessOrEqualVarCheckVectorized) {
   for (int i = 0; i < N; ++i)
     a.push_back(var(i));
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(5U, stack_size);
   EXPECT_NO_THROW(check_less_or_equal(function, "a", a, 10.0));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(5U, stack_size_after_call);
 
   EXPECT_THROW(check_less_or_equal(function, "a", a, 2.0), std::domain_error);
   stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(5U, stack_size_after_call);
 
   stan::math::recover_memory();
@@ -155,24 +159,29 @@ TEST(AgradRevErrorHandlingScalar, CheckLessOrEqualVarCheckUnivariate) {
   const char* function = "check_less_or_equal";
   var a(5.0);
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(1U, stack_size);
   EXPECT_THROW(check_less_or_equal(function, "a", a, 2.0), std::domain_error);
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(1U, stack_size_after_call);
 
   EXPECT_NO_THROW(check_less_or_equal(function, "a", a, 5.0));
 
   stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(1U, stack_size_after_call);
 
   EXPECT_NO_THROW(check_less_or_equal(function, "a", a, 10.0));
   stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(1U, stack_size_after_call);
 
   stan::math::recover_memory();

diff --git a/test/unit/math/rev/err/check_less_test.cpp b/test/unit/math/rev/err/check_less_test.cpp
@@ -14,18 +14,22 @@ TEST(AgradRevErrorHandlingScalar, CheckLessVarCheckVectorized) {
   for (int i = 0; i < N; ++i)
     a.push_back(var(i));
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(5U, stack_size);
   EXPECT_NO_THROW(check_less(function, "a", a, 10.0));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(5U, stack_size_after_call);
 
   EXPECT_THROW(check_less(function, "a", a, 2.0), std::domain_error);
   stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(5U, stack_size_after_call);
 
   stan::math::recover_memory();
@@ -152,18 +156,22 @@ TEST(AgradRevErrorHandlingScalar, CheckLessVarCheckUnivariate) {
   const char* function = "check_less";
   var a(5.0);
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(1U, stack_size);
   EXPECT_THROW(check_less(function, "a", a, 2.0), std::domain_error);
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(1U, stack_size_after_call);
 
   EXPECT_NO_THROW(check_less(function, "a", a, 10.0));
   stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size() + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(1U, stack_size_after_call);
 
   stan::math::recover_memory();