Wrap all tests in unnamed namespaces.

This makes the compiler warn about test cases that aren't ever used,
which is a good thing.

package/ci/leaksanitizer.conf

@@ -2,4 +2,4 @@
 
 # The test case intentionally leaks because there is currently no other way to
 # trigger given behavior without asserting elsewhere
-leak:Magnum::Test::ResourceManagerTest::clearWhileReferenced
+leak:ResourceManagerTest::clearWhileReferenced

src/Magnum/Animation/Test/Benchmark.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/Animation/Player.h"
 
-namespace Magnum { namespace Animation { namespace Test {
+namespace Magnum { namespace Animation { namespace Test { namespace {
 
 struct Benchmark: TestSuite::Tester {
     explicit Benchmark();
@@ -260,6 +260,6 @@ void Benchmark::playerAdvanceRawCallbackDirectInterpolator() {
     CORRADE_COMPARE(result, 125000);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Animation::Test::Benchmark)

src/Magnum/Animation/Test/EasingTest.cpp

@@ -31,7 +31,7 @@
 
 #include "Magnum/Animation/Easing.h"
 
-namespace Magnum { namespace Animation { namespace Test {
+namespace Magnum { namespace Animation { namespace Test { namespace {
 
 struct EasingTest: TestSuite::Tester {
     explicit EasingTest();
@@ -44,8 +44,6 @@ struct EasingTest: TestSuite::Tester {
     void benchmark();
 };
 
-namespace {
-
 #define _c(name) #name, Easing::name
 constexpr struct {
     const char* name;
@@ -188,8 +186,6 @@ constexpr struct {
 };
 #undef _c
 
-}
-
 EasingTest::EasingTest() {
     addInstancedTests({&EasingTest::bounds},
         Containers::arraySize(BoundsData));
@@ -207,9 +203,7 @@ EasingTest::EasingTest() {
         Containers::arraySize(ValueData));
 }
 
-namespace {
-    constexpr std::size_t PropertyVerificationStepCount = 50;
-}
+enum: std::size_t { PropertyVerificationStepCount = 50 };
 
 void EasingTest::bounds() {
     auto&& data = BoundsData[testCaseInstanceId()];
@@ -264,9 +258,7 @@ void EasingTest::values() {
     CORRADE_COMPARE(data.function(0.75f), data.values[2]);
 }
 
-namespace {
-    constexpr Int BenchmarkStepCount = 5000;
-}
+enum: Int { BenchmarkStepCount = 5000 };
 
 void EasingTest::benchmark() {
     auto&& data = ValueData[testCaseInstanceId()];
@@ -284,6 +276,6 @@ void EasingTest::benchmark() {
     CORRADE_COMPARE_AS(result, -350.0f, TestSuite::Compare::Greater);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Animation::Test::EasingTest)

src/Magnum/Animation/Test/InterpolationTest.cpp

@@ -33,7 +33,7 @@
 #include "Magnum/Math/DualQuaternion.h"
 #include "Magnum/Math/Half.h"
 
-namespace Magnum { namespace Animation { namespace Test {
+namespace Magnum { namespace Animation { namespace Test { namespace {
 
 struct InterpolationTest: TestSuite::Tester {
     explicit InterpolationTest();
@@ -76,8 +76,6 @@ struct InterpolationTest: TestSuite::Tester {
     void debugExtrapolation();
 };
 
-namespace {
-
 using namespace Math::Literals;
 
 const struct {
@@ -146,8 +144,6 @@ const struct {
     {"out of bounds", 405780454}
 };
 
-}
-
 InterpolationTest::InterpolationTest() {
     addTests({&InterpolationTest::interpolatorFor,
               &InterpolationTest::interpolatorForBool,
@@ -374,10 +370,8 @@ void InterpolationTest::interpolatorForCubicHermiteQuaternion() {
         "Animation::interpolatorFor(): can't deduce interpolator function for Animation::Interpolation(0xde)\n");
 }
 
-namespace {
 constexpr Float Keys[]{0.0f, 2.0f, 4.0f, 5.0f};
 constexpr Float Values[]{3.0f, 1.0f, 2.5f, 0.5f};
-}
 
 void InterpolationTest::interpolate() {
     const auto& data = Data[testCaseInstanceId()];
@@ -442,7 +436,6 @@ void InterpolationTest::interpolateStrictHint() {
     CORRADE_COMPARE(hint, 2);
 }
 
-namespace {
 using namespace Math::Literals;
 
 const Half HalfValues[]{3.0_h, 1.0_h, 2.5_h, 0.5_h};
@@ -450,7 +443,6 @@ namespace {
 Float lerpHalf(const Half& a, const Half& b, Float t) {
     return Math::lerp(Float(a), Float(b), t);
 }
-}
 
 void InterpolationTest::interpolateDifferentResultType() {
     std::size_t hint{};
@@ -466,9 +458,7 @@ void InterpolationTest::interpolateStrictDifferentResultType() {
     CORRADE_COMPARE(hint, 2);
 }
 
-namespace {
 constexpr Int IntegerKeys[]{0, 48, 96, 120};
-}
 
 void InterpolationTest::interpolateIntegerKey() {
     std::size_t hint{};
@@ -581,6 +571,6 @@ void InterpolationTest::debugExtrapolation() {
     CORRADE_COMPARE(out.str(), "Animation::Extrapolation::DefaultConstructed Animation::Extrapolation(0xde)\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Animation::Test::InterpolationTest)

src/Magnum/Animation/Test/PlayerCustomTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/Animation/Player.hpp"
 
-namespace Magnum { namespace Animation { namespace Test {
+namespace Magnum { namespace Animation { namespace Test { namespace {
 
 struct PlayerCustomTest: TestSuite::Tester {
     explicit PlayerCustomTest();
@@ -43,14 +43,12 @@ PlayerCustomTest::PlayerCustomTest() {
 typedef std::uint64_t UnsignedLong; /** @todo what about this? */
 #endif
 
-namespace {
 const Animation::Track<UnsignedShort, Float> Track{{
     {24, 1.5f}, /* 1.0 sec */
     {60, 3.0f}, /* 2.5 sec */
     {72, 5.0f}, /* 3.0 sec */
     {96, 2.0f}  /* 4.0 sec */
 }, Math::lerp};
-}
 
 void PlayerCustomTest::test() {
     Player<UnsignedLong, UnsignedShort> player{
@@ -75,6 +73,6 @@ void PlayerCustomTest::test() {
     CORRADE_COMPARE(value, 4.0f);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Animation::Test::PlayerCustomTest)

src/Magnum/Animation/Test/PlayerTest.cpp

@@ -30,7 +30,7 @@
 
 #include "Magnum/Animation/Player.h"
 
-namespace Magnum { namespace Animation { namespace Test {
+namespace Magnum { namespace Animation { namespace Test { namespace {
 
 struct PlayerTest: TestSuite::Tester {
     explicit PlayerTest();
@@ -89,7 +89,6 @@ struct PlayerTest: TestSuite::Tester {
     void debugState();
 };
 
-namespace {
 const struct {
     const char* name;
     Float offsetFloat;
@@ -116,7 +115,6 @@ namespace {
         #endif
         true, true},
 };
-}
 
 PlayerTest::PlayerTest() {
     addTests({&PlayerTest::constructEmpty,
@@ -184,14 +182,12 @@ void PlayerTest::constructEmpty() {
     CORRADE_COMPARE(player.size(), 0);
 }
 
-namespace {
 const Animation::Track<Float, Float> Track{{
     {1.0f, 1.5f},
     {2.5f, 3.0f},
     {3.0f, 5.0f},
     {4.0f, 2.0f}
 }, Math::lerp};
-}
 
 void PlayerTest::construct() {
     Animation::Track<Float, Int> track2{{
@@ -1248,12 +1244,10 @@ void PlayerTest::addWithCallbackOnChangeTemplate() {
     CORRADE_COMPARE(data.called, 2);
 }
 
-namespace {
 /* Can't use raw lambdas because MSVC 2015 */
 void callback(std::vector<Int>& data, Int value) {
     data.push_back(value);
 }
-}
 
 void PlayerTest::addRawCallback() {
     Animation::Track<Float, Int> track;
@@ -1357,6 +1351,6 @@ void PlayerTest::debugState() {
     CORRADE_COMPARE(out.str(), "Animation::State::Playing Animation::State(0xde)\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Animation::Test::PlayerTest)

src/Magnum/Animation/Test/TrackTest.cpp

@@ -29,7 +29,7 @@
 #include "Magnum/Math/Half.h"
 #include "Magnum/Math/Vector3.h"
 
-namespace Magnum { namespace Animation { namespace Test {
+namespace Magnum { namespace Animation { namespace Test { namespace {
 
 struct TrackTest: TestSuite::Tester {
     explicit TrackTest();
@@ -56,8 +56,6 @@ struct TrackTest: TestSuite::Tester {
     void atDifferentResultTypeStrict();
 };
 
-namespace {
-
 /* Reduced version from InterpolateTest, keep in sync with TrackViewTest */
 const struct {
     const char* name;
@@ -93,8 +91,6 @@ const struct {
         6.0f, -1.5f, -1.5f, 2}
 };
 
-}
-
 TrackTest::TrackTest() {
     addTests({&TrackTest::constructEmpty,
               &TrackTest::constructArrayInterpolator,
@@ -217,9 +213,7 @@ void TrackTest::constructArrayInterpolationDefaults() {
     CORRADE_COMPARE(a.values()[0], (Vector3{3.0f, 1.0f, 0.1f}));
 }
 
-namespace {
 Vector3 customLerp(const Vector3&, const Vector3&, Float) { return {}; }
-}
 
 void TrackTest::constructArrayInterpolationInterpolator() {
     const Track<Float, Vector3> a{
@@ -437,11 +431,9 @@ void TrackTest::atStrict() {
     CORRADE_COMPARE(hint, data.expectedHint);
 }
 
-namespace {
 Float lerpHalf(const Half& a, const Half& b, Float t) {
     return Math::lerp(Float(a), Float(b), t);
 }
-}
 
 void TrackTest::atDifferentResultType() {
     using namespace Math::Literals;
@@ -472,6 +464,6 @@ void TrackTest::atDifferentResultTypeStrict() {
     CORRADE_COMPARE(hint, 2);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Animation::Test::TrackTest)

src/Magnum/Animation/Test/TrackViewTest.cpp

@@ -29,7 +29,7 @@
 #include "Magnum/Math/Half.h"
 #include "Magnum/Math/Vector3.h"
 
-namespace Magnum { namespace Animation { namespace Test {
+namespace Magnum { namespace Animation { namespace Test { namespace {
 
 struct TrackViewTest: TestSuite::Tester {
     explicit TrackViewTest();
@@ -56,8 +56,6 @@ struct TrackViewTest: TestSuite::Tester {
     void atDifferentResultTypeStrict();
 };
 
-namespace {
-
 /* Reduced version from InterpolateTest, keep in sync with TrackTest */
 const struct {
     const char* name;
@@ -93,8 +91,6 @@ const struct {
         6.0f, -1.5f, -1.5f, 2}
 };
 
-}
-
 TrackViewTest::TrackViewTest() {
     addTests({&TrackViewTest::constructEmpty,
               &TrackViewTest::constructInterpolator,
@@ -204,9 +200,7 @@ void TrackViewTest::constructInterpolationDefaults() {
     CORRADE_COMPARE(a[1], (std::pair<Float, Vector3>{5.0f, {0.3f, 0.6f, 1.0f}}));
 }
 
-namespace {
 Vector3 customLerp(const Vector3&, const Vector3&, Float) { return {}; }
-}
 
 void TrackViewTest::constructInterpolationInterpolator() {
     constexpr Float keys[]{1.0f, 5.0f};
@@ -381,13 +375,12 @@ void TrackViewTest::constructCopyStorage() {
     CORRADE_COMPARE(bv[1], (std::pair<Float, Vector3>{5.0f, {0.3f, 0.6f, 1.0f}}));
 }
 
-namespace {
 const std::pair<Float, Float> Keyframes[]{
     {0.0f, 3.0f},
     {2.0f, 1.0f},
     {4.0f, 2.5f},
-        {5.0f, 0.5f}};
-}
+    {5.0f, 0.5f}
+};
 
 void TrackViewTest::at() {
     const auto& data = AtData[testCaseInstanceId()];
@@ -414,7 +407,6 @@ void TrackViewTest::atStrict() {
     CORRADE_COMPARE(hint, data.expectedHint);
 }
 
-namespace {
 using namespace Math::Literals;
 
 const Half HalfValues[]{3.0_h, 1.0_h, 2.5_h, 0.5_h};
@@ -422,7 +414,6 @@ namespace {
 Float lerpHalf(const Half& a, const Half& b, Float t) {
     return Math::lerp(Float(a), Float(b), t);
 }
-}
 
 void TrackViewTest::atDifferentResultType() {
     const TrackView<Float, Half, Float> a{
@@ -445,6 +436,6 @@ void TrackViewTest::atDifferentResultTypeStrict() {
     CORRADE_COMPARE(hint, 2);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Animation::Test::TrackViewTest)

src/Magnum/Audio/Test/AbstractImporterTest.cpp

@@ -31,7 +31,7 @@
 
 #include "configure.h"
 
-namespace Magnum { namespace Audio { namespace Test {
+namespace Magnum { namespace Audio { namespace Test { namespace {
 
 struct AbstractImporterTest: TestSuite::Tester {
     explicit AbstractImporterTest();
@@ -71,6 +71,6 @@ void AbstractImporterTest::openFile() {
     CORRADE_VERIFY(importer.isOpened());
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Audio::Test::AbstractImporterTest)

src/Magnum/Audio/Test/BufferALTest.cpp

@@ -28,7 +28,7 @@
 #include "Magnum/Audio/Buffer.h"
 #include "Magnum/Audio/Context.h"
 
-namespace Magnum { namespace Audio { namespace Test {
+namespace Magnum { namespace Audio { namespace Test { namespace {
 
 struct BufferALTest: TestSuite::Tester {
     explicit BufferALTest();
@@ -47,6 +47,6 @@ void BufferALTest::construct() {
     CORRADE_VERIFY(buf.id() != 0);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Audio::Test::BufferALTest)

src/Magnum/Audio/Test/BufferFormatTest.cpp

@@ -28,7 +28,7 @@
 
 #include "Magnum/Audio/BufferFormat.h"
 
-namespace Magnum { namespace Audio { namespace Test {
+namespace Magnum { namespace Audio { namespace Test { namespace {
 
 struct BufferFormatTest: TestSuite::Tester {
     explicit BufferFormatTest();
@@ -46,6 +46,6 @@ void BufferFormatTest::debugFormat() {
     CORRADE_COMPARE(out.str(), "Audio::BufferFormat::Stereo16 Audio::BufferFormat(0xdead)\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Audio::Test::BufferFormatTest)

src/Magnum/Audio/Test/ContextALTest.cpp

@@ -29,7 +29,7 @@
 #include "Magnum/Audio/Extensions.h"
 #include "Magnum/Audio/Context.h"
 
-namespace Magnum { namespace Audio { namespace Test {
+namespace Magnum { namespace Audio { namespace Test { namespace {
 
 struct ContextALTest: TestSuite::Tester {
     explicit ContextALTest();
@@ -87,6 +87,6 @@ void ContextALTest::isExtensionEnabled() {
     CORRADE_VERIFY(Context::current().isExtensionSupported<Extensions::ALC::EXT::ENUMERATION>());
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Audio::Test::ContextALTest)

src/Magnum/Audio/Test/ContextTest.cpp

@@ -29,7 +29,7 @@
 
 #include "Magnum/Audio/Context.h"
 
-namespace Magnum { namespace Audio { namespace Test {
+namespace Magnum { namespace Audio { namespace Test { namespace {
 
 struct ContextTest: TestSuite::Tester {
     explicit ContextTest();
@@ -94,6 +94,6 @@ void ContextTest::debugHrtfStatus() {
     CORRADE_COMPARE(out.str(), "Audio::Context::HrtfStatus::Denied Audio::Context::HrtfStatus(0xdead)\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Audio::Test::ContextTest)

src/Magnum/Audio/Test/ListenerALTest.cpp

@@ -36,7 +36,7 @@
 #include "Magnum/SceneGraph/MatrixTransformation2D.h"
 #include "Magnum/SceneGraph/MatrixTransformation3D.h"
 
-namespace Magnum { namespace Audio { namespace Test {
+namespace Magnum { namespace Audio { namespace Test { namespace {
 
 typedef SceneGraph::Scene<SceneGraph::MatrixTransformation2D> Scene2D;
 typedef SceneGraph::Object<SceneGraph::MatrixTransformation2D> Object2D;
@@ -106,6 +106,6 @@ void ListenerALTest::updateGroups() {
     CORRADE_COMPARE(playable.source().position(), offset*13.0f);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Audio::Test::ListenerALTest)

src/Magnum/Audio/Test/PlayableALTest.cpp

@@ -33,7 +33,7 @@
 #include "Magnum/SceneGraph/Object.h"
 #include "Magnum/SceneGraph/MatrixTransformation3D.h"
 
-namespace Magnum { namespace Audio { namespace Test {
+namespace Magnum { namespace Audio { namespace Test { namespace {
 
 typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D> Scene3D;
 typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D> Object3D;
@@ -100,6 +100,6 @@ void PlayableALTest::group() {
     group.stop();
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Audio::Test::PlayableALTest)

src/Magnum/Audio/Test/RendererALTest.cpp

@@ -28,7 +28,7 @@
 #include "Magnum/Audio/Context.h"
 #include "Magnum/Audio/Renderer.h"
 
-namespace Magnum { namespace Audio { namespace Test {
+namespace Magnum { namespace Audio { namespace Test { namespace {
 
 struct RendererALTest: TestSuite::Tester {
     explicit RendererALTest();
@@ -105,6 +105,6 @@ void RendererALTest::distanceModel() {
     CORRADE_COMPARE(Renderer::distanceModel(), model);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Audio::Test::RendererALTest)

src/Magnum/Audio/Test/RendererTest.cpp

@@ -29,7 +29,7 @@
 #include "Magnum/Magnum.h"
 #include "Magnum/Audio/Renderer.h"
 
-namespace Magnum { namespace Audio { namespace Test {
+namespace Magnum { namespace Audio { namespace Test { namespace {
 
 struct RendererTest: TestSuite::Tester {
     explicit RendererTest();
@@ -55,6 +55,6 @@ void RendererTest::debugDistanceModel() {
     CORRADE_COMPARE(out.str(), "Audio::Renderer::DistanceModel::Inverse Audio::Renderer::DistanceModel(0xdead)\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Audio::Test::RendererTest)

src/Magnum/Audio/Test/SourceALTest.cpp

@@ -28,7 +28,7 @@
 #include "Magnum/Audio/Context.h"
 #include "Magnum/Audio/Source.h"
 
-namespace Magnum { namespace Audio { namespace Test {
+namespace Magnum { namespace Audio { namespace Test { namespace {
 
 struct SourceALTest: TestSuite::Tester {
     explicit SourceALTest();
@@ -168,6 +168,6 @@ void SourceALTest::rolloffFactor() {
     CORRADE_COMPARE(source.rolloffFactor(), fact);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Audio::Test::SourceALTest)

src/Magnum/Audio/Test/SourceTest.cpp

@@ -28,7 +28,7 @@
 
 #include "Magnum/Audio/Source.h"
 
-namespace Magnum { namespace Audio { namespace Test {
+namespace Magnum { namespace Audio { namespace Test { namespace {
 
 struct SourceTest: TestSuite::Tester {
     explicit SourceTest();
@@ -46,6 +46,6 @@ void SourceTest::debugState() {
     CORRADE_COMPARE(out.str(), "Audio::Source::State::Playing Audio::Source::State(0xdead)\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Audio::Test::SourceTest)

src/Magnum/DebugTools/Test/BufferDataGLTest.cpp

@@ -28,7 +28,7 @@
 #include "Magnum/DebugTools/BufferData.h"
 #include "Magnum/GL/OpenGLTester.h"
 
-namespace Magnum { namespace DebugTools { namespace Test {
+namespace Magnum { namespace DebugTools { namespace Test { namespace {
 
 struct BufferDataGLTest: Magnum::GL::OpenGLTester {
     explicit BufferDataGLTest();
@@ -42,9 +42,7 @@ BufferDataGLTest::BufferDataGLTest() {
               &BufferDataGLTest::subData});
 }
 
-namespace {
 constexpr Int Data[] = {2, 7, 5, 13, 25};
-}
 
 void BufferDataGLTest::data() {
     GL::Buffer buffer;
@@ -64,6 +62,6 @@ void BufferDataGLTest::subData() {
         TestSuite::Compare::Container);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::DebugTools::Test::BufferDataGLTest)

src/Magnum/DebugTools/Test/CapsuleRendererTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/DebugTools/Implementation/CapsuleRendererTransformation.h"
 
-namespace Magnum { namespace DebugTools { namespace Test {
+namespace Magnum { namespace DebugTools { namespace Test { namespace {
 
 struct CapsuleRendererTest: TestSuite::Tester {
     explicit CapsuleRendererTest();
@@ -174,6 +174,6 @@ void CapsuleRendererTest::common3D() {
 }
 CORRADE_IGNORE_DEPRECATED_POP
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::DebugTools::Test::CapsuleRendererTest)

src/Magnum/DebugTools/Test/CompareImageTest.cpp

@@ -40,7 +40,7 @@
 
 #include "configure.h"
 
-namespace Magnum { namespace DebugTools { namespace Test {
+namespace Magnum { namespace DebugTools { namespace Test { namespace {
 
 struct CompareImageTest: TestSuite::Tester {
     explicit CompareImageTest();
@@ -166,7 +166,6 @@ CompareImageTest::CompareImageTest() {
               &CompareImageTest::fileToImageActualIsCompressed});
 }
 
-namespace {
 const Float ActualRedData[] = {
         0.3f, 1.0f, 0.9f,
         0.9f, 0.6f, 0.2f,
@@ -182,11 +181,11 @@ namespace {
 const std::vector<Float> DeltaRed{
     0.35f, 0.0f, 0.3f,
     0.01f, 0.0f, 0.1f,
-        0.12f, 1.0f, 0.0f};
+    0.12f, 1.0f, 0.0f
+};
 
 const ImageView2D ActualRed{PixelFormat::R32F, {3, 3}, ActualRedData};
 const ImageView2D ExpectedRed{PixelFormat::R32F, {3, 3}, ExpectedRedData};
-}
 
 void CompareImageTest::formatUnknown() {
     std::ostringstream out;
@@ -242,7 +241,6 @@ void CompareImageTest::calculateDelta() {
     CORRADE_COMPARE(mean, 0.208889f);
 }
 
-namespace {
 /* Different storage for each */
 const UnsignedByte ActualRgbData[] = {
        0,    0,    0,    0,    0,    0,    0,    0,
@@ -260,7 +258,6 @@ namespace {
 const ImageView2D ExpectedRgb{
     PixelStorage{}.setSkip({1, 0, 0}).setRowLength(3),
     PixelFormat::RGB8Unorm, {2, 2}, ExpectedRgbData};
-}
 
 void CompareImageTest::calculateDeltaStorage() {
     std::vector<Float> delta;
@@ -489,7 +486,6 @@ void CompareImageTest::teardownExternalPluginManager() {
     _manager = Containers::NullOpt;
 }
 
-namespace {
 constexpr const char* ImageCompareError =
     "Images a and b have both max and mean delta above threshold, actual 39/18.5 but at most 20/10 expected. Delta image:\n"
     "          |?M|\n"
@@ -497,7 +493,6 @@ namespace {
     "          [1,1] #abcd85, expected #abcdfa (Δ = 39)\n"
     "          [1,0] #5647ec, expected #5610ed (Δ = 18.6667)\n"
     "          [0,1] #235710, expected #232710 (Δ = 16)\n";
-}
 
 void CompareImageTest::image() {
     CORRADE_COMPARE_WITH(ActualRgb, ExpectedRgb, (CompareImage{40.0f, 20.0f}));
@@ -936,6 +931,6 @@ void CompareImageTest::fileToImageActualIsCompressed() {
         "Actual image a (.../CompareImageCompressed.dds) is compressed, comparison not possible.\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::DebugTools::Test::CompareImageTest)

src/Magnum/DebugTools/Test/CylinderRendererTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/DebugTools/Implementation/CylinderRendererTransformation.h"
 
-namespace Magnum { namespace DebugTools { namespace Test {
+namespace Magnum { namespace DebugTools { namespace Test { namespace {
 
 struct CylinderRendererTest: TestSuite::Tester {
     explicit CylinderRendererTest();
@@ -122,6 +122,6 @@ void CylinderRendererTest::common3D() {
 }
 CORRADE_IGNORE_DEPRECATED_POP
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::DebugTools::Test::CylinderRendererTest)

src/Magnum/DebugTools/Test/ForceRendererTest.cpp

@@ -28,7 +28,7 @@
 
 #include "Magnum/DebugTools/Implementation/ForceRendererTransformation.h"
 
-namespace Magnum { namespace DebugTools { namespace Implementation { namespace Test {
+namespace Magnum { namespace DebugTools { namespace Implementation { namespace Test { namespace {
 
 struct ForceRendererTest: TestSuite::Tester {
     explicit ForceRendererTest();
@@ -115,6 +115,6 @@ void ForceRendererTest::arbitrary3D() {
         TestSuite::Compare::Less);
 }
 
-}}}}
+}}}}}
 
 CORRADE_TEST_MAIN(Magnum::DebugTools::Implementation::Test::ForceRendererTest)

src/Magnum/DebugTools/Test/LineSegmentRendererTest.cpp

@@ -31,7 +31,7 @@
 
 #include "Magnum/DebugTools/Implementation/LineSegmentRendererTransformation.h"
 
-namespace Magnum { namespace DebugTools { namespace Test {
+namespace Magnum { namespace DebugTools { namespace Test { namespace {
 
 struct LineSegmentRendererTest: TestSuite::Tester {
     explicit LineSegmentRendererTest();
@@ -65,6 +65,6 @@ void LineSegmentRendererTest::line3D() {
 }
 CORRADE_IGNORE_DEPRECATED_POP
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::DebugTools::Test::LineSegmentRendererTest)

src/Magnum/DebugTools/Test/TextureImageGLTest.cpp

@@ -40,7 +40,7 @@
 #include "Magnum/GL/BufferImage.h"
 #endif
 
-namespace Magnum { namespace DebugTools { namespace Test {
+namespace Magnum { namespace DebugTools { namespace Test { namespace {
 
 struct TextureImageGLTest: GL::OpenGLTester {
     explicit TextureImageGLTest();
@@ -83,12 +83,10 @@ TextureImageGLTest::TextureImageGLTest() {
               });
 }
 
-namespace {
 constexpr UnsignedByte Data2D[] = { 0x00, 0x01, 0x02, 0x03,
                                     0x04, 0x05, 0x06, 0x07,
                                     0x08, 0x09, 0x0a, 0x0b,
                                     0x0c, 0x0d, 0x0e, 0x0f };
-}
 
 void TextureImageGLTest::subImage2D() {
     GL::Texture2D texture;
@@ -199,12 +197,10 @@ void TextureImageGLTest::subImageCubeBuffer() {
 #endif
 
 #ifndef MAGNUM_TARGET_GLES2
-namespace {
 constexpr UnsignedInt Data2DUInt[] = { 0xcafebabe,
                                        0xdeadbeef,
                                        0xbadf00d,
                                        0xdeadbabe };
-}
 
 void TextureImageGLTest::subImage2DUInt() {
     GL::Texture2D texture;
@@ -221,12 +217,10 @@ void TextureImageGLTest::subImage2DUInt() {
         TestSuite::Compare::Container);
 }
 
-namespace {
 constexpr Float Data2DFloat[] = { 1.0f,
                                   3.14159f,
                                   2.71828f,
                                   1.41421f };
-}
 
 void TextureImageGLTest::subImage2DFloat() {
     GL::Texture2D texture;
@@ -261,6 +255,6 @@ void TextureImageGLTest::subImage2DFloatGeneric() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::DebugTools::Test::TextureImageGLTest)

src/Magnum/GL/Test/AbstractObjectGLTest.cpp

@@ -28,7 +28,7 @@
 #include "Magnum/GL/Extensions.h"
 #include "Magnum/GL/OpenGLTester.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct AbstractObjectGLTest: OpenGLTester {
     explicit AbstractObjectGLTest();
@@ -52,6 +52,6 @@ void AbstractObjectGLTest::labelNoOp() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::AbstractObjectGLTest)

src/Magnum/GL/Test/AbstractQueryGLTest.cpp

@@ -28,7 +28,7 @@
 #include "Magnum/GL/OpenGLTester.h"
 #include "Magnum/GL/SampleQuery.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct AbstractQueryGLTest: OpenGLTester {
     explicit AbstractQueryGLTest();
@@ -143,6 +143,6 @@ void AbstractQueryGLTest::label() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::AbstractQueryGLTest)

src/Magnum/GL/Test/AbstractShaderProgramGLTest.cpp

@@ -43,7 +43,7 @@
 #include "Magnum/Math/Vector4.h"
 #include "Magnum/Math/Color.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct AbstractShaderProgramGLTest: OpenGLTester {
     explicit AbstractShaderProgramGLTest();
@@ -126,12 +126,10 @@ AbstractShaderProgramGLTest::AbstractShaderProgramGLTest() {
               });
 }
 
-namespace {
 class DummyShader: public AbstractShaderProgram {
     public:
         explicit DummyShader() {}
 };
-}
 
 void AbstractShaderProgramGLTest::construct() {
     {
@@ -183,7 +181,6 @@ void AbstractShaderProgramGLTest::label() {
 }
 #endif
 
-namespace {
 struct MyPublicShader: AbstractShaderProgram {
     using AbstractShaderProgram::attachShaders;
     using AbstractShaderProgram::bindAttributeLocation;
@@ -197,7 +194,6 @@ namespace {
     using AbstractShaderProgram::uniformBlockIndex;
     #endif
 };
-}
 
 void AbstractShaderProgramGLTest::create() {
     Utility::Resource rs("AbstractShaderProgramGLTest");
@@ -440,7 +436,6 @@ void AbstractShaderProgramGLTest::uniformNotFound() {
         "GL::AbstractShaderProgram: location of uniform 'another' cannot be retrieved\n");
 }
 
-namespace {
 struct MyShader: AbstractShaderProgram {
     explicit MyShader();
 
@@ -451,7 +446,6 @@ namespace {
         colorUniform,
         additionsUniform;
 };
-}
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 MyShader::MyShader() {
@@ -546,8 +540,6 @@ void AbstractShaderProgramGLTest::uniformArray() {
 }
 
 #ifndef MAGNUM_TARGET_GLES
-
-namespace {
 struct MyDoubleShader: AbstractShaderProgram {
     explicit MyDoubleShader();
 
@@ -558,7 +550,6 @@ namespace {
         colorUniform,
         additionsUniform;
 };
-}
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 MyDoubleShader::MyDoubleShader() {
@@ -720,7 +711,6 @@ void AbstractShaderProgramGLTest::uniformBlockIndexNotFound() {
         "GL::AbstractShaderProgram: index of uniform block 'another' cannot be retrieved\n");
 }
 
-namespace {
 struct UniformBlockShader: AbstractShaderProgram {
     explicit UniformBlockShader();
 
@@ -729,7 +719,6 @@ namespace {
     Int matricesUniformBlock,
         materialUniformBlock;
 };
-}
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 UniformBlockShader::UniformBlockShader() {
@@ -854,6 +843,6 @@ void AbstractShaderProgramGLTest::compute() {
 #endif
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::AbstractShaderProgramGLTest)

src/Magnum/GL/Test/AbstractShaderProgramTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/GL/AbstractShaderProgram.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct AbstractShaderProgramTest: TestSuite::Tester {
     explicit AbstractShaderProgramTest();
@@ -63,6 +63,6 @@ void AbstractShaderProgramTest::constructCopy() {
     CORRADE_VERIFY(!(std::is_assignable<DummyShader, const DummyShader&>{}));
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::AbstractShaderProgramTest)

src/Magnum/GL/Test/AbstractTextureGLTest.cpp

@@ -28,7 +28,7 @@
 #include "Magnum/GL/Texture.h"
 #include "Magnum/GL/OpenGLTester.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct AbstractTextureGLTest: OpenGLTester {
     explicit AbstractTextureGLTest();
@@ -103,6 +103,6 @@ void AbstractTextureGLTest::label() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::AbstractTextureGLTest)

src/Magnum/GL/Test/AttributeTest.cpp

@@ -28,7 +28,7 @@
 
 #include "Magnum/GL/AbstractShaderProgram.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct AttributeTest: TestSuite::Tester {
     explicit AttributeTest();
@@ -463,6 +463,6 @@ void AttributeTest::debugDataTypeVector4() {
     CORRADE_COMPARE(out.str(), "GL::Attribute::DataType::HalfFloat GL::Attribute::DataType(0xdead)\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::AttributeTest)

src/Magnum/GL/Test/BufferGLTest.cpp

@@ -33,7 +33,7 @@
 #include "Magnum/GL/Extensions.h"
 #include "Magnum/GL/OpenGLTester.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct BufferGLTest: OpenGLTester {
     explicit BufferGLTest();
@@ -410,6 +410,6 @@ void BufferGLTest::invalidate() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::BufferGLTest)

src/Magnum/GL/Test/BufferImageGLTest.cpp

@@ -32,7 +32,7 @@
 #include "Magnum/GL/PixelFormat.h"
 #include "Magnum/GL/OpenGLTester.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct BufferImageGLTest: OpenGLTester {
     explicit BufferImageGLTest();
@@ -606,6 +606,6 @@ void BufferImageGLTest::releaseCompressed() {
     CORRADE_COMPARE(b.id(), id);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::BufferImageGLTest)

src/Magnum/GL/Test/BufferImageTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/GL/BufferImage.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct BufferImageTest: TestSuite::Tester {
     explicit BufferImageTest();
@@ -75,6 +75,6 @@ void BufferImageTest::constructCopyCompressed() {
     CORRADE_VERIFY(!(std::is_assignable<CompressedBufferImage2D, const CompressedBufferImage2D&>{}));
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::BufferImageTest)

src/Magnum/GL/Test/BufferTest.cpp

@@ -29,7 +29,7 @@
 
 #include "Magnum/GL/Buffer.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct BufferTest: TestSuite::Tester {
     explicit BufferTest();
@@ -82,6 +82,6 @@ void BufferTest::debugTarget() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::BufferTest)

src/Magnum/GL/Test/BufferTextureGLTest.cpp

@@ -33,7 +33,7 @@
 #include "Magnum/GL/ImageFormat.h"
 #include "Magnum/GL/OpenGLTester.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct BufferTextureGLTest: OpenGLTester {
     explicit BufferTextureGLTest();
@@ -215,6 +215,6 @@ void BufferTextureGLTest::setBufferOffset() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::BufferTextureGLTest)

src/Magnum/GL/Test/BufferTextureTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/GL/BufferTexture.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct BufferTextureTest: TestSuite::Tester {
     explicit BufferTextureTest();
@@ -55,6 +55,6 @@ void BufferTextureTest::constructCopy() {
     CORRADE_VERIFY(!(std::is_assignable<BufferTexture, const BufferTexture&>{}));
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::BufferTextureTest)

src/Magnum/GL/Test/ContextGLTest.cpp

@@ -29,7 +29,7 @@
 #include "Magnum/GL/Extensions.h"
 #include "Magnum/GL/OpenGLTester.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct ContextGLTest: OpenGLTester {
     explicit ContextGLTest();
@@ -127,6 +127,6 @@ void ContextGLTest::isExtensionDisabled() {
     #endif
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::ContextGLTest)

src/Magnum/GL/Test/ContextTest.cpp

@@ -29,7 +29,7 @@
 #include "Magnum/GL/Context.h"
 #include "Magnum/GL/Version.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct ContextTest: TestSuite::Tester {
     explicit ContextTest();
@@ -154,6 +154,6 @@ void ContextTest::debugDetectedDrivers() {
     #endif
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::ContextTest)

src/Magnum/GL/Test/CubeMapTextureArrayGLTest.cpp

@@ -37,7 +37,7 @@
 #include "Magnum/Math/Color.h"
 #include "Magnum/Math/Range.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct CubeMapTextureArrayGLTest: OpenGLTester {
     explicit CubeMapTextureArrayGLTest();
@@ -83,7 +83,6 @@ struct CubeMapTextureArrayGLTest: OpenGLTester {
     void invalidateSubImage();
 };
 
-namespace {
 struct GenericSampler {
     typedef Magnum::SamplerFilter Filter;
     typedef Magnum::SamplerMipmap Mipmap;
@@ -272,7 +271,6 @@ namespace {
         Containers::arrayView(CompressedSubData), 16*4}
     #endif
 };
-}
 
 CubeMapTextureArrayGLTest::CubeMapTextureArrayGLTest() {
     addTests({&CubeMapTextureArrayGLTest::construct,
@@ -725,7 +723,6 @@ void CubeMapTextureArrayGLTest::compressedImageBuffer() {
     #endif
 }
 
-namespace {
 constexpr UnsignedByte Zero[4*4*4*6]{};
 #ifndef MAGNUM_TARGET_GLES
 constexpr UnsignedByte SubDataComplete[]{
@@ -760,7 +757,6 @@ namespace {
     0, 0, 0, 0,    0,    0,    0,    0,    0,    0,    0,    0, 0, 0, 0, 0
 };
 #endif
-}
 
 void CubeMapTextureArrayGLTest::subImage() {
     setTestCaseDescription(SubPixelStorageData[testCaseInstanceId()].name);
@@ -886,7 +882,6 @@ void CubeMapTextureArrayGLTest::subImageQueryBuffer() {
 }
 #endif
 
-namespace {
 /* Just 12x12x6 zeros compressed using RGBA DXT3 by the driver */
 constexpr UnsignedByte CompressedZero[9*16*6]{};
 
@@ -952,7 +947,6 @@ namespace {
     0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0
 };
 #endif
-}
 
 void CubeMapTextureArrayGLTest::compressedSubImage() {
     setTestCaseDescription(CompressedSubPixelStorageData[testCaseInstanceId()].name);
@@ -1173,6 +1167,6 @@ void CubeMapTextureArrayGLTest::invalidateSubImage() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::CubeMapTextureArrayGLTest)

src/Magnum/GL/Test/CubeMapTextureArrayTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/GL/CubeMapTextureArray.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct CubeMapTextureArrayTest: TestSuite::Tester {
     explicit CubeMapTextureArrayTest();
@@ -55,6 +55,6 @@ void CubeMapTextureArrayTest::constructCopy() {
     CORRADE_VERIFY(!(std::is_assignable<CubeMapTextureArray, const CubeMapTextureArray&>{}));
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::CubeMapTextureArrayTest)

src/Magnum/GL/Test/CubeMapTextureGLTest.cpp

@@ -41,7 +41,7 @@
 #include "Magnum/Math/Color.h"
 #include "Magnum/Math/Range.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct CubeMapTextureGLTest: OpenGLTester {
     explicit CubeMapTextureGLTest();
@@ -117,7 +117,6 @@ struct CubeMapTextureGLTest: OpenGLTester {
     void invalidateSubImage();
 };
 
-namespace {
 struct GenericSampler {
     typedef Magnum::SamplerFilter Filter;
     typedef Magnum::SamplerMipmap Mipmap;
@@ -295,8 +294,6 @@ namespace {
 };
 #endif
 
-}
-
 CubeMapTextureGLTest::CubeMapTextureGLTest() {
     addTests({&CubeMapTextureGLTest::construct,
               &CubeMapTextureGLTest::wrap,
@@ -374,12 +371,10 @@ CubeMapTextureGLTest::CubeMapTextureGLTest() {
               &CubeMapTextureGLTest::invalidateSubImage});
 }
 
-namespace {
 template<std::size_t size, class T> Containers::ArrayView<const T> unsafeSuffix(const T(&data)[size], std::size_t offset) {
     static_assert(sizeof(T) == 1, "");
     return {data - offset, size + offset};
 }
-}
 
 void CubeMapTextureGLTest::construct() {
     {
@@ -627,9 +622,7 @@ void CubeMapTextureGLTest::storage() {
     #endif
 }
 
-namespace {
 constexpr UnsignedByte Zero[4*4*4]{};
-}
 
 void CubeMapTextureGLTest::image() {
     setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
@@ -721,7 +714,6 @@ void CubeMapTextureGLTest::imageBuffer() {
 }
 #endif
 
-namespace {
 #ifndef MAGNUM_TARGET_GLES
 constexpr UnsignedByte SubDataComplete[]{
     0, 0, 0, 0,    0,    0,    0,    0,    0,    0,    0,    0, 0, 0, 0, 0,
@@ -730,7 +722,6 @@ namespace {
     0, 0, 0, 0,    0,    0,    0,    0,    0,    0,    0,    0, 0, 0, 0, 0
 };
 #endif
-}
 
 void CubeMapTextureGLTest::subImage() {
     setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
@@ -1037,7 +1028,6 @@ void CubeMapTextureGLTest::immutableCompressedImage() {
 }
 #endif
 
-namespace {
 /* Just 12x12 zeros compressed using RGBA DXT3 by the driver */
 constexpr UnsignedByte CompressedZero[9*16]{};
 
@@ -1066,7 +1056,6 @@ namespace {
       0,   0,   0,   0,   0,   0,   0,   0
 };
 #endif
-}
 
 void CubeMapTextureGLTest::compressedSubImage() {
     setTestCaseDescription(CompressedPixelStorageData[testCaseInstanceId()].name);
@@ -1458,6 +1447,6 @@ void CubeMapTextureGLTest::invalidateSubImage() {
     }
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::CubeMapTextureGLTest)

src/Magnum/GL/Test/CubeMapTextureTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/GL/CubeMapTexture.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct CubeMapTextureTest: TestSuite::Tester {
     explicit CubeMapTextureTest();
@@ -55,6 +55,6 @@ void CubeMapTextureTest::constructCopy() {
     CORRADE_VERIFY(!(std::is_assignable<CubeMapTexture, const CubeMapTexture&>{}));
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::CubeMapTextureTest)

src/Magnum/GL/Test/DebugOutputGLTest.cpp

@@ -30,7 +30,7 @@
 #include "Magnum/GL/Extensions.h"
 #include "Magnum/GL/OpenGLTester.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct DebugOutputGLTest: OpenGLTester {
     explicit DebugOutputGLTest();
@@ -173,6 +173,6 @@ void DebugOutputGLTest::groupFallback() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::DebugOutputGLTest)

src/Magnum/GL/Test/DebugOutputTest.cpp

@@ -28,7 +28,7 @@
 
 #include "Magnum/GL/DebugOutput.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct DebugOutputTest: TestSuite::Tester {
     explicit DebugOutputTest();
@@ -90,6 +90,6 @@ void DebugOutputTest::debugGroupSource() {
     CORRADE_COMPARE(o.str(), "GL::DebugGroup::Source::ThirdParty GL::DebugGroup::Source(0xdead)\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::DebugOutputTest)

src/Magnum/GL/Test/DefaultFramebufferTest.cpp

@@ -28,7 +28,7 @@
 
 #include "Magnum/GL/DefaultFramebuffer.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct DefaultFramebufferTest: TestSuite::Tester {
     explicit DefaultFramebufferTest();
@@ -47,6 +47,6 @@ void DefaultFramebufferTest::debugStatus() {
     CORRADE_COMPARE(out.str(), "GL::DefaultFramebuffer::Status::Complete GL::DefaultFramebuffer::Status(0xdead)\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::DefaultFramebufferTest)

src/Magnum/GL/Test/FramebufferGLTest.cpp

@@ -50,7 +50,7 @@
 #include "Magnum/GL/RectangleTexture.h"
 #endif
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct FramebufferGLTest: OpenGLTester {
     explicit FramebufferGLTest();
@@ -1368,10 +1368,8 @@ void FramebufferGLTest::invalidateSub() {
 }
 #endif
 
-namespace {
 const auto DataStorage = PixelStorage{}.setSkip({0, 16, 0});
 const std::size_t DataOffset = 16*8;
-}
 
 void FramebufferGLTest::read() {
     #ifndef MAGNUM_TARGET_GLES
@@ -1523,7 +1521,6 @@ void FramebufferGLTest::readBuffer() {
 }
 #endif
 
-namespace {
 constexpr char StorageData[]{
     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
@@ -1532,7 +1529,6 @@ namespace {
 };
 
 constexpr char ZeroStorage[4*4*4*6]{};
-}
 
 #ifndef MAGNUM_TARGET_GLES
 void FramebufferGLTest::copyImageTexture1D() {
@@ -2096,6 +2092,6 @@ void FramebufferGLTest::blit() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::FramebufferGLTest)

src/Magnum/GL/Test/FramebufferTest.cpp

@@ -28,7 +28,7 @@
 
 #include "Magnum/GL/Framebuffer.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct FramebufferTest: TestSuite::Tester {
     explicit FramebufferTest();
@@ -67,6 +67,6 @@ void FramebufferTest::debugStatus() {
     CORRADE_COMPARE(out.str(), "GL::Framebuffer::Status::IncompleteMissingAttachment GL::Framebuffer::Status(0xdead)\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::FramebufferTest)

src/Magnum/GL/Test/MeshGLTest.cpp

@@ -44,7 +44,7 @@
 #include "Magnum/Math/Matrix.h"
 #include "Magnum/Math/Vector4.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 /* Tests also the MeshView class. */
 
@@ -304,11 +304,9 @@ void MeshGLTest::construct() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 }
 
-namespace {
 struct FloatShader: AbstractShaderProgram {
     explicit FloatShader(const std::string& type, const std::string& conversion);
 };
-}
 
 void MeshGLTest::constructMove() {
     const Float data = Math::unpack<Float, UnsignedByte>(96);
@@ -467,7 +465,6 @@ void MeshGLTest::label() {
 }
 #endif
 
-namespace {
 #ifndef MAGNUM_TARGET_GLES2
 struct IntegerShader: AbstractShaderProgram {
     explicit IntegerShader(const std::string& type);
@@ -488,7 +485,6 @@ namespace {
     Renderbuffer renderbuffer;
     Framebuffer framebuffer;
 };
-}
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 FloatShader::FloatShader(const std::string& type, const std::string& conversion) {
@@ -1520,7 +1516,6 @@ void MeshGLTest::addVertexBufferBGRA() {
 }
 #endif
 
-namespace {
 struct MultipleShader: AbstractShaderProgram {
     typedef Attribute<0, Vector3> Position;
     typedef Attribute<1, Vector3> Normal;
@@ -1528,7 +1523,6 @@ namespace {
 
     explicit MultipleShader();
 };
-}
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 MultipleShader::MultipleShader() {
@@ -1811,7 +1805,6 @@ void MeshGLTest::addVertexBufferInstancedDynamicTransferOwnwership() {
     CORRADE_VERIFY(!glIsBuffer(id));
 }
 
-namespace {
 const Float indexedVertexData[] = {
     0.0f, /* Offset */
 
@@ -1863,7 +1856,6 @@ namespace {
 #endif
 
 constexpr Color4ub indexedResult(64 + 15 + 97, 17 + 164 + 28, 56 + 17, 255);
-}
 
 template<class T> void MeshGLTest::setIndexBuffer() {
     setTestCaseName(std::is_same<T, MeshIndexType>::value ?
@@ -2648,7 +2640,6 @@ void MeshGLTest::resetDivisorAfterInstancedDraw() {
     }
 }
 
-namespace {
 struct MultiChecker {
     MultiChecker(AbstractShaderProgram&& shader, Mesh& mesh);
 
@@ -2657,7 +2648,6 @@ namespace {
     Renderbuffer renderbuffer;
     Framebuffer framebuffer;
 };
-}
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 MultiChecker::MultiChecker(AbstractShaderProgram&& shader, Mesh& mesh): framebuffer({{}, Vector2i(1)}) {
@@ -2775,6 +2765,6 @@ void MeshGLTest::multiDrawBaseVertex() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::MeshGLTest)

src/Magnum/GL/Test/MeshTest.cpp

@@ -31,7 +31,7 @@
 #include "Magnum/GL/Mesh.h"
 #include "Magnum/GL/MeshView.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 /* Tests MeshView as well */
 
@@ -131,11 +131,9 @@ void MeshTest::constructMoveNoCreate() {
     CORRADE_VERIFY(true);
 }
 
-namespace {
 struct Shader: AbstractShaderProgram {
     explicit Shader(NoCreateT): AbstractShaderProgram{NoCreate} {}
 };
-}
 
 void MeshTest::drawCountNotSet() {
     std::ostringstream out;
@@ -225,6 +223,6 @@ void MeshTest::debugIndexType() {
     CORRADE_COMPARE(o.str(), "GL::MeshIndexType::UnsignedShort GL::MeshIndexType(0xdead)\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::MeshTest)

src/Magnum/GL/Test/MultisampleTextureGLTest.cpp

@@ -34,7 +34,7 @@
 #include "Magnum/Math/Vector3.h"
 #include "Magnum/Math/Functions.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct MultisampleTextureGLTest: OpenGLTester {
     explicit MultisampleTextureGLTest();
@@ -411,6 +411,6 @@ void MultisampleTextureGLTest::invalidateSubImage2DArray() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::MultisampleTextureGLTest)

src/Magnum/GL/Test/MultisampleTextureTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/GL/MultisampleTexture.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct MultisampleTextureTest: TestSuite::Tester {
     explicit MultisampleTextureTest();
@@ -75,6 +75,6 @@ void MultisampleTextureTest::constructCopy2DArray() {
     CORRADE_VERIFY(!(std::is_assignable<MultisampleTexture2DArray, const MultisampleTexture2DArray&>{}));
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::MultisampleTextureTest)

src/Magnum/GL/Test/PixelFormatTest.cpp

@@ -33,7 +33,7 @@
 #include "Magnum/PixelStorage.h"
 #endif
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct PixelFormatTest: TestSuite::Tester {
     explicit PixelFormatTest();
@@ -523,6 +523,6 @@ void PixelFormatTest::debugCompressedPixelFormat() {
     CORRADE_COMPARE(out.str(), "GL::CompressedPixelFormat::RGBS3tcDxt1 GL::CompressedPixelFormat(0xdead)\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::PixelFormatTest)

src/Magnum/GL/Test/PixelStorageGLTest.cpp

@@ -40,7 +40,7 @@
 #include "Magnum/GL/Framebuffer.h"
 #endif
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct PixelStorageGLTest: OpenGLTester {
     explicit PixelStorageGLTest();
@@ -81,7 +81,6 @@ PixelStorageGLTest::PixelStorageGLTest() {
               });
 }
 
-namespace {
 constexpr const char Data2D[] = {
     /* Row length ------------------------------------------------------ */ /* Alignment */
     '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
@@ -98,7 +97,6 @@ namespace {
     '\x06', '\x07', '\x08', '\x09', '\x0a', '\x0b', '\x00', '\x00',
     '\x0c', '\x0d', '\x0e', '\x0f', '\x10', '\x11', '\x00', '\x00'
 };
-}
 
 void PixelStorageGLTest::unpack2D() {
     #ifdef MAGNUM_TARGET_GLES2
@@ -173,7 +171,6 @@ void PixelStorageGLTest::pack2D() {
 }
 
 #ifndef MAGNUM_TARGET_GLES2
-namespace {
 constexpr const char Data3D[] = {
     /* Row length ------------------------------------------------------ */ /* Alignment */
     '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
@@ -192,7 +189,6 @@ namespace {
 
     /* Filling to image height not needed */
 };
-}
 
 void PixelStorageGLTest::unpack3D() {
     PixelStorage storage;
@@ -260,7 +256,6 @@ void PixelStorageGLTest::pack3D() {
 #endif
 
 #ifndef MAGNUM_TARGET_GLES
-namespace {
 constexpr const UnsignedByte CompressedData2D[] = {
     /* Skip */
       0,   0,   0,   0,   0,   0,   0,   0,
@@ -282,7 +277,6 @@ namespace {
       0,  17,  17,  34,  34,  51,  51,  67,
     232,  57,   0,   0, 213, 255, 170,   2,
 };
-}
 
 void PixelStorageGLTest::unpackCompressed2D() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
@@ -339,7 +333,6 @@ void PixelStorageGLTest::packCompressed2D() {
         TestSuite::Compare::Container);
 }
 
-namespace {
 constexpr const UnsignedByte CompressedData3D[] = {
     /* Skip image */
       0,   0,   0,   0,   0,   0,   0,   0,
@@ -390,7 +383,6 @@ namespace {
       0,  17,  17,  34,  34,  51,  51,  67,
     232,  57,   0,   0, 213, 255, 170,   2
 };
-}
 
 void PixelStorageGLTest::unpackCompressed3D() {
     if(!Context::current().isExtensionSupported<Extensions::ARB::compressed_texture_pixel_storage>())
@@ -450,6 +442,6 @@ void PixelStorageGLTest::packCompressed3D() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::PixelStorageGLTest)

src/Magnum/GL/Test/PrimitiveQueryGLTest.cpp

@@ -40,7 +40,7 @@
 #include "Magnum/GL/TransformFeedback.h"
 #include "Magnum/Math/Vector2.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct PrimitiveQueryGLTest: OpenGLTester {
     explicit PrimitiveQueryGLTest();
@@ -404,6 +404,6 @@ void PrimitiveQueryGLTest::transformFeedbackOverflow() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::PrimitiveQueryGLTest)

src/Magnum/GL/Test/PrimitiveQueryTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/GL/PrimitiveQuery.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct PrimitiveQueryTest: TestSuite::Tester {
     explicit PrimitiveQueryTest();
@@ -55,6 +55,6 @@ void PrimitiveQueryTest::constructCopy() {
     CORRADE_VERIFY(!(std::is_assignable<PrimitiveQuery, const PrimitiveQuery&>{}));
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::PrimitiveQueryTest)

src/Magnum/GL/Test/RectangleTextureGLTest.cpp

@@ -38,7 +38,7 @@
 #include "Magnum/Math/Color.h"
 #include "Magnum/Math/Range.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct RectangleTextureGLTest: OpenGLTester {
     explicit RectangleTextureGLTest();
@@ -74,7 +74,6 @@ struct RectangleTextureGLTest: OpenGLTester {
     void invalidateSubImage();
 };
 
-namespace {
 struct GenericSampler {
     typedef Magnum::SamplerFilter Filter;
     typedef Magnum::SamplerWrapping Wrapping;
@@ -107,7 +106,6 @@ namespace {
         Containers::arrayView(Data), 8}
     #endif
 };
-}
 
 RectangleTextureGLTest::RectangleTextureGLTest() {
     addTests({&RectangleTextureGLTest::construct,
@@ -361,7 +359,6 @@ void RectangleTextureGLTest::imageBuffer() {
         TestSuite::Compare::Container);
 }
 
-namespace {
 constexpr UnsignedByte Zero[4*4*4]{};
 constexpr UnsignedByte SubDataComplete[]{
     0, 0, 0, 0,    0,    0,    0,    0,    0,    0,    0,    0, 0, 0, 0, 0,
@@ -369,7 +366,6 @@ namespace {
     0, 0, 0, 0, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0, 0, 0, 0,
     0, 0, 0, 0,    0,    0,    0,    0,    0,    0,    0,    0, 0, 0, 0, 0
 };
-}
 
 void RectangleTextureGLTest::subImage() {
     setTestCaseDescription(PixelStorageData[testCaseInstanceId()].name);
@@ -523,6 +519,6 @@ void RectangleTextureGLTest::invalidateSubImage() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::RectangleTextureGLTest)

src/Magnum/GL/Test/RectangleTextureTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/GL/RectangleTexture.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct RectangleTextureTest: TestSuite::Tester {
     explicit RectangleTextureTest();
@@ -55,6 +55,6 @@ void RectangleTextureTest::constructCopy() {
     CORRADE_VERIFY(!(std::is_assignable<RectangleTexture, const RectangleTexture&>{}));
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::RectangleTextureTest)

src/Magnum/GL/Test/RenderbufferGLTest.cpp

@@ -30,7 +30,7 @@
 #include "Magnum/GL/RenderbufferFormat.h"
 #include "Magnum/Math/Vector2.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct RenderbufferGLTest: OpenGLTester {
     explicit RenderbufferGLTest();
@@ -191,6 +191,6 @@ void RenderbufferGLTest::setStorageMultisample() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::RenderbufferGLTest)

src/Magnum/GL/Test/RenderbufferTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/GL/Renderbuffer.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct RenderbufferTest: TestSuite::Tester {
     explicit RenderbufferTest();
@@ -55,6 +55,6 @@ void RenderbufferTest::constructNoCreate() {
     CORRADE_VERIFY(true);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::RenderbufferTest)

src/Magnum/GL/Test/RendererGLTest.cpp

@@ -28,7 +28,7 @@
 #include "Magnum/GL/OpenGLTester.h"
 #include "Magnum/Math/Range.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct RendererGLTest: OpenGLTester {
     explicit RendererGLTest();
@@ -60,6 +60,6 @@ void RendererGLTest::maxLineWidth() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::RendererGLTest)

src/Magnum/GL/Test/RendererTest.cpp

@@ -28,7 +28,7 @@
 
 #include "Magnum/GL/Renderer.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct RendererTest: TestSuite::Tester {
     explicit RendererTest();
@@ -72,6 +72,6 @@ void RendererTest::debugGraphicsResetStatus() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::RendererTest)

src/Magnum/GL/Test/SampleQueryGLTest.cpp

@@ -38,7 +38,7 @@
 #include "Magnum/GL/SampleQuery.h"
 #include "Magnum/GL/Shader.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct SampleQueryGLTest: OpenGLTester {
     explicit SampleQueryGLTest();
@@ -89,13 +89,11 @@ void SampleQueryGLTest::wrap() {
     #endif
 }
 
-namespace {
 struct MyShader: public AbstractShaderProgram {
     typedef Attribute<0, Vector2> Position;
 
     explicit MyShader();
 };
-}
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 MyShader::MyShader() {
@@ -268,6 +266,6 @@ void SampleQueryGLTest::conditionalRender() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::SampleQueryGLTest)

src/Magnum/GL/Test/SampleQueryTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/GL/SampleQuery.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct SampleQueryTest: TestSuite::Tester {
     explicit SampleQueryTest();
@@ -55,6 +55,6 @@ void SampleQueryTest::constructCopy() {
     CORRADE_VERIFY(!(std::is_assignable<SampleQuery, const SampleQuery&>{}));
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::SampleQueryTest)

src/Magnum/GL/Test/SamplerTest.cpp

@@ -29,7 +29,7 @@
 #include "Magnum/Sampler.h"
 #include "Magnum/GL/Sampler.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct SamplerTest: TestSuite::Tester {
     explicit SamplerTest();
@@ -205,6 +205,6 @@ void SamplerTest::debugDepthStencilMode() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::SamplerTest)

src/Magnum/GL/Test/ShaderGLTest.cpp

@@ -32,7 +32,7 @@
 
 #include "configure.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct ShaderGLTest: OpenGLTester {
     explicit ShaderGLTest();
@@ -298,6 +298,6 @@ void ShaderGLTest::compileNoVersion() {
     CORRADE_VERIFY(shader.compile());
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::ShaderGLTest)

src/Magnum/GL/Test/ShaderTest.cpp

@@ -28,7 +28,7 @@
 
 #include "Magnum/GL/Shader.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct ShaderTest: TestSuite::Tester {
     explicit ShaderTest();
@@ -54,6 +54,6 @@ void ShaderTest::debugType() {
     CORRADE_COMPARE(out.str(), "GL::Shader::Type::Fragment GL::Shader::Type(0xdead)\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::ShaderTest)

src/Magnum/GL/Test/TextureArrayGLTest.cpp

@@ -40,7 +40,7 @@
 #include "Magnum/GL/ImageFormat.h"
 #endif
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct TextureArrayGLTest: OpenGLTester {
     explicit TextureArrayGLTest();
@@ -155,7 +155,6 @@ struct TextureArrayGLTest: OpenGLTester {
     void invalidateSubImage2D();
 };
 
-namespace {
 struct GenericSampler {
     typedef Magnum::SamplerFilter Filter;
     typedef Magnum::SamplerMipmap Mipmap;
@@ -260,8 +259,6 @@ namespace {
     #endif
 };
 
-}
-
 TextureArrayGLTest::TextureArrayGLTest() {
     addTests({
         #ifndef MAGNUM_TARGET_GLES
@@ -894,7 +891,6 @@ void TextureArrayGLTest::image1DBuffer() {
         TestSuite::Compare::Container);
 }
 
-namespace {
 constexpr UnsignedByte Zero1D[4*4*4] = {};
 constexpr UnsignedByte SubData1DComplete[] = {
     0, 0, 0, 0,    0,    0,    0,    0,    0,    0,    0,    0, 0, 0, 0, 0,
@@ -902,7 +898,6 @@ namespace {
     0, 0, 0, 0, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0, 0, 0, 0,
     0, 0, 0, 0,    0,    0,    0,    0,    0,    0,    0,    0, 0, 0, 0, 0
 };
-}
 
 void TextureArrayGLTest::subImage1D() {
     setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
@@ -1099,7 +1094,6 @@ void TextureArrayGLTest::image2DBuffer() {
     #endif
 }
 
-namespace {
 constexpr UnsignedByte Zero2D[4*4*4*4]{};
 
 #ifndef MAGNUM_TARGET_GLES
@@ -1125,7 +1119,6 @@ namespace {
     0, 0, 0, 0,    0,    0,    0,    0,    0,    0,    0,    0, 0, 0, 0, 0
 };
 #endif
-}
 
 void TextureArrayGLTest::subImage2D() {
     setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
@@ -1332,7 +1325,6 @@ void TextureArrayGLTest::compressedImage2DBuffer() {
     #endif
 }
 
-namespace {
 /* Just 12x4x4 zeros compressed using RGBA DXT3 by the driver */
 constexpr UnsignedByte CompressedZero2D[3*4*16]{};
 
@@ -1368,7 +1360,6 @@ namespace {
       0,   0,   0,   0,   0,   0,   0,   0
 };
 #endif
-}
 
 void TextureArrayGLTest::compressedSubImage2D() {
     setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
@@ -1648,6 +1639,6 @@ void TextureArrayGLTest::invalidateSubImage2D() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::TextureArrayGLTest)

src/Magnum/GL/Test/TextureArrayTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/GL/TextureArray.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct TextureArrayTest: TestSuite::Tester {
     explicit TextureArrayTest();
@@ -88,6 +88,6 @@ void TextureArrayTest::constructCopy2D() {
     CORRADE_VERIFY(!(std::is_assignable<Texture2DArray, const Texture2DArray&>{}));
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::TextureArrayTest)

src/Magnum/GL/Test/TextureGLTest.cpp

@@ -41,7 +41,7 @@
 #include "Magnum/Math/Color.h"
 #include "Magnum/Math/Range.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct TextureGLTest: OpenGLTester {
     explicit TextureGLTest();
@@ -234,7 +234,6 @@ struct TextureGLTest: OpenGLTester {
     void srgbAlphaStorage();
 };
 
-namespace {
 struct GenericSampler {
     typedef Magnum::SamplerFilter Filter;
     typedef Magnum::SamplerMipmap Mipmap;
@@ -429,7 +428,6 @@ namespace {
         Containers::arrayView(CompressedData3D), 16*4}
     #endif
 };
-}
 
 TextureGLTest::TextureGLTest() {
     addTests({
@@ -1302,10 +1300,6 @@ void TextureGLTest::storage3D() {
 }
 #endif
 
-namespace {
-
-}
-
 #ifndef MAGNUM_TARGET_GLES
 void TextureGLTest::image1D() {
     setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
@@ -1353,12 +1347,10 @@ void TextureGLTest::image1DBuffer() {
         TestSuite::Compare::Container);
 }
 
-namespace {
 constexpr UnsignedByte Zero1D[4*4] = {};
 constexpr UnsignedByte SubData1DComplete[]{
     0, 0, 0, 0, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0, 0, 0, 0
 };
-}
 
 void TextureGLTest::subImage1D() {
     setTestCaseDescription(PixelStorage1DData[testCaseInstanceId()].name);
@@ -1552,7 +1544,6 @@ void TextureGLTest::image2DBuffer() {
 }
 #endif
 
-namespace {
 constexpr UnsignedByte Zero2D[4*4*4]{};
 
 #ifndef MAGNUM_TARGET_GLES
@@ -1563,7 +1554,6 @@ namespace {
     0, 0, 0, 0,    0,    0,    0,    0,    0,    0,    0,    0, 0, 0, 0, 0
 };
 #endif
-}
 
 void TextureGLTest::subImage2D() {
     setTestCaseDescription(PixelStorage2DData[testCaseInstanceId()].name);
@@ -1765,7 +1755,6 @@ void TextureGLTest::compressedImage2DBuffer() {
 }
 #endif
 
-namespace {
 /* Just 12x4 zeros compressed using RGBA DXT3 by the driver */
 constexpr UnsignedByte CompressedZero2D[3*16]{};
 
@@ -1780,7 +1769,6 @@ namespace {
       0,   0,   0,   0,   0,   0,   0,   0
 };
 #endif
-}
 
 void TextureGLTest::compressedSubImage2D() {
     setTestCaseDescription(CompressedPixelStorage2DData[testCaseInstanceId()].name);
@@ -1990,7 +1978,6 @@ void TextureGLTest::image3DBuffer() {
 }
 #endif
 
-namespace {
 constexpr UnsignedByte Zero3D[4*4*4*4]{};
 
 #ifndef MAGNUM_TARGET_GLES
@@ -2016,7 +2003,6 @@ namespace {
     0, 0, 0, 0,    0,    0,    0,    0,    0,    0,    0,    0, 0, 0, 0, 0
 };
 #endif
-}
 
 void TextureGLTest::subImage3D() {
     setTestCaseDescription(PixelStorage3DData[testCaseInstanceId()].name);
@@ -2205,7 +2191,6 @@ void TextureGLTest::compressedImage3DBuffer() {
 }
 #endif
 
-namespace {
 #ifndef MAGNUM_TARGET_GLES
 /* Just 12x4x4 zeros compressed using RGBA BPTC Unorm by the driver */
 constexpr UnsignedByte CompressedZero3D[3*4*16]{
@@ -2249,7 +2234,6 @@ namespace {
     64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 };
 #endif
-}
 
 void TextureGLTest::compressedSubImage3D() {
     setTestCaseDescription(CompressedPixelStorage3DData[testCaseInstanceId()].name);
@@ -2657,6 +2641,6 @@ void TextureGLTest::srgbAlphaStorage() {
     MAGNUM_VERIFY_NO_GL_ERROR();
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::TextureGLTest)

src/Magnum/GL/Test/TextureTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/GL/Texture.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct TextureTest: TestSuite::Tester {
     explicit TextureTest();
@@ -119,6 +119,6 @@ void TextureTest::constructCopy3D() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::TextureTest)

src/Magnum/GL/Test/TimeQueryGLTest.cpp

@@ -30,7 +30,7 @@
 #include "Magnum/GL/OpenGLTester.h"
 #include "Magnum/GL/TimeQuery.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct TimeQueryGLTest: OpenGLTester {
     explicit TimeQueryGLTest();
@@ -134,6 +134,6 @@ void TimeQueryGLTest::queryTimestamp() {
     CORRADE_COMPARE_AS(result2 - result1, result, TestSuite::Compare::GreaterOrEqual);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::TimeQueryGLTest)

src/Magnum/GL/Test/TimeQueryTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/GL/TimeQuery.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct TimeQueryTest: TestSuite::Tester {
     explicit TimeQueryTest();
@@ -55,6 +55,6 @@ void TimeQueryTest::constructCopy() {
     CORRADE_VERIFY(!(std::is_assignable<TimeQuery, const TimeQuery&>{}));
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::TimeQueryTest)

src/Magnum/GL/Test/TransformFeedbackGLTest.cpp

@@ -40,7 +40,7 @@
 #include "Magnum/GL/TransformFeedback.h"
 #include "Magnum/Math/Vector2.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct TransformFeedbackGLTest: OpenGLTester {
     explicit TransformFeedbackGLTest();
@@ -65,8 +65,6 @@ struct TransformFeedbackGLTest: OpenGLTester {
     #endif
 };
 
-namespace {
-
 #ifndef MAGNUM_TARGET_GLES
 enum: std::size_t { DrawDataCount = 4 };
 
@@ -85,8 +83,6 @@ const struct {
 };
 #endif
 
-}
-
 TransformFeedbackGLTest::TransformFeedbackGLTest() {
     addTests({&TransformFeedbackGLTest::construct,
               &TransformFeedbackGLTest::constructMove,
@@ -212,8 +208,6 @@ void TransformFeedbackGLTest::label() {
 }
 #endif
 
-namespace {
-
 constexpr const Vector2 inputData[] = {
     {0.0f, 0.0f},
     {-1.0f, 1.0f}
@@ -259,8 +253,6 @@ XfbShader::XfbShader() {
     CORRADE_INTERNAL_ASSERT_OUTPUT(link());
 }
 
-}
-
 void TransformFeedbackGLTest::attachBase() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback2>())
@@ -355,8 +347,6 @@ void TransformFeedbackGLTest::attachRange() {
     #endif
 }
 
-namespace {
-
 struct XfbMultiShader: AbstractShaderProgram {
     typedef Attribute<0, Vector2> Input;
 
@@ -399,8 +389,6 @@ XfbMultiShader::XfbMultiShader() {
     CORRADE_INTERNAL_ASSERT_OUTPUT(link());
 }
 
-}
-
 void TransformFeedbackGLTest::attachBases() {
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current().isExtensionSupported<Extensions::ARB::transform_feedback2>())
@@ -720,6 +708,6 @@ void TransformFeedbackGLTest::draw() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::TransformFeedbackGLTest)

src/Magnum/GL/Test/TransformFeedbackTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/GL/TransformFeedback.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct TransformFeedbackTest: TestSuite::Tester {
     explicit TransformFeedbackTest();
@@ -55,6 +55,6 @@ void TransformFeedbackTest::constructCopy() {
     CORRADE_VERIFY(!(std::is_assignable<TransformFeedback, const TransformFeedback&>{}));
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::TransformFeedbackTest)

src/Magnum/GL/Test/VersionTest.cpp

@@ -28,7 +28,7 @@
 
 #include "Magnum/GL/Version.h"
 
-namespace Magnum { namespace GL { namespace Test {
+namespace Magnum { namespace GL { namespace Test { namespace {
 
 struct VersionTest: TestSuite::Tester {
     explicit VersionTest();
@@ -126,6 +126,6 @@ void VersionTest::debugES() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::GL::Test::VersionTest)

src/Magnum/Math/Algorithms/Test/GaussJordanTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/Math/Algorithms/GaussJordan.h"
 
-namespace Magnum { namespace Math { namespace Algorithms { namespace Test {
+namespace Magnum { namespace Math { namespace Algorithms { namespace Test { namespace {
 
 struct GaussJordanTest: Corrade::TestSuite::Tester {
     explicit GaussJordanTest();
@@ -92,6 +92,6 @@ void GaussJordanTest::inverted() {
     CORRADE_COMPARE(inverse*m, Matrix4x4{});
 }
 
-}}}}
+}}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Algorithms::Test::GaussJordanTest)

src/Magnum/Math/Algorithms/Test/GramSchmidtTest.cpp

@@ -27,7 +27,7 @@
 
 #include "Magnum/Math/Algorithms/GramSchmidt.h"
 
-namespace Magnum { namespace Math { namespace Algorithms { namespace Test {
+namespace Magnum { namespace Math { namespace Algorithms { namespace Test { namespace {
 
 struct GramSchmidtTest: Corrade::TestSuite::Tester {
     explicit GramSchmidtTest();
@@ -95,6 +95,6 @@ void GramSchmidtTest::orthonormalize() {
     CORRADE_COMPARE(orthonormalized, expected);
 }
 
-}}}}
+}}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Algorithms::Test::GramSchmidtTest)

src/Magnum/Math/Algorithms/Test/KahanSumTest.cpp

@@ -29,7 +29,7 @@
 #include "Magnum/Magnum.h"
 #include "Magnum/Math/Algorithms/KahanSum.h"
 
-namespace Magnum { namespace Math { namespace Algorithms { namespace Test {
+namespace Magnum { namespace Math { namespace Algorithms { namespace Test { namespace {
 
 struct KahanSumTest: TestSuite::Tester {
     explicit KahanSumTest();
@@ -52,8 +52,6 @@ KahanSumTest::KahanSumTest() {
                    &KahanSumTest::kahan100k}, 50);
 }
 
-namespace {
-
 /* Custom iterator class to avoid allocating half a gigabyte for hundred
    million values */
 template<class T> struct Iterator
@@ -84,8 +82,6 @@ template<class T> struct Iterator
         std::size_t _i{};
 };
 
-}
-
 void KahanSumTest::floats() {
     Iterator<Float> begin{1.0f};
     Iterator<Float> end{1.0f, 100000000};
@@ -165,6 +161,6 @@ void KahanSumTest::kahan100k() {
     CORRADE_COMPARE(Float(a), 100000.0f);
 }
 
-}}}}
+}}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Algorithms::Test::KahanSumTest)

src/Magnum/Math/Algorithms/Test/QrTest.cpp

@@ -30,7 +30,7 @@
 #include "Magnum/Math/Matrix4.h"
 #include "Magnum/Math/Algorithms/Qr.h"
 
-namespace Magnum { namespace Math { namespace Algorithms { namespace Test {
+namespace Magnum { namespace Math { namespace Algorithms { namespace Test { namespace {
 
 struct QrTest: Corrade::TestSuite::Tester {
     explicit QrTest();
@@ -84,6 +84,6 @@ void QrTest::decomposeRotationShear() {
     CORRADE_COMPARE(r4.rotationShear(), Matrix4::shearingXZ(0.274077f, 0.0f).rotationShear());
 }
 
-}}}}
+}}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Algorithms::Test::QrTest)

src/Magnum/Math/Algorithms/Test/SvdTest.cpp

@@ -28,7 +28,7 @@
 #include "Magnum/Math/Matrix4.h"
 #include "Magnum/Math/Algorithms/Svd.h"
 
-namespace Magnum { namespace Math { namespace Algorithms { namespace Test {
+namespace Magnum { namespace Math { namespace Algorithms { namespace Test { namespace {
 
 struct SvdTest: Corrade::TestSuite::Tester {
     explicit SvdTest();
@@ -116,6 +116,6 @@ void SvdTest::decomposeRotationShear() {
     CORRADE_COMPARE(Matrix4::from(u*v.transposed(), {}), Matrix4::rotationZ(35.0_degf));
 }
 
-}}}}
+}}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Algorithms::Test::SvdTest)

src/Magnum/Math/Test/AngleTest.cpp

@@ -35,7 +35,7 @@
 
 #include "Magnum/Math/Angle.h"
 
-namespace Magnum { namespace Math { namespace Test {
+namespace Magnum { namespace Math { namespace Test { namespace {
 
 struct AngleTest: Corrade::TestSuite::Tester {
     explicit AngleTest();
@@ -67,8 +67,6 @@ typedef Math::Rad<Double> Radd;
 using namespace Literals;
 
 #if defined(DOXYGEN_GENERATING_OUTPUT) || defined(CORRADE_TARGET_UNIX) || (defined(CORRADE_TARGET_WINDOWS) && !defined(CORRADE_TARGET_WINDOWS_RT)) || defined(CORRADE_TARGET_EMSCRIPTEN)
-namespace {
-
 constexpr struct {
     const char* name;
     const char* data;
@@ -114,8 +112,6 @@ template<> struct TweakableTraits<Radd> {
     static const char* name() { return "Radd"; }
     static const char* literal() { return "rad"; }
 };
-
-}
 #endif
 
 AngleTest::AngleTest() {
@@ -340,6 +336,6 @@ template<class T> void AngleTest::tweakableError() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::AngleTest)

src/Magnum/Math/Test/BezierTest.cpp

@@ -54,7 +54,7 @@ template<> struct BezierConverter<2, 2, Float, QBezier2D> {
 
 }
 
-namespace Test {
+namespace Test { namespace {
 
 typedef Math::Vector2<Float> Vector2;
 typedef Math::Vector2<Double> Vector2d;
@@ -349,6 +349,6 @@ void BezierTest::configuration() {
     CORRADE_COMPARE(c.value<CubicBezier2D>("bezier"), bezier);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::BezierTest)

src/Magnum/Math/Test/BoolVectorTest.cpp

@@ -49,7 +49,7 @@ template<> struct BoolVectorConverter<3, BVec3> {
 
 }
 
-namespace Test {
+namespace Test { namespace {
 
 struct BoolVectorTest: Corrade::TestSuite::Tester {
     explicit BoolVectorTest();
@@ -335,6 +335,6 @@ void BoolVectorTest::debug() {
     CORRADE_COMPARE(o.str(), "BoolVector(10100100 11001010 010)\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::BoolVectorTest)

src/Magnum/Math/Test/ColorTest.cpp

@@ -69,7 +69,7 @@ template<> struct VectorConverter<4, float, Vec4> {
 
 }
 
-namespace Test {
+namespace Test { namespace {
 
 struct ColorTest: Corrade::TestSuite::Tester {
     explicit ColorTest();
@@ -147,8 +147,6 @@ typedef Math::Deg<Float> Deg;
 using namespace Literals;
 
 #if defined(DOXYGEN_GENERATING_OUTPUT) || defined(CORRADE_TARGET_UNIX) || (defined(CORRADE_TARGET_WINDOWS) && !defined(CORRADE_TARGET_WINDOWS_RT)) || defined(CORRADE_TARGET_EMSCRIPTEN)
-namespace {
-
 const struct {
     const char* name;
     const char* dataRgb;
@@ -180,8 +178,6 @@ constexpr struct {
     {"bad size", "0x333_{1}", Corrade::Utility::TweakableState::Error,
         "Utility::TweakableParser: 0x333_{2}{1} doesn't have expected number of digits\n"},
 };
-
-}
 #endif
 
 ColorTest::ColorTest() {
@@ -1130,6 +1126,6 @@ void ColorTest::tweakableErrorSrgbaf() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::ColorTest)

src/Magnum/Math/Test/ComplexTest.cpp

@@ -51,7 +51,7 @@ template<> struct ComplexConverter<Float, Cmpl> {
 
 }
 
-namespace Test {
+namespace Test { namespace {
 
 struct ComplexTest: Corrade::TestSuite::Tester {
     explicit ComplexTest();
@@ -575,6 +575,6 @@ void ComplexTest::configuration() {
     CORRADE_COMPARE(c.value<Complex>("overflow"), (Complex{2.0f, 9.0f}));
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::ComplexTest)

src/Magnum/Math/Test/ConstantsTest.cpp

@@ -29,7 +29,7 @@
 #include "Magnum/Math/Constants.h"
 #include "Magnum/Math/Functions.h"
 
-namespace Magnum { namespace Math { namespace Test {
+namespace Magnum { namespace Math { namespace Test { namespace {
 
 struct ConstantsTest: Corrade::TestSuite::Tester {
     explicit ConstantsTest();
@@ -87,6 +87,6 @@ template<class T> void ConstantsTest::specials() {
     CORRADE_VERIFY(h != h);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::ConstantsTest)

src/Magnum/Math/Test/CubicHermiteTest.cpp

@@ -33,7 +33,7 @@
 #include "Magnum/Math/StrictWeakOrdering.h"
 
 
-namespace Magnum { namespace Math { namespace Test {
+namespace Magnum { namespace Math { namespace Test { namespace {
 
 struct CubicHermiteTest: Corrade::TestSuite::Tester {
     explicit CubicHermiteTest();
@@ -1181,6 +1181,6 @@ void CubicHermiteTest::debugQuaternion() {
     CORRADE_COMPARE(out.str(), "CubicHermite(Quaternion({2, 1.5, 0.3}, 1.1), Quaternion({3, 0.1, 2.3}, 0.7), Quaternion({-1, 0, 0.3}, 0.4))\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::CubicHermiteTest)

src/Magnum/Math/Test/DistanceTest.cpp

@@ -30,7 +30,7 @@
 #include "Magnum/Math/Constants.h"
 #include "Magnum/Math/Distance.h"
 
-namespace Magnum { namespace Math { namespace Test {
+namespace Magnum { namespace Math { namespace Test { namespace {
 
 struct DistanceTest: Corrade::TestSuite::Tester {
     explicit DistanceTest();
@@ -199,6 +199,6 @@ void DistanceTest::pointPlaneNormalizedNotNormalized() {
     CORRADE_COMPARE(out.str(), "Math::Distance::pointPlaneNormalized(): plane normal Vector(2, 2, 2) is not normalized\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::DistanceTest)

src/Magnum/Math/Test/DualComplexTest.cpp

@@ -51,7 +51,7 @@ template<> struct DualComplexConverter<Float, DualCmpl> {
 
 }
 
-namespace Test {
+namespace Test { namespace {
 
 struct DualComplexTest: Corrade::TestSuite::Tester {
     explicit DualComplexTest();
@@ -318,7 +318,6 @@ void DualComplexTest::normalized() {
     CORRADE_COMPARE(a.normalized(), b);
 }
 
-namespace {
 template<class> struct NormalizedIterativeData;
 template<> struct NormalizedIterativeData<Float> {
     static Math::Vector2<Float> translation() { return {10000.0f, -50.0f}; }
@@ -326,7 +325,6 @@ namespace {
 template<> struct NormalizedIterativeData<Double> {
     static Math::Vector2<Double> translation() { return {10000000.0, -500.0}; }
 };
-}
 
 template<class T> void DualComplexTest::normalizedIterative() {
     setTestCaseName(std::string{"normalizedIterative<"} + TypeTraits<T>::name() + ">");
@@ -491,6 +489,6 @@ void DualComplexTest::configuration() {
     CORRADE_COMPARE(c.value<DualComplex>("overflow"), (DualComplex{{2.0f, 1.0f}, {8.0f, 9.0f}}));
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::DualComplexTest)

src/Magnum/Math/Test/DualQuaternionTest.cpp

@@ -53,7 +53,7 @@ template<> struct DualQuaternionConverter<Float, DualQuat> {
 
 }
 
-namespace Test {
+namespace Test { namespace {
 
 struct DualQuaternionTest: Corrade::TestSuite::Tester {
     explicit DualQuaternionTest();
@@ -348,7 +348,6 @@ void DualQuaternionTest::normalized() {
     CORRADE_COMPARE(a.normalized(), b);
 }
 
-namespace {
 template<class> struct NormalizedIterativeData;
 template<> struct NormalizedIterativeData<Float> {
     static Math::Vector3<Float> translation() { return {10000.0f, -50.0f, 20000.0f}; }
@@ -356,7 +355,6 @@ namespace {
 template<> struct NormalizedIterativeData<Double> {
     static Math::Vector3<Double> translation() { return {10000000000000.0, -500.0, 20000000000000.0}; }
 };
-}
 
 template<class T> void DualQuaternionTest::normalizedIterative() {
     setTestCaseName(std::string{"normalizedIterative<"} + TypeTraits<T>::name() + ">");
@@ -666,6 +664,6 @@ void DualQuaternionTest::configuration() {
     CORRADE_COMPARE(c.value<DualQuaternion>("overflow"), (DualQuaternion{{{2.0f, 1.0f, 8.0f}, 9.0f}, {{16.0f, 33.0f, -1.0f}, 5.0f}}));
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::DualQuaternionTest)

src/Magnum/Math/Test/DualTest.cpp

@@ -31,7 +31,7 @@
 #include "Magnum/Math/Vector2.h"
 #include "Magnum/Math/StrictWeakOrdering.h"
 
-namespace Magnum { namespace Math { namespace Test {
+namespace Magnum { namespace Math { namespace Test { namespace {
 
 struct DualTest: Corrade::TestSuite::Tester {
     explicit DualTest();
@@ -298,8 +298,6 @@ void DualTest::strictWeakOrdering() {
     CORRADE_VERIFY(!o(a, a));
 }
 
-namespace {
-
 template<class T> class BasicDualVec2: public Math::Dual<Math::Vector2<T>> {
     public:
         template<class ...U> constexpr BasicDualVec2(U&&... args): Math::Dual<Math::Vector2<T>>{args...} {}
@@ -312,8 +310,6 @@ MAGNUM_DUAL_OPERATOR_IMPLEMENTATION(BasicDualVec2, Math::Vector2, T)
 
 typedef BasicDualVec2<Float> DualVec2;
 
-}
-
 void DualTest::subclassTypes() {
     const DualVec2 a;
     CORRADE_VERIFY((std::is_same<decltype(-a), DualVec2>::value));
@@ -373,6 +369,6 @@ void DualTest::debug() {
     CORRADE_COMPARE(o.str(), "Dual(2.5, -0.3)\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::DualTest)

src/Magnum/Math/Test/FrustumTest.cpp

@@ -61,7 +61,7 @@ template<> struct FrustumConverter<Float, Frstm> {
 
 }
 
-namespace Test {
+namespace Test { namespace {
 
 struct FrustumTest: Corrade::TestSuite::Tester {
     explicit FrustumTest();
@@ -368,6 +368,6 @@ void FrustumTest::debug() {
                                "        {7, -8, 9, 0.6})\n");
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::FrustumTest)

src/Magnum/Math/Test/FunctionsTest.cpp

@@ -29,7 +29,7 @@
 #include "Magnum/Math/Functions.h"
 #include "Magnum/Math/Vector4.h"
 
-namespace Magnum { namespace Math { namespace Test {
+namespace Magnum { namespace Math { namespace Test { namespace {
 
 struct FunctionsTest: Corrade::TestSuite::Tester {
     explicit FunctionsTest();
@@ -445,6 +445,6 @@ void FunctionsTest::trigonometricWithBase() {
     CORRADE_COMPARE(Math::tan(2*Rad(Constants::pi()/8)), 1.0f);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::FunctionsTest)

src/Magnum/Math/Test/HalfTest.cpp

@@ -35,7 +35,7 @@
 #include "Magnum/Math/Vector3.h"
 #include "Magnum/Math/StrictWeakOrdering.h"
 
-namespace Magnum { namespace Math { namespace Test {
+namespace Magnum { namespace Math { namespace Test { namespace {
 
 struct HalfTest: Corrade::TestSuite::Tester {
     explicit HalfTest();
@@ -94,8 +94,6 @@ typedef Math::Constants<Float> Constants;
 using namespace Literals;
 
 #if defined(DOXYGEN_GENERATING_OUTPUT) || defined(CORRADE_TARGET_UNIX) || (defined(CORRADE_TARGET_WINDOWS) && !defined(CORRADE_TARGET_WINDOWS_RT)) || defined(CORRADE_TARGET_EMSCRIPTEN)
-namespace {
-
 const struct {
     const char* name;
     const char* data;
@@ -125,8 +123,6 @@ constexpr struct {
     {"different suffix", "42.0u", Corrade::Utility::TweakableState::Recompile, /* not for double */
         "Utility::TweakableParser: 42.0u has an unexpected suffix, expected _h\n"}
 };
-
-}
 #endif
 
 HalfTest::HalfTest() {
@@ -221,8 +217,6 @@ HalfTest::HalfTest() {
     }
 }
 
-namespace {
-
 union FloatBits {
     UnsignedInt u;
     Float f;
@@ -242,8 +236,6 @@ union HalfBits {
     } bits;
 };
 
-}
-
 /* float_to_half_full() from https://gist.github.com/rygorous/2156668,
    originally from ISPC */
 UnsignedShort HalfTest::packNaive(Float value) {
@@ -708,6 +700,6 @@ void HalfTest::tweakableError() {
 }
 #endif
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::HalfTest)

src/Magnum/Math/Test/InterpolationBenchmark.cpp

@@ -28,7 +28,7 @@
 #define CORRADE_NO_ASSERT
 #include "Magnum/Math/DualQuaternion.h"
 
-namespace Magnum { namespace Math { namespace Test {
+namespace Magnum { namespace Math { namespace Test { namespace {
 
 struct InterpolationBenchmark: Corrade::TestSuite::Tester {
     explicit InterpolationBenchmark();
@@ -147,6 +147,6 @@ void InterpolationBenchmark::dualQuaternionSclerpShortestPath() {
     CORRADE_VERIFY(!c.isNormalized());
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::InterpolationBenchmark)

src/Magnum/Math/Test/IntersectionBenchmark.cpp

@@ -32,7 +32,7 @@
 #include "Magnum/Math/Angle.h"
 #include "Magnum/Math/Intersection.h"
 
-namespace Magnum { namespace Math { namespace Test {
+namespace Magnum { namespace Math { namespace Test { namespace {
 
 template<class T> bool rangeFrustumNaive(const Math::Range3D<T>& box, const Math::Frustum<T>& frustum) {
     for(const Math::Vector4<T>& plane: frustum.planes()) {
@@ -218,6 +218,6 @@ void IntersectionBenchmark::sphereConeView() {
     }
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::IntersectionBenchmark)

src/Magnum/Math/Test/IntersectionTest.cpp

@@ -29,7 +29,7 @@
 
 #include "Magnum/Math/Intersection.h"
 
-namespace Magnum { namespace Math { namespace Test {
+namespace Magnum { namespace Math { namespace Test { namespace {
 
 using namespace Literals;
 
@@ -451,6 +451,6 @@ void IntersectionTest::aabbCone() {
     CORRADE_VERIFY(!Intersection::aabbCone(-15.0f*normal, Vector3{1.0f}, center, normal, angle));
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::IntersectionTest)

src/Magnum/Math/Test/Matrix3Test.cpp

@@ -55,7 +55,7 @@ template<> struct RectangularMatrixConverter<3, 3, float, Mat3> {
 
 }
 
-namespace Test {
+namespace Test { namespace {
 
 struct Matrix3Test: Corrade::TestSuite::Tester {
     explicit Matrix3Test();
@@ -638,6 +638,6 @@ void Matrix3Test::configuration() {
     CORRADE_COMPARE(c.value<Matrix3>("matrix"), m);
 }
 
-}}}
+}}}}
 
 CORRADE_TEST_MAIN(Magnum::Math::Test::Matrix3Test)