vpiotr#60: correct formatting of test case code

vpiotr · vpiotr · commit b68a0b320afb · 2023-12-16T23:43:46.000+01:00
diff --git a/tests/decimalTest.ipp b/tests/decimalTest.ipp
@@ -20,7 +20,7 @@ std::string uint_to_string(unsigned int arg) {
     return (out.str());
 }
 
-    BOOST_AUTO_TEST_CASE(decimalAsInteger)
+BOOST_AUTO_TEST_CASE(decimalAsInteger)
 {
     // rounded value
     dec::decimal<6> a;
@@ -40,7 +40,7 @@ std::string uint_to_string(unsigned int arg) {
 }
 
 // test with values internally > 2^32
-    BOOST_AUTO_TEST_CASE(decimalMidOverflow)
+BOOST_AUTO_TEST_CASE(decimalMidOverflow)
 {
     dec::decimal<6> a;
     dec::decimal<6> b;
@@ -57,7 +57,7 @@ std::string uint_to_string(unsigned int arg) {
     BOOST_CHECK((c - expected).abs() < dec::decimal<6>("1.0"));
 }
 
-    BOOST_AUTO_TEST_CASE(decimalUnpack)
+BOOST_AUTO_TEST_CASE(decimalUnpack)
 {
     using namespace dec;
 
@@ -83,7 +83,7 @@ std::string uint_to_string(unsigned int arg) {
     BOOST_CHECK(after == 5121);
 }
 
-    BOOST_AUTO_TEST_CASE(decimalPack)
+BOOST_AUTO_TEST_CASE(decimalPack)
 {
     using namespace dec;
     decimal<4> d;
@@ -108,7 +108,7 @@ std::string uint_to_string(unsigned int arg) {
     BOOST_CHECK(d.pack_rounded<5>(1, 51211) == decimal<4>("1.5121"));
 }
 
-    BOOST_AUTO_TEST_CASE(decimalZeroPrec)
+BOOST_AUTO_TEST_CASE(decimalZeroPrec)
 {
     using namespace dec;
     decimal<0> d;
@@ -130,7 +130,7 @@ std::string uint_to_string(unsigned int arg) {
     BOOST_CHECK(d == decimal<0>(-2));
 }
 
-    BOOST_AUTO_TEST_CASE(decimalComparison)
+BOOST_AUTO_TEST_CASE(decimalComparison)
 {
     const double pi = 3.1415926;
     BOOST_CHECK_EQUAL(dec::decimal<8>(0.), 0);
@@ -151,7 +151,7 @@ std::string uint_to_string(unsigned int arg) {
     BOOST_CHECK(dec::decimal<8>(pi) != 3.0);
 }
 
-    BOOST_AUTO_TEST_CASE(decimalSign)
+BOOST_AUTO_TEST_CASE(decimalSign)
 {
     dec::decimal<4> d(-4.1234);
     BOOST_CHECK(d.sign() < 0);
@@ -169,7 +169,7 @@ std::string uint_to_string(unsigned int arg) {
     BOOST_CHECK(d.sign() == 0);
 }
 
-    BOOST_AUTO_TEST_CASE(decimalFloatConstructorHighPrec) {
+BOOST_AUTO_TEST_CASE(decimalFloatConstructorHighPrec) {
     dec::decimal<2> d1(3.1549999999999998);
     dec::decimal<2> d2("3.1549999999999998");
     BOOST_CHECK_EQUAL(d1, d2);
@@ -188,7 +188,7 @@ std::string uint_to_string(unsigned int arg) {
 }
 
 #ifndef DEC_NO_CPP11
-    BOOST_AUTO_TEST_CASE(trivialAndNoThrowConstructor) {
+BOOST_AUTO_TEST_CASE(trivialAndNoThrowConstructor) {
     BOOST_CHECK_EQUAL(std::is_trivial<dec::decimal<6>>::value, false);
 
     BOOST_CHECK_EQUAL(std::is_trivially_constructible<dec::decimal<6>>::value, false);
diff --git a/tests/decimalTestAbout.cpp b/tests/decimalTestAbout.cpp
@@ -5,7 +5,7 @@
 #include "decimal.h"
 
 
-    BOOST_AUTO_TEST_CASE(decimalAbout) {
+BOOST_AUTO_TEST_CASE(decimalAbout) {
     using namespace dec;
     using namespace std;
 
diff --git a/tests/decimalTestArithmetic.cpp b/tests/decimalTestArithmetic.cpp
@@ -4,7 +4,7 @@
 
 #include "decimal.h"
 
-    BOOST_AUTO_TEST_CASE(decimalArithmetic)
+BOOST_AUTO_TEST_CASE(decimalArithmetic)
 {
     dec::decimal<2> balance;
     dec::decimal<2> a(123);
diff --git a/tests/decimalTestDiv.cpp b/tests/decimalTestDiv.cpp
@@ -4,7 +4,7 @@
 
 #include "decimal.h"
 
-    BOOST_AUTO_TEST_CASE(decimalDivInt)
+BOOST_AUTO_TEST_CASE(decimalDivInt)
 {
     BOOST_CHECK_EQUAL(dec::decimal<4>("1.0001") / 2, dec::decimal<4>("0.5001"));
 #ifdef DEC_HANDLE_LONG
diff --git a/tests/decimalTestMult.cpp b/tests/decimalTestMult.cpp
@@ -4,7 +4,7 @@
 
 #include "decimal.h"
 
-    BOOST_AUTO_TEST_CASE(decimalMultiplyPrec)
+BOOST_AUTO_TEST_CASE(decimalMultiplyPrec)
 {
     // check mult prec
     BOOST_CHECK_EQUAL(dec::decimal<4>("0.0001") * dec::decimal<4>("1.0000"), dec::decimal<4>("0.0001"));
@@ -41,7 +41,7 @@
                       dec::decimal<6>("1894327894.925618"));
 }
 
-    BOOST_AUTO_TEST_CASE(decimalMultiplyInt)
+BOOST_AUTO_TEST_CASE(decimalMultiplyInt)
 {
     BOOST_CHECK_EQUAL(dec::decimal<4>("0.0001") * 2, dec::decimal<4>("0.0002"));
     BOOST_CHECK_EQUAL(dec::decimal<4>("0.1001") * 3, dec::decimal<4>("0.3003"));
diff --git a/tests/decimalTestMultDiv.cpp b/tests/decimalTestMultDiv.cpp
@@ -16,7 +16,7 @@ class mult_div_tester {
     }
 };
 
-    BOOST_AUTO_TEST_CASE(multDiv)
+BOOST_AUTO_TEST_CASE(multDiv)
 {
 
     {
diff --git a/tests/decimalTestRoundOth.cpp b/tests/decimalTestRoundOth.cpp
@@ -4,23 +4,23 @@
 
 #include "decimal.h"
 
-    BOOST_AUTO_TEST_CASE(testFloor) {
+BOOST_AUTO_TEST_CASE(testFloor) {
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(2).floor(), 2);
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(2.4).floor(), 2);
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(2.9).floor(), 2);
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(-2.7).floor(), -3);
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(-2).floor(), -2);
 }
 
-    BOOST_AUTO_TEST_CASE(testCeil) {
+BOOST_AUTO_TEST_CASE(testCeil) {
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(2).ceil(), 2);
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(2.4).ceil(), 3);
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(2.9).ceil(), 3);
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(-2.7).ceil(), -2);
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(-2).ceil(), -2);
 }
 
-    BOOST_AUTO_TEST_CASE(testRound) {
+BOOST_AUTO_TEST_CASE(testRound) {
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(2).round(), 2);
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(2.4).round(), 2);
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(2.9).round(), 3);
@@ -29,7 +29,7 @@
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(-2).round(), -2);
 }
 
-    BOOST_AUTO_TEST_CASE(testTrunc) {
+BOOST_AUTO_TEST_CASE(testTrunc) {
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(2).trunc(), 2);
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(2.4).trunc(), 2);
     BOOST_CHECK_EQUAL(dec::decimal_cast<2>(2.9).trunc(), 2);
diff --git a/tests/decimalTestRounding.cpp b/tests/decimalTestRounding.cpp
@@ -4,7 +4,7 @@
 
 #include "decimal.h"
 
-    BOOST_AUTO_TEST_CASE(decimalRounding)
+BOOST_AUTO_TEST_CASE(decimalRounding)
 {
     dec::decimal<2> balance;
 
@@ -58,7 +58,7 @@
     BOOST_CHECK_EQUAL(longDec1, longDec2);
 }
 
-    BOOST_AUTO_TEST_CASE(decimalDefRoundPolicy)
+BOOST_AUTO_TEST_CASE(decimalDefRoundPolicy)
 {
     using namespace dec;
     decimal<1, def_round_policy> a("0.5");
@@ -70,7 +70,7 @@
     BOOST_CHECK(c == expected);
 }
 
-    BOOST_AUTO_TEST_CASE(decimalNoRoundPolicy)
+BOOST_AUTO_TEST_CASE(decimalNoRoundPolicy)
 {
     using namespace dec;
     decimal<1, null_round_policy> a("0.5");
@@ -127,7 +127,7 @@ class round_tester_t {
     std::string m_name;
 };
 
-    BOOST_AUTO_TEST_CASE(decimalRoundingPolicyOther)
+BOOST_AUTO_TEST_CASE(decimalRoundingPolicyOther)
 {
     using namespace dec;
     {
diff --git a/tests/decimalTestTypeLevel.cpp b/tests/decimalTestTypeLevel.cpp
@@ -4,7 +4,7 @@
 
 #include "decimal.h"
 
-    BOOST_AUTO_TEST_CASE(decimalTypeLevel)
+BOOST_AUTO_TEST_CASE(decimalTypeLevel)
 {
     using namespace dec;
     dec::decimal<4> d4("-4.1234");
diff --git a/tests/decimalTestWithExponent.cpp b/tests/decimalTestWithExponent.cpp
@@ -4,7 +4,7 @@
 
 #include "decimal.h"
 
-    BOOST_AUTO_TEST_CASE(decimalWithExponent)
+BOOST_AUTO_TEST_CASE(decimalWithExponent)
 {
     // build positive values
     BOOST_CHECK_EQUAL(dec::decimal<4>::buildWithExponent(11, 0), dec::decimal<4>("11"));

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ std::string uint_to_string(unsigned int arg) {`
`20`	`20`	`return (out.str());`
`21`	`21`	`}`
`22`	`22`
`23`		`- BOOST_AUTO_TEST_CASE(decimalAsInteger)`
	`23`	`+BOOST_AUTO_TEST_CASE(decimalAsInteger)`
`24`	`24`	`{`
`25`	`25`	`// rounded value`
`26`	`26`	`dec::decimal<6> a;`
`@@ -40,7 +40,7 @@ std::string uint_to_string(unsigned int arg) {`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`// test with values internally > 2^32`
`43`		`- BOOST_AUTO_TEST_CASE(decimalMidOverflow)`
	`43`	`+BOOST_AUTO_TEST_CASE(decimalMidOverflow)`
`44`	`44`	`{`
`45`	`45`	`dec::decimal<6> a;`
`46`	`46`	`dec::decimal<6> b;`
`@@ -57,7 +57,7 @@ std::string uint_to_string(unsigned int arg) {`
`57`	`57`	`BOOST_CHECK((c - expected).abs() < dec::decimal<6>("1.0"));`
`58`	`58`	`}`
`59`	`59`
`60`		`- BOOST_AUTO_TEST_CASE(decimalUnpack)`
	`60`	`+BOOST_AUTO_TEST_CASE(decimalUnpack)`
`61`	`61`	`{`
`62`	`62`	`using namespace dec;`
`63`	`63`
`@@ -83,7 +83,7 @@ std::string uint_to_string(unsigned int arg) {`
`83`	`83`	`BOOST_CHECK(after == 5121);`
`84`	`84`	`}`
`85`	`85`
`86`		`- BOOST_AUTO_TEST_CASE(decimalPack)`
	`86`	`+BOOST_AUTO_TEST_CASE(decimalPack)`
`87`	`87`	`{`
`88`	`88`	`using namespace dec;`
`89`	`89`	`decimal<4> d;`
`@@ -108,7 +108,7 @@ std::string uint_to_string(unsigned int arg) {`
`108`	`108`	`BOOST_CHECK(d.pack_rounded<5>(1, 51211) == decimal<4>("1.5121"));`
`109`	`109`	`}`
`110`	`110`
`111`		`- BOOST_AUTO_TEST_CASE(decimalZeroPrec)`
	`111`	`+BOOST_AUTO_TEST_CASE(decimalZeroPrec)`
`112`	`112`	`{`
`113`	`113`	`using namespace dec;`
`114`	`114`	`decimal<0> d;`
`@@ -130,7 +130,7 @@ std::string uint_to_string(unsigned int arg) {`
`130`	`130`	`BOOST_CHECK(d == decimal<0>(-2));`
`131`	`131`	`}`
`132`	`132`
`133`		`- BOOST_AUTO_TEST_CASE(decimalComparison)`
	`133`	`+BOOST_AUTO_TEST_CASE(decimalComparison)`
`134`	`134`	`{`
`135`	`135`	`const double pi = 3.1415926;`
`136`	`136`	`BOOST_CHECK_EQUAL(dec::decimal<8>(0.), 0);`
`@@ -151,7 +151,7 @@ std::string uint_to_string(unsigned int arg) {`
`151`	`151`	`BOOST_CHECK(dec::decimal<8>(pi) != 3.0);`
`152`	`152`	`}`
`153`	`153`
`154`		`- BOOST_AUTO_TEST_CASE(decimalSign)`
	`154`	`+BOOST_AUTO_TEST_CASE(decimalSign)`
`155`	`155`	`{`
`156`	`156`	`dec::decimal<4> d(-4.1234);`
`157`	`157`	`BOOST_CHECK(d.sign() < 0);`
`@@ -169,7 +169,7 @@ std::string uint_to_string(unsigned int arg) {`
`169`	`169`	`BOOST_CHECK(d.sign() == 0);`
`170`	`170`	`}`
`171`	`171`
`172`		`- BOOST_AUTO_TEST_CASE(decimalFloatConstructorHighPrec) {`
	`172`	`+BOOST_AUTO_TEST_CASE(decimalFloatConstructorHighPrec) {`
`173`	`173`	`dec::decimal<2> d1(3.1549999999999998);`
`174`	`174`	`dec::decimal<2> d2("3.1549999999999998");`
`175`	`175`	`BOOST_CHECK_EQUAL(d1, d2);`
`@@ -188,7 +188,7 @@ std::string uint_to_string(unsigned int arg) {`
`188`	`188`	`}`
`189`	`189`
`190`	`190`	`#ifndef DEC_NO_CPP11`
`191`		`- BOOST_AUTO_TEST_CASE(trivialAndNoThrowConstructor) {`
	`191`	`+BOOST_AUTO_TEST_CASE(trivialAndNoThrowConstructor) {`
`192`	`192`	`BOOST_CHECK_EQUAL(std::is_trivial<dec::decimal<6>>::value, false);`
`193`	`193`
`194`	`194`	`BOOST_CHECK_EQUAL(std::is_trivially_constructible<dec::decimal<6>>::value, false);`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`#include "decimal.h"`
`6`	`6`
`7`		`- BOOST_AUTO_TEST_CASE(decimalArithmetic)`
	`7`	`+BOOST_AUTO_TEST_CASE(decimalArithmetic)`
`8`	`8`	`{`
`9`	`9`	`dec::decimal<2> balance;`
`10`	`10`	`dec::decimal<2> a(123);`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`#include "decimal.h"`
`6`	`6`
`7`		`- BOOST_AUTO_TEST_CASE(decimalDivInt)`
	`7`	`+BOOST_AUTO_TEST_CASE(decimalDivInt)`
`8`	`8`	`{`
`9`	`9`	`BOOST_CHECK_EQUAL(dec::decimal<4>("1.0001") / 2, dec::decimal<4>("0.5001"));`
`10`	`10`	`#ifdef DEC_HANDLE_LONG`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`#include "decimal.h"`
`6`	`6`
`7`		`- BOOST_AUTO_TEST_CASE(decimalMultiplyPrec)`
	`7`	`+BOOST_AUTO_TEST_CASE(decimalMultiplyPrec)`
`8`	`8`	`{`
`9`	`9`	`// check mult prec`
`10`	`10`	`BOOST_CHECK_EQUAL(dec::decimal<4>("0.0001") * dec::decimal<4>("1.0000"), dec::decimal<4>("0.0001"));`
`@@ -41,7 +41,7 @@`
`41`	`41`	`dec::decimal<6>("1894327894.925618"));`
`42`	`42`	`}`
`43`	`43`
`44`		`- BOOST_AUTO_TEST_CASE(decimalMultiplyInt)`
	`44`	`+BOOST_AUTO_TEST_CASE(decimalMultiplyInt)`
`45`	`45`	`{`
`46`	`46`	`BOOST_CHECK_EQUAL(dec::decimal<4>("0.0001") * 2, dec::decimal<4>("0.0002"));`
`47`	`47`	`BOOST_CHECK_EQUAL(dec::decimal<4>("0.1001") * 3, dec::decimal<4>("0.3003"));`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ class mult_div_tester {`
`16`	`16`	`}`
`17`	`17`	`};`
`18`	`18`
`19`		`- BOOST_AUTO_TEST_CASE(multDiv)`
	`19`	`+BOOST_AUTO_TEST_CASE(multDiv)`
`20`	`20`	`{`
`21`	`21`
`22`	`22`	`{`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`#include "decimal.h"`
`6`	`6`
`7`		`- BOOST_AUTO_TEST_CASE(decimalRounding)`
	`7`	`+BOOST_AUTO_TEST_CASE(decimalRounding)`
`8`	`8`	`{`
`9`	`9`	`dec::decimal<2> balance;`
`10`	`10`
`@@ -58,7 +58,7 @@`
`58`	`58`	`BOOST_CHECK_EQUAL(longDec1, longDec2);`
`59`	`59`	`}`
`60`	`60`
`61`		`- BOOST_AUTO_TEST_CASE(decimalDefRoundPolicy)`
	`61`	`+BOOST_AUTO_TEST_CASE(decimalDefRoundPolicy)`
`62`	`62`	`{`
`63`	`63`	`using namespace dec;`
`64`	`64`	`decimal<1, def_round_policy> a("0.5");`
`@@ -70,7 +70,7 @@`
`70`	`70`	`BOOST_CHECK(c == expected);`
`71`	`71`	`}`
`72`	`72`
`73`		`- BOOST_AUTO_TEST_CASE(decimalNoRoundPolicy)`
	`73`	`+BOOST_AUTO_TEST_CASE(decimalNoRoundPolicy)`
`74`	`74`	`{`
`75`	`75`	`using namespace dec;`
`76`	`76`	`decimal<1, null_round_policy> a("0.5");`
`@@ -127,7 +127,7 @@ class round_tester_t {`
`127`	`127`	`std::string m_name;`
`128`	`128`	`};`
`129`	`129`
`130`		`- BOOST_AUTO_TEST_CASE(decimalRoundingPolicyOther)`
	`130`	`+BOOST_AUTO_TEST_CASE(decimalRoundingPolicyOther)`
`131`	`131`	`{`
`132`	`132`	`using namespace dec;`
`133`	`133`	`{`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`#include "decimal.h"`
`6`	`6`
`7`		`- BOOST_AUTO_TEST_CASE(decimalTypeLevel)`
	`7`	`+BOOST_AUTO_TEST_CASE(decimalTypeLevel)`
`8`	`8`	`{`
`9`	`9`	`using namespace dec;`
`10`	`10`	`dec::decimal<4> d4("-4.1234");`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`#include "decimal.h"`
`6`	`6`
`7`		`- BOOST_AUTO_TEST_CASE(decimalWithExponent)`
	`7`	`+BOOST_AUTO_TEST_CASE(decimalWithExponent)`
`8`	`8`	`{`
`9`	`9`	`// build positive values`
`10`	`10`	`BOOST_CHECK_EQUAL(dec::decimal<4>::buildWithExponent(11, 0), dec::decimal<4>("11"));`