source/modules/juce_dsp/containers/juce_FixedSizeFunction_test.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library.
   5    Copyright (c) 2022 - Raw Material Software Limited
   6
   7    JUCE is an open source library subject to commercial or open-source
   8    licensing.
   9
  10    By using JUCE, you agree to the terms of both the JUCE 7 End-User License
  11    Agreement and JUCE Privacy Policy.
  12
  13    End User License Agreement: www.juce.com/juce-7-licence
  14    Privacy Policy: www.juce.com/juce-privacy-policy
  15
  16    Or: You may also use this code under the terms of the GPL v3 (see
  17    www.gnu.org/licenses).
  18
  19    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
  20    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
  21    DISCLAIMED.
  22
  23   ==============================================================================
  24 */
  25
  26 #if JUCE_ENABLE_ALLOCATION_HOOKS
  27 #define JUCE_FAIL_ON_ALLOCATION_IN_SCOPE const UnitTestAllocationChecker checker (*this)
  28 #else
  29 #define JUCE_FAIL_ON_ALLOCATION_IN_SCOPE
  30 #endif
  31
  32 namespace juce
  33 {
  34 namespace dsp
  35 {
  36 namespace
  37 {
  38
  39 class ConstructCounts
  40 {
  41     auto tie() const noexcept { return std::tie (constructions, copies, moves, calls, destructions); }
  42
  43 public:
  44     int constructions = 0;
  45     int copies        = 0;
  46     int moves         = 0;
  47     int calls         = 0;
  48     int destructions  = 0;
  49
  50     ConstructCounts withConstructions (int i) const noexcept { auto c = *this; c.constructions = i; return c; }
  51     ConstructCounts withCopies        (int i) const noexcept { auto c = *this; c.copies        = i; return c; }
  52     ConstructCounts withMoves         (int i) const noexcept { auto c = *this; c.moves         = i; return c; }
  53     ConstructCounts withCalls         (int i) const noexcept { auto c = *this; c.calls         = i; return c; }
  54     ConstructCounts withDestructions  (int i) const noexcept { auto c = *this; c.destructions  = i; return c; }
  55
  56     bool operator== (const ConstructCounts& other) const noexcept { return tie() == other.tie(); }
  57     bool operator!= (const ConstructCounts& other) const noexcept { return tie() != other.tie(); }
  58 };
  59
  60 String& operator<< (String& str, const ConstructCounts& c)
  61 {
  62     return str << "{ constructions: " << c.constructions
  63                << ", copies: " << c.copies
  64                << ", moves: " << c.moves
  65                << ", calls: " << c.calls
  66                << ", destructions: " << c.destructions
  67                << " }";
  68 }
  69
  70 class FixedSizeFunctionTest  : public UnitTest
  71 {
  72     static void toggleBool (bool& b) { b = ! b; }
  73
  74     struct ConstructCounter
  75     {
  76         explicit ConstructCounter (ConstructCounts& countsIn)
  77             : counts (countsIn) {}
  78
  79         ConstructCounter (const ConstructCounter& c)
  80             : counts (c.counts)
  81         {
  82             counts.copies += 1;
  83         }
  84
  85         ConstructCounter (ConstructCounter&& c) noexcept
  86             : counts (c.counts)
  87         {
  88             counts.moves += 1;
  89         }
  90
  91         ~ConstructCounter() noexcept { counts.destructions += 1; }
  92
  93         void operator()() const noexcept { counts.calls += 1; }
  94
  95         ConstructCounts& counts;
  96     };
  97
  98 public:
  99     FixedSizeFunctionTest()
 100         : UnitTest ("Fixed Size Function", UnitTestCategories::dsp)
 101     {}
 102
 103     void runTest() override
 104     {
 105         beginTest ("Can be constructed and called from a lambda");
 106         {
 107             JUCE_FAIL_ON_ALLOCATION_IN_SCOPE;
 108
 109             const auto result = 5;
 110             bool wasCalled = false;
 111             const auto lambda = [&] { wasCalled = true; return result; };
 112
 113             const FixedSizeFunction<sizeof (lambda), int()> fn (lambda);
 114             const auto out = fn();
 115
 116             expect (wasCalled);
 117             expectEquals (result, out);
 118         }
 119
 120         beginTest ("void fn can be constructed from function with return value");
 121         {
 122             JUCE_FAIL_ON_ALLOCATION_IN_SCOPE;
 123
 124             bool wasCalled = false;
 125             const auto lambda = [&] { wasCalled = true; return 5; };
 126             const FixedSizeFunction<sizeof (lambda), void()> fn (lambda);
 127
 128             fn();
 129             expect (wasCalled);
 130         }
 131
 132         beginTest ("Can be constructed and called from a function pointer");
 133         {
 134             JUCE_FAIL_ON_ALLOCATION_IN_SCOPE;
 135
 136             bool state = false;
 137
 138             const FixedSizeFunction<sizeof (void*), void (bool&)> fn (toggleBool);
 139
 140             fn (state);
 141             expect (state);
 142
 143             fn (state);
 144             expect (! state);
 145
 146             fn (state);
 147             expect (state);
 148         }
 149
 150         beginTest ("Default constructed functions throw if called");
 151         {
 152             const auto a = FixedSizeFunction<8, void()>();
 153             expectThrowsType (a(), std::bad_function_call)
 154
 155             const auto b = FixedSizeFunction<8, void()> (nullptr);
 156             expectThrowsType (b(), std::bad_function_call)
 157         }
 158
 159         beginTest ("Functions can be moved");
 160         {
 161             JUCE_FAIL_ON_ALLOCATION_IN_SCOPE;
 162
 163             ConstructCounts counts;
 164
 165             auto a = FixedSizeFunction<sizeof (ConstructCounter), void()> (ConstructCounter { counts });
 166             expectEquals (counts, ConstructCounts().withMoves (1).withDestructions (1)); // The temporary gets destroyed
 167
 168             a();
 169             expectEquals (counts, ConstructCounts().withMoves (1).withDestructions (1).withCalls (1));
 170
 171             const auto b = std::move (a);
 172             expectEquals (counts, ConstructCounts().withMoves (2).withDestructions (1).withCalls (1));
 173
 174             b();
 175             expectEquals (counts, ConstructCounts().withMoves (2).withDestructions (1).withCalls (2));
 176
 177             b();
 178             expectEquals (counts, ConstructCounts().withMoves (2).withDestructions (1).withCalls (3));
 179         }
 180
 181         beginTest ("Functions are destructed properly");
 182         {
 183             JUCE_FAIL_ON_ALLOCATION_IN_SCOPE;
 184
 185             ConstructCounts counts;
 186             const ConstructCounter toCopy { counts };
 187
 188             {
 189                 auto a = FixedSizeFunction<sizeof (ConstructCounter), void()> (toCopy);
 190                 expectEquals (counts, ConstructCounts().withCopies (1));
 191             }
 192
 193             expectEquals (counts, ConstructCounts().withCopies (1).withDestructions (1));
 194         }
 195
 196         beginTest ("Avoid destructing functions that fail to construct");
 197         {
 198             struct BadConstructor
 199             {
 200                 explicit BadConstructor (ConstructCounts& c)
 201                     : counts (c)
 202                 {
 203                     counts.constructions += 1;
 204                     throw std::runtime_error { "this was meant to happen" };
 205                 }
 206
 207                 BadConstructor (const BadConstructor&) = default;
 208                 BadConstructor& operator= (const BadConstructor&) = delete;
 209
 210                 ~BadConstructor() noexcept { counts.destructions += 1; }
 211
 212                 void operator()() const noexcept { counts.calls += 1; }
 213
 214                 ConstructCounts& counts;
 215             };
 216
 217             ConstructCounts counts;
 218
 219             expectThrowsType ((FixedSizeFunction<sizeof (BadConstructor), void()> (BadConstructor { counts })),
 220                               std::runtime_error)
 221
 222             expectEquals (counts, ConstructCounts().withConstructions (1));
 223         }
 224
 225         beginTest ("Equality checks work");
 226         {
 227             JUCE_FAIL_ON_ALLOCATION_IN_SCOPE;
 228
 229             FixedSizeFunction<8, void()> a;
 230             expect (! bool (a));
 231             expect (a == nullptr);
 232             expect (nullptr == a);
 233             expect (! (a != nullptr));
 234             expect (! (nullptr != a));
 235
 236             FixedSizeFunction<8, void()> b ([] {});
 237             expect (bool (b));
 238             expect (b != nullptr);
 239             expect (nullptr != b);
 240             expect (! (b == nullptr));
 241             expect (! (nullptr == b));
 242         }
 243
 244         beginTest ("Functions can be cleared");
 245         {
 246             JUCE_FAIL_ON_ALLOCATION_IN_SCOPE;
 247
 248             FixedSizeFunction<8, void()> fn ([] {});
 249             expect (bool (fn));
 250
 251             fn = nullptr;
 252             expect (! bool (fn));
 253         }
 254
 255         beginTest ("Functions can be assigned");
 256         {
 257             JUCE_FAIL_ON_ALLOCATION_IN_SCOPE;
 258
 259             using Fn = FixedSizeFunction<8, void()>;
 260
 261             int numCallsA = 0;
 262             int numCallsB = 0;
 263
 264             Fn x;
 265             Fn y;
 266             expect (! bool (x));
 267             expect (! bool (y));
 268
 269             x = [&] { numCallsA += 1; };
 270             y = [&] { numCallsB += 1; };
 271             expect (bool (x));
 272             expect (bool (y));
 273
 274             x();
 275             expectEquals (numCallsA, 1);
 276             expectEquals (numCallsB, 0);
 277
 278             y();
 279             expectEquals (numCallsA, 1);
 280             expectEquals (numCallsB, 1);
 281
 282             x = std::move (y);
 283             expectEquals (numCallsA, 1);
 284             expectEquals (numCallsB, 1);
 285
 286             x();
 287             expectEquals (numCallsA, 1);
 288             expectEquals (numCallsB, 2);
 289         }
 290
 291         beginTest ("Functions may mutate internal state");
 292         {
 293             JUCE_FAIL_ON_ALLOCATION_IN_SCOPE;
 294
 295             using Fn = FixedSizeFunction<64, void()>;
 296
 297             Fn x;
 298             expect (! bool (x));
 299
 300             int numCalls = 0;
 301             x = [&numCalls, counter = 0]() mutable { counter += 1; numCalls = counter; };
 302             expect (bool (x));
 303
 304             expectEquals (numCalls, 0);
 305
 306             x();
 307             expectEquals (numCalls, 1);
 308
 309             x();
 310             expectEquals (numCalls, 2);
 311         }
 312
 313         beginTest ("Functions can sink move-only parameters");
 314         {
 315             JUCE_FAIL_ON_ALLOCATION_IN_SCOPE;
 316
 317             using Fn = FixedSizeFunction<64, int (std::unique_ptr<int>)>;
 318
 319             auto value = 5;
 320             auto ptr = std::make_unique<int> (value);
 321
 322             Fn fn = [] (std::unique_ptr<int> p) { return *p; };
 323
 324             expect (value == fn (std::move (ptr)));
 325         }
 326
 327         beginTest ("Functions be converted from smaller functions");
 328         {
 329             JUCE_FAIL_ON_ALLOCATION_IN_SCOPE;
 330
 331             using SmallFn = FixedSizeFunction<20, void()>;
 332             using LargeFn = FixedSizeFunction<21, void()>;
 333
 334             bool smallCalled = false;
 335             bool largeCalled = false;
 336
 337             SmallFn small = [&smallCalled, a = std::array<char, 8>{}] { smallCalled = true; juce::ignoreUnused (a); };
 338             LargeFn large = [&largeCalled, a = std::array<char, 8>{}] { largeCalled = true; juce::ignoreUnused (a); };
 339
 340             large = std::move (small);
 341
 342             large();
 343
 344             expect (smallCalled);
 345             expect (! largeCalled);
 346         }
 347     }
 348 };
 349
 350 FixedSizeFunctionTest fixedSizedFunctionTest;
 351
 352 }
 353 }
 354 }
 355 #undef JUCE_FAIL_ON_ALLOCATION_IN_SCOPE