From 23b94c3f7680cad17cd067e36d18e1e06c8fb9e0 Mon Sep 17 00:00:00 2001
From: siddharthmehrotra <siddharthmehrotra1234@gmail.com>
Date: Wed, 8 Nov 2023 13:15:55 +0800
Subject: [PATCH 1/4] Migrated marketmodel.cpp

---
 test-suite/CMakeLists.txt            |    1 -
 test-suite/Makefile.am               |    1 -
 test-suite/marketmodel.cpp           | 1626 ++++++++++++--------------
 test-suite/marketmodel.hpp           |   61 -
 test-suite/quantlibtestsuite.cpp     |   10 -
 test-suite/testsuite.vcxproj         |    1 -
 test-suite/testsuite.vcxproj.filters |    3 -
 7 files changed, 760 insertions(+), 943 deletions(-)
 delete mode 100644 test-suite/marketmodel.hpp

diff --git a/test-suite/CMakeLists.txt b/test-suite/CMakeLists.txt
index bcda36b2ebd..77be2c64b24 100644
--- a/test-suite/CMakeLists.txt
+++ b/test-suite/CMakeLists.txt
@@ -175,7 +175,6 @@ set(QL_TEST_SOURCES
 )
 
 set(QL_TEST_HEADERS
-    marketmodel.hpp
     paralleltestrunner.hpp
     preconditions.hpp
     quantlibglobalfixture.hpp
diff --git a/test-suite/Makefile.am b/test-suite/Makefile.am
index b144e06f64c..c453c4bb92d 100644
--- a/test-suite/Makefile.am
+++ b/test-suite/Makefile.am
@@ -175,7 +175,6 @@ QL_TEST_SRCS = \
 	zerocouponswap.cpp
 
 QL_TEST_HDRS = \
-    marketmodel.hpp \
     preconditions.hpp \
 	quantlibglobalfixture.hpp \
 	swaptionvolstructuresutilities.hpp \
diff --git a/test-suite/marketmodel.cpp b/test-suite/marketmodel.cpp
index 861e6e1404b..698a4fab96c 100644
--- a/test-suite/marketmodel.cpp
+++ b/test-suite/marketmodel.cpp
@@ -22,7 +22,8 @@ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE.  See the license for more details.
 */
 
-#include "marketmodel.hpp"
+#include "preconditions.hpp"
+#include "toplevelfixture.hpp"
 #include "utilities.hpp"
 #include <ql/models/marketmodels/accountingengine.hpp>
 #include <ql/models/marketmodels/browniangenerators/mtbrowniangenerator.hpp>
@@ -116,227 +117,230 @@ using namespace boost::unit_test_framework;
 using std::fabs;
 using std::sqrt;
 
-namespace market_model_test {
-
-    Date todaysDate, startDate, endDate;
-    Schedule dates;
-    std::vector<Time> rateTimes, paymentTimes;
-    std::vector<Real> accruals;
-    Calendar calendar;
-    DayCounter dayCounter;
-    std::vector<Rate> todaysForwards, todaysCoterminalSwapRates;
-    Rate meanForward;
-    std::vector<Real> coterminalAnnuity;
-    Spread displacement;
-    std::vector<DiscountFactor> todaysDiscounts;
-    std::vector<Volatility> volatilities, blackVols, normalVols;
-    std::vector<Volatility> swaptionsVolatilities, swaptionsBlackVols;
-    Real a, b, c, d;
-    Real longTermCorrelation, beta;
-    Size measureOffset_;
-    unsigned long seed_;
-    Size paths_, trainingPaths_;
-    bool printReport_ = false;
-
-
-    // a simple structure to store some data which will be used during tests
-    struct SubProductExpectedValues {
-        explicit SubProductExpectedValues(std::string descr) : description(std::move(descr)) {}
-        std::string description;
-        std::vector<Real> values;
-        bool testBias = false;
-        Real errorThreshold;
-    };
+BOOST_FIXTURE_TEST_SUITE(QuantLibTests, TopLevelFixture)
+
+BOOST_AUTO_TEST_SUITE(MarketModelTests)
+
+enum MarketModelType { ExponentialCorrelationFlatVolatility,
+                       ExponentialCorrelationAbcdVolatility/*, CalibratedMM*/
+};
+
+Date todaysDate, startDate, endDate;
+Schedule dates;
+std::vector<Time> rateTimes, paymentTimes;
+std::vector<Real> accruals;
+Calendar calendar;
+DayCounter dayCounter;
+std::vector<Rate> todaysForwards, todaysCoterminalSwapRates;
+Rate meanForward;
+std::vector<Real> coterminalAnnuity;
+Spread displacement;
+std::vector<DiscountFactor> todaysDiscounts;
+std::vector<Volatility> volatilities, blackVols, normalVols;
+std::vector<Volatility> swaptionsVolatilities, swaptionsBlackVols;
+Real a, b, c, d;
+Real longTermCorrelation, beta;
+Size measureOffset_;
+unsigned long seed_;
+Size paths_, trainingPaths_;
+bool printReport_ = false;
+
+
+// a simple structure to store some data which will be used during tests
+struct SubProductExpectedValues {
+    explicit SubProductExpectedValues(std::string descr) : description(std::move(descr)) {}
+    std::string description;
+    std::vector<Real> values;
+    bool testBias = false;
+    Real errorThreshold;
+};
+
+void setup() {
+
+    // Times
+    calendar = NullCalendar();
+    todaysDate = Settings::instance().evaluationDate();
+    //startDate = todaysDate + 5*Years;
+    endDate = todaysDate + 5*Years;
+    dates =Schedule(todaysDate, endDate, Period(Semiannual),
+                    calendar, Following, Following,
+                    DateGeneration::Backward, false);
+    rateTimes = std::vector<Time>(dates.size()-1);
+    paymentTimes = std::vector<Time>(rateTimes.size()-1);
+    accruals = std::vector<Real>(rateTimes.size()-1);
+    dayCounter = SimpleDayCounter();
+    for (Size i=1; i<dates.size(); ++i)
+        rateTimes[i-1] = dayCounter.yearFraction(todaysDate, dates[i]);
+    std::copy(rateTimes.begin()+1, rateTimes.end(), paymentTimes.begin());
+    for (Size i=1; i<rateTimes.size(); ++i)
+        accruals[i-1] = rateTimes[i] - rateTimes[i-1];
+
+    // Rates & displacement
+    todaysForwards = std::vector<Rate>(paymentTimes.size());
+    displacement = 0.0;
+    meanForward=0.0;
 
-    void setup() {
-
-        // Times
-        calendar = NullCalendar();
-        todaysDate = Settings::instance().evaluationDate();
-        //startDate = todaysDate + 5*Years;
-        endDate = todaysDate + 5*Years;
-        dates =Schedule(todaysDate, endDate, Period(Semiannual),
-            calendar, Following, Following,
-            DateGeneration::Backward, false);
-        rateTimes = std::vector<Time>(dates.size()-1);
-        paymentTimes = std::vector<Time>(rateTimes.size()-1);
-        accruals = std::vector<Real>(rateTimes.size()-1);
-        dayCounter = SimpleDayCounter();
-        for (Size i=1; i<dates.size(); ++i)
-            rateTimes[i-1] = dayCounter.yearFraction(todaysDate, dates[i]);
-        std::copy(rateTimes.begin()+1, rateTimes.end(), paymentTimes.begin());
-        for (Size i=1; i<rateTimes.size(); ++i)
-            accruals[i-1] = rateTimes[i] - rateTimes[i-1];
-
-        // Rates & displacement
-        todaysForwards = std::vector<Rate>(paymentTimes.size());
-        displacement = 0.0;
-        meanForward=0.0;
-
-        for (Size i=0; i<todaysForwards.size(); ++i)
+    for (Size i=0; i<todaysForwards.size(); ++i)
         {
             todaysForwards[i] = 0.03 + 0.0010*i;
             meanForward+= todaysForwards[i];
         }
-        meanForward /= todaysForwards.size();
-
+    meanForward /= todaysForwards.size();
 
-
-        // Discounts
-        todaysDiscounts = std::vector<DiscountFactor>(rateTimes.size());
-        todaysDiscounts[0] = 0.95;
-        for (Size i=1; i<rateTimes.size(); ++i)
-            todaysDiscounts[i] = todaysDiscounts[i-1] /
+    // Discounts
+    todaysDiscounts = std::vector<DiscountFactor>(rateTimes.size());
+    todaysDiscounts[0] = 0.95;
+    for (Size i=1; i<rateTimes.size(); ++i)
+        todaysDiscounts[i] = todaysDiscounts[i-1] /
             (1.0+todaysForwards[i-1]*accruals[i-1]);
 
-        // Coterminal swap rates & annuities
-        Size N = todaysForwards.size();
-        todaysCoterminalSwapRates = std::vector<Rate>(N);
-        coterminalAnnuity = std::vector<Real>(N);
-        Real floatingLeg = 0.0;
-        for (Size i=1; i<=N; ++i) {
-            if (i==1) {
-                coterminalAnnuity[N-1] = accruals[N-1]*todaysDiscounts[N];
-            } else {
-                coterminalAnnuity[N-i] = coterminalAnnuity[N-i+1] +
-                    accruals[N-i]*todaysDiscounts[N-i+1];
-            }
-            floatingLeg = todaysDiscounts[N-i]-todaysDiscounts[N];
-            todaysCoterminalSwapRates[N-i] = floatingLeg/coterminalAnnuity[N-i];
+    // Coterminal swap rates & annuities
+    Size N = todaysForwards.size();
+    todaysCoterminalSwapRates = std::vector<Rate>(N);
+    coterminalAnnuity = std::vector<Real>(N);
+    Real floatingLeg = 0.0;
+    for (Size i=1; i<=N; ++i) {
+        if (i==1) {
+            coterminalAnnuity[N-1] = accruals[N-1]*todaysDiscounts[N];
+        } else {
+            coterminalAnnuity[N-i] = coterminalAnnuity[N-i+1] +
+                accruals[N-i]*todaysDiscounts[N-i+1];
         }
+        floatingLeg = todaysDiscounts[N-i]-todaysDiscounts[N];
+        todaysCoterminalSwapRates[N-i] = floatingLeg/coterminalAnnuity[N-i];
+    }
 
-        // Cap/Floor Volatilities
-        Volatility mktVols[] = {
-            0.15541283,
-            0.18719678,
-            0.20890740,
-            0.22318179,
-            0.23212717,
-            0.23731450,
-            0.23988649,
-            0.24066384,
-            0.24023111,
-            0.23900189,
-            0.23726699,
-            0.23522952,
-            0.23303022,
-            0.23076564,
-            0.22850101,
-            0.22627951,
-            0.22412881,
-            0.22206569,
-            0.22009939
-        };
+    // Cap/Floor Volatilities
+    Volatility mktVols[] = {
+        0.15541283,
+        0.18719678,
+        0.20890740,
+        0.22318179,
+        0.23212717,
+        0.23731450,
+        0.23988649,
+        0.24066384,
+        0.24023111,
+        0.23900189,
+        0.23726699,
+        0.23522952,
+        0.23303022,
+        0.23076564,
+        0.22850101,
+        0.22627951,
+        0.22412881,
+        0.22206569,
+        0.22009939
+    };
 
-        a = -0.0597;
-        b =  0.1677;
-        c =  0.5403;
-        d =  0.1710;
-        volatilities = std::vector<Volatility>(todaysForwards.size());
-        blackVols = std::vector<Volatility>(todaysForwards.size());
-        normalVols = std::vector<Volatility>(todaysForwards.size());
-        for (Size i=0; i<std::min(LENGTH(mktVols),todaysForwards.size()); i++) {
-            volatilities[i] = todaysForwards[i]*mktVols[i]/
-                (todaysForwards[i]+displacement);
-            blackVols[i]= mktVols[i];
-            normalVols[i]= mktVols[i]*todaysForwards[i];
-        }
+    a = -0.0597;
+    b =  0.1677;
+    c =  0.5403;
+    d =  0.1710;
+    volatilities = std::vector<Volatility>(todaysForwards.size());
+    blackVols = std::vector<Volatility>(todaysForwards.size());
+    normalVols = std::vector<Volatility>(todaysForwards.size());
+    for (Size i=0; i<std::min(LENGTH(mktVols),todaysForwards.size()); i++) {
+        volatilities[i] = todaysForwards[i]*mktVols[i]/
+            (todaysForwards[i]+displacement);
+        blackVols[i]= mktVols[i];
+        normalVols[i]= mktVols[i]*todaysForwards[i];
+    }
 
-        // Swaption volatility quick fix
-        swaptionsVolatilities = volatilities;
+    // Swaption volatility quick fix
+    swaptionsVolatilities = volatilities;
 
-        // Cap/Floor Correlation
-        longTermCorrelation = 0.5;
-        beta = 0.2;
-        measureOffset_ = 5;
+    // Cap/Floor Correlation
+    longTermCorrelation = 0.5;
+    beta = 0.2;
+    measureOffset_ = 5;
 
-        // Monte Carlo
-        seed_ = 42;
+    // Monte Carlo
+    seed_ = 42;
 
 #ifdef _DEBUG
-        paths_ = 127;
-        trainingPaths_ = 31;
+    paths_ = 127;
+    trainingPaths_ = 31;
 #else
-        paths_ = 32767; //262144-1; //; // 2^15-1
-        trainingPaths_ = 8191; // 2^13-1
+    paths_ = 32767; //262144-1; //; // 2^15-1
+    trainingPaths_ = 8191; // 2^13-1
 #endif
-    }
+}
 
-    ext::shared_ptr<SequenceStatisticsInc>
-    simulate(const ext::shared_ptr<MarketModelEvolver>& evolver,
-             const MarketModelMultiProduct& product) {
-        Size initialNumeraire = evolver->numeraires().front();
-        Real initialNumeraireValue = todaysDiscounts[initialNumeraire];
+ext::shared_ptr<SequenceStatisticsInc>
+simulate(const ext::shared_ptr<MarketModelEvolver>& evolver,
+         const MarketModelMultiProduct& product) {
+    Size initialNumeraire = evolver->numeraires().front();
+    Real initialNumeraireValue = todaysDiscounts[initialNumeraire];
 
-        AccountingEngine engine(evolver, product, initialNumeraireValue);
-        ext::shared_ptr<SequenceStatisticsInc> stats(
+    AccountingEngine engine(evolver, product, initialNumeraireValue);
+    ext::shared_ptr<SequenceStatisticsInc> stats(
             new SequenceStatisticsInc(product.numberOfProducts()));
-        engine.multiplePathValues(*stats, paths_);
-        return stats;
-    }
+    engine.multiplePathValues(*stats, paths_);
+    return stats;
+}
 
 
-    std::string marketModelTypeToString(MarketModelTest::MarketModelType type) {
-        switch (type) {
-          case MarketModelTest::ExponentialCorrelationFlatVolatility:
-              return "Exp. Corr. Flat Vol.";
-          case MarketModelTest::ExponentialCorrelationAbcdVolatility:
-              return "Exp. Corr. Abcd Vol.";
-              //case CalibratedMM:
-              //    return "CalibratedMarketModel";
-          default:
-              QL_FAIL("unknown MarketModelEvolver type");
-        }
+std::string marketModelTypeToString(MarketModelType type) {
+    switch (type) {
+      case ExponentialCorrelationFlatVolatility:
+        return "Exp. Corr. Flat Vol.";
+      case ExponentialCorrelationAbcdVolatility:
+        return "Exp. Corr. Abcd Vol.";
+        //case CalibratedMM:
+        //    return "CalibratedMarketModel";
+      default:
+        QL_FAIL("unknown MarketModelEvolver type");
     }
+}
+
+ext::shared_ptr<MarketModel> makeMarketModel(bool logNormal,
+                                             const EvolutionDescription& evolution,
+                                             Size numberOfFactors,
+                                             MarketModelType marketModelType,
+                                             Spread forwardBump = 0.0,
+                                             Volatility volBump = 0.0) {
 
-    ext::shared_ptr<MarketModel> makeMarketModel(
-        bool logNormal,
-        const EvolutionDescription& evolution,
-        Size numberOfFactors,
-        MarketModelTest::MarketModelType marketModelType,
-        Spread forwardBump = 0.0,
-        Volatility volBump = 0.0) {
-
-            std::vector<Time> fixingTimes(evolution.rateTimes());
-            fixingTimes.pop_back();
-            ext::shared_ptr<LmVolatilityModel> volModel(new
+    std::vector<Time> fixingTimes(evolution.rateTimes());
+    fixingTimes.pop_back();
+    ext::shared_ptr<LmVolatilityModel> volModel(new
                 LmExtLinearExponentialVolModel(fixingTimes,0.5, 0.6, 0.1, 0.1));
-            ext::shared_ptr<LmCorrelationModel> corrModel(
+    ext::shared_ptr<LmCorrelationModel> corrModel(
                 new LmLinearExponentialCorrelationModel(evolution.numberOfRates(),
                 longTermCorrelation, beta));
 
-            std::vector<Rate> bumpedForwards(todaysForwards.size());
-            std::transform(todaysForwards.begin(), todaysForwards.end(),
-                           bumpedForwards.begin(),
-                           [=](Rate r){ return r + forwardBump; });
-
-            std::vector<Volatility> bumpedVols(volatilities.size());
-            if (logNormal)
-                std::transform(volatilities.begin(), volatilities.end(),
-                               bumpedVols.begin(),
-                               [=](Volatility v){ return v + volBump; });
-            else
-                std::transform(normalVols.begin(), normalVols.end(),
-                               bumpedVols.begin(),
-                               [=](Volatility v){ return v + volBump; });
-
-            Matrix correlations = exponentialCorrelations(evolution.rateTimes(),
-                longTermCorrelation,
-                beta);
-            ext::shared_ptr<PiecewiseConstantCorrelation> corr(new
+    std::vector<Rate> bumpedForwards(todaysForwards.size());
+    std::transform(todaysForwards.begin(), todaysForwards.end(),
+                   bumpedForwards.begin(),
+                   [=](Rate r){ return r + forwardBump; });
+
+    std::vector<Volatility> bumpedVols(volatilities.size());
+    if (logNormal)
+        std::transform(volatilities.begin(), volatilities.end(),
+                       bumpedVols.begin(),
+                       [=](Volatility v){ return v + volBump; });
+    else
+        std::transform(normalVols.begin(), normalVols.end(),
+                       bumpedVols.begin(),
+                       [=](Volatility v){ return v + volBump; });
+
+    Matrix correlations = exponentialCorrelations(evolution.rateTimes(),
+                                                  longTermCorrelation,
+                                                  beta);
+    ext::shared_ptr<PiecewiseConstantCorrelation> corr(new
                 TimeHomogeneousForwardCorrelation(correlations,
                 evolution.rateTimes()));
-            switch (marketModelType) {
-        case MarketModelTest::ExponentialCorrelationFlatVolatility:
-            return ext::shared_ptr<MarketModel>(new
+    switch (marketModelType) {
+      case ExponentialCorrelationFlatVolatility:
+        return ext::shared_ptr<MarketModel>(new
                 FlatVol(bumpedVols,
                 corr,
                 evolution,
                 numberOfFactors,
                 bumpedForwards,
                 std::vector<Spread>(bumpedForwards.size(), displacement)));
-        case MarketModelTest::ExponentialCorrelationAbcdVolatility:
-            return ext::shared_ptr<MarketModel>(new
+      case ExponentialCorrelationAbcdVolatility:
+        return ext::shared_ptr<MarketModel>(new
                 AbcdVol(0.0,0.0,1.0,1.0,
                 bumpedVols,
                 corr,
@@ -344,368 +348,361 @@ namespace market_model_test {
                 numberOfFactors,
                 bumpedForwards,
                 std::vector<Spread>(bumpedForwards.size(), displacement)));
-            //case CalibratedMM:
-            //    return ext::shared_ptr<MarketModel>(new
-            //        CalibratedMarketModel(volModel, corrModel,
-            //                              evolution,
-            //                              numberOfFactors,
-            //                              bumpedForwards,
-            //                              displacement));
-        default:
-            QL_FAIL("unknown MarketModel type");
-            }
+        //case CalibratedMM:
+        //    return ext::shared_ptr<MarketModel>(new
+        //        CalibratedMarketModel(volModel, corrModel,
+        //                              evolution,
+        //                              numberOfFactors,
+        //                              bumpedForwards,
+        //                              displacement));
+      default:
+        QL_FAIL("unknown MarketModel type");
     }
+}
 
-    enum MeasureType { ProductSuggested, Terminal,
-        MoneyMarket, MoneyMarketPlus };
-
-    std::string measureTypeToString(MeasureType type) {
-        switch (type) {
-          case ProductSuggested:
-              return "ProductSuggested measure";
-          case Terminal:
-              return "Terminal measure";
-          case MoneyMarket:
-              return "Money Market measure";
-          case MoneyMarketPlus:
-              return "Money Market Plus measure";
-          default:
-              QL_FAIL("unknown measure type");
-        }
+enum MeasureType { ProductSuggested, Terminal,
+                   MoneyMarket, MoneyMarketPlus };
+
+std::string measureTypeToString(MeasureType type) {
+    switch (type) {
+      case ProductSuggested:
+        return "ProductSuggested measure";
+      case Terminal:
+        return "Terminal measure";
+      case MoneyMarket:
+        return "Money Market measure";
+      case MoneyMarketPlus:
+        return "Money Market Plus measure";
+      default:
+        QL_FAIL("unknown measure type");
     }
+}
 
-    std::vector<Size> makeMeasure(const MarketModelMultiProduct& product,
-        MeasureType measureType) {
-            std::vector<Size> result;
-            const EvolutionDescription& evolution(product.evolution());
-            switch (measureType) {
-          case ProductSuggested:
-              result = product.suggestedNumeraires();
-              break;
-          case Terminal:
-              result = terminalMeasure(evolution);
-              if (!isInTerminalMeasure(evolution, result)) {
-                  BOOST_ERROR("\nfailure in verifying Terminal measure:\n"
-                              << to_stream(result));
-              }
-              break;
-          case MoneyMarket:
-              result = moneyMarketMeasure(evolution);
-              if (!isInMoneyMarketMeasure(evolution, result)) {
-                  BOOST_ERROR("\nfailure in verifying MoneyMarket measure:\n"
-                              << to_stream(result));
-              }
-              break;
-          case MoneyMarketPlus:
-              result = moneyMarketPlusMeasure(evolution, measureOffset_);
-              if (!isInMoneyMarketPlusMeasure(evolution, result, measureOffset_)) {
-                  BOOST_ERROR("\nfailure in verifying MoneyMarketPlus(" <<
-                      measureOffset_ << ") measure:\n" << to_stream(result));
-              }
-              break;
-          default:
-              QL_FAIL("unknown measure type");
-            }
-            checkCompatibility(evolution, result);
-            if (printReport_) {
-                BOOST_TEST_MESSAGE("    " << measureTypeToString(measureType) << ": " << to_stream(result));
-            }
-            return result;
+std::vector<Size> makeMeasure(const MarketModelMultiProduct& product,
+                              MeasureType measureType) {
+    std::vector<Size> result;
+    const EvolutionDescription& evolution(product.evolution());
+    switch (measureType) {
+      case ProductSuggested:
+        result = product.suggestedNumeraires();
+        break;
+      case Terminal:
+        result = terminalMeasure(evolution);
+        if (!isInTerminalMeasure(evolution, result)) {
+            BOOST_ERROR("\nfailure in verifying Terminal measure:\n"
+                        << to_stream(result));
+        }
+        break;
+      case MoneyMarket:
+        result = moneyMarketMeasure(evolution);
+        if (!isInMoneyMarketMeasure(evolution, result)) {
+            BOOST_ERROR("\nfailure in verifying MoneyMarket measure:\n"
+                        << to_stream(result));
+        }
+        break;
+      case MoneyMarketPlus:
+        result = moneyMarketPlusMeasure(evolution, measureOffset_);
+        if (!isInMoneyMarketPlusMeasure(evolution, result, measureOffset_)) {
+            BOOST_ERROR("\nfailure in verifying MoneyMarketPlus(" <<
+                        measureOffset_ << ") measure:\n" << to_stream(result));
+        }
+        break;
+      default:
+        QL_FAIL("unknown measure type");
     }
+    checkCompatibility(evolution, result);
+    if (printReport_) {
+        BOOST_TEST_MESSAGE("    " << measureTypeToString(measureType) << ": " << to_stream(result));
+    }
+    return result;
+}
 
-    enum EvolverType { Ipc, Balland, Pc, NormalPc};
-
-    std::string evolverTypeToString(EvolverType type) {
-        switch (type) {
-          case Ipc:
-              return "iterative predictor corrector";
-          case Balland:
-              return "Balland predictor corrector";
-          case Pc:
-              return "predictor corrector";
-          case NormalPc:
-              return "predictor corrector for normal case";
-          default:
-              QL_FAIL("unknown MarketModelEvolver type");
-        }
+enum EvolverType { Ipc, Balland, Pc, NormalPc};
+
+std::string evolverTypeToString(EvolverType type) {
+    switch (type) {
+      case Ipc:
+        return "iterative predictor corrector";
+      case Balland:
+        return "Balland predictor corrector";
+      case Pc:
+        return "predictor corrector";
+      case NormalPc:
+        return "predictor corrector for normal case";
+      default:
+        QL_FAIL("unknown MarketModelEvolver type");
     }
+}
 
-    ext::shared_ptr<MarketModelEvolver> makeMarketModelEvolver(
-        const ext::shared_ptr<MarketModel>& marketModel,
-        const std::vector<Size>& numeraires,
-        const BrownianGeneratorFactory& generatorFactory,
-        EvolverType evolverType,
-        Size initialStep = 0) {
-            switch (evolverType) {
-          case Ipc:
-              return ext::shared_ptr<MarketModelEvolver>(
+ext::shared_ptr<MarketModelEvolver> makeMarketModelEvolver(const ext::shared_ptr<MarketModel>& marketModel,
+                                                           const std::vector<Size>& numeraires,
+                                                           const BrownianGeneratorFactory& generatorFactory,
+                                                           EvolverType evolverType,
+                                                           Size initialStep = 0) {
+    switch (evolverType) {
+      case Ipc:
+        return ext::shared_ptr<MarketModelEvolver>(
                   new LogNormalFwdRateIpc(marketModel, generatorFactory,
                   numeraires, initialStep));
-          case Balland:
-              return ext::shared_ptr<MarketModelEvolver>(
+      case Balland:
+        return ext::shared_ptr<MarketModelEvolver>(
                   new LogNormalFwdRateBalland(marketModel, generatorFactory,
                   numeraires, initialStep));
-          case Pc:
-              return ext::shared_ptr<MarketModelEvolver>(
+      case Pc:
+        return ext::shared_ptr<MarketModelEvolver>(
                   new LogNormalFwdRatePc(marketModel, generatorFactory,
                   numeraires, initialStep));
-          case NormalPc:
-              return ext::shared_ptr<MarketModelEvolver>(
+      case NormalPc:
+        return ext::shared_ptr<MarketModelEvolver>(
                   new NormalFwdRatePc(marketModel, generatorFactory,
                   numeraires, initialStep));
-          default:
-              QL_FAIL("unknown MarketModelEvolver type");
-            }
+      default:
+        QL_FAIL("unknown MarketModelEvolver type");
     }
+}
 
-    void checkMultiProductCompositeResults (const SequenceStatisticsInc& stats,
-        const std::vector<SubProductExpectedValues>& subProductExpectedValues,
-        const std::string& config) {
+void checkMultiProductCompositeResults(const SequenceStatisticsInc& stats,
+                                       const std::vector<SubProductExpectedValues>& subProductExpectedValues,
+                                       const std::string& config) {
 
-            std::vector<Real> results = stats.mean();
-            std::vector<Real> errors = stats.errorEstimate();
+    std::vector<Real> results = stats.mean();
+    std::vector<Real> errors = stats.errorEstimate();
 
-            // size check
-            Size nbOfResults = 0;
-            for (const auto& subProductExpectedValue : subProductExpectedValues) {
-                for (Size j = 0; j < subProductExpectedValue.values.size(); ++j)
-                    ++nbOfResults;
-            }
+    // size check
+    Size nbOfResults = 0;
+    for (const auto& subProductExpectedValue : subProductExpectedValues) {
+        for (Size j = 0; j < subProductExpectedValue.values.size(); ++j)
+            ++nbOfResults;
+    }
 
-            if (nbOfResults != results.size())
-                BOOST_ERROR("mismatch between the size of the result and the \
+    if (nbOfResults != results.size())
+        BOOST_ERROR("mismatch between the size of the result and the \
                             number of results");
-            Size currentResultIndex = 0;
-
-            std::vector<Real> stdDevs;
-            std::vector<SubProductExpectedValues>::const_iterator subProductExpectedValue;
-            for (subProductExpectedValue = subProductExpectedValues.begin();
-                subProductExpectedValue != subProductExpectedValues.end();
-                ++subProductExpectedValue) {
-                    Real minError = QL_MAX_REAL;
-                    Real maxError = QL_MIN_REAL;
-                    Real errorThreshold = subProductExpectedValue->errorThreshold;
-                    for (Real value : subProductExpectedValue->values) {
-                        Real stdDev =
-                            (results[currentResultIndex] - value) / errors[currentResultIndex];
-                        stdDevs.push_back(stdDev);
-                        maxError = std::max(maxError, stdDev);
-                        minError = std::min(minError, stdDev);
-                        ++currentResultIndex;
-                    }
-                    bool isBiased = minError > 0.0 || maxError < 0.0;
-                    if (printReport_
-                        || (subProductExpectedValue->testBias && isBiased)
-                        || std::max(-minError, maxError) > errorThreshold) {
-                            BOOST_TEST_MESSAGE(config);
-                            currentResultIndex = 0;
-                            for (Size j=0; j<subProductExpectedValue->values.size(); ++j) {
-                                BOOST_TEST_MESSAGE(io::ordinal(j+1)
-                                    << " "  << subProductExpectedValue->description
-                                    << ": " << io::rate(results[currentResultIndex])
-                                    << "\t" << io::rate(subProductExpectedValue->values[j])
-                                    << "\t" << io::rate(errors[currentResultIndex])
-                                    << "; discrepancy = "
-                                    << stdDevs[currentResultIndex]
-                                << "\n");
-                                ++currentResultIndex;
-                            }
-                            BOOST_ERROR("test failed");
-                    }
+    Size currentResultIndex = 0;
+
+    std::vector<Real> stdDevs;
+    std::vector<SubProductExpectedValues>::const_iterator subProductExpectedValue;
+    for (subProductExpectedValue = subProductExpectedValues.begin();
+         subProductExpectedValue != subProductExpectedValues.end();
+         ++subProductExpectedValue) {
+        Real minError = QL_MAX_REAL;
+        Real maxError = QL_MIN_REAL;
+        Real errorThreshold = subProductExpectedValue->errorThreshold;
+        for (Real value : subProductExpectedValue->values) {
+            Real stdDev =
+                (results[currentResultIndex] - value) / errors[currentResultIndex];
+            stdDevs.push_back(stdDev);
+            maxError = std::max(maxError, stdDev);
+            minError = std::min(minError, stdDev);
+            ++currentResultIndex;
+        }
+        bool isBiased = minError > 0.0 || maxError < 0.0;
+        if (printReport_
+            || (subProductExpectedValue->testBias && isBiased)
+            || std::max(-minError, maxError) > errorThreshold) {
+            BOOST_TEST_MESSAGE(config);
+            currentResultIndex = 0;
+            for (Size j=0; j<subProductExpectedValue->values.size(); ++j) {
+                BOOST_TEST_MESSAGE(io::ordinal(j+1)
+                                   << " "  << subProductExpectedValue->description
+                                   << ": " << io::rate(results[currentResultIndex])
+                                   << "\t" << io::rate(subProductExpectedValue->values[j])
+                                   << "\t" << io::rate(errors[currentResultIndex])
+                                   << "; discrepancy = "
+                                   << stdDevs[currentResultIndex]
+                                   << "\n");
+                ++currentResultIndex;
             }
+            BOOST_ERROR("test failed");
+        }
     }
+}
 
 
-    void checkForwardsAndOptionlets(const SequenceStatisticsInc& stats,
-        const std::vector<Rate>& forwardStrikes,
-        const std::vector<ext::shared_ptr<StrikedTypePayoff> >& displacedPayoffs,
-        const std::string& config) {
-
-            std::vector<Real> results = stats.mean();
-            std::vector<Real> errors = stats.errorEstimate();
-            std::vector<Real> stdDevs(todaysForwards.size());
-
-            Size N = todaysForwards.size();
-            std::vector<Rate> expectedForwards(N), expectedCaplets(N);
-            std::vector<Real> forwardStdDevs(N), capletStdDev(N);
-            Real minError = QL_MAX_REAL;
-            Real maxError = QL_MIN_REAL;
-            // forwards check
-            for (Size i=0; i<N; ++i) {
-                expectedForwards[i] = (todaysForwards[i]-forwardStrikes[i])
-                    *accruals[i]*todaysDiscounts[i+1];
-                forwardStdDevs[i] = (results[i]-expectedForwards[i])/errors[i];
-                if (forwardStdDevs[i]>maxError)
-                    maxError = forwardStdDevs[i];
-                else if (forwardStdDevs[i]<minError)
-                    minError = forwardStdDevs[i];
-                Time expiry = rateTimes[i];
-                expectedCaplets[i] =
-                    BlackCalculator(displacedPayoffs[i],
-                    todaysForwards[i]+displacement,
-                    volatilities[i]*std::sqrt(expiry),
-                    todaysDiscounts[i+1]*accruals[i]).value();
-                capletStdDev[i] = (results[i+N]-expectedCaplets[i])/errors[i+N];
-                if (capletStdDev[i]>maxError)
-                    maxError = capletStdDev[i];
-                else if (capletStdDev[i]<minError)
-                    minError = capletStdDev[i];
-            }
+void checkForwardsAndOptionlets(const SequenceStatisticsInc& stats,
+                                const std::vector<Rate>& forwardStrikes,
+                                const std::vector<ext::shared_ptr<StrikedTypePayoff> >& displacedPayoffs,
+                                const std::string& config) {
+
+    std::vector<Real> results = stats.mean();
+    std::vector<Real> errors = stats.errorEstimate();
+    std::vector<Real> stdDevs(todaysForwards.size());
+
+    Size N = todaysForwards.size();
+    std::vector<Rate> expectedForwards(N), expectedCaplets(N);
+    std::vector<Real> forwardStdDevs(N), capletStdDev(N);
+    Real minError = QL_MAX_REAL;
+    Real maxError = QL_MIN_REAL;
+    // forwards check
+    for (Size i=0; i<N; ++i) {
+        expectedForwards[i] = (todaysForwards[i]-forwardStrikes[i])
+            *accruals[i]*todaysDiscounts[i+1];
+        forwardStdDevs[i] = (results[i]-expectedForwards[i])/errors[i];
+        if (forwardStdDevs[i]>maxError)
+            maxError = forwardStdDevs[i];
+        else if (forwardStdDevs[i]<minError)
+            minError = forwardStdDevs[i];
+        Time expiry = rateTimes[i];
+        expectedCaplets[i] =
+            BlackCalculator(displacedPayoffs[i],
+                            todaysForwards[i]+displacement,
+                            volatilities[i]*std::sqrt(expiry),
+                            todaysDiscounts[i+1]*accruals[i]).value();
+        capletStdDev[i] = (results[i+N]-expectedCaplets[i])/errors[i+N];
+        if (capletStdDev[i]>maxError)
+            maxError = capletStdDev[i];
+        else if (capletStdDev[i]<minError)
+            minError = capletStdDev[i];
+    }
 
-            Real errorThreshold = 2.50;
-            if ( printReport_ || minError > 0.0 || maxError < 0.0 ||
-                minError <-errorThreshold || maxError > errorThreshold) {
-                    BOOST_TEST_MESSAGE(config);
-                    Size i;
-                    for (i=0; i<N; ++i) {
-                        BOOST_TEST_MESSAGE(io::ordinal(i+1) << " forward: "
-                            << io::rate(results[i])
-                            << "\t" << io::rate(expectedForwards[i])
-                            << "\t" << io::rate(errors[i])
-                            << "; discrepancy = "
-                            << forwardStdDevs[i]
-                        << "\n");
-                    }
-                    for (i=0; i<N; ++i) {
-                        BOOST_TEST_MESSAGE(
-                            io::ordinal(i+1) << "\t"
-                            << io::rate(results[i+N])
-                            << " +- " << io::rate(errors[i+N])
-                            << "\t" << io::rate(expectedCaplets[i])
-                            << "\t" << io::rate(errors[i+N])
-                            << "; discrepancy = "
-                            << (results[i+N]-expectedCaplets[i])/(errors[i+N] == 0.0 ?
-                            1.0 : errors[i+N])
-                            << "\n");
-                    }
-                    BOOST_ERROR("test failed");
-            }
+    Real errorThreshold = 2.50;
+    if ( printReport_ || minError > 0.0 || maxError < 0.0 ||
+         minError <-errorThreshold || maxError > errorThreshold) {
+        BOOST_TEST_MESSAGE(config);
+        Size i;
+        for (i=0; i<N; ++i) {
+            BOOST_TEST_MESSAGE(io::ordinal(i+1) << " forward: "
+                               << io::rate(results[i])
+                               << "\t" << io::rate(expectedForwards[i])
+                               << "\t" << io::rate(errors[i])
+                               << "; discrepancy = "
+                               << forwardStdDevs[i]
+                               << "\n");
+        }
+        for (i=0; i<N; ++i) {
+            BOOST_TEST_MESSAGE(io::ordinal(i+1) << "\t"
+                               << io::rate(results[i+N])
+                               << " +- " << io::rate(errors[i+N])
+                               << "\t" << io::rate(expectedCaplets[i])
+                               << "\t" << io::rate(errors[i+N])
+                               << "; discrepancy = "
+                               << (results[i+N]-expectedCaplets[i])/(errors[i+N] == 0.0 ?
+                                                                     1.0 : errors[i+N])
+                               << "\n");
+        }
+        BOOST_ERROR("test failed");
     }
+}
 
 
 
-    void checkNormalForwardsAndOptionlets(const SequenceStatisticsInc& stats,
-        const std::vector<Rate>& forwardStrikes,
-        const std::vector<ext::shared_ptr<PlainVanillaPayoff> >& displacedPayoffs,
-        const std::string& config) {
-
-            std::vector<Real> results = stats.mean();
-            std::vector<Real> errors = stats.errorEstimate();
-            std::vector<Real> stdDevs(todaysForwards.size());
-
-            Size N = todaysForwards.size();
-            std::vector<Rate> expectedForwards(N), expectedCaplets(N);
-            std::vector<Real> forwardStdDevs(N), capletStdDev(N);
-            Real minError = QL_MAX_REAL;
-            Real maxError = QL_MIN_REAL;
-            // forwards check
-            for (Size i=0; i<N; ++i) {
-                expectedForwards[i] = (todaysForwards[i]-forwardStrikes[i])
-                    *accruals[i]*todaysDiscounts[i+1];
-                forwardStdDevs[i] = (results[i]-expectedForwards[i])/errors[i];
-                if (forwardStdDevs[i]>maxError)
-                    maxError = forwardStdDevs[i];
-                else if (forwardStdDevs[i]<minError)
-                    minError = forwardStdDevs[i];
-                Time expiry = rateTimes[i];
-                expectedCaplets[i] =
-                    bachelierBlackFormula(displacedPayoffs[i],
-                    todaysForwards[i]+displacement,
-                    normalVols[i]*std::sqrt(expiry),
-                    todaysDiscounts[i+1]*accruals[i]);
-                capletStdDev[i] = (results[i+N]-expectedCaplets[i])/errors[i+N];
-                if (capletStdDev[i]>maxError)
-                    maxError = capletStdDev[i];
-                else if (capletStdDev[i]<minError)
-                    minError = capletStdDev[i];
-            }
+void checkNormalForwardsAndOptionlets(const SequenceStatisticsInc& stats,
+                                      const std::vector<Rate>& forwardStrikes,
+                                      const std::vector<ext::shared_ptr<PlainVanillaPayoff> >& displacedPayoffs,
+                                      const std::string& config) {
+
+    std::vector<Real> results = stats.mean();
+    std::vector<Real> errors = stats.errorEstimate();
+    std::vector<Real> stdDevs(todaysForwards.size());
+
+    Size N = todaysForwards.size();
+    std::vector<Rate> expectedForwards(N), expectedCaplets(N);
+    std::vector<Real> forwardStdDevs(N), capletStdDev(N);
+    Real minError = QL_MAX_REAL;
+    Real maxError = QL_MIN_REAL;
+    // forwards check
+    for (Size i=0; i<N; ++i) {
+        expectedForwards[i] = (todaysForwards[i]-forwardStrikes[i])
+            *accruals[i]*todaysDiscounts[i+1];
+        forwardStdDevs[i] = (results[i]-expectedForwards[i])/errors[i];
+        if (forwardStdDevs[i]>maxError)
+            maxError = forwardStdDevs[i];
+        else if (forwardStdDevs[i]<minError)
+            minError = forwardStdDevs[i];
+        Time expiry = rateTimes[i];
+        expectedCaplets[i] =
+            bachelierBlackFormula(displacedPayoffs[i],
+                                  todaysForwards[i]+displacement,
+                                  normalVols[i]*std::sqrt(expiry),
+                                  todaysDiscounts[i+1]*accruals[i]);
+        capletStdDev[i] = (results[i+N]-expectedCaplets[i])/errors[i+N];
+        if (capletStdDev[i]>maxError)
+            maxError = capletStdDev[i];
+        else if (capletStdDev[i]<minError)
+            minError = capletStdDev[i];
+    }
 
-            Real errorThreshold = 2.50;
-            if (minError > 0.0 || maxError < 0.0 ||
-                minError <-errorThreshold || maxError > errorThreshold) {
-                    BOOST_TEST_MESSAGE(config);
-                    Size i;
-                    for (i=0; i<N; ++i) {
-                        BOOST_TEST_MESSAGE(io::ordinal(i+1) << " forward: "
-                            << io::rate(results[i])
-                            << " +- " << io::rate(errors[i])
-                            << "; expected: " << io::rate(expectedForwards[i])
-                            << "; discrepancy = "
-                            << forwardStdDevs[i]
-                        << " standard errors");
-                    }
-                    for (i=0; i<N; ++i) {
-                        BOOST_TEST_MESSAGE(
-                            io::ordinal(i+1) << " caplet: "
-                            << io::rate(results[i+N])
-                            << " +- " << io::rate(errors[i+N])
-                            << "; expected: " << io::rate(expectedCaplets[i])
-                            << "; discrepancy = "
-                            << (results[i+N]-expectedCaplets[i])/(errors[i+N] == 0.0 ?
-                            1.0 : errors[i+N])
-                            << " standard errors");
-                    }
-                    BOOST_ERROR("test failed");
-            }
+    Real errorThreshold = 2.50;
+    if (minError > 0.0 || maxError < 0.0 ||
+        minError <-errorThreshold || maxError > errorThreshold) {
+        BOOST_TEST_MESSAGE(config);
+        Size i;
+        for (i=0; i<N; ++i) {
+            BOOST_TEST_MESSAGE(io::ordinal(i+1) << " forward: "
+                               << io::rate(results[i])
+                               << " +- " << io::rate(errors[i])
+                               << "; expected: " << io::rate(expectedForwards[i])
+                               << "; discrepancy = "
+                               << forwardStdDevs[i]
+                               << " standard errors");
+        }
+        for (i=0; i<N; ++i) {
+            BOOST_TEST_MESSAGE(io::ordinal(i+1) << " caplet: "
+                               << io::rate(results[i+N])
+                               << " +- " << io::rate(errors[i+N])
+                               << "; expected: " << io::rate(expectedCaplets[i])
+                               << "; discrepancy = "
+                               << (results[i+N]-expectedCaplets[i])/(errors[i+N] == 0.0 ?
+                                                                     1.0 : errors[i+N])
+                               << " standard errors");
+        }
+        BOOST_ERROR("test failed");
     }
+}
 
 
 
-    void checkCallableSwap(const SequenceStatisticsInc& stats,
-        const std::string& config) {
-            Real payerNPV    = stats.mean()[0];
-            Real receiverNPV = stats.mean()[1];
-            Real bermudanNPV = stats.mean()[2];
-            Real callableNPV = stats.mean()[3];
-            Real tolerance = 1.1e-15;
-            Real swapError = std::fabs(receiverNPV+payerNPV);
-            Real callableError = std::fabs(receiverNPV+bermudanNPV-callableNPV);
-
-            if (swapError>tolerance || bermudanNPV<0.0 ||
-                callableNPV<receiverNPV || callableError>tolerance)
-                BOOST_TEST_MESSAGE(config);  // detailed error info below
-            if (swapError>tolerance)
-                BOOST_ERROR("agreement between payer and receiver swap failed:"
-                "\n    payer swap:    " << payerNPV <<
-                "\n    receiver swap: " << receiverNPV <<
-                "\n    error:         " << swapError <<
-                "\n    tolerance:     " << tolerance);
-            if (bermudanNPV<0.0)
-                BOOST_ERROR("negative bermudan option value:"
-                "\n    bermudan:          " << bermudanNPV);
-            if (callableNPV<receiverNPV)
-                BOOST_ERROR("callable receiver less valuable than plain receiver:"
-                "\n    receiver swap:     " << receiverNPV <<
-                "\n    callable:          " << callableNPV);
-            if (callableError>tolerance)
-                BOOST_ERROR("agreement between receiver+bermudan and callable failed:"
-                "\n    receiver swap:     " << receiverNPV <<
-                "\n    bermudan:          " << bermudanNPV <<
-                "\n    receiver+bermudan: " << receiverNPV+bermudanNPV <<
-                "\n    callable:          " << callableNPV <<
-                "\n    error:             " << callableError <<
-                "\n    tolerance:         " << tolerance);
-            if (printReport_) {
-                BOOST_TEST_MESSAGE(std::setprecision(2) <<
-                    "    payer swap:        " << io::rate(payerNPV) << " +/- " << io::rate(stats.errorEstimate()[0]) <<
-                    "\n    receiver swap:     " << io::rate(receiverNPV) << " +/- " << io::rate(stats.errorEstimate()[1]) <<
-                    "\n    bermudan:          " << io::rate(bermudanNPV) << " +/- " << io::rate(stats.errorEstimate()[2]) <<
-                    "\n    receiver+bermudan: " << io::rate(receiverNPV+bermudanNPV) <<
-                    "\n    callable:          " << io::rate(callableNPV) << " +/- " << io::rate(stats.errorEstimate()[3]));
-            }
+void checkCallableSwap(const SequenceStatisticsInc& stats,
+                       const std::string& config) {
+    Real payerNPV    = stats.mean()[0];
+    Real receiverNPV = stats.mean()[1];
+    Real bermudanNPV = stats.mean()[2];
+    Real callableNPV = stats.mean()[3];
+    Real tolerance = 1.1e-15;
+    Real swapError = std::fabs(receiverNPV+payerNPV);
+    Real callableError = std::fabs(receiverNPV+bermudanNPV-callableNPV);
+
+    if (swapError>tolerance || bermudanNPV<0.0 ||
+        callableNPV<receiverNPV || callableError>tolerance)
+        BOOST_TEST_MESSAGE(config);  // detailed error info below
+    if (swapError>tolerance)
+        BOOST_ERROR("agreement between payer and receiver swap failed:"
+                    "\n    payer swap:    " << payerNPV <<
+                    "\n    receiver swap: " << receiverNPV <<
+                    "\n    error:         " << swapError <<
+                    "\n    tolerance:     " << tolerance);
+    if (bermudanNPV<0.0)
+        BOOST_ERROR("negative bermudan option value:"
+                    "\n    bermudan:          " << bermudanNPV);
+    if (callableNPV<receiverNPV)
+        BOOST_ERROR("callable receiver less valuable than plain receiver:"
+                    "\n    receiver swap:     " << receiverNPV <<
+                    "\n    callable:          " << callableNPV);
+    if (callableError>tolerance)
+        BOOST_ERROR("agreement between receiver+bermudan and callable failed:"
+                    "\n    receiver swap:     " << receiverNPV <<
+                    "\n    bermudan:          " << bermudanNPV <<
+                    "\n    receiver+bermudan: " << receiverNPV+bermudanNPV <<
+                    "\n    callable:          " << callableNPV <<
+                    "\n    error:             " << callableError <<
+                    "\n    tolerance:         " << tolerance);
+    if (printReport_) {
+        BOOST_TEST_MESSAGE(std::setprecision(2) <<
+                           "    payer swap:        " << io::rate(payerNPV) << " +/- " << io::rate(stats.errorEstimate()[0]) <<
+                           "\n    receiver swap:     " << io::rate(receiverNPV) << " +/- " << io::rate(stats.errorEstimate()[1]) <<
+                           "\n    bermudan:          " << io::rate(bermudanNPV) << " +/- " << io::rate(stats.errorEstimate()[2]) <<
+                           "\n    receiver+bermudan: " << io::rate(receiverNPV+bermudanNPV) <<
+                           "\n    callable:          " << io::rate(callableNPV) << " +/- " << io::rate(stats.errorEstimate()[3]));
     }
-
 }
 
 
-void MarketModelTest::testOneStepForwardsAndOptionlets() {
+BOOST_AUTO_TEST_CASE(testOneStepForwardsAndOptionlets) {
 
     BOOST_TEST_MESSAGE("Testing exact repricing of "
                        "one-step forwards and optionlets "
                        "in a lognormal forward rate market model...");
 
-    using namespace market_model_test;
-
     setup();
 
     std::vector<Rate> forwardStrikes(todaysForwards.size());
@@ -785,14 +782,12 @@ void MarketModelTest::testOneStepForwardsAndOptionlets() {
     }
 }
 
-void MarketModelTest::testOneStepNormalForwardsAndOptionlets() {
+BOOST_AUTO_TEST_CASE(testOneStepNormalForwardsAndOptionlets) {
 
     BOOST_TEST_MESSAGE("Testing exact repricing of "
                        "one-step forwards and optionlets "
                        "in a normal forward rate market model...");
 
-    using namespace market_model_test;
-
     setup();
 
     std::vector<Rate> forwardStrikes(todaysForwards.size());
@@ -871,15 +866,12 @@ void MarketModelTest::testOneStepNormalForwardsAndOptionlets() {
     }
 }
 
-void MarketModelTest::testInverseFloater() 
-{
+BOOST_AUTO_TEST_CASE(testInverseFloater) {
 
     BOOST_TEST_MESSAGE("Testing exact repricing of "
                        "inverse floater "
                        "in forward rate market model...");
 
-    using namespace market_model_test;
-
     setup();
 
 
@@ -891,35 +883,30 @@ void MarketModelTest::testInverseFloater()
 
     bool payer = true;
 
-
-    MultiStepInverseFloater product(
-                                                        rateTimes,
-                                                        fixedAccruals,
-                                                         floatingAccruals,
-                                                        fixedStrikes,
-                                                        fixedMultipliers, 
-                                                        floatingSpreads,
-                                                         paymentTimes,
-                                                         payer);
-
-       MarketModelPathwiseInverseFloater productPathwise(
-                                                        rateTimes,
-                                                        fixedAccruals,
-                                                         floatingAccruals,
-                                                        fixedStrikes,
-                                                        fixedMultipliers, 
-                                                        floatingSpreads,
-                                                         paymentTimes,
-                                                         payer);
-
-       MultiProductPathwiseWrapper productWrapped(productPathwise);
-
-       MultiProductComposite productComposite;
-       productComposite.add(product);
-       productComposite.add(productWrapped);
-       productComposite.finalize();
-
-   
+    MultiStepInverseFloater product(rateTimes,
+                                    fixedAccruals,
+                                    floatingAccruals,
+                                    fixedStrikes,
+                                    fixedMultipliers, 
+                                    floatingSpreads,
+                                    paymentTimes,
+                                    payer);
+
+    MarketModelPathwiseInverseFloater productPathwise(rateTimes,
+                                                      fixedAccruals,
+                                                      floatingAccruals,
+                                                      fixedStrikes,
+                                                      fixedMultipliers, 
+                                                      floatingSpreads,
+                                                      paymentTimes,
+                                                      payer);
+
+    MultiProductPathwiseWrapper productWrapped(productPathwise);
+
+    MultiProductComposite productComposite;
+    productComposite.add(product);
+    productComposite.add(productWrapped);
+    productComposite.finalize();
 
     
     EvolutionDescription evolution = productComposite.evolution();
@@ -1009,243 +996,222 @@ void MarketModelTest::testInverseFloater()
 }
 
 void testMultiProductComposite(const MarketModelMultiProduct& product,
-                               const std::vector<market_model_test::SubProductExpectedValues>& subProductExpectedValues,
+                               const std::vector<SubProductExpectedValues>& subProductExpectedValues,
                                const std::string& testDescription) {
 
-    using namespace market_model_test;
-
-                                   BOOST_TEST_MESSAGE(
-                                       "Testing exact repricing of "
-                                       << testDescription
-                                       << "in a lognormal forward rate market model...");
-
-                                   setup();
-
-                                   const EvolutionDescription& evolution = product.evolution();
-
-                                   MarketModelTest::MarketModelType marketModels[] = {
-                                       // CalibratedMM,
-                                           MarketModelTest::ExponentialCorrelationFlatVolatility,
-                                           MarketModelTest::ExponentialCorrelationAbcdVolatility };
-                                   for (auto& j : marketModels) {
-
-                                       Size testedFactors[] = {4, 8, todaysForwards.size()};
-                                       for (unsigned long factors : testedFactors) {
-                                           // Composite's ProductSuggested is the Terminal one
-                                           MeasureType measures[] = {// ProductSuggested,
-                                                                     Terminal, MoneyMarketPlus,
-                                                                     MoneyMarket};
-                                           for (auto& measure : measures) {
-                                               std::vector<Size> numeraires =
-                                                   makeMeasure(product, measure);
-
-                                               bool logNormal = true;
-                                               ext::shared_ptr<MarketModel> marketModel =
-                                                   makeMarketModel(logNormal, evolution, factors,
-                                                                   j);
-
-
-                                               EvolverType evolvers[] = {Pc, Balland, Ipc};
-                                               ext::shared_ptr<MarketModelEvolver> evolver;
-                                               Size stop =
-                                                   isInTerminalMeasure(evolution, numeraires) ? 0 :
-                                                                                                1;
-                                               for (Size i = 0; i < LENGTH(evolvers) - stop; i++) {
-
-                                                   for (Size n = 0; n < 1; n++) {
-                                                       // MTBrownianGeneratorFactory
-                                                       // generatorFactory(seed_);
-                                                       SobolBrownianGeneratorFactory
-                                                           generatorFactory(
-                                                               SobolBrownianGenerator::Diagonal,
-                                                               seed_);
-
-                                                       evolver = makeMarketModelEvolver(
-                                                           marketModel, numeraires,
-                                                           generatorFactory, evolvers[i]);
-                                                       std::ostringstream config;
-                                                       config
-                                                           << marketModelTypeToString(j) << ", "
-                                                           << factors
-                                                           << (factors > 1 ?
-                                                                   (factors ==
-                                                                            todaysForwards.size() ?
-                                                                        " (full) factors, " :
-                                                                        " factors, ") :
-                                                                   " factor,")
-                                                           << measureTypeToString(measure) << ", "
-                                                           << evolverTypeToString(evolvers[i])
-                                                           << ", "
-                                                           << "MT BGF";
-                                                       if (printReport_)
-                                                           BOOST_TEST_MESSAGE("    "
-                                                                              << config.str());
-
-                                                       ext::shared_ptr<SequenceStatisticsInc>
-                                                           stats = simulate(evolver, product);
-                                                       checkMultiProductCompositeResults(
-                                                           *stats, subProductExpectedValues,
-                                                           config.str());
-                                                   }
-                                               }
-                                           }
-                                       }
-                                   }
+    BOOST_TEST_MESSAGE("Testing exact repricing of "
+                       << testDescription
+                       << "in a lognormal forward rate market model...");
+
+    setup();
+
+    const EvolutionDescription& evolution = product.evolution();
+
+    MarketModelType marketModels[] = {
+        // CalibratedMM,
+        ExponentialCorrelationFlatVolatility,
+        ExponentialCorrelationAbcdVolatility };
+    for (auto& j : marketModels) {
+
+        Size testedFactors[] = {4, 8, todaysForwards.size()};
+        for (unsigned long factors : testedFactors) {
+            // Composite's ProductSuggested is the Terminal one
+            MeasureType measures[] = {// ProductSuggested,
+                Terminal, MoneyMarketPlus,
+                MoneyMarket};
+            for (auto& measure : measures) {
+                std::vector<Size> numeraires =
+                    makeMeasure(product, measure);
+
+                bool logNormal = true;
+                ext::shared_ptr<MarketModel> marketModel =
+                    makeMarketModel(logNormal, evolution, factors,
+                                    j);
+
+
+                EvolverType evolvers[] = {Pc, Balland, Ipc};
+                ext::shared_ptr<MarketModelEvolver> evolver;
+                Size stop =
+                    isInTerminalMeasure(evolution, numeraires) ? 0 :
+                    1;
+                for (Size i = 0; i < LENGTH(evolvers) - stop; i++) {
+
+                    for (Size n = 0; n < 1; n++) {
+                        // MTBrownianGeneratorFactory
+                        // generatorFactory(seed_);
+                        SobolBrownianGeneratorFactory
+                            generatorFactory(SobolBrownianGenerator::Diagonal,
+                                             seed_);
+
+                        evolver = makeMarketModelEvolver(marketModel, numeraires,
+                                                         generatorFactory, evolvers[i]);
+                        std::ostringstream config;
+                        config
+                            << marketModelTypeToString(j) << ", "
+                            << factors
+                            << (factors > 1 ?
+                                (factors ==
+                                 todaysForwards.size() ?
+                                 " (full) factors, " :
+                                 " factors, ") :
+                                " factor,")
+                            << measureTypeToString(measure) << ", "
+                            << evolverTypeToString(evolvers[i])
+                            << ", "
+                            << "MT BGF";
+                        if (printReport_)
+                            BOOST_TEST_MESSAGE("    "
+                                               << config.str());
+
+                        ext::shared_ptr<SequenceStatisticsInc>
+                            stats = simulate(evolver, product);
+                        checkMultiProductCompositeResults(*stats, subProductExpectedValues,
+                                                          config.str());
+                    }
+                }
+            }
+        }
+    }
 }
 
 void addForwards(MultiProductComposite& product,
-                 std::vector<market_model_test::SubProductExpectedValues>& subProductExpectedValues) {
+                 std::vector<SubProductExpectedValues>& subProductExpectedValues) {
 
-    using namespace market_model_test;
-
-                     // create forwards and add them to the product...
-                     std::vector<Rate> forwardStrikes(todaysForwards.size());
+    // create forwards and add them to the product...
+    std::vector<Rate> forwardStrikes(todaysForwards.size());
 
-                     for (Size i=0; i<todaysForwards.size(); ++i)
-                         forwardStrikes[i] = todaysForwards[i] + 0.01;
+    for (Size i=0; i<todaysForwards.size(); ++i)
+        forwardStrikes[i] = todaysForwards[i] + 0.01;
 
-                     MultiStepForwards forwards(rateTimes, accruals,
-                         paymentTimes, forwardStrikes);
-                     product.add(forwards);
+    MultiStepForwards forwards(rateTimes, accruals,
+                               paymentTimes, forwardStrikes);
+    product.add(forwards);
 
-                     // computing and storing expected values
-                     subProductExpectedValues.emplace_back("Forward");
-                     subProductExpectedValues.back().errorThreshold = 2.50;
-                     for (Size i=0; i<todaysForwards.size(); ++i) {
-                         subProductExpectedValues.back().values.push_back(
-                             (todaysForwards[i]-forwardStrikes[i])
-                             *accruals[i]*todaysDiscounts[i+1]);
-                     }
+    // computing and storing expected values
+    subProductExpectedValues.emplace_back("Forward");
+    subProductExpectedValues.back().errorThreshold = 2.50;
+    for (Size i=0; i<todaysForwards.size(); ++i) {
+        subProductExpectedValues.back().values.push_back((todaysForwards[i]-forwardStrikes[i])
+                                                         *accruals[i]*todaysDiscounts[i+1]);
+    }
 }
 
 void addOptionLets(MultiProductComposite& product,
-                   std::vector<market_model_test::SubProductExpectedValues>& subProductExpectedValues) {
-
-    using namespace market_model_test;
-
-                       // create the products...
-                       std::vector<ext::shared_ptr<Payoff> > optionletPayoffs(todaysForwards.size());
-                       std::vector<ext::shared_ptr<StrikedTypePayoff> >
-                           displacedPayoffs(todaysForwards.size());
-
-                       for (Size i=0; i<todaysForwards.size(); ++i) {
-                           optionletPayoffs[i] = ext::shared_ptr<Payoff>(new
-                               PlainVanillaPayoff(Option::Call, todaysForwards[i]));
-                           //CashOrNothingPayoff(Option::Call, todaysForwards[i], 0.01));
-                           displacedPayoffs[i] = ext::shared_ptr<StrikedTypePayoff>(new
-                               PlainVanillaPayoff(Option::Call, todaysForwards[i]+displacement));
-                           //CashOrNothingPayoff(Option::Call, todaysForwards[i]+displacement, 0.01));
-                       }
+                   std::vector<SubProductExpectedValues>& subProductExpectedValues) {
 
-                       MultiStepOptionlets optionlets(rateTimes, accruals,
-                           paymentTimes, optionletPayoffs);
-                       product.add(optionlets);
-
-                       // computing and storing expected values
-                       subProductExpectedValues.emplace_back("Caplet");
-                       subProductExpectedValues.back().errorThreshold = 2.50;
-                       for (Size i=0; i<todaysForwards.size(); ++i) {
-                           subProductExpectedValues.back().values.push_back(
-                               BlackCalculator(displacedPayoffs[i],
-                               todaysForwards[i]+displacement,
-                               volatilities[i]*std::sqrt(rateTimes[i]),
-                               todaysDiscounts[i+1]*accruals[i]).value());
-                       }
+    // create the products...
+    std::vector<ext::shared_ptr<Payoff> > optionletPayoffs(todaysForwards.size());
+    std::vector<ext::shared_ptr<StrikedTypePayoff> >
+        displacedPayoffs(todaysForwards.size());
+
+    for (Size i=0; i<todaysForwards.size(); ++i) {
+        optionletPayoffs[i] = ext::shared_ptr<Payoff>(new
+                                                      PlainVanillaPayoff(Option::Call, todaysForwards[i]));
+        //CashOrNothingPayoff(Option::Call, todaysForwards[i], 0.01));
+        displacedPayoffs[i] = ext::shared_ptr<StrikedTypePayoff>(new
+                                                                 PlainVanillaPayoff(Option::Call, todaysForwards[i]+displacement));
+        //CashOrNothingPayoff(Option::Call, todaysForwards[i]+displacement, 0.01));
+    }
+
+    MultiStepOptionlets optionlets(rateTimes, accruals,
+                                   paymentTimes, optionletPayoffs);
+    product.add(optionlets);
+
+    // computing and storing expected values
+    subProductExpectedValues.emplace_back("Caplet");
+    subProductExpectedValues.back().errorThreshold = 2.50;
+    for (Size i=0; i<todaysForwards.size(); ++i) {
+        subProductExpectedValues.back().values.push_back(BlackCalculator(displacedPayoffs[i],
+                                                                         todaysForwards[i]+displacement,
+                                                                         volatilities[i]*std::sqrt(rateTimes[i]),
+                                                                         todaysDiscounts[i+1]*accruals[i]).value());
+    }
 }
 
 
 void addCoinitialSwaps(MultiProductComposite& product,
-                       std::vector<market_model_test::SubProductExpectedValues>& subProductExpectedValues) {
-
-    using namespace market_model_test;
-
-                           // create the products...
-                           Real fixedRate = 0.04;
-                           MultiStepCoinitialSwaps multiStepCoinitialSwaps(rateTimes, accruals, accruals,
-                               paymentTimes, fixedRate);
-                           product.add(multiStepCoinitialSwaps);
-                           // computing and storing expected values
-                           subProductExpectedValues.emplace_back("coinitial swap");
-                           subProductExpectedValues.back().testBias = false;
-                           subProductExpectedValues.back().errorThreshold = 2.32;
-                           Real coinitialSwapValue = 0;
-                           for (Size i=0; i<todaysForwards.size(); ++i) {
-                               coinitialSwapValue += (todaysForwards[i]-fixedRate)
-                                   *accruals[i]*todaysDiscounts[i+1];
-                               subProductExpectedValues.back().values.push_back(coinitialSwapValue);
-                           }
+                       std::vector<SubProductExpectedValues>& subProductExpectedValues) {
+
+    // create the products...
+    Real fixedRate = 0.04;
+    MultiStepCoinitialSwaps multiStepCoinitialSwaps(rateTimes, accruals, accruals,
+                                                    paymentTimes, fixedRate);
+    product.add(multiStepCoinitialSwaps);
+    // computing and storing expected values
+    subProductExpectedValues.emplace_back("coinitial swap");
+    subProductExpectedValues.back().testBias = false;
+    subProductExpectedValues.back().errorThreshold = 2.32;
+    Real coinitialSwapValue = 0;
+    for (Size i=0; i<todaysForwards.size(); ++i) {
+        coinitialSwapValue += (todaysForwards[i]-fixedRate)
+            *accruals[i]*todaysDiscounts[i+1];
+        subProductExpectedValues.back().values.push_back(coinitialSwapValue);
+    }
 }
 
 void addCoterminalSwapsAndSwaptions(MultiProductComposite& product,
-                                    std::vector<market_model_test::SubProductExpectedValues>& subProductExpectedValues) {
-
-    using namespace market_model_test;
-
-                                        Real fixedRate = 0.04;
-                                        MultiStepCoterminalSwaps swaps(rateTimes, accruals, accruals,
-                                            paymentTimes, fixedRate);
-
-                                        std::vector<ext::shared_ptr<StrikedTypePayoff> > payoffs(todaysForwards.size());
-                                        for (Size i = 0; i < payoffs.size(); ++i)
-                                            payoffs[i] = ext::shared_ptr<StrikedTypePayoff>(new
-                                            PlainVanillaPayoff(Option::Call, todaysForwards[i]));
-
-                                        MultiStepCoterminalSwaptions swaptions(rateTimes,
-                                            rateTimes, payoffs);
-                                        product.add(swaps);
-                                        product.add(swaptions);
-
-                                        subProductExpectedValues.emplace_back("coterminal swap");
-                                        subProductExpectedValues.back().testBias = false;
-                                        subProductExpectedValues.back().errorThreshold = 2.32;
-                                        LMMCurveState curveState(rateTimes);  // not the best way to detect errors in LMMCurveState...
-                                        curveState.setOnForwardRates(todaysForwards);
-                                        std::vector<Rate> atmRates = curveState.coterminalSwapRates();
-                                        for (Size i=0; i<todaysForwards.size(); ++i) {
-                                            Real expectedNPV = curveState.coterminalSwapAnnuity(0, i) * (atmRates[i]-fixedRate) *
-                                                todaysDiscounts.front();
-                                            subProductExpectedValues.back().values.push_back(expectedNPV);
-                                        }
-                                        // we clone the prooduct to be able to finalize it and call evolution function member on it
-                                        MultiProductComposite productClone = product;
-                                        productClone.finalize();
-                                        subProductExpectedValues.emplace_back(
-                                            "coterminal swaption");
-                                        subProductExpectedValues.back().testBias = false;
-                                        subProductExpectedValues.back().errorThreshold = 2.32;
-                                        const Spread displacement = 0;
-                                        Matrix jacobian =
-                                            SwapForwardMappings::coterminalSwapZedMatrix(
-                                            curveState, displacement);
-                                        bool logNormal = true;
-
-                                        EvolutionDescription evolution = productClone.evolution();
-                                        Size factors = todaysForwards.size();
-                                        MarketModelTest::MarketModelType marketModelType = MarketModelTest::ExponentialCorrelationFlatVolatility;
-                                        ext::shared_ptr<MarketModel> marketModel =
-                                            makeMarketModel(logNormal, evolution, factors, marketModelType);
-                                        for (Size i=0; i<todaysForwards.size(); ++i) {
-                                            const Matrix& forwardsCovariance = marketModel->totalCovariance(i);
-                                            Matrix cotSwapsCovariance =
-                                                jacobian * forwardsCovariance * transpose(jacobian);
-                                            ext::shared_ptr<PlainVanillaPayoff> payoff(
-                                                new PlainVanillaPayoff(Option::Call, todaysForwards[i]+displacement));
-
-                                            Real expectedSwaption =
-                                                BlackCalculator(payoff,
-                                                todaysCoterminalSwapRates[i]+displacement,
-                                                std::sqrt(cotSwapsCovariance[i][i]),
-                                                curveState.coterminalSwapAnnuity(0,i) *
-                                                todaysDiscounts[0]).value();
-                                            subProductExpectedValues.back().values.push_back(expectedSwaption);
-                                        }
-}
+                                    std::vector<SubProductExpectedValues>& subProductExpectedValues) {
 
+    Real fixedRate = 0.04;
+    MultiStepCoterminalSwaps swaps(rateTimes, accruals, accruals,
+                                   paymentTimes, fixedRate);
+
+    std::vector<ext::shared_ptr<StrikedTypePayoff> > payoffs(todaysForwards.size());
+    for (Size i = 0; i < payoffs.size(); ++i)
+        payoffs[i] = ext::shared_ptr<StrikedTypePayoff>(new
+                                                        PlainVanillaPayoff(Option::Call, todaysForwards[i]));
+
+    MultiStepCoterminalSwaptions swaptions(rateTimes,
+                                           rateTimes, payoffs);
+    product.add(swaps);
+    product.add(swaptions);
+
+    subProductExpectedValues.emplace_back("coterminal swap");
+    subProductExpectedValues.back().testBias = false;
+    subProductExpectedValues.back().errorThreshold = 2.32;
+    LMMCurveState curveState(rateTimes);  // not the best way to detect errors in LMMCurveState...
+    curveState.setOnForwardRates(todaysForwards);
+    std::vector<Rate> atmRates = curveState.coterminalSwapRates();
+    for (Size i=0; i<todaysForwards.size(); ++i) {
+        Real expectedNPV = curveState.coterminalSwapAnnuity(0, i) * (atmRates[i]-fixedRate) *
+            todaysDiscounts.front();
+        subProductExpectedValues.back().values.push_back(expectedNPV);
+    }
+    // we clone the prooduct to be able to finalize it and call evolution function member on it
+    MultiProductComposite productClone = product;
+    productClone.finalize();
+    subProductExpectedValues.emplace_back(
+                                          "coterminal swaption");
+    subProductExpectedValues.back().testBias = false;
+    subProductExpectedValues.back().errorThreshold = 2.32;
+    const Spread displacement = 0;
+    Matrix jacobian =
+        SwapForwardMappings::coterminalSwapZedMatrix(curveState, displacement);
+    bool logNormal = true;
 
-void MarketModelTest::testAllMultiStepProducts() {
-    std::string testDescription = "all multi-step products ";
+    EvolutionDescription evolution = productClone.evolution();
+    Size factors = todaysForwards.size();
+    MarketModelType marketModelType = ExponentialCorrelationFlatVolatility;
+    ext::shared_ptr<MarketModel> marketModel =
+        makeMarketModel(logNormal, evolution, factors, marketModelType);
+    for (Size i=0; i<todaysForwards.size(); ++i) {
+        const Matrix& forwardsCovariance = marketModel->totalCovariance(i);
+        Matrix cotSwapsCovariance =
+            jacobian * forwardsCovariance * transpose(jacobian);
+        ext::shared_ptr<PlainVanillaPayoff> payoff(new PlainVanillaPayoff(Option::Call, todaysForwards[i]+displacement));
+
+        Real expectedSwaption =
+            BlackCalculator(payoff,
+                            todaysCoterminalSwapRates[i]+displacement,
+                            std::sqrt(cotSwapsCovariance[i][i]),
+                            curveState.coterminalSwapAnnuity(0,i) *
+                            todaysDiscounts[0]).value();
+        subProductExpectedValues.back().values.push_back(expectedSwaption);
+    }
+}
 
-    using namespace market_model_test;
+BOOST_AUTO_TEST_CASE(testAllMultiStepProducts, *precondition(if_speed(Slow))) {
+    std::string testDescription = "all multi-step products ";
 
     setup();
 
@@ -1260,13 +1226,10 @@ void MarketModelTest::testAllMultiStepProducts() {
         testDescription);
 }
 
-
-void MarketModelTest::testPeriodAdapter() {
+BOOST_AUTO_TEST_CASE(testPeriodAdapter) {
 
     BOOST_TEST_MESSAGE("Testing period-adaptation routines in LIBOR market model...");
 
-    using namespace market_model_test;
-
     setup();
     LMMCurveState cs(rateTimes);
     cs.setOnForwardRates(todaysForwards);
@@ -1414,11 +1377,10 @@ void MarketModelTest::testPeriodAdapter() {
         }
     }
 }
-void MarketModelTest::testCallableSwapNaif() {
 
-    BOOST_TEST_MESSAGE("Pricing callable swap with naif exercise strategy in a LIBOR market model...");
+BOOST_AUTO_TEST_CASE(testCallableSwapNaif, *precondition(if_speed(Slow))) {
 
-    using namespace market_model_test;
+    BOOST_TEST_MESSAGE("Pricing callable swap with naif exercise strategy in a LIBOR market model...");
 
     setup();
 
@@ -1569,12 +1531,10 @@ void MarketModelTest::testCallableSwapNaif() {
     }
 }
 
-void MarketModelTest::testCallableSwapLS() {
+BOOST_AUTO_TEST_CASE(testCallableSwapLS, *precondition(if_speed(Slow))) {
 
     BOOST_TEST_MESSAGE("Pricing callable swap with Longstaff-Schwartz exercise strategy in a LIBOR market model...");
 
-    using namespace market_model_test;
-
     setup();
 
     Real fixedRate = 0.04;
@@ -1730,10 +1690,29 @@ void MarketModelTest::testCallableSwapLS() {
     }
 }
 
-void MarketModelTest::testCallableSwapAnderson(
-    MarketModelType marketModelType, Size testedFactor) {
+BOOST_AUTO_TEST_SUITE(CallableSwapAnderson, *precondition(if_speed(Slow)))
 
-    using namespace market_model_test;
+template <MarketModelType mmtype, Size factors>
+struct slice {
+    static const MarketModelType marketModelType = mmtype;
+    static const Size testedFactor = factors;
+};
+
+using slices = boost::mpl::vector<
+    slice<ExponentialCorrelationFlatVolatility, 4>,
+    slice<ExponentialCorrelationFlatVolatility, 8>,
+    slice<ExponentialCorrelationFlatVolatility, 0>,
+    slice<ExponentialCorrelationAbcdVolatility, 4>,
+    slice<ExponentialCorrelationAbcdVolatility, 8>,
+    slice<ExponentialCorrelationAbcdVolatility, 0>
+>;
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(testCallableSwapAnderson, T, slices) {
+
+    setup();
+
+    MarketModelType marketModelType = T::marketModelType;
+    Size testedFactor = T::testedFactor != 0 ? T::testedFactor : todaysForwards.size();
 
     BOOST_TEST_MESSAGE("Pricing callable swap with Anderson exercise "
                        "strategy in a LIBOR market model for test factor "
@@ -1893,14 +1872,12 @@ void MarketModelTest::testCallableSwapAnderson(
     }
 }
 
+BOOST_AUTO_TEST_SUITE_END()
 
-
-void MarketModelTest::testGreeks() {
+BOOST_AUTO_TEST_CASE(testGreeks, *precondition(if_speed(Fast))) {
 
     BOOST_TEST_MESSAGE("Testing caplet greeks in a lognormal forward rate market model using partial proxy simulation...");
 
-    using namespace market_model_test;
-
     setup();
 
     std::vector<ext::shared_ptr<Payoff> > payoffs(todaysForwards.size());
@@ -2110,18 +2087,13 @@ void MarketModelTest::testGreeks() {
 
 // pathwise deltas
 
-
-void MarketModelTest::testPathwiseGreeks()
-{
+BOOST_AUTO_TEST_CASE(testPathwiseGreeks) {
 
     BOOST_TEST_MESSAGE("Testing caplet deltas in a lognormal forward rate market model using pathwise method...");
 
-    using namespace market_model_test;
-
     setup();
 
 
-
     std::vector<ext::shared_ptr<Payoff> > payoffs(todaysForwards.size());
     std::vector<ext::shared_ptr<StrikedTypePayoff> >
         displacedPayoffs(todaysForwards.size());
@@ -2350,14 +2322,11 @@ void MarketModelTest::testPathwiseGreeks()
     }
 }
 
-void MarketModelTest::testPathwiseVegas()
-{
+BOOST_AUTO_TEST_CASE(testPathwiseVegas, *precondition(if_speed(Fast))) {
 
     BOOST_TEST_MESSAGE(
         "Testing pathwise vegas in a lognormal forward rate market model...");
 
-    using namespace market_model_test;
-
     setup();
 
 
@@ -3498,13 +3467,10 @@ void MarketModelTest::testPathwiseVegas()
 
 }
 
-void MarketModelTest::testPathwiseMarketVegas()
-{
+BOOST_AUTO_TEST_CASE(testPathwiseMarketVegas) {
 
     BOOST_TEST_MESSAGE("Testing pathwise market vegas in a lognormal forward rate market model...");
 
-    using namespace market_model_test;
-
     setup();
 
     // specify collection of caps and swaptions and then see if their vegas are correct
@@ -4161,12 +4127,10 @@ void MarketModelTest::testPathwiseMarketVegas()
 
 //--------------------- Volatility tests ---------------------
 
-void MarketModelTest::testAbcdVolatilityIntegration() {
+BOOST_AUTO_TEST_CASE(testAbcdVolatilityIntegration) {
 
     BOOST_TEST_MESSAGE("Testing Abcd-volatility integration...");
 
-    using namespace market_model_test;
-
     setup();
 
     Real a = -0.0597;
@@ -4216,12 +4180,10 @@ void MarketModelTest::testAbcdVolatilityIntegration() {
     }
 }
 
-void MarketModelTest::testAbcdVolatilityCompare() {
+BOOST_AUTO_TEST_CASE(testAbcdVolatilityCompare) {
 
     BOOST_TEST_MESSAGE("Testing different implementations of Abcd-volatility...");
 
-    using namespace market_model_test;
-
     setup();
 
     /*
@@ -4266,12 +4228,10 @@ void MarketModelTest::testAbcdVolatilityCompare() {
     }
 }
 
-void MarketModelTest::testAbcdVolatilityFit() {
+BOOST_AUTO_TEST_CASE(testAbcdVolatilityFit) {
 
     BOOST_TEST_MESSAGE("Testing Abcd-volatility fit...");
 
-    using namespace market_model_test;
-
     setup();
 
     AbcdCalibration instVol(std::vector<Time>(rateTimes.begin(), rateTimes.end()-1), blackVols);
@@ -4318,15 +4278,14 @@ void MarketModelTest::testAbcdVolatilityFit() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void MarketModelTest::testStochVolForwardsAndOptionlets() {
+
+BOOST_AUTO_TEST_CASE(testStochVolForwardsAndOptionlets) {
 
     BOOST_TEST_MESSAGE(
         "Testing exact repricing of "
         "forwards and optionlets "
         "in a stochastic vol displaced diffusion forward rate market model...");
 
-    using namespace market_model_test;
-
     setup();
 
     std::vector<Rate> forwardStrikes(todaysForwards.size());
@@ -4519,15 +4478,13 @@ void MarketModelTest::testStochVolForwardsAndOptionlets() {
 
 //--------------------- Other tests ---------------------
 
-void MarketModelTest::testDriftCalculator() {
+BOOST_AUTO_TEST_CASE(testDriftCalculator) {
 
     // Test full factor drift equivalence between compute() and
     // computeReduced()
 
     BOOST_TEST_MESSAGE("Testing drift calculation...");
 
-    using namespace market_model_test;
-
     setup();
 
     Real tolerance = 1.0e-16;
@@ -4575,14 +4532,12 @@ void MarketModelTest::testDriftCalculator() {
     }
 }
 
-void MarketModelTest::testIsInSubset() {
+BOOST_AUTO_TEST_CASE(testIsInSubset) {
 
     // Performance test for isInSubset function (temporary)
 
     BOOST_TEST_MESSAGE("Testing isInSubset function...");
 
-    using namespace market_model_test;
-
     setup();
 
     Size dim = 100;
@@ -4600,8 +4555,7 @@ void MarketModelTest::testIsInSubset() {
     }
 }
 
-
-void MarketModelTest::testAbcdDegenerateCases() {
+BOOST_AUTO_TEST_CASE(testAbcdDegenerateCases) {
     BOOST_TEST_MESSAGE("Testing abcd degenerate cases...");
 
     AbcdFunction f1(0.0,0.0,1.0E-15,1.0);
@@ -4620,7 +4574,7 @@ void MarketModelTest::testAbcdDegenerateCases() {
         << "error is " << std::fabs(cov2 - 1.0));
 }
 
-void MarketModelTest::testCovariance() {
+BOOST_AUTO_TEST_CASE(testCovariance) {
     BOOST_TEST_MESSAGE("Testing market models covariance...");
 
     const Size n = 10;
@@ -4705,66 +4659,6 @@ void MarketModelTest::testCovariance() {
     }
 }
 
-// --- Call the desired tests
-test_suite* MarketModelTest::suite(SpeedLevel speed) {
-    auto* suite = BOOST_TEST_SUITE("Market-model tests");
-
-    suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testInverseFloater));
-
-    suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testPathwiseMarketVegas));
-    suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testPathwiseGreeks));
+BOOST_AUTO_TEST_SUITE_END()
 
-    suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testStochVolForwardsAndOptionlets));
-
-    suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testOneStepForwardsAndOptionlets));
-    suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testOneStepNormalForwardsAndOptionlets));
-
-    suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testAbcdVolatilityIntegration));
-    suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testAbcdVolatilityCompare));
-    suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testAbcdVolatilityFit));
-
-    suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testPeriodAdapter));
-
-    suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testDriftCalculator));
-    suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testIsInSubset));
-
-    suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testAbcdDegenerateCases));
-    suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testCovariance));
-
-    if (speed <= Fast) {
-        suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testGreeks));
-        suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testPathwiseVegas));
-    }
-
-    if (speed == Slow) {
-        using namespace market_model_test;
-
-        setup();
-
-        // unrolled to get different test names
-        suite->add(QUANTLIB_TEST_CASE([=](){
-            MarketModelTest::testCallableSwapAnderson(ExponentialCorrelationFlatVolatility, 4);
-        }));
-        suite->add(QUANTLIB_TEST_CASE([=](){
-            MarketModelTest::testCallableSwapAnderson(ExponentialCorrelationFlatVolatility, 8);
-        }));
-        suite->add(QUANTLIB_TEST_CASE([=](){
-            MarketModelTest::testCallableSwapAnderson(ExponentialCorrelationFlatVolatility, todaysForwards.size());
-        }));
-        suite->add(QUANTLIB_TEST_CASE([=](){
-            MarketModelTest::testCallableSwapAnderson(ExponentialCorrelationAbcdVolatility, 4);
-        }));
-        suite->add(QUANTLIB_TEST_CASE([=](){
-            MarketModelTest::testCallableSwapAnderson(ExponentialCorrelationAbcdVolatility, 8);
-        }));
-        suite->add(QUANTLIB_TEST_CASE([=](){
-            MarketModelTest::testCallableSwapAnderson(ExponentialCorrelationAbcdVolatility, todaysForwards.size());
-        }));
-
-        suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testAllMultiStepProducts));
-        suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testCallableSwapNaif));
-        suite->add(QUANTLIB_TEST_CASE(&MarketModelTest::testCallableSwapLS));
-    }
-
-    return suite;
-}
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test-suite/marketmodel.hpp b/test-suite/marketmodel.hpp
deleted file mode 100644
index 4421f503849..00000000000
--- a/test-suite/marketmodel.hpp
+++ /dev/null
@@ -1,61 +0,0 @@
-/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-
-/*
- Copyright (C) 2006 Ferdinando Ametrano
- Copyright (C) 2006 StatPro Italia srl
- Copyright (C) 2012 Peter Caspers
-
- This file is part of QuantLib, a free-software/open-source library
- for financial quantitative analysts and developers - http://quantlib.org/
-
- QuantLib is free software: you can redistribute it and/or modify it
- under the terms of the QuantLib license.  You should have received a
- copy of the license along with this program; if not, please email
- <quantlib-dev@lists.sf.net>. The license is also available online at
- <http://quantlib.org/license.shtml>.
-
- This program is distributed in the hope that it will be useful, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- FOR A PARTICULAR PURPOSE.  See the license for more details.
-*/
-
-#ifndef quantlib_test_market_model_hpp
-#define quantlib_test_market_model_hpp
-
-#include "preconditions.hpp"
-#include <ql/qldefines.hpp>
-#include <boost/test/unit_test.hpp>
-
-/* remember to document new and/or updated tests in the Doxygen
-   comment block of the corresponding class */
-
-class MarketModelTest {
-  public:
-    enum MarketModelType { ExponentialCorrelationFlatVolatility,
-        ExponentialCorrelationAbcdVolatility/*, CalibratedMM*/
-    };
-    static void testInverseFloater();
-    static void testPeriodAdapter();
-    static void testAllMultiStepProducts();
-    static void testOneStepForwardsAndOptionlets();
-    static void testOneStepNormalForwardsAndOptionlets();
-    static void testCallableSwapNaif();
-    static void testCallableSwapLS();
-    static void testCallableSwapAnderson(
-        MarketModelType marketModel, std::size_t testedFactor);
-    static void testGreeks();
-    static void testPathwiseGreeks();
-    static void testPathwiseVegas();
-    static void testPathwiseMarketVegas();
-    static void testStochVolForwardsAndOptionlets();
-    static void testAbcdVolatilityIntegration();
-    static void testAbcdVolatilityCompare();
-    static void testAbcdVolatilityFit();
-    static void testDriftCalculator();
-    static void testIsInSubset();
-    static void testAbcdDegenerateCases();
-    static void testCovariance();
-    static boost::unit_test_framework::test_suite* suite(SpeedLevel);
-};
-
-#endif
diff --git a/test-suite/quantlibtestsuite.cpp b/test-suite/quantlibtestsuite.cpp
index 516ede1303e..bb2cdd7c6c4 100644
--- a/test-suite/quantlibtestsuite.cpp
+++ b/test-suite/quantlibtestsuite.cpp
@@ -18,9 +18,6 @@
  FOR A PARTICULAR PURPOSE.  See the license for more details.
 */
 
-#include <ql/settings.hpp>
-#include <ql/utilities/dataparsers.hpp>
-
 #ifdef QL_ENABLE_PARALLEL_UNIT_TEST_RUNNER
 #include "paralleltestrunner.hpp"
 #else
@@ -34,20 +31,13 @@
 #  include <ql/auto_link.hpp>
 #endif
 
-#include "marketmodel.hpp"
 #include "quantlibglobalfixture.hpp"
 
 using namespace boost::unit_test_framework;
 
 test_suite* init_unit_test_suite(int, char* []) {
 
-    int argc = boost::unit_test::framework::master_test_suite().argc;
-    char **argv = boost::unit_test::framework::master_test_suite().argv;
-    SpeedLevel speed = speed_level(argc, argv);
-
     auto* test = BOOST_TEST_SUITE("QuantLib test suite");
 
-    test->add(MarketModelTest::suite(speed));
-
     return test;
 }
diff --git a/test-suite/testsuite.vcxproj b/test-suite/testsuite.vcxproj
index 64c6dbd624f..b9fa64738c0 100644
--- a/test-suite/testsuite.vcxproj
+++ b/test-suite/testsuite.vcxproj
@@ -811,7 +811,6 @@
     <ClCompile Include="quantlibtestsuite.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="marketmodel.hpp" />
     <ClInclude Include="paralleltestrunner.hpp" />
     <ClInclude Include="preconditions.hpp" />
     <ClInclude Include="quantlibglobalfixture.hpp" />
diff --git a/test-suite/testsuite.vcxproj.filters b/test-suite/testsuite.vcxproj.filters
index b56a15fb1ea..c8eee42571b 100644
--- a/test-suite/testsuite.vcxproj.filters
+++ b/test-suite/testsuite.vcxproj.filters
@@ -530,9 +530,6 @@
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
-     <ClInclude Include="marketmodel.hpp">
-       <Filter>Header Files</Filter>
-     </ClInclude>
     <ClInclude Include="paralleltestrunner.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>

From 3fa1d1fc5063dda5b01befcf67bd9e4ca0470864 Mon Sep 17 00:00:00 2001
From: Luigi Ballabio <luigi.ballabio@gmail.com>
Date: Mon, 18 Dec 2023 23:35:02 +0100
Subject: [PATCH 2/4] Remove libUnitMain from test suite compilation

---
 acinclude.m4              | 40 ++++++++++++++++-----------------------
 test-suite/CMakeLists.txt | 18 ++----------------
 test-suite/Makefile.am    |  8 ++------
 test-suite/main.cpp       | 20 --------------------
 4 files changed, 20 insertions(+), 66 deletions(-)
 delete mode 100644 test-suite/main.cpp

diff --git a/acinclude.m4 b/acinclude.m4
index 32a095f80ad..6c0cfec0593 100644
--- a/acinclude.m4
+++ b/acinclude.m4
@@ -113,43 +113,35 @@ AC_DEFUN([QL_CHECK_BOOST_VERSION_1_59_OR_HIGHER],
     ])
 ])
 
-# QL_CHECK_BOOST_UNIT_TEST
+# QL_CHECK_BOOST_UNIT§_TEST
 # ------------------------
 # Check whether the Boost unit-test framework is available
 AC_DEFUN([QL_CHECK_BOOST_UNIT_TEST],
 [AC_MSG_CHECKING([for Boost.Test])
  AC_REQUIRE([AC_PROG_CC])
- ql_original_CXXFLAGS=$CXXFLAGS
- for test_flags in "" \
-                   "-DBOOST_TEST_MAIN -DBOOST_TEST_DYN_LINK" ; do
-     # static version
-     CXXFLAGS="$ql_original_CXXFLAGS $test_flags"
-     boost_unit_found=no
-     AC_LINK_IFELSE([AC_LANG_SOURCE(
-         [@%:@include <boost/test/included/unit_test.hpp>
-          using namespace boost::unit_test_framework;
-          test_suite*
-          init_unit_test_suite(int argc, char** argv)
-          {
-              return (test_suite*) 0;
-          }
-         ])],
-         [boost_unit_found=yes
-          boost_defines=$test_flags
-          break],
-         [])
- done
- CXXFLAGS="$ql_original_CXXFLAGS"
+ # static version
+ boost_unit_found=no
+ AC_LINK_IFELSE([AC_LANG_SOURCE(
+     [@%:@include <boost/test/included/unit_test.hpp>
+      using namespace boost::unit_test_framework;
+      test_suite*
+      init_unit_test_suite(int argc, char** argv)
+      {
+          return (test_suite*) 0;
+      }
+     ])],
+     [boost_unit_found=yes
+      boost_defines=$test_flags
+      break],
+     [])
  if test "$boost_unit_found" = no ; then
      AC_MSG_RESULT([no])
      AC_SUBST([HAVE_BOOST_TEST],[""])
-     AC_SUBST([BOOST_UNIT_TEST_MAIN_CXXFLAGS],[""])
      AC_MSG_WARN([Boost unit-test framework not found.])
      AC_MSG_WARN([The test suite will be disabled.])
  else
      AC_MSG_RESULT([yes])
      AC_SUBST([HAVE_BOOST_TEST],["yes"])
-     AC_SUBST([BOOST_UNIT_TEST_MAIN_CXXFLAGS],[$boost_defines])
  fi
 ])
 
diff --git a/test-suite/CMakeLists.txt b/test-suite/CMakeLists.txt
index 77be2c64b24..0e5f0e56d8c 100644
--- a/test-suite/CMakeLists.txt
+++ b/test-suite/CMakeLists.txt
@@ -211,27 +211,14 @@ set(QL_BENCHMARK_SOURCES
                                         swaptionvolstructuresutilities.hpp
 )
 
-if (QL_BUILD_TEST_SUITE OR QL_BUILD_BENCHMARK)
-    add_library(ql_unit_test_main STATIC main.cpp)
-    target_include_directories(ql_unit_test_main PRIVATE
-        ${PROJECT_BINARY_DIR}
-        ${PROJECT_SOURCE_DIR})
-    target_include_directories(ql_unit_test_main SYSTEM PRIVATE
-        ${Boost_INCLUDE_DIRS})
-    if (NOT Boost_USE_STATIC_LIBS)
-        target_compile_definitions(ql_unit_test_main PRIVATE BOOST_TEST_DYN_LINK)
-    endif()
-endif()
-
 if (QL_BUILD_TEST_SUITE)
     add_executable(ql_test_suite ${QL_TEST_SOURCES} ${QL_TEST_HEADERS})
     set_target_properties(ql_test_suite PROPERTIES OUTPUT_NAME "quantlib-test-suite")
     if (NOT Boost_USE_STATIC_LIBS)
-        target_compile_definitions(ql_test_suite PRIVATE BOOST_ALL_DYN_LINK BOOST_TEST_DYN_LINK)
+        target_compile_definitions(ql_test_suite PRIVATE BOOST_ALL_DYN_LINK)
     endif()
     target_link_libraries(ql_test_suite PRIVATE
         ql_library
-        ql_unit_test_main
         ${QL_THREAD_LIBRARIES})
     if(MSVC AND CMAKE_UNITY_BUILD)
         # for Unity builds, we need to add /bigobj
@@ -248,11 +235,10 @@ IF (QL_BUILD_BENCHMARK)
     set_target_properties(ql_benchmark PROPERTIES OUTPUT_NAME "quantlib-benchmark")
     set_source_files_properties(quantlibbenchmark.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION true)
     if (NOT Boost_USE_STATIC_LIBS)
-        target_compile_definitions(ql_benchmark PRIVATE BOOST_ALL_DYN_LINK BOOST_TEST_DYN_LINK)
+        target_compile_definitions(ql_benchmark PRIVATE BOOST_ALL_DYN_LINK)
     endif()
     target_link_libraries(ql_benchmark PRIVATE
         ql_library
-        ql_unit_test_main
         ${QL_THREAD_LIBRARIES})
     if(MSVC AND CMAKE_UNITY_BUILD)
         # for Unity builds, we need to add /bigobj
diff --git a/test-suite/Makefile.am b/test-suite/Makefile.am
index c453c4bb92d..eebc8c21b13 100644
--- a/test-suite/Makefile.am
+++ b/test-suite/Makefile.am
@@ -225,10 +225,6 @@ if BUILD_TEST_SUITE
 
 AM_CPPFLAGS = -I${top_builddir} -I${top_srcdir}
 
-noinst_LTLIBRARIES = libUnitMain.la
-libUnitMain_la_SOURCES = main.cpp
-libUnitMain_la_CXXFLAGS = ${BOOST_UNIT_TEST_MAIN_CXXFLAGS}
-
 if AUTO_BENCHMARK
 bin_PROGRAMS = quantlib-test-suite quantlib-benchmark
 else
@@ -271,10 +267,10 @@ EXTRA_DIST =
 
 endif
 
-quantlib_test_suite_LDADD = libUnitMain.la ${top_builddir}/ql/libQuantLib.la \
+quantlib_test_suite_LDADD = ${top_builddir}/ql/libQuantLib.la \
                             ${PTHREAD_LIB} ${BOOST_INTERPROCESS_LIB}
 
-quantlib_benchmark_LDADD = libUnitMain.la ${top_builddir}/ql/libQuantLib.la \
+quantlib_benchmark_LDADD = ${top_builddir}/ql/libQuantLib.la \
                            ${PTHREAD_LIB}
 
 TESTS = quantlib-test-suite$(EXEEXT)
diff --git a/test-suite/main.cpp b/test-suite/main.cpp
deleted file mode 100644
index 38d3a7ae654..00000000000
--- a/test-suite/main.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifdef BOOST_TEST_DYN_LINK
-/* This file needs to be linked with the test suite in case the
-   shared-library version of the Boost unit-test framework is used. */
-#include <boost/test/unit_test.hpp>
-#include <boost/test/framework.hpp>
-
-using namespace boost::unit_test;
-
-test_suite* init_unit_test_suite(int, char* []);
-
-bool init_function() {
-    framework::master_test_suite().add(init_unit_test_suite(0, nullptr));
-    return true;
-}
-
-int main( int argc, char* argv[] ) {
-    return ::boost::unit_test::unit_test_main( &init_function, argc, argv );
-}
-
-#endif

From 45d5750198a642e74f5e125da811d1873126e9c6 Mon Sep 17 00:00:00 2001
From: Luigi Ballabio <luigi.ballabio@gmail.com>
Date: Tue, 19 Dec 2023 09:20:49 +0100
Subject: [PATCH 3/4] Use autogenerated initializer function

---
 test-suite/CMakeLists.txt         |  1 +
 test-suite/paralleltestrunner.hpp |  4 ++--
 test-suite/quantlibtestsuite.cpp  | 12 ++----------
 test-suite/testsuite.vcxproj      |  4 +++-
 4 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/test-suite/CMakeLists.txt b/test-suite/CMakeLists.txt
index 0e5f0e56d8c..c26feddaeaf 100644
--- a/test-suite/CMakeLists.txt
+++ b/test-suite/CMakeLists.txt
@@ -214,6 +214,7 @@ set(QL_BENCHMARK_SOURCES
 if (QL_BUILD_TEST_SUITE)
     add_executable(ql_test_suite ${QL_TEST_SOURCES} ${QL_TEST_HEADERS})
     set_target_properties(ql_test_suite PROPERTIES OUTPUT_NAME "quantlib-test-suite")
+    set_source_files_properties(quantlibtestsuite.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION true)
     if (NOT Boost_USE_STATIC_LIBS)
         target_compile_definitions(ql_test_suite PRIVATE BOOST_ALL_DYN_LINK)
     endif()
diff --git a/test-suite/paralleltestrunner.hpp b/test-suite/paralleltestrunner.hpp
index f343af95cee..df77bb94033 100755
--- a/test-suite/paralleltestrunner.hpp
+++ b/test-suite/paralleltestrunner.hpp
@@ -88,8 +88,8 @@ namespace {
         bool visit(test_unit const& tu) {
             if (tu.p_parent_id == framework::master_test_suite().p_id) {
                 BOOST_TEST_MESSAGE(tu.p_name.get());
-                QL_REQUIRE(!tu.p_name.get().compare("QuantLibTests") or !tu.p_name.get().compare("QuantLib test suite"),
-                     "could not find QuantLib test suite");
+                QL_REQUIRE(!tu.p_name.get().compare("QuantLibTests"),
+                           "could not find QuantLib test suite");
 
                 testSuiteId_ = tu.p_id;
             }
diff --git a/test-suite/quantlibtestsuite.cpp b/test-suite/quantlibtestsuite.cpp
index bb2cdd7c6c4..18ff8baaa80 100644
--- a/test-suite/quantlibtestsuite.cpp
+++ b/test-suite/quantlibtestsuite.cpp
@@ -18,6 +18,8 @@
  FOR A PARTICULAR PURPOSE.  See the license for more details.
 */
 
+#define BOOST_TEST_MODULE QuantLibTests
+
 #ifdef QL_ENABLE_PARALLEL_UNIT_TEST_RUNNER
 #include "paralleltestrunner.hpp"
 #else
@@ -31,13 +33,3 @@
 #  include <ql/auto_link.hpp>
 #endif
 
-#include "quantlibglobalfixture.hpp"
-
-using namespace boost::unit_test_framework;
-
-test_suite* init_unit_test_suite(int, char* []) {
-
-    auto* test = BOOST_TEST_SUITE("QuantLib test suite");
-
-    return test;
-}
diff --git a/test-suite/testsuite.vcxproj b/test-suite/testsuite.vcxproj
index b9fa64738c0..82ab01a4c24 100644
--- a/test-suite/testsuite.vcxproj
+++ b/test-suite/testsuite.vcxproj
@@ -808,7 +808,9 @@
     <ClCompile Include="xoshiro256starstar.cpp" />
     <ClCompile Include="zabr.cpp" />
     <ClCompile Include="zerocouponswap.cpp" />
-    <ClCompile Include="quantlibtestsuite.cpp" />
+    <ClCompile Include="quantlibtestsuite.cpp">
+      <IncludeInUnityFile>false</IncludeInUnityFile>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="paralleltestrunner.hpp" />

From 7dd751cdd29d6e1870a73eb662f4b60843c0774b Mon Sep 17 00:00:00 2001
From: Luigi Ballabio <luigi.ballabio@gmail.com>
Date: Tue, 19 Dec 2023 15:48:39 +0100
Subject: [PATCH 4/4] Fix typo

---
 acinclude.m4 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/acinclude.m4 b/acinclude.m4
index 6c0cfec0593..d361a8e9023 100644
--- a/acinclude.m4
+++ b/acinclude.m4
@@ -113,7 +113,7 @@ AC_DEFUN([QL_CHECK_BOOST_VERSION_1_59_OR_HIGHER],
     ])
 ])
 
-# QL_CHECK_BOOST_UNIT§_TEST
+# QL_CHECK_BOOST_UNIT_TEST
 # ------------------------
 # Check whether the Boost unit-test framework is available
 AC_DEFUN([QL_CHECK_BOOST_UNIT_TEST],