From 909f7c66626bab00a3402fa5fc6b7387d6721409 Mon Sep 17 00:00:00 2001
From: Luigi Ballabio <luigi.ballabio@gmail.com>
Date: Fri, 19 Feb 2021 23:34:21 +0100
Subject: [PATCH 1/3] Use initializer lists to create test data

---
 test-suite/andreasenhugevolatilityinterpl.cpp |  12 +-
 test-suite/barrieroption.cpp                  |   7 +-
 test-suite/basismodels.cpp                    |  65 ++---
 test-suite/basketoption.cpp                   |  23 +-
 test-suite/brownianbridge.cpp                 |  31 +--
 test-suite/capfloor.cpp                       |  27 +-
 test-suite/cms.cpp                            |  61 ++---
 test-suite/covariance.cpp                     |  19 +-
 test-suite/creditdefaultswap.cpp              | 120 ++++----
 test-suite/curvestates.cpp                    |   3 -
 test-suite/daycounters.cpp                    |  37 ++-
 test-suite/defaultprobabilitycurves.cpp       |  26 +-
 test-suite/dividendoption.cpp                 |  29 +-
 test-suite/europeanoption.cpp                 |  19 +-
 test-suite/fdmlinearop.cpp                    | 137 ++++------
 test-suite/forwardrateagreement.cpp           |   9 +-
 test-suite/hestonmodel.cpp                    |  63 ++---
 test-suite/hestonslvmodel.cpp                 |  38 ++-
 test-suite/hybridhestonhullwhiteprocess.cpp   |  55 ++--
 test-suite/inflation.cpp                      |  24 +-
 test-suite/inflationcapfloor.cpp              |  30 +-
 test-suite/inflationcapflooredcoupon.cpp      |  12 +-
 test-suite/inflationcpibond.cpp               |  12 +-
 test-suite/inflationcpiswap.cpp               |   3 +-
 test-suite/inflationvolatility.cpp            |   4 -
 test-suite/interpolations.cpp                 | 170 +++++-------
 test-suite/libormarketmodel.cpp               |  16 +-
 test-suite/libormarketmodelprocess.cpp        |   8 +-
 test-suite/linearleastsquaresregression.cpp   |  36 +--
 test-suite/margrabeoption.cpp                 |  12 +-
 test-suite/marketmodel.cpp                    |   3 -
 test-suite/marketmodel_cms.cpp                |   3 -
 test-suite/marketmodel_smm.cpp                |   3 -
 .../marketmodel_smmcapletalphacalibration.cpp |   3 -
 .../marketmodel_smmcapletcalibration.cpp      |   3 -
 .../marketmodel_smmcaplethomocalibration.cpp  |   3 -
 test-suite/markovfunctional.cpp               | 258 +++++++-----------
 test-suite/nthtodefault.cpp                   |  22 +-
 test-suite/observable.cpp                     |  15 +-
 test-suite/optimizers.cpp                     |  97 +++----
 test-suite/optionletstripper.cpp              | 229 ++++++++--------
 .../piecewisezerospreadedtermstructure.cpp    | 109 +++-----
 test-suite/rangeaccrual.cpp                   | 147 +++-------
 test-suite/riskneutraldensitycalculator.cpp   |  19 +-
 test-suite/schedule.cpp                       |  14 +-
 test-suite/shortratemodels.cpp                |  10 +-
 test-suite/swapforwardmappings.cpp            |   3 -
 test-suite/termstructures.cpp                 | 115 ++------
 test-suite/timegrid.cpp                       |  63 +----
 test-suite/timeseries.cpp                     |  32 +--
 test-suite/utilities.hpp                      |   2 +-
 test-suite/vpp.cpp                            |  24 +-
 52 files changed, 873 insertions(+), 1412 deletions(-)

diff --git a/test-suite/andreasenhugevolatilityinterpl.cpp b/test-suite/andreasenhugevolatilityinterpl.cpp
index 4e1b3d61c91..a1b779566b3 100644
--- a/test-suite/andreasenhugevolatilityinterpl.cpp
+++ b/test-suite/andreasenhugevolatilityinterpl.cpp
@@ -147,9 +147,7 @@ namespace andreasen_huge_volatility_interpl_test {
             }
         }
 
-        CalibrationData data = { spot, rTS, qTS, calibrationSet };
-
-        return data;
+        return { spot, rTS, qTS, calibrationSet };
     }
 
     void testAndreasenHugeVolatilityInterpolation(
@@ -346,9 +344,7 @@ namespace andreasen_huge_volatility_interpl_test {
                 ext::make_shared<SimpleQuote>(vol)));
         }
 
-        CalibrationData data = { spot, rTS, qTS, calibrationSet };
-
-        return data;
+        return { spot, rTS, qTS, calibrationSet };
     }
 }
 
@@ -1030,8 +1026,8 @@ void AndreasenHugeVolatilityInterplTest::testFlatVolCalibration() {
         const Time t = rTS->timeFromReference(expiry);
         const Real fwd = spot->value() / rTS->discount(t) * qTS->discount(t);
 
-        for (double moneynes : moneyness) {
-            const Real strike = fwd * moneynes;
+        for (double m : moneyness) {
+            const Real strike = fwd * m;
             const Real mn = std::log(fwd/strike)/std::sqrt(t);
 
             if (std::fabs(mn) < 3.72*vol->value()) {
diff --git a/test-suite/barrieroption.cpp b/test-suite/barrieroption.cpp
index 76ac7fb6189..3187e938336 100644
--- a/test-suite/barrieroption.cpp
+++ b/test-suite/barrieroption.cpp
@@ -794,11 +794,10 @@ void BarrierOptionTest::testLocalVolAndHestonComparison() {
 
     const Handle<Quote> s0(ext::make_shared<SimpleQuote>(4500.00));
     
-    Real tmp[] = { 100 ,500 ,2000,3400,3600,3800,4000,4200,4400,4500,
-                   4600,4800,5000,5200,5400,5600,7500,10000,20000,30000 };
-    const std::vector<Real> strikes(tmp, tmp+LENGTH(tmp));
+    const std::vector<Real> strikes = { 100 ,500 ,2000,3400,3600,3800,4000,4200,4400,4500,
+                                        4600,4800,5000,5200,5400,5600,7500,10000,20000,30000 };
     
-    Volatility v[] =
+    const std::vector<Volatility> v =
       { 1.015873, 1.015873, 1.015873, 0.89729, 0.796493, 0.730914, 0.631335, 0.568895,
         0.711309, 0.711309, 0.711309, 0.641309, 0.635593, 0.583653, 0.508045, 0.463182,
         0.516034, 0.500534, 0.500534, 0.500534, 0.448706, 0.416661, 0.375470, 0.353442,
diff --git a/test-suite/basismodels.cpp b/test-suite/basismodels.cpp
index 721dda4ca8d..524d5a83125 100644
--- a/test-suite/basismodels.cpp
+++ b/test-suite/basismodels.cpp
@@ -87,27 +87,6 @@ namespace {
     Real capletStrikesData[] = {-0.0050, 0.0000, 0.0050, 0.0100, 0.0150, 0.0200, 0.0300, 0.0500};
     std::vector<Real> capletStrikes(capletStrikesData, capletStrikesData + 8);
 
-    Real cplRow01[] = {0.003010094, 0.002628065, 0.00456118,  0.006731268,
-                       0.008678572, 0.010570881, 0.014149552, 0.021000638};
-    Real cplRow02[] = {0.004173715, 0.003727039, 0.004180263, 0.005726083,
-                       0.006905876, 0.008263514, 0.010555395, 0.014976523};
-    Real cplRow03[] = {0.005870143, 0.005334526, 0.005599775, 0.006633987,
-                       0.007773317, 0.009036581, 0.011474391, 0.016277549};
-    Real cplRow04[] = {0.007458597, 0.007207522, 0.007263995, 0.007308727,
-                       0.007813586, 0.008274858, 0.009743988, 0.012555171};
-    Real cplRow05[] = {0.007711531, 0.007608826, 0.007572816, 0.007684107,
-                       0.007971932, 0.008283118, 0.009268828, 0.011574083};
-    Real cplRow06[] = {0.007619605, 0.007639059, 0.007719825, 0.007823373,
-                       0.00800813,  0.008113384, 0.008616374, 0.009785436};
-    Real cplRow07[] = {0.007312199, 0.007352993, 0.007369116, 0.007468333,
-                       0.007515657, 0.00767695,  0.008020447, 0.009072769};
-    Real cplRow08[] = {0.006905851, 0.006966315, 0.007056413, 0.007116494,
-                       0.007259661, 0.00733308,  0.007667563, 0.008419696};
-    Real cplRow09[] = {0.006529553, 0.006630731, 0.006749022, 0.006858027,
-                       0.007001959, 0.007139097, 0.007390404, 0.008036255};
-    Real cplRow10[] = {0.006225482, 0.006404012, 0.00651594,  0.006642273,
-                       0.006640887, 0.006885713, 0.007093024, 0.00767373};
-
 
     Handle<OptionletVolatilityStructure> getOptionletTS() {
         Date today = Settings::instance().evaluationDate();
@@ -116,17 +95,19 @@ namespace {
         for (auto& capletTerm : capletTerms)
             dates.push_back(TARGET().advance(today, capletTerm, Following));
         // set up vol data manually
-        std::vector<std::vector<Real> > capletVols;
-        capletVols.emplace_back(cplRow01, cplRow01 + 8);
-        capletVols.emplace_back(cplRow02, cplRow02 + 8);
-        capletVols.emplace_back(cplRow03, cplRow03 + 8);
-        capletVols.emplace_back(cplRow04, cplRow04 + 8);
-        capletVols.emplace_back(cplRow05, cplRow05 + 8);
-        capletVols.emplace_back(cplRow06, cplRow06 + 8);
-        capletVols.emplace_back(cplRow07, cplRow07 + 8);
-        capletVols.emplace_back(cplRow08, cplRow08 + 8);
-        capletVols.emplace_back(cplRow09, cplRow09 + 8);
-        capletVols.emplace_back(cplRow10, cplRow10 + 8);
+        std::vector<std::vector<Real> > capletVols =
+        {
+         {0.003010094, 0.002628065, 0.00456118,  0.006731268, 0.008678572, 0.010570881, 0.014149552, 0.021000638},
+         {0.004173715, 0.003727039, 0.004180263, 0.005726083, 0.006905876, 0.008263514, 0.010555395, 0.014976523},
+         {0.005870143, 0.005334526, 0.005599775, 0.006633987, 0.007773317, 0.009036581, 0.011474391, 0.016277549},
+         {0.007458597, 0.007207522, 0.007263995, 0.007308727, 0.007813586, 0.008274858, 0.009743988, 0.012555171},
+         {0.007711531, 0.007608826, 0.007572816, 0.007684107, 0.007971932, 0.008283118, 0.009268828, 0.011574083},
+         {0.007619605, 0.007639059, 0.007719825, 0.007823373, 0.00800813,  0.008113384, 0.008616374, 0.009785436},
+         {0.007312199, 0.007352993, 0.007369116, 0.007468333, 0.007515657, 0.00767695,  0.008020447, 0.009072769},
+         {0.006905851, 0.006966315, 0.007056413, 0.007116494, 0.007259661, 0.00733308,  0.007667563, 0.008419696},
+         {0.006529553, 0.006630731, 0.006749022, 0.006858027, 0.007001959, 0.007139097, 0.007390404, 0.008036255},
+         {0.006225482, 0.006404012, 0.00651594,  0.006642273, 0.006640887, 0.006885713, 0.007093024, 0.00767373}
+        };
         // create quotes
         std::vector<std::vector<Handle<Quote> > > capletVolQuotes;
         for (auto& capletVol : capletVols) {
@@ -150,19 +131,15 @@ namespace {
     };
     std::vector<Period> swaptionVTSTerms(swaptionVTSTermsData, swaptionVTSTermsData + 5);
 
-    Real swtRow01[] = {0.002616, 0.00468, 0.0056, 0.005852, 0.005823};
-    Real swtRow02[] = {0.006213, 0.00643, 0.006622, 0.006124, 0.005958};
-    Real swtRow03[] = {0.006658, 0.006723, 0.006602, 0.005802, 0.005464};
-    Real swtRow04[] = {0.005728, 0.005814, 0.005663, 0.004689, 0.004276};
-    Real swtRow05[] = {0.005041, 0.005059, 0.004746, 0.003927, 0.003608};
-
     Handle<SwaptionVolatilityStructure> getSwaptionVTS() {
-        std::vector<std::vector<Real> > swaptionVols;
-        swaptionVols.emplace_back(swtRow01, swtRow01 + 5);
-        swaptionVols.emplace_back(swtRow02, swtRow02 + 5);
-        swaptionVols.emplace_back(swtRow03, swtRow03 + 5);
-        swaptionVols.emplace_back(swtRow04, swtRow04 + 5);
-        swaptionVols.emplace_back(swtRow05, swtRow05 + 5);
+        std::vector<std::vector<Real> > swaptionVols =
+            {
+             {0.002616, 0.00468, 0.0056, 0.005852, 0.005823},
+             {0.006213, 0.00643, 0.006622, 0.006124, 0.005958},
+             {0.006658, 0.006723, 0.006602, 0.005802, 0.005464},
+             {0.005728, 0.005814, 0.005663, 0.004689, 0.004276},
+             {0.005041, 0.005059, 0.004746, 0.003927, 0.003608}
+            };
         std::vector<std::vector<Handle<Quote> > > swaptionVolQuotes;
         for (auto& swaptionVol : swaptionVols) {
             std::vector<Handle<Quote> > row;
diff --git a/test-suite/basketoption.cpp b/test-suite/basketoption.cpp
index cd7718d2578..48f09d0957c 100644
--- a/test-suite/basketoption.cpp
+++ b/test-suite/basketoption.cpp
@@ -323,9 +323,7 @@ void BasketOptionTest::testEuroTwoValues() {
                 QL_FAIL("unknown basket type");
         }
 
-        std::vector<ext::shared_ptr<StochasticProcess1D> > procs;
-        procs.push_back(p1);
-        procs.push_back(p2);
+        std::vector<ext::shared_ptr<StochasticProcess1D> > procs = { p1, p2 };
 
         Matrix correlationMatrix(2, 2, value.rho);
         for (Integer j=0; j < 2; j++) {
@@ -521,10 +519,8 @@ void BasketOptionTest::testBarraquandThreeValues() {
                                       Handle<YieldTermStructure>(rTS),
                                       Handle<BlackVolTermStructure>(volTS3)));
 
-        std::vector<ext::shared_ptr<StochasticProcess1D> > procs;
-        procs.push_back(stochProcess1);
-        procs.push_back(stochProcess2);
-        procs.push_back(stochProcess3);
+        std::vector<ext::shared_ptr<StochasticProcess1D> > procs
+            = {stochProcess1, stochProcess2, stochProcess3 };
 
         Matrix correlation(3, 3, value.rho);
         for (Integer j=0; j < 3; j++) {
@@ -658,10 +654,9 @@ void BasketOptionTest::testTavellaValues() {
                                   Handle<YieldTermStructure>(rTS),
                                   Handle<BlackVolTermStructure>(volTS3)));
 
-    std::vector<ext::shared_ptr<StochasticProcess1D> > procs;
-    procs.push_back(stochProcess1);
-    procs.push_back(stochProcess2);
-    procs.push_back(stochProcess3);
+    std::vector<ext::shared_ptr<StochasticProcess1D> > procs = {stochProcess1,
+                                                                stochProcess2,
+                                                                stochProcess3};
 
     Matrix correlation(3,3, 0.0);
     for (Integer j=0; j < 3; j++) {
@@ -775,8 +770,7 @@ void BasketOptionTest::testOneDAmericanValues(std::size_t from, std::size_t to)
                                   Handle<YieldTermStructure>(rTS),
                                   Handle<BlackVolTermStructure>(volTS1)));
 
-    std::vector<ext::shared_ptr<StochasticProcess1D> > procs;
-    procs.push_back(stochProcess1);
+    std::vector<ext::shared_ptr<StochasticProcess1D> > procs = {stochProcess1};
 
     Matrix correlation(1, 1, 1.0);
 
@@ -863,8 +857,7 @@ void BasketOptionTest::testOddSamples() {
                                   Handle<YieldTermStructure>(rTS),
                                   Handle<BlackVolTermStructure>(volTS1)));
 
-    std::vector<ext::shared_ptr<StochasticProcess1D> > procs;
-    procs.push_back(stochProcess1);
+    std::vector<ext::shared_ptr<StochasticProcess1D> > procs = {stochProcess1};
 
     Matrix correlation(1, 1, 1.0);
 
diff --git a/test-suite/brownianbridge.cpp b/test-suite/brownianbridge.cpp
index 7ef783ea094..99f097c2ad3 100644
--- a/test-suite/brownianbridge.cpp
+++ b/test-suite/brownianbridge.cpp
@@ -62,19 +62,7 @@ namespace {
 void BrownianBridgeTest::testVariates() {
     BOOST_TEST_MESSAGE("Testing Brownian-bridge variates...");
 
-    std::vector<Time> times;
-    times.push_back(0.1);
-    times.push_back(0.2);
-    times.push_back(0.3);
-    times.push_back(0.4);
-    times.push_back(0.5);
-    times.push_back(0.6);
-    times.push_back(0.7);
-    times.push_back(0.8);
-    times.push_back(0.9);
-    times.push_back(1.0);
-    times.push_back(2.0);
-    times.push_back(5.0);
+    std::vector<Time> times = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 2.0, 5.0};
 
     Size N = times.size();
 
@@ -179,22 +167,7 @@ void BrownianBridgeTest::testVariates() {
 void BrownianBridgeTest::testPathGeneration() {
     BOOST_TEST_MESSAGE("Testing Brownian-bridge path generation...");
 
-    std::vector<Time> times;
-    times.push_back(0.1);
-    times.push_back(0.2);
-    times.push_back(0.3);
-    times.push_back(0.4);
-    times.push_back(0.5);
-    times.push_back(0.6);
-    times.push_back(0.7);
-    times.push_back(0.8);
-    times.push_back(0.9);
-    times.push_back(1.0);
-    times.push_back(2.0);
-    times.push_back(5.0);
-    times.push_back(7.0);
-    times.push_back(9.0);
-    times.push_back(10.0);
+    std::vector<Time> times = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 2.0, 5.0, 7.0, 9.0, 10.0};
 
     TimeGrid grid(times.begin(), times.end());
 
diff --git a/test-suite/capfloor.cpp b/test-suite/capfloor.cpp
index e0606105ece..faf362fe31e 100644
--- a/test-suite/capfloor.cpp
+++ b/test-suite/capfloor.cpp
@@ -169,16 +169,15 @@ void CapFloorTest::testVega() {
     static const Real tolerance = 0.005;
 
     for (int length : lengths) {
-        for (Size j=0; j<LENGTH(vols); j++) {
+        for (double vol : vols) {
             for (double strike : strikes) {
                 for (auto& type : types) {
                     Leg leg = vars.makeLeg(startDate, length);
-                    ext::shared_ptr<CapFloor> capFloor =
-                        vars.makeCapFloor(type, leg, strike, vols[j]);
+                    ext::shared_ptr<CapFloor> capFloor = vars.makeCapFloor(type, leg, strike, vol);
                     ext::shared_ptr<CapFloor> shiftedCapFloor2 =
-                        vars.makeCapFloor(type, leg, strike, vols[j] + shift);
+                        vars.makeCapFloor(type, leg, strike, vol + shift);
                     ext::shared_ptr<CapFloor> shiftedCapFloor1 =
-                        vars.makeCapFloor(type, leg, strike, vols[j] - shift);
+                        vars.makeCapFloor(type, leg, strike, vol - shift);
                     Real value1 = shiftedCapFloor1->NPV();
                     Real value2 = shiftedCapFloor2->NPV();
                     Real numericalVega = (value2 - value1) / (2*shift);
@@ -189,7 +188,7 @@ void CapFloorTest::testVega() {
                         discrepancy /= numericalVega;
                         if (discrepancy > tolerance)
                             BOOST_FAIL("failed to compute cap/floor vega:"
-                                       << "\n   lengths:     " << lengths[j] * Years
+                                       << "\n   lengths:     " << length * Years
                                        << "\n   strike:      " << io::rate(strike) <<
                                        //"\n   types:       " << types[h] <<
                                        std::fixed << std::setprecision(12) << "\n   calculated:  "
@@ -275,16 +274,16 @@ void CapFloorTest::testConsistency() {
     Date startDate = vars.termStructure->referenceDate();
 
     for (int& length : lengths) {
-        for (Size j = 0; j < LENGTH(cap_rates); j++) {
+        for (double& cap_rate : cap_rates) {
             for (double& floor_rate : floor_rates) {
                 for (double vol : vols) {
 
                     Leg leg = vars.makeLeg(startDate, length);
                     ext::shared_ptr<CapFloor> cap =
-                        vars.makeCapFloor(CapFloor::Cap, leg, cap_rates[j], vol);
+                        vars.makeCapFloor(CapFloor::Cap, leg, cap_rate, vol);
                     ext::shared_ptr<CapFloor> floor =
                         vars.makeCapFloor(CapFloor::Floor, leg, floor_rate, vol);
-                    Collar collar(leg, std::vector<Rate>(1, cap_rates[j]),
+                    Collar collar(leg, std::vector<Rate>(1, cap_rate),
                                   std::vector<Rate>(1, floor_rate));
                     collar.setPricingEngine(vars.makeEngine(vol));
 
@@ -293,7 +292,7 @@ void CapFloorTest::testConsistency() {
                                    << "    length:       " << length << " years\n"
                                    << "    volatility:   " << io::volatility(vol) << "\n"
                                    << "    cap value:    " << cap->NPV()
-                                   << " at strike: " << io::rate(cap_rates[j]) << "\n"
+                                   << " at strike: " << io::rate(cap_rate) << "\n"
                                    << "    floor value:  " << floor->NPV()
                                    << " at strike: " << io::rate(floor_rate) << "\n"
                                    << "    collar value: " << collar.NPV());
@@ -313,7 +312,7 @@ void CapFloorTest::testConsistency() {
                                        << "    length:       " << length << " years\n"
                                        << "    volatility:   " << io::volatility(vol) << "\n"
                                        << "    cap value:    " << cap->NPV()
-                                       << " at strike: " << io::rate(cap_rates[j]) << "\n"
+                                       << " at strike: " << io::rate(cap_rate) << "\n"
                                        << "    sum of caplets value:  " << capletsNPV
                                        << " at strike (first): "
                                        << io::rate(caplets[0]->capRates()[0]) << "\n");
@@ -332,7 +331,7 @@ void CapFloorTest::testConsistency() {
                                        << "    length:       " << length << " years\n"
                                        << "    volatility:   " << io::volatility(vol) << "\n"
                                        << "    cap value:    " << floor->NPV()
-                                       << " at strike: " << io::rate(floor_rates[j]) << "\n"
+                                       << " at strike: " << io::rate(floor_rate) << "\n"
                                        << "    sum of floorlets value:  " << floorletsNPV
                                        << " at strike (first): "
                                        << io::rate(floorlets[0]->floorRates()[0]) << "\n");
@@ -351,8 +350,8 @@ void CapFloorTest::testConsistency() {
                                        << "    length:       " << length << " years\n"
                                        << "    volatility:   " << io::volatility(vol) << "\n"
                                        << "    cap value:    " << collar.NPV()
-                                       << " at strike floor: " << io::rate(floor_rates[j])
-                                       << " at strike cap: " << io::rate(cap_rates[j]) << "\n"
+                                       << " at strike floor: " << io::rate(floor_rate)
+                                       << " at strike cap: " << io::rate(cap_rate) << "\n"
                                        << "    sum of collarlets value:  " << collarletsNPV
                                        << " at strike floor (first): "
                                        << io::rate(collarlets[0]->floorRates()[0])
diff --git a/test-suite/cms.cpp b/test-suite/cms.cpp
index 07d61d9893d..9cade6bfdd4 100644
--- a/test-suite/cms.cpp
+++ b/test-suite/cms.cpp
@@ -74,19 +74,10 @@ namespace cms_test {
                                           Actual365Fixed()));
 
             // ATM Volatility structure
-            std::vector<Period> atmOptionTenors;
-            atmOptionTenors.emplace_back(1, Months);
-            atmOptionTenors.emplace_back(6, Months);
-            atmOptionTenors.emplace_back(1, Years);
-            atmOptionTenors.emplace_back(5, Years);
-            atmOptionTenors.emplace_back(10, Years);
-            atmOptionTenors.emplace_back(30, Years);
-
-            std::vector<Period> atmSwapTenors;
-            atmSwapTenors.emplace_back(1, Years);
-            atmSwapTenors.emplace_back(5, Years);
-            atmSwapTenors.emplace_back(10, Years);
-            atmSwapTenors.emplace_back(30, Years);
+            std::vector<Period> atmOptionTenors = {1 * Months, 6 * Months, 1 * Years,
+                                                   5 * Years,  10 * Years, 30 * Years};
+
+            std::vector<Period> atmSwapTenors = {1 * Years, 5 * Years, 10 * Years, 30 * Years};
 
             Matrix m(atmOptionTenors.size(), atmSwapTenors.size());
             m[0][0]=0.1300; m[0][1]=0.1560; m[0][2]=0.1390; m[0][3]=0.1220;
@@ -106,22 +97,9 @@ namespace cms_test {
                                              Actual365Fixed())));
 
             // Vol cubes
-            std::vector<Period> optionTenors;
-            optionTenors.emplace_back(1, Years);
-            optionTenors.emplace_back(10, Years);
-            optionTenors.emplace_back(30, Years);
-
-            std::vector<Period> swapTenors;
-            swapTenors.emplace_back(2, Years);
-            swapTenors.emplace_back(10, Years);
-            swapTenors.emplace_back(30, Years);
-
-            std::vector<Spread> strikeSpreads;
-            strikeSpreads.push_back(-0.020);
-            strikeSpreads.push_back(-0.005);
-            strikeSpreads.push_back(+0.000);
-            strikeSpreads.push_back(+0.005);
-            strikeSpreads.push_back(+0.020);
+            std::vector<Period> optionTenors = {{1, Years}, {10, Years}, {30, Years}};
+            std::vector<Period> swapTenors = {{2, Years}, {10, Years}, {30, Years}};
+            std::vector<Spread> strikeSpreads = {-0.020, -0.005, 0.000, 0.005, 0.020};
 
             Size nRows = optionTenors.size()*swapTenors.size();
             Size nCols = strikeSpreads.size();
@@ -241,14 +219,13 @@ namespace cms_test {
                                      isAtmCalibrated)));
             SabrVolCube1->enableExtrapolation();
 
-            yieldCurveModels.clear();
-            yieldCurveModels.push_back(GFunctionFactory::Standard);
-            yieldCurveModels.push_back(GFunctionFactory::ExactYield);
-            yieldCurveModels.push_back(GFunctionFactory::ParallelShifts);
-            yieldCurveModels.push_back(GFunctionFactory::NonParallelShifts);
-            yieldCurveModels.push_back(GFunctionFactory::NonParallelShifts); // for linear tsr model
+            yieldCurveModels = {GFunctionFactory::Standard,
+                                GFunctionFactory::ExactYield,
+                                GFunctionFactory::ParallelShifts,
+                                GFunctionFactory::NonParallelShifts,
+                                GFunctionFactory::NonParallelShifts};
 
-            Handle<Quote> zeroMeanRev(ext::shared_ptr<Quote>(new SimpleQuote(0.0)));
+            Handle<Quote> zeroMeanRev(ext::make_shared<SimpleQuote>(0.0));
 
             numericalPricers.clear();
             analyticPricers.clear();
@@ -358,11 +335,7 @@ void CmsTest::testCmsSwap() {
     //ext::shared_ptr<SwapIndex> swapIndex(new
     //    EuriborSwapIsdaFixA(10*Years, vars.iborIndex->termStructure()));
     Spread spread = 0.0;
-    std::vector<Size> swapLengths;
-    swapLengths.push_back(1);
-    swapLengths.push_back(5);
-    swapLengths.push_back(6);
-    swapLengths.push_back(10);
+    std::vector<Size> swapLengths = {1, 5, 6, 10};
     Size n = swapLengths.size();
     std::vector<ext::shared_ptr<Swap> > cms(n);
     for (Size i=0; i<n; ++i)
@@ -412,10 +385,8 @@ void CmsTest::testParity() {
 
     CommonVars vars;
 
-    std::vector<Handle<SwaptionVolatilityStructure> > swaptionVols;
-    swaptionVols.push_back(vars.atmVol);
-    swaptionVols.push_back(vars.SabrVolCube1);
-    swaptionVols.push_back(vars.SabrVolCube2);
+    std::vector<Handle<SwaptionVolatilityStructure> > swaptionVols = {
+                           vars.atmVol, vars.SabrVolCube1, vars.SabrVolCube2};
 
     ext::shared_ptr<SwapIndex> swapIndex(new
         EuriborSwapIsdaFixA(10*Years,
diff --git a/test-suite/covariance.cpp b/test-suite/covariance.cpp
index 8165096c21a..4a323b3d373 100644
--- a/test-suite/covariance.cpp
+++ b/test-suite/covariance.cpp
@@ -159,15 +159,16 @@ void CovarianceTest::testCovariance() {
 
     BOOST_TEST_MESSAGE("Testing covariance and correlation calculations...");
 
-    Real data00[] = { 3.0,  9.0 };
-    Real data01[] = { 2.0,  7.0 };
-    Real data02[] = { 4.0, 12.0 };
-    Real data03[] = { 5.0, 15.0 };
-    Real data04[] = { 6.0, 17.0 };
-    Real* data[5] = { data00, data01, data02, data03, data04 };
-    std::vector<Real> weights(LENGTH(data), 1.0);
+    std::vector<std::vector<Real>> data = {
+        { 3.0,  9.0 },
+        { 2.0,  7.0 },
+        { 4.0, 12.0 },
+        { 5.0, 15.0 },
+        { 6.0, 17.0 }
+    };
+    std::vector<Real> weights(data.size(), 1.0);
 
-    Size i, j, n = LENGTH(data00);
+    Size i, j, n = data[0].size();
 
     Matrix expCor(n, n);
     expCor[0][0] = 1.0000000000000000; expCor[0][1] = 0.9970544855015813;
@@ -176,7 +177,7 @@ void CovarianceTest::testCovariance() {
     SequenceStatistics s(n);
     std::vector<Real> temp(n);
 
-    for (i = 0; i<LENGTH(data); i++) {
+    for (i = 0; i<data.size(); i++) {
         for (j=0; j<n; j++) {
             temp[j]= data[i][j];
         }
diff --git a/test-suite/creditdefaultswap.cpp b/test-suite/creditdefaultswap.cpp
index 39a6e282b66..759b292c084 100644
--- a/test-suite/creditdefaultswap.cpp
+++ b/test-suite/creditdefaultswap.cpp
@@ -176,43 +176,45 @@ void CreditDefaultSwapTest::testCachedMarketValue() {
     Date evalDate = Settings::instance().evaluationDate();
     Calendar calendar = UnitedStates();
 
-    std::vector<Date> discountDates;
-    discountDates.push_back(evalDate);
-    discountDates.push_back(calendar.advance(evalDate, 1, Weeks,  ModifiedFollowing));
-    discountDates.push_back(calendar.advance(evalDate, 1, Months, ModifiedFollowing));
-    discountDates.push_back(calendar.advance(evalDate, 2, Months, ModifiedFollowing));
-    discountDates.push_back(calendar.advance(evalDate, 3, Months, ModifiedFollowing));
-    discountDates.push_back(calendar.advance(evalDate, 6, Months, ModifiedFollowing));
-    discountDates.push_back(calendar.advance(evalDate,12, Months, ModifiedFollowing));
-    discountDates.push_back(calendar.advance(evalDate, 2, Years, ModifiedFollowing));
-    discountDates.push_back(calendar.advance(evalDate, 3, Years, ModifiedFollowing));
-    discountDates.push_back(calendar.advance(evalDate, 4, Years, ModifiedFollowing));
-    discountDates.push_back(calendar.advance(evalDate, 5, Years, ModifiedFollowing));
-    discountDates.push_back(calendar.advance(evalDate, 6, Years, ModifiedFollowing));
-    discountDates.push_back(calendar.advance(evalDate, 7, Years, ModifiedFollowing));
-    discountDates.push_back(calendar.advance(evalDate, 8, Years, ModifiedFollowing));
-    discountDates.push_back(calendar.advance(evalDate, 9, Years, ModifiedFollowing));
-    discountDates.push_back(calendar.advance(evalDate,10, Years, ModifiedFollowing));
-    discountDates.push_back(calendar.advance(evalDate,15, Years, ModifiedFollowing));
-
-    std::vector<DiscountFactor> dfs;
-    dfs.push_back(1.0);
-    dfs.push_back(0.9990151375768731);
-    dfs.push_back(0.99570502636871183);
-    dfs.push_back(0.99118260474528685);
-    dfs.push_back(0.98661167950906203);
-    dfs.push_back(0.9732592953359388 );
-    dfs.push_back(0.94724424481038083);
-    dfs.push_back(0.89844996737120875  );
-    dfs.push_back(0.85216647839921411  );
-    dfs.push_back(0.80775477692556874  );
-    dfs.push_back(0.76517289234200347  );
-    dfs.push_back(0.72401019553182933  );
-    dfs.push_back(0.68503909569219212  );
-    dfs.push_back(0.64797499814013748  );
-    dfs.push_back(0.61263171936255534  );
-    dfs.push_back(0.5791942350748791   );
-    dfs.push_back(0.43518868769953606  );
+    std::vector<Date> discountDates = {
+        evalDate,
+        calendar.advance(evalDate, 1, Weeks,  ModifiedFollowing),
+        calendar.advance(evalDate, 1, Months, ModifiedFollowing),
+        calendar.advance(evalDate, 2, Months, ModifiedFollowing),
+        calendar.advance(evalDate, 3, Months, ModifiedFollowing),
+        calendar.advance(evalDate, 6, Months, ModifiedFollowing),
+        calendar.advance(evalDate,12, Months, ModifiedFollowing),
+        calendar.advance(evalDate, 2, Years, ModifiedFollowing),
+        calendar.advance(evalDate, 3, Years, ModifiedFollowing),
+        calendar.advance(evalDate, 4, Years, ModifiedFollowing),
+        calendar.advance(evalDate, 5, Years, ModifiedFollowing),
+        calendar.advance(evalDate, 6, Years, ModifiedFollowing),
+        calendar.advance(evalDate, 7, Years, ModifiedFollowing),
+        calendar.advance(evalDate, 8, Years, ModifiedFollowing),
+        calendar.advance(evalDate, 9, Years, ModifiedFollowing),
+        calendar.advance(evalDate,10, Years, ModifiedFollowing),
+        calendar.advance(evalDate,15, Years, ModifiedFollowing)
+    };
+    
+    std::vector<DiscountFactor> dfs = {
+        1.0,
+        0.9990151375768731,
+        0.99570502636871183,
+        0.99118260474528685,
+        0.98661167950906203,
+        0.9732592953359388,
+        0.94724424481038083,
+        0.89844996737120875,
+        0.85216647839921411,
+        0.80775477692556874,
+        0.76517289234200347,
+        0.72401019553182933,
+        0.68503909569219212,
+        0.64797499814013748,
+        0.61263171936255534,
+        0.5791942350748791,
+        0.43518868769953606
+    };
 
     const DayCounter& curveDayCounter=Actual360();
 
@@ -222,27 +224,29 @@ void CreditDefaultSwapTest::testCachedMarketValue() {
             new DiscountCurve(discountDates, dfs, curveDayCounter)));
 
     DayCounter dayCounter = Thirty360();
-    std::vector<Date> dates;
-    dates.push_back(evalDate);
-    dates.push_back(calendar.advance(evalDate, 6, Months, ModifiedFollowing));
-    dates.push_back(calendar.advance(evalDate, 1, Years, ModifiedFollowing));
-    dates.push_back(calendar.advance(evalDate, 2, Years, ModifiedFollowing));
-    dates.push_back(calendar.advance(evalDate, 3, Years, ModifiedFollowing));
-    dates.push_back(calendar.advance(evalDate, 4, Years, ModifiedFollowing));
-    dates.push_back(calendar.advance(evalDate, 5, Years, ModifiedFollowing));
-    dates.push_back(calendar.advance(evalDate, 7, Years, ModifiedFollowing));
-    dates.push_back(calendar.advance(evalDate,10, Years, ModifiedFollowing));
-
-    std::vector<Probability> defaultProbabilities;
-    defaultProbabilities.push_back(0.0000);
-    defaultProbabilities.push_back(0.0047);
-    defaultProbabilities.push_back(0.0093);
-    defaultProbabilities.push_back(0.0286);
-    defaultProbabilities.push_back(0.0619);
-    defaultProbabilities.push_back(0.0953);
-    defaultProbabilities.push_back(0.1508);
-    defaultProbabilities.push_back(0.2288);
-    defaultProbabilities.push_back(0.3666);
+    std::vector<Date> dates = {
+        evalDate,
+        calendar.advance(evalDate, 6, Months, ModifiedFollowing),
+        calendar.advance(evalDate, 1, Years, ModifiedFollowing),
+        calendar.advance(evalDate, 2, Years, ModifiedFollowing),
+        calendar.advance(evalDate, 3, Years, ModifiedFollowing),
+        calendar.advance(evalDate, 4, Years, ModifiedFollowing),
+        calendar.advance(evalDate, 5, Years, ModifiedFollowing),
+        calendar.advance(evalDate, 7, Years, ModifiedFollowing),
+        calendar.advance(evalDate,10, Years, ModifiedFollowing)
+    };
+
+    std::vector<Probability> defaultProbabilities = {
+        0.0000,
+        0.0047,
+        0.0093,
+        0.0286,
+        0.0619,
+        0.0953,
+        0.1508,
+        0.2288,
+        0.3666
+    };
 
     std::vector<Real> hazardRates;
     hazardRates.push_back(0.0);
diff --git a/test-suite/curvestates.cpp b/test-suite/curvestates.cpp
index 4e5f9267080..6e4cf08f0d2 100644
--- a/test-suite/curvestates.cpp
+++ b/test-suite/curvestates.cpp
@@ -37,9 +37,6 @@
 using namespace QuantLib;
 using namespace boost::unit_test_framework;
 
-#define BEGIN(x) (x+0)
-#define END(x) (x+LENGTH(x))
-
 namespace curve_states_test {
 
     struct CommonVars {
diff --git a/test-suite/daycounters.cpp b/test-suite/daycounters.cpp
index 61d6b232bea..6ca54c4305b 100644
--- a/test-suite/daycounters.cpp
+++ b/test-suite/daycounters.cpp
@@ -578,22 +578,23 @@ void DayCounterTest::testBusiness252() {
 
     BOOST_TEST_MESSAGE("Testing business/252 day counter...");
 
-    std::vector<Date> testDates;
-    testDates.emplace_back(1, February, 2002);
-    testDates.emplace_back(4, February, 2002);
-    testDates.emplace_back(16, May, 2003);
-    testDates.emplace_back(17, December, 2003);
-    testDates.emplace_back(17, December, 2004);
-    testDates.emplace_back(19, December, 2005);
-    testDates.emplace_back(2, January, 2006);
-    testDates.emplace_back(13, March, 2006);
-    testDates.emplace_back(15, May, 2006);
-    testDates.emplace_back(17, March, 2006);
-    testDates.emplace_back(15, May, 2006);
-    testDates.emplace_back(26, July, 2006);
-    testDates.emplace_back(28, June, 2007);
-    testDates.emplace_back(16, September, 2009);
-    testDates.emplace_back(26, July, 2016);
+    std::vector<Date> testDates = {
+        Date(1, February, 2002),
+        Date(4, February, 2002),
+        Date(16, May, 2003),
+        Date(17, December, 2003),
+        Date(17, December, 2004),
+        Date(19, December, 2005),
+        Date(2, January, 2006),
+        Date(13, March, 2006),
+        Date(15, May, 2006),
+        Date(17, March, 2006),
+        Date(15, May, 2006),
+        Date(26, July, 2006),
+        Date(28, June, 2007),
+        Date(16, September, 2009),
+        Date(26, July, 2016)
+    };
 
     Time expected[] = {
         0.0039682539683,
@@ -920,9 +921,7 @@ void DayCounterTest::testIntraday() {
     const DayCounter dayCounters[]
         = { ActualActual(), Actual365Fixed(), Actual360() };
 
-    for (Size i=0; i < LENGTH(dayCounters); ++i) {
-        const DayCounter dc = dayCounters[i];
-
+    for (DayCounter dc : dayCounters) {
         const Time expected = ((12*60 + 34)*60 + 17 + 0.231298)
                              * dc.yearFraction(d1, d1+1)/86400
                              + dc.yearFraction(d1, d1+2);
diff --git a/test-suite/defaultprobabilitycurves.cpp b/test-suite/defaultprobabilitycurves.cpp
index 55764b8c649..77820d8720a 100644
--- a/test-suite/defaultprobabilitycurves.cpp
+++ b/test-suite/defaultprobabilitycurves.cpp
@@ -160,17 +160,8 @@ namespace {
 
         Integer settlementDays = 1;
 
-        std::vector<Real> quote;
-        quote.push_back(0.005);
-        quote.push_back(0.006);
-        quote.push_back(0.007);
-        quote.push_back(0.009);
-
-        std::vector<Integer> n;
-        n.push_back(1);
-        n.push_back(2);
-        n.push_back(3);
-        n.push_back(5);
+        std::vector<Real> quote = {0.005, 0.006, 0.007, 0.009};
+        std::vector<Integer> n = {1, 2, 3, 5};
 
         Frequency frequency = Quarterly;
         BusinessDayConvention convention = Following;
@@ -244,17 +235,8 @@ namespace {
 
         Integer settlementDays = 1;
 
-        std::vector<Real> quote;
-        quote.push_back(0.01);
-        quote.push_back(0.02);
-        quote.push_back(0.04);
-        quote.push_back(0.06);
-
-        std::vector<Integer> n;
-        n.push_back(2);
-        n.push_back(3);
-        n.push_back(5);
-        n.push_back(7);
+        std::vector<Real> quote = {0.01, 0.02, 0.04, 0.06};
+        std::vector<Integer> n = {2, 3, 5, 7};
 
         Rate fixedRate = 0.05;
         Frequency frequency = Quarterly;
diff --git a/test-suite/dividendoption.cpp b/test-suite/dividendoption.cpp
index 820dfbd16da..7359debb7f6 100644
--- a/test-suite/dividendoption.cpp
+++ b/test-suite/dividendoption.cpp
@@ -174,12 +174,8 @@ void DividendOptionTest::testEuropeanKnownValue() {
     Date exDate = today + 6*Months;
     ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-    std::vector<Date> dividendDates;
-    std::vector<Real> dividends;
-    dividendDates.push_back(today + 2*Months);
-    dividends.push_back(0.50);
-    dividendDates.push_back(today + 5*Months);
-    dividends.push_back(0.50);
+    std::vector<Date> dividendDates = {today + 2*Months, today + 5*Months};
+    std::vector<Real> dividends = {0.50, 0.50};
 
     ext::shared_ptr<StrikedTypePayoff> payoff(
             new PlainVanillaPayoff(Option::Call, 40.0));
@@ -251,10 +247,8 @@ void DividendOptionTest::testEuropeanStartLimit() {
                 Date exDate = today + length * Years;
                 ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-                std::vector<Date> dividendDates;
-                std::vector<Real> dividends;
-                dividendDates.push_back(today);
-                dividends.push_back(dividendValue);
+                std::vector<Date> dividendDates = {today};
+                std::vector<Real> dividends = {dividendValue};
 
                 ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, strike));
 
@@ -335,10 +329,8 @@ void DividendOptionTest::testEuropeanEndLimit() {
                 Date exDate = today + length * Years;
                 ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exDate));
 
-                std::vector<Date> dividendDates;
-                std::vector<Real> dividends;
-                dividendDates.push_back(exercise->lastDate());
-                dividends.push_back(dividendValue);
+                std::vector<Date> dividendDates = {exercise->lastDate()};
+                std::vector<Real> dividends = {dividendValue};
 
                 ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, strike));
 
@@ -994,13 +986,8 @@ void DividendOptionTest::testEscrowedDividendModel() {
     const ext::shared_ptr<Exercise> exercise(
         ext::make_shared<EuropeanExercise>(maturity));
 
-    std::vector<Date> dividendDates;
-    dividendDates.emplace_back(today + Period(3, Months));
-    dividendDates.emplace_back(today + Period(9, Months));
-
-    std::vector<Real> dividendAmounts;
-    dividendAmounts.push_back(8.3);
-    dividendAmounts.push_back(6.8);
+    std::vector<Date> dividendDates = {today + Period(3, Months), today + Period(9, Months)};
+    std::vector<Real> dividendAmounts = {8.3, 6.8};
 
     DividendVanillaOption option(
         payoff, exercise, dividendDates, dividendAmounts);
diff --git a/test-suite/europeanoption.cpp b/test-suite/europeanoption.cpp
index 29814dcad59..4e0f36d1a8e 100644
--- a/test-suite/europeanoption.cpp
+++ b/test-suite/europeanoption.cpp
@@ -1300,9 +1300,8 @@ void EuropeanOptionTest::testLocalVolatility() {
 
     const ext::shared_ptr<Quote> s0(new SimpleQuote(4500.00));
     
-    Real tmp[] = { 100 ,500 ,2000,3400,3600,3800,4000,4200,4400,4500,
-                   4600,4800,5000,5200,5400,5600,7500,10000,20000,30000 };
-    const std::vector<Real> strikes(tmp, tmp+LENGTH(tmp));
+    const std::vector<Real> strikes = { 100 ,500 ,2000,3400,3600,3800,4000,4200,4400,4500,
+                                        4600,4800,5000,5200,5400,5600,7500,10000,20000,30000 };
     
     Volatility v[] =
       { 1.015873, 1.015873, 1.015873, 0.89729, 0.796493, 0.730914, 0.631335, 0.568895,
@@ -1596,14 +1595,16 @@ void EuropeanOptionTest::testPDESchemes() {
     }
 
     // make sure that Douglas and Crank-Nicolson are giving the same result
-    const Size idxDouglas = std::distance(engines,
-        std::find(engines, engines + LENGTH(engines),
-            std::make_pair(douglas, std::string("Douglas"))));
+    const Size idxDouglas =
+        std::distance(std::begin(engines),
+                      std::find(std::begin(engines), std::end(engines),
+                                std::make_pair(douglas, std::string("Douglas"))));
     const Real douglasNPV = dividendPrices[idxDouglas];
 
-    const Size idxCrankNicolson = std::distance(engines,
-        std::find(engines, engines + LENGTH(engines),
-            std::make_pair(crankNicolson, std::string("Crank-Nicolson"))));
+    const Size idxCrankNicolson =
+        std::distance(std::begin(engines),
+                      std::find(std::begin(engines), std::end(engines),
+                                std::make_pair(crankNicolson, std::string("Crank-Nicolson"))));
     const Real crankNicolsonNPV = dividendPrices[idxCrankNicolson];
 
     const Real schemeTol = 1e-12;
diff --git a/test-suite/fdmlinearop.cpp b/test-suite/fdmlinearop.cpp
index 66414e52e57..3aac76e24ad 100644
--- a/test-suite/fdmlinearop.cpp
+++ b/test-suite/fdmlinearop.cpp
@@ -149,8 +149,7 @@ void FdmLinearOpTest::testFdmLinearOpLayout() {
 
     BOOST_TEST_MESSAGE("Testing indexing of a linear operator...");
 
-    Size dims[] = {5,7,8};
-    const std::vector<Size> dim(dims, dims+LENGTH(dims));
+    const std::vector<Size> dim = {5,7,8};
 
     FdmLinearOpLayout layout = FdmLinearOpLayout(dim);
 
@@ -222,14 +221,10 @@ void FdmLinearOpTest::testUniformGridMesher() {
 
     BOOST_TEST_MESSAGE("Testing uniform grid mesher...");
 
-    Size dims[] = {5,7,8};
-    const std::vector<Size> dim(dims, dims+LENGTH(dims));
+    const std::vector<Size> dim = {5,7,8};
 
     ext::shared_ptr<FdmLinearOpLayout> layout(new FdmLinearOpLayout(dim));
-    std::vector<std::pair<Real, Real> > boundaries;
-    boundaries.emplace_back(-5, 10);
-    boundaries.emplace_back(5, 100);
-    boundaries.emplace_back(10, 20);
+    std::vector<std::pair<Real, Real> > boundaries = {{-5, 10}, {5, 100}, {10, 20}};
 
     UniformGridMesher mesher(layout, boundaries);
 
@@ -252,15 +247,11 @@ void FdmLinearOpTest::testFirstDerivativesMapApply() {
 
     BOOST_TEST_MESSAGE("Testing application of first-derivatives map...");
 
-    Size dims[] = {400, 100, 50};
-    const std::vector<Size> dim(dims, dims+LENGTH(dims));
+    const std::vector<Size> dim = {400, 100, 50};
 
     ext::shared_ptr<FdmLinearOpLayout> index(new FdmLinearOpLayout(dim));
 
-    std::vector<std::pair<Real, Real> > boundaries;
-    boundaries.emplace_back(-5, 5);
-    boundaries.emplace_back(0, 10);
-    boundaries.emplace_back(5, 15);
+    std::vector<std::pair<Real, Real> > boundaries = {{-5, 5}, {0, 10}, { 5, 15}};
 
     ext::shared_ptr<FdmMesher> mesher(
                                  new UniformGridMesher(index, boundaries));
@@ -276,12 +267,12 @@ void FdmLinearOpTest::testFirstDerivativesMapApply() {
     }
 
     Array t = map.apply(r);
-    const Real dz = (boundaries[2].second-boundaries[2].first)/(dims[2]-1);
+    const Real dz = (boundaries[2].second-boundaries[2].first)/(dim[2]-1);
     for (FdmLinearOpIterator iter = index->begin(); iter != endIter; ++iter) {
         const Size z = iter.coordinates()[2];
 
         const Size z0 = (z > 0) ? z-1 : 1;
-        const Size z2 = (z < dims[2]-1) ? z+1 : dims[2]-2;
+        const Size z2 = (z < dim[2]-1) ? z+1 : dim[2]-2;
         const Real lz0 = boundaries[2].first + z0*dz;
         const Real lz2 = boundaries[2].first + z2*dz;
 
@@ -313,19 +304,14 @@ void FdmLinearOpTest::testSecondDerivativesMapApply() {
 
     BOOST_TEST_MESSAGE("Testing application of second-derivatives map...");
 
-    Size dims[] = {50, 50, 50};
-    const std::vector<Size> dim(dims, dims+LENGTH(dims));
+    const std::vector<Size> dim = {50, 50, 50};
 
     ext::shared_ptr<FdmLinearOpLayout> index(new FdmLinearOpLayout(dim));
 
-    std::vector<std::pair<Real, Real> > boundaries;
-    boundaries.emplace_back(0, 0.5);
-    boundaries.emplace_back(0, 0.5);
-    boundaries.emplace_back(0, 0.5);
+    std::vector<std::pair<Real, Real> > boundaries = {{0, 0.5}, {0, 0.5}, {0, 0.5}};
 
     ext::shared_ptr<FdmMesher> mesher(
                             new UniformGridMesher(index, boundaries));
-
     Array r(mesher->layout()->size());
     const FdmLinearOpIterator endIter = index->end();
 
@@ -347,7 +333,7 @@ void FdmLinearOpTest::testSecondDerivativesMapApply() {
         const Real z = mesher->location(iter, 2);
 
         Real d = -std::sin(x)*std::cos(y)*std::exp(z);
-        if (iter.coordinates()[0] == 0 || iter.coordinates()[0] == dims[0]-1) {
+        if (iter.coordinates()[0] == 0 || iter.coordinates()[0] == dim[0]-1) {
             d = 0;
         }
 
@@ -365,7 +351,7 @@ void FdmLinearOpTest::testSecondDerivativesMapApply() {
         const Real z = mesher->location(iter, 2);
 
         Real d = -std::sin(x)*std::cos(y)*std::exp(z);
-        if (iter.coordinates()[1] == 0 || iter.coordinates()[1] == dims[1]-1) {
+        if (iter.coordinates()[1] == 0 || iter.coordinates()[1] == dim[1]-1) {
             d = 0;
         }
 
@@ -383,7 +369,7 @@ void FdmLinearOpTest::testSecondDerivativesMapApply() {
         const Real z = mesher->location(iter, 2);
 
         Real d = std::sin(x)*std::cos(y)*std::exp(z);
-        if (iter.coordinates()[2] == 0 || iter.coordinates()[2] == dims[2]-1) {
+        if (iter.coordinates()[2] == 0 || iter.coordinates()[2] == dim[2]-1) {
             d = 0;
         }
 
@@ -579,15 +565,11 @@ void FdmLinearOpTest::testSecondOrderMixedDerivativesMapApply() {
     BOOST_TEST_MESSAGE(
         "Testing application of second-order mixed-derivatives map...");
 
-    Size dims[] = {50, 50, 50};
-    const std::vector<Size> dim(dims, dims+LENGTH(dims));
+    const std::vector<Size> dim = {50, 50, 50};
 
     ext::shared_ptr<FdmLinearOpLayout> index(new FdmLinearOpLayout(dim));
 
-    std::vector<std::pair<Real, Real> > boundaries;
-    boundaries.emplace_back(0, 0.5);
-    boundaries.emplace_back(0, 0.5);
-    boundaries.emplace_back(0, 0.5);
+    std::vector<std::pair<Real, Real> > boundaries = {{0, 0.5}, {0, 0.5}, {0, 0.5}};
 
     ext::shared_ptr<FdmMesher> mesher(
         new UniformGridMesher(index, boundaries));
@@ -678,14 +660,11 @@ void FdmLinearOpTest::testTripleBandMapSolve() {
 
     BOOST_TEST_MESSAGE("Testing triple-band map solution...");
 
-    Size dims[] = {100, 400};
-    const std::vector<Size> dim(dims, dims+LENGTH(dims));
+    const std::vector<Size> dim = {100, 400};
 
     ext::shared_ptr<FdmLinearOpLayout> layout(new FdmLinearOpLayout(dim));
 
-    std::vector<std::pair<Real, Real> > boundaries;
-    boundaries.emplace_back(0, 1.0);
-    boundaries.emplace_back(0, 1.0);
+    std::vector<std::pair<Real, Real> > boundaries = {{0, 1.0}, {0, 1.0}};
 
     ext::shared_ptr<FdmMesher> mesher(
         new UniformGridMesher(layout, boundaries));
@@ -763,14 +742,11 @@ void FdmLinearOpTest::testFdmHestonBarrier() {
 
     SavedSettings backup;
 
-    Size dims[] = {200, 100};
-    const std::vector<Size> dim(dims, dims+LENGTH(dims));
+    const std::vector<Size> dim = {200, 100};
 
     ext::shared_ptr<FdmLinearOpLayout> index(new FdmLinearOpLayout(dim));
 
-    std::vector<std::pair<Real, Real> > boundaries;
-    boundaries.emplace_back(3.8, 4.905274778);
-    boundaries.emplace_back(0.000, 1.0);
+    std::vector<std::pair<Real, Real> > boundaries = {{3.8, 4.905274778}, {0.0, 1.0}};
 
     ext::shared_ptr<FdmMesher> mesher(
         new UniformGridMesher(index, boundaries));
@@ -796,20 +772,20 @@ void FdmLinearOpTest::testFdmHestonBarrier() {
         rhs[iter.index()]=std::max(std::exp(mesher->location(iter,0))-100, 0.0);
     }
 
-    FdmBoundaryConditionSet bcSet;
-    bcSet.push_back(ext::make_shared<FdmDirichletBoundary>(
-        mesher, 0.0, 0,
-                                 FdmDirichletBoundary::Upper));
+    FdmBoundaryConditionSet bcSet = {
+        ext::make_shared<FdmDirichletBoundary>(mesher, 0.0, 0,
+                                               FdmDirichletBoundary::Upper)
+    };
 
     const Real theta=0.5+std::sqrt(3.0)/6.;
     HundsdorferScheme hsEvolver(theta, 0.5, hestonOp, bcSet);
     FiniteDifferenceModel<HundsdorferScheme> hsModel(hsEvolver);
     hsModel.rollback(rhs, 1.0, 0.0, 50);
 
-    Matrix ret(dims[0], dims[1]);
-    for (Size i=0; i < dims[0]; ++i)
-        for (Size j=0; j < dims[1]; ++j)
-            ret[i][j] = rhs[i+j*dims[0]];
+    Matrix ret(dim[0], dim[1]);
+    for (Size i=0; i < dim[0]; ++i)
+        for (Size j=0; j < dim[1]; ++j)
+            ret[i][j] = rhs[i+j*dim[0]];
 
     std::vector<Real> tx, ty;
     for (FdmLinearOpIterator iter = mesher->layout()->begin();
@@ -857,14 +833,11 @@ void FdmLinearOpTest::testFdmHestonAmerican() {
 
     SavedSettings backup;
 
-    Size dims[] = {200, 100};
-    const std::vector<Size> dim(dims, dims+LENGTH(dims));
+    const std::vector<Size> dim = {200, 100};
 
     ext::shared_ptr<FdmLinearOpLayout> index(new FdmLinearOpLayout(dim));
 
-    std::vector<std::pair<Real, Real> > boundaries;
-    boundaries.emplace_back(3.8, std::log(220.0));
-    boundaries.emplace_back(0.000, 1.0);
+    std::vector<std::pair<Real, Real> > boundaries = {{3.8, std::log(220.0)}, {0.0, 1.0}};
 
     ext::shared_ptr<FdmMesher> mesher(
         new UniformGridMesher(index, boundaries));
@@ -900,10 +873,10 @@ void FdmLinearOpTest::testFdmHestonAmerican() {
     FiniteDifferenceModel<HundsdorferScheme> hsModel(hsEvolver);
     hsModel.rollback(rhs, 1.0, 0.0, 50, condition);
 
-    Matrix ret(dims[0], dims[1]);
-    for (Size i=0; i < dims[0]; ++i)
-        for (Size j=0; j < dims[1]; ++j)
-            ret[i][j] = rhs[i+j*dims[0]];
+    Matrix ret(dim[0], dim[1]);
+    for (Size i=0; i < dim[0]; ++i)
+        for (Size j=0; j < dim[1]; ++j)
+            ret[i][j] = rhs[i+j*dim[0]];
 
     std::vector<Real> tx, ty;
     for (FdmLinearOpIterator iter = mesher->layout()->begin();
@@ -936,14 +909,11 @@ void FdmLinearOpTest::testFdmHestonExpress() {
 
     SavedSettings backup;
 
-    Size dims[] = {200, 100};
-    const std::vector<Size> dim(dims, dims+LENGTH(dims));
+    const std::vector<Size> dim = {200, 100};
 
     ext::shared_ptr<FdmLinearOpLayout> index(new FdmLinearOpLayout(dim));
 
-    std::vector<std::pair<Real, Real> > boundaries;
-    boundaries.emplace_back(3.8, std::log(220.0));
-    boundaries.emplace_back(0.000, 1.0);
+    std::vector<std::pair<Real, Real> > boundaries = {{3.8, std::log(220.0)}, {0.0, 1.0}};
 
     ext::shared_ptr<FdmMesher> mesher(
                             new UniformGridMesher(index, boundaries));
@@ -978,13 +948,13 @@ void FdmLinearOpTest::testFdmHestonExpress() {
         new FdmHestonExpressCondition(redemptions, triggerLevels,
                                       exerciseTimes, mesher));
 
-    std::list<std::vector<Time> > stoppingTimes;
-    stoppingTimes.push_back(exerciseTimes);
-    stoppingTimes.push_back(dividendCondition->dividendTimes());
+    std::list<std::vector<Time>> stoppingTimes = {
+        exerciseTimes, dividendCondition->dividendTimes()
+    };
 
-    std::list<ext::shared_ptr<StepCondition<Array> > > conditions;
-    conditions.push_back(expressCondition);
-    conditions.push_back(dividendCondition);
+    std::list<ext::shared_ptr<StepCondition<Array>>> conditions = {
+        expressCondition, dividendCondition
+    };
 
     ext::shared_ptr<FdmStepConditionComposite> condition(
         new FdmStepConditionComposite(stoppingTimes, conditions));
@@ -1074,14 +1044,15 @@ namespace {
 
         ext::shared_ptr<FdmLinearOpLayout> layout(new FdmLinearOpLayout(dim));
 
-        std::vector<ext::shared_ptr<Fdm1dMesher> > mesher1d;
-        mesher1d.push_back(ext::shared_ptr<Fdm1dMesher>(
-                new Uniform1dMesher(std::log(22.0), std::log(440.0), dim[0])));
-        mesher1d.push_back(ext::shared_ptr<Fdm1dMesher>(
+        std::vector<ext::shared_ptr<Fdm1dMesher> > mesher1d = {
+            ext::shared_ptr<Fdm1dMesher>(
+                new Uniform1dMesher(std::log(22.0), std::log(440.0), dim[0])),
+            ext::shared_ptr<Fdm1dMesher>(
                 new FdmHestonVarianceMesher(dim[1], process->hestonProcess(),
-                                            maturity)));
-        mesher1d.push_back(ext::shared_ptr<Fdm1dMesher>(
-                new Uniform1dMesher(-0.15, 0.15, dim[2])));
+                                            maturity)),
+            ext::shared_ptr<Fdm1dMesher>(
+                new Uniform1dMesher(-0.15, 0.15, dim[2]))
+        };
 
         const ext::shared_ptr<FdmMesher> mesher(
             new FdmMesherComposite(mesher1d));
@@ -1124,8 +1095,7 @@ void FdmLinearOpTest::testFdmHestonHullWhiteOp() {
     Date exerciseDate(28, March, 2012);
     const Time maturity = Actual365Fixed().yearFraction(today, exerciseDate);
 
-    Size dims[] = {51, 31, 31};
-    const std::vector<Size> dim(dims, dims+LENGTH(dims));
+    const std::vector<Size> dim = {51, 31, 31};
 
     ext::shared_ptr<HybridHestonHullWhiteProcess> jointProcess
                                             = createHestonHullWhite(maturity);
@@ -1692,11 +1662,10 @@ void FdmLinearOpTest::testLowVolatilityHighDiscreteDividendBlackScholesMesher()
     const Date secondDivDate = today + Period(11, Months);
     const Real secondDivAmount = 5.0;
 
-    DividendSchedule divSchedule;
-    divSchedule.push_back(
-        ext::make_shared<FixedDividend>(firstDivAmount, firstDivDate));
-    divSchedule.push_back(
-        ext::make_shared<FixedDividend>(secondDivAmount, secondDivDate));
+    DividendSchedule divSchedule = {
+        ext::make_shared<FixedDividend>(firstDivAmount, firstDivDate),
+        ext::make_shared<FixedDividend>(secondDivAmount, secondDivDate)
+    };
 
     const Size size = 5;
     const Time maturity = 1.0;
diff --git a/test-suite/forwardrateagreement.cpp b/test-suite/forwardrateagreement.cpp
index 51ea7a8d9dd..d8b5fffb3e0 100644
--- a/test-suite/forwardrateagreement.cpp
+++ b/test-suite/forwardrateagreement.cpp
@@ -43,10 +43,11 @@ void ForwardRateAgreementTest::testConstructionWithoutACurve() {
         Date settlementDate = index->fixingCalendar().advance(today, index->fixingDays() * Days);
 
         // set up quotes with no values
-        std::vector<ext::shared_ptr<SimpleQuote> > quotes;
-        quotes.push_back(ext::make_shared<SimpleQuote>());
-        quotes.push_back(ext::make_shared<SimpleQuote>());
-        quotes.push_back(ext::make_shared<SimpleQuote>());
+        std::vector<ext::shared_ptr<SimpleQuote> > quotes = {
+            ext::make_shared<SimpleQuote>(),
+            ext::make_shared<SimpleQuote>(),
+            ext::make_shared<SimpleQuote>()
+        };
 
 #ifdef QL_USE_INDEXED_COUPON
         bool useIndexedFra = false;
diff --git a/test-suite/hestonmodel.cpp b/test-suite/hestonmodel.cpp
index 1f646aa3980..2cd9fec611d 100644
--- a/test-suite/hestonmodel.cpp
+++ b/test-suite/hestonmodel.cpp
@@ -158,14 +158,8 @@ void HestonModelTest::testBlackCalibration() {
     Handle<YieldTermStructure> riskFreeTS(flatRate(0.04, dayCounter));
     Handle<YieldTermStructure> dividendTS(flatRate(0.50, dayCounter));
 
-    std::vector<Period> optionMaturities;
-    optionMaturities.emplace_back(1, Months);
-    optionMaturities.emplace_back(2, Months);
-    optionMaturities.emplace_back(3, Months);
-    optionMaturities.emplace_back(6, Months);
-    optionMaturities.emplace_back(9, Months);
-    optionMaturities.emplace_back(1, Years);
-    optionMaturities.emplace_back(2, Years);
+    std::vector<Period> optionMaturities = {1 * Months, 2 * Months, 3 * Months, 6 * Months,
+                                            9 * Months, 1 * Years,  2 * Years};
 
     std::vector<ext::shared_ptr<CalibrationHelper> > options;
     Handle<Quote> s0(ext::make_shared<SimpleQuote>(1.0));
@@ -895,13 +889,13 @@ void HestonModelTest::testDifferentIntegrals() {
     const HestonParameter highVolOfVol  = { 0.07, 1.0, 0.04, 5.0, -0.75 };
     const HestonParameter kappaEqSigRho = { 0.07, 0.4, 0.04, 0.5, 0.8 };
 
-    std::vector<HestonParameter> params;
-    params.push_back(equityfx);
-    params.push_back(highCorr);
-    params.push_back(lowVolOfVol);
-    params.push_back(highVolOfVol);
-    params.push_back(kappaEqSigRho);
-
+    std::vector<HestonParameter> params = {
+        equityfx,
+        highCorr,
+        lowVolOfVol,
+        highVolOfVol,
+        kappaEqSigRho
+    };
     const Real tol[] = { 1e-3, 1e-3, 0.2, 0.01, 1e-3 };
 
     for (std::vector<HestonParameter>::const_iterator iter = params.begin();
@@ -1019,14 +1013,12 @@ void HestonModelTest::testMultipleStrikesEngine() {
         ext::make_shared<HestonProcess>(
                      riskFreeTS, dividendTS, s0, 0.16, 2.5, 0.09, 0.8, -0.8));
     ext::shared_ptr<HestonModel> model(
-        ext::make_shared<HestonModel>(process));
+		ext::make_shared<HestonModel>(process));
 
-    std::vector<Real> strikes;
-    strikes.push_back(1.0);  strikes.push_back(0.5);
-    strikes.push_back(0.75); strikes.push_back(1.5); strikes.push_back(2.0);
+    std::vector<Real> strikes = {1.0, 0.5, 0.75, 1.5, 2.0};
 
     ext::shared_ptr<FdHestonVanillaEngine> singleStrikeEngine(
-        ext::make_shared<FdHestonVanillaEngine>(model, 20, 400, 50));
+		ext::make_shared<FdHestonVanillaEngine>(model, 20, 400, 50));
     ext::shared_ptr<FdHestonVanillaEngine> multiStrikeEngine(
         ext::make_shared<FdHestonVanillaEngine>(model, 20, 400, 50));
     multiStrikeEngine->enableMultipleStrikesCaching(strikes);
@@ -1092,22 +1084,17 @@ void HestonModelTest::testAnalyticPiecewiseTimeDependent() {
     ext::shared_ptr<StrikedTypePayoff> payoff(
         ext::make_shared<PlainVanillaPayoff>(Option::Call, 1.0));
     ext::shared_ptr<Exercise> exercise(
-        ext::make_shared<EuropeanExercise>(exerciseDate));
+		ext::make_shared<EuropeanExercise>(exerciseDate));
 
-    std::vector<Date> dates; 
-    dates.push_back(settlementDate);
-    dates.emplace_back(01, January, 2007);
-    std::vector<Rate> irates;
-    irates.push_back(0.0); irates.push_back(0.2);
+    std::vector<Date> dates = {settlementDate, {1, January, 2007}};
+    std::vector<Rate> irates = {0.0, 0.2};
     Handle<YieldTermStructure> riskFreeTS(
-        ext::make_shared<ZeroCurve>(dates, irates, dayCounter));
+		ext::make_shared<ZeroCurve>(dates, irates, dayCounter));
 
-    std::vector<Rate> qrates;
-    qrates.push_back(0.0); qrates.push_back(0.3);
+    std::vector<Rate> qrates = {0.0, 0.3};
     Handle<YieldTermStructure> dividendTS(
-        ext::make_shared<ZeroCurve>(dates, qrates, dayCounter));
+		ext::make_shared<ZeroCurve>(dates, qrates, dayCounter));
     
-
     const Real v0 = 0.1;
     Handle<Quote> s0(ext::make_shared<SimpleQuote>(1.0));
 
@@ -1176,9 +1163,7 @@ void HestonModelTest::testDAXCalibrationOfTimeDependentModel() {
 
     const std::vector<ext::shared_ptr<CalibrationHelper> >& options = marketData.options;
 
-    std::vector<Time> modelTimes;
-    modelTimes.push_back(0.25);
-    modelTimes.push_back(10.0);
+    std::vector<Time> modelTimes = {0.25, 10.0};
     const TimeGrid modelGrid(modelTimes.begin(), modelTimes.end());
 
     const Real v0=0.1;
@@ -2474,10 +2459,7 @@ void HestonModelTest::testPiecewiseTimeDependentComparison() {
 
     const Handle<Quote> s0(ext::make_shared<SimpleQuote>(100.0));
 
-    std::vector<Time> modelTimes;
-    modelTimes.push_back(0.25);
-    modelTimes.push_back(0.75);
-    modelTimes.push_back(10.0);
+    std::vector<Time> modelTimes = {0.25, 0.75, 10.0};
     const TimeGrid modelGrid(modelTimes.begin(), modelTimes.end());
 
     const Real v0 = 0.1;
@@ -2609,10 +2591,7 @@ void HestonModelTest::testPiecewiseTimeDependentChFAsymtotic() {
     const Time maturity = dc.yearFraction(settlementDate, maturityDate);
     const Handle<YieldTermStructure> rTS(flatRate(0.0, dc));
 
-    std::vector<Time> modelTimes;
-    modelTimes.push_back(0.01);
-    modelTimes.push_back(0.5);
-    modelTimes.push_back(2.0);
+    std::vector<Time> modelTimes = {0.01, 0.5, 2.0};
 
     const TimeGrid modelGrid(modelTimes.begin(), modelTimes.end());
 
diff --git a/test-suite/hestonslvmodel.cpp b/test-suite/hestonslvmodel.cpp
index 4cfabb8fce2..703a7c973fd 100644
--- a/test-suite/hestonslvmodel.cpp
+++ b/test-suite/hestonslvmodel.cpp
@@ -1011,10 +1011,10 @@ namespace {
             dates.push_back(date);
         }
 
-        Real tmp[] = { 2.222222222, 11.11111111, 44.44444444, 75.55555556, 80, 84.44444444, 88.88888889, 93.33333333, 97.77777778, 100,
-                       102.2222222, 106.6666667, 111.1111111, 115.5555556, 120, 124.4444444, 166.6666667, 222.2222222, 444.4444444, 666.6666667
-             };
-        const std::vector<Real> surfaceStrikes(tmp, tmp+LENGTH(tmp));
+        const std::vector<Real> surfaceStrikes = {
+            2.222222222, 11.11111111, 44.44444444, 75.55555556, 80, 84.44444444, 88.88888889, 93.33333333, 97.77777778, 100,
+            102.2222222, 106.6666667, 111.1111111, 115.5555556, 120, 124.4444444, 166.6666667, 222.2222222, 444.4444444, 666.6666667
+        };
 
         Volatility v[] =
           { 1.015873, 1.015873, 0.915873, 0.89729, 0.796493, 0.730914, 0.631335, 0.568895,
@@ -1104,10 +1104,9 @@ void HestonSLVModelTest::testHestonFokkerPlanckFwdEquationLogLVLeverage() {
     const Real lowerBound = rnd.stationary_invcdf(0.01);
 
     const Real beta = 10.0;
-    std::vector<ext::tuple<Real, Real, bool> > critPoints;
-    critPoints.emplace_back(lowerBound, beta, true);
-    critPoints.emplace_back(v0, beta / 100, true);
-    critPoints.emplace_back(upperBound, beta, true);
+    std::vector<ext::tuple<Real, Real, bool>> critPoints = {{lowerBound, beta, true},
+                                                            {v0, beta/100, true},
+                                                            {upperBound, beta, true}};
     const ext::shared_ptr<Fdm1dMesher> varianceMesher(
 		ext::make_shared<Concentrating1dMesher>(lowerBound, upperBound, vGrid, critPoints));
 
@@ -1155,24 +1154,22 @@ void HestonSLVModelTest::testHestonFokkerPlanckFwdEquationLogLVLeverage() {
     const Time dt = (maturity-eT)/tGrid;
 
 
-    Real denseStrikes[] =
+    const std::vector<Real> denseStrikes =
         { 2.222222222, 11.11111111, 20, 25, 30, 35, 40,
           44.44444444, 50, 55, 60, 65, 70, 75.55555556,
           80, 84.44444444, 88.88888889, 93.33333333, 97.77777778, 100,
           102.2222222, 106.6666667, 111.1111111, 115.5555556, 120,
           124.4444444, 166.6666667, 222.2222222, 444.4444444, 666.6666667 };
 
-    const std::vector<Real> ds(denseStrikes, denseStrikes+LENGTH(denseStrikes));
-
-    Matrix surface(ds.size(), ext::get<1>(smoothSurface).size());
+    Matrix surface(denseStrikes.size(), ext::get<1>(smoothSurface).size());
     std::vector<Time> times(surface.columns());
 
     const std::vector<Date>& dates = ext::get<1>(smoothSurface);
     ext::shared_ptr<Matrix> m = createLocalVolMatrixFromProcess(
-        lvProcess, ds, dates, times);
+        lvProcess, denseStrikes, dates, times);
 
     const ext::shared_ptr<FixedLocalVolSurface> leverage(
-		ext::make_shared<FixedLocalVolSurface>(todaysDate, dates, ds, m, dc));
+		ext::make_shared<FixedLocalVolSurface>(todaysDate, dates, denseStrikes, m, dc));
 
     const ext::shared_ptr<PricingEngine> lvEngine(
 		ext::make_shared<AnalyticEuropeanEngine>(lvProcess));
@@ -2151,9 +2148,7 @@ void HestonSLVModelTest::testForwardSkewSLV() {
     const Date resetDate = todaysDate + Period(12, Months);
     const Time resetTime = dc.yearFraction(todaysDate, resetDate);
     const Time maturityTime = dc.yearFraction(todaysDate, maturityDate);
-    std::vector<Time> mandatoryTimes;
-    mandatoryTimes.push_back(resetTime);
-    mandatoryTimes.push_back(maturityTime);
+    std::vector<Time> mandatoryTimes = {resetTime, maturityTime};
 
     const Size tSteps = 100;
     const TimeGrid grid(mandatoryTimes.begin(), mandatoryTimes.end(), tSteps);
@@ -2164,13 +2159,12 @@ void HestonSLVModelTest::testForwardSkewSLV() {
 
     const Size factors = mcSlvProcess->factors();
 
-    std::vector<ext::shared_ptr<MultiPathGenerator<rsg_type> > > pathGen;
-    pathGen.push_back(
+    std::vector<ext::shared_ptr<MultiPathGenerator<rsg_type> > > pathGen = {
         ext::make_shared<MultiPathGenerator<rsg_type> >(
-            mcSlvProcess, grid, rsg_type(factors, tSteps), false));
-    pathGen.push_back(
+            mcSlvProcess, grid, rsg_type(factors, tSteps), false),
         ext::make_shared<MultiPathGenerator<rsg_type> >(
-            fdmSlvProcess, grid, rsg_type(factors, tSteps), false));
+            fdmSlvProcess, grid, rsg_type(factors, tSteps), false)
+    };
 
     const Real strikes[] = {
         0.5, 0.7, 0.8, 0.9, 1.0, 1.1, 1.25, 1.5, 1.75, 2.0
diff --git a/test-suite/hybridhestonhullwhiteprocess.cpp b/test-suite/hybridhestonhullwhiteprocess.cpp
index fa4b10db593..ec46a7e5153 100644
--- a/test-suite/hybridhestonhullwhiteprocess.cpp
+++ b/test-suite/hybridhestonhullwhiteprocess.cpp
@@ -1006,12 +1006,13 @@ void HybridHestonHullWhiteProcessTest::testBsmHullWhitePricing() {
     Date today(27, December, 2004);
     Settings::instance().evaluationDate() = today;
 
+
     Real maturity = 5.0;
     Real equityIrCorr = -0.4;
-    Real strikes[] = {75,85,90,95,100,105,110,115,120,125,130,140,150};
+    std::vector<Real> strikes = {75,85,90,95,100,105,110,115,120,125,130,140,150};
     Size listOfTimeStepsPerYear[] = { 20 };
 
-    HestonModelData hestonModelData
+    HestonModelData hestonModelData 
         = { "BSM-HW Model", 0.09, 1.0, 0.09, QL_EPSILON, 0.0, 0.04, 0.03 };
     HullWhiteModelData hwModelData = hullWhiteModels[0];
     bool controlVariate[] = { true, false };
@@ -1049,8 +1050,7 @@ void HybridHestonHullWhiteProcessTest::testBsmHullWhitePricing() {
                 ext::shared_ptr<FdHestonHullWhiteVanillaEngine> fdEngine(
                     new FdHestonHullWhiteVanillaEngine(hestonModel, hwProcess, equityIrCorr, tSteps,
                                                        400, 2, 10, 0, i, scheme.schemeDesc));
-                fdEngine->enableMultipleStrikesCaching(
-                    std::vector<Real>(strikes, strikes + LENGTH(strikes)));
+                fdEngine->enableMultipleStrikesCaching(strikes);
 
                 Real avgPriceDiff = 0.0;
                 for (double& strike : strikes) {
@@ -1063,7 +1063,7 @@ void HybridHestonHullWhiteProcessTest::testBsmHullWhitePricing() {
                     option->setPricingEngine(fdEngine);
                     Real calculated = option->NPV();
                     avgPriceDiff
-                        +=std::fabs(expected-calculated)/LENGTH(strikes); // NOLINT(bugprone-integer-division)
+                        += std::fabs(expected-calculated)/strikes.size(); // NOLINT(bugprone-integer-division)
                 }
 
                 if (i && tolWithCV[l] < avgPriceDiff) {
@@ -1095,7 +1095,7 @@ void HybridHestonHullWhiteProcessTest::testSpatialDiscretizatinError() {
     Settings::instance().evaluationDate() = today;
 
     Real maturity=1.0;
-    Real strikes[] = {75,85,90,95,100,105,110,115,120,125,130,140,150};
+    std::vector<Real> strikes = {75,85,90,95,100,105,110,115,120,125,130,140,150};
     Size listOfTimeStepsPerYear[] = { 40 };
 
     const Real tol[] = { 0.02, 0.02, 0.02, 0.02, 0.05 };
@@ -1116,8 +1116,7 @@ void HybridHestonHullWhiteProcessTest::testSpatialDiscretizatinError() {
                     new FdHestonVanillaEngine(
                         hestonModel, tSteps, 200, 40, 0,
                         schemes[i].schemeDesc));
-                fdEngine->enableMultipleStrikesCaching(
-                    std::vector<Real>(strikes, strikes + LENGTH(strikes)));
+                fdEngine->enableMultipleStrikesCaching(strikes);
 
                 for (double& strike : strikes) {
                     VanillaOptionData optionData = {strike, maturity, Option::Call};
@@ -1130,7 +1129,7 @@ void HybridHestonHullWhiteProcessTest::testSpatialDiscretizatinError() {
                     Real calculated = option->NPV();
 
                     avgPriceDiff
-                        +=std::fabs(expected-calculated)/LENGTH(strikes); // NOLINT(bugprone-integer-division)
+                        += std::fabs(expected-calculated)/strikes.size(); // NOLINT(bugprone-integer-division)
                 }
 
                 if (avgPriceDiff > tol[i]) {
@@ -1225,12 +1224,13 @@ void HybridHestonHullWhiteProcessTest::testHestonHullWhiteCalibration() {
     const ext::shared_ptr<HestonModel> fdmHestonModel
                                             (new HestonModel(hestonProcess));
 
-    const Real equityShortRateCorr = -0.5;
 
-    const Real strikes[]    = { 50, 75, 90, 100, 110, 125, 150, 200 };
-    const Time maturities[] = { 1/12., 3/12., 0.5, 1.0, 2.0, 3.0, 5.0, 7.5, 10};
+    const Real equityShortRateCorr = -0.5;
 
-    const Volatility vol[] = {
+    std::vector<Real> strikes    = { 50, 75, 90, 100, 110, 125, 150, 200 };
+    std::vector<Time> maturities = { 1/12., 3/12., 0.5, 1.0, 2.0, 3.0, 5.0, 7.5, 10};
+    
+    std::vector<Volatility> vol = {
         0.482627,0.407617,0.366682,0.340110,0.314266,0.280241,0.252471,0.325552,
         0.464811,0.393336,0.354664,0.329758,0.305668,0.273563,0.244024,0.244886,
         0.441864,0.375618,0.340464,0.318249,0.297127,0.268839,0.237972,0.225553,
@@ -1244,20 +1244,19 @@ void HybridHestonHullWhiteProcessTest::testHestonHullWhiteCalibration() {
 
     std::vector<ext::shared_ptr<CalibrationHelper> > options;
 
-    for (Size i=0; i < LENGTH(maturities); ++i) {
+    for (Size i=0; i < maturities.size(); ++i) {
         const Period maturity((int)std::lround(maturities[i]*12.0), Months);
         ext::shared_ptr<Exercise> exercise(
                                         new EuropeanExercise(today + maturity));
 
-        for (Size j=0; j < LENGTH(strikes); ++j) {
+        for (Size j=0; j < strikes.size(); ++j) {
             ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(
                 strikes[j] * rTS->discount(maturities[i]) >=
                         s0->value() * qTS->discount(maturities[i])
                     ? Option::Call
                     : Option::Put,
                 strikes[j]));
-            RelinkableHandle<Quote> v(ext::shared_ptr<Quote>(
-                                   new SimpleQuote(vol[i*LENGTH(strikes)+j])));
+            RelinkableHandle<Quote> v(ext::shared_ptr<Quote>(new SimpleQuote(vol[i*strikes.size()+j])));
 
             ext::shared_ptr<BlackCalibrationHelper> helper(
                 new HestonModelHelper(maturity, calendar, s0,
@@ -1272,7 +1271,6 @@ void HybridHestonHullWhiteProcessTest::testHestonHullWhiteCalibration() {
             ext::shared_ptr<GeneralizedBlackScholesProcess> bsProcess =
                 QuantLib::detail::ImpliedVolatilityHelper::clone(
                     ext::make_shared<GeneralizedBlackScholesProcess>(
-
                             s0, qTS, rTS, Handle<BlackVolTermStructure>(
                                                     flatVol(v->value(), dc))),
                         volQuote);
@@ -1303,29 +1301,27 @@ void HybridHestonHullWhiteProcessTest::testHestonHullWhiteCalibration() {
     options.clear();
     fdmHestonModel->setParams(analyticHestonModel->params());
 
-    for (Size i=0; i < LENGTH(maturities); ++i) {
+    for (Size i=0; i < maturities.size(); ++i) {
         const Size tGrid = static_cast<Size>(std::max(5.0, maturities[i]*5.0));
         ext::shared_ptr<FdHestonHullWhiteVanillaEngine> engine(
             new FdHestonHullWhiteVanillaEngine(fdmHestonModel, hwProcess,
                                                equityShortRateCorr,
                                                tGrid, 45, 11, 5, 0, true));
 
-        engine->enableMultipleStrikesCaching(
-                     std::vector<Real>(strikes, strikes + LENGTH(strikes)));
+        engine->enableMultipleStrikesCaching(strikes);
 
         const Period maturity((int)std::lround(maturities[i]*12.0), Months);
 
-        for (Size j=0; j < LENGTH(strikes); ++j) {
+        for (Size j=0; j < strikes.size(); ++j) {
             // multiple strikes engine works best if the first option
             // per maturity has the average strike (because the first option
             // is priced first during the calibration and the first pricing
             // is used to calculate the prices for all strikes
-            const Size js = (j + (LENGTH(strikes)-1)/2) % LENGTH(strikes);
+            const Size js = (j + (strikes.size()-1)/2) % strikes.size();
 
             ext::shared_ptr<StrikedTypePayoff> payoff(
                              new PlainVanillaPayoff(Option::Call, strikes[js]));
-            Handle<Quote> v(ext::shared_ptr<Quote>(
-                                   new SimpleQuote(vol[i*LENGTH(strikes)+js])));
+            Handle<Quote> v(ext::shared_ptr<Quote>(new SimpleQuote(vol[i*strikes.size()+js])));
             ext::shared_ptr<BlackCalibrationHelper> helper(
                 new HestonModelHelper(maturity, calendar, s0,
                                       strikes[js], v, rTS, qTS,
@@ -1354,22 +1350,19 @@ void HybridHestonHullWhiteProcessTest::testHestonHullWhiteCalibration() {
                  << "\n   v0 expected  : " << expected_v0
                  << "\n   relatove tol : " << relTol);
     }
-    if (std::fabs(fdmHestonModel->theta() - expected_theta)/expected_theta
-                                                                    > relTol) {
+    if (std::fabs(fdmHestonModel->theta() - expected_theta)/expected_theta > relTol) {
          BOOST_ERROR("Failed to reproduce Heston-Hull-White model"
                  << "\n   theta calculated: " << fdmHestonModel->theta()
                  << "\n   theta expected  : " << expected_theta
                  << "\n   relatove tol    : " << relTol);
     }
-    if (std::fabs(fdmHestonModel->kappa() - expected_kappa)/expected_kappa
-                                                                    > relTol) {
+    if (std::fabs(fdmHestonModel->kappa() - expected_kappa)/expected_kappa > relTol) {
         BOOST_ERROR("Failed to reproduce Heston-Hull-White model"
                 << "\n   kappa calculated: " << fdmHestonModel->kappa()
                 << "\n   kappa expected  : " << expected_kappa
                 << "\n   relatove tol    : " << relTol);
     }
-    if (std::fabs(fdmHestonModel->sigma() - expected_sigma)/expected_sigma
-                                                                    > relTol) {
+    if (std::fabs(fdmHestonModel->sigma() - expected_sigma)/expected_sigma > relTol) {
        BOOST_ERROR("Failed to reproduce Heston-Hull-White model"
                << "\n   sigma calculated: " << fdmHestonModel->sigma()
                << "\n   sigma expected  : " << expected_sigma
diff --git a/test-suite/inflation.cpp b/test-suite/inflation.cpp
index 82975e9f82b..888d2269266 100644
--- a/test-suite/inflation.cpp
+++ b/test-suite/inflation.cpp
@@ -74,7 +74,7 @@ namespace inflation_test {
 
     template <class T, class U, class I>
     std::vector<ext::shared_ptr<BootstrapHelper<T> > > makeHelpers(
-            Datum iiData[], Size N,
+            const std::vector<Datum> iiData,
             const ext::shared_ptr<I> &ii, const Period &observationLag,
             const Calendar &calendar,
             const BusinessDayConvention &bdc,
@@ -82,10 +82,10 @@ namespace inflation_test {
             const Handle<YieldTermStructure>& yTS) {
 
         std::vector<ext::shared_ptr<BootstrapHelper<T> > > instruments;
-        for (Size i=0; i<N; i++) {
-            Date maturity = iiData[i].date;
+        for (Datum datum : iiData) {
+            Date maturity = datum.date;
             Handle<Quote> quote(ext::shared_ptr<Quote>(
-                new SimpleQuote(iiData[i].rate/100.0)));
+                new SimpleQuote(datum.rate/100.0)));
             ext::shared_ptr<BootstrapHelper<T> > anInstrument(new U(
                 quote, observationLag, maturity,
                 calendar, bdc, dc, ii, yTS));
@@ -345,7 +345,7 @@ void InflationTest::testZeroTermStructure() {
     ext::shared_ptr<YieldTermStructure> nominalTS = nominalTermStructure();
 
     // now build the zero inflation curve
-    Datum zcData[] = {
+    std::vector<Datum> zcData = {
         { Date(13, August, 2008), 2.93 },
         { Date(13, August, 2009), 2.95 },
         { Date(13, August, 2010), 2.965 },
@@ -367,7 +367,7 @@ void InflationTest::testZeroTermStructure() {
     Frequency frequency = Monthly;
     std::vector<ext::shared_ptr<BootstrapHelper<ZeroInflationTermStructure> > > helpers =
     makeHelpers<ZeroInflationTermStructure,ZeroCouponInflationSwapHelper,
-                ZeroInflationIndex>(zcData, LENGTH(zcData), ii,
+                ZeroInflationIndex>(zcData, ii,
                                     observationLag,
                                     calendar, bdc, dc,
                                     Handle<YieldTermStructure>(nominalTS));
@@ -384,7 +384,7 @@ void InflationTest::testZeroTermStructure() {
     // and that the helpers give the correct impled rates
     const Real eps = 0.00000001;
     bool forceLinearInterpolation = false;
-    for (Size i=0; i<LENGTH(zcData); i++) {
+    for (Size i=0; i<zcData.size(); i++) {
         BOOST_REQUIRE_MESSAGE(std::fabs(zcData[i].rate/100.0
             - pZITS->zeroRate(zcData[i].date, observationLag, forceLinearInterpolation)) < eps,
             "ZITS zeroRate != instrument "
@@ -502,7 +502,7 @@ void InflationTest::testZeroTermStructure() {
     Period observationLagyes = Period(3,Months);
     std::vector<ext::shared_ptr<BootstrapHelper<ZeroInflationTermStructure> > > helpersyes =
     makeHelpers<ZeroInflationTermStructure,ZeroCouponInflationSwapHelper,
-    ZeroInflationIndex>(zcData, LENGTH(zcData), iiyes,
+    ZeroInflationIndex>(zcData, iiyes,
                         observationLagyes,
                         calendar, bdc, dc,
                         Handle<YieldTermStructure>(nominalTS));
@@ -517,7 +517,7 @@ void InflationTest::testZeroTermStructure() {
     // first check that the zero rates on the curve match the data
     // and that the helpers give the correct impled rates
     forceLinearInterpolation = false;   // still
-    for (Size i=0; i<LENGTH(zcData); i++) {
+    for (Size i=0; i<zcData.size(); i++) {
         BOOST_CHECK_MESSAGE(std::fabs(zcData[i].rate/100.0
                     - pZITSyes->zeroRate(zcData[i].date, observationLagyes, forceLinearInterpolation)) < eps,
                     "ZITS INTERPOLATED zeroRate != instrument "
@@ -834,7 +834,7 @@ void InflationTest::testYYTermStructure() {
     ext::shared_ptr<YieldTermStructure> nominalTS = nominalTermStructure();
 
     // now build the YoY inflation curve
-    Datum yyData[] = {
+    std::vector<Datum> yyData = {
         { Date(13, August, 2008), 2.95 },
         { Date(13, August, 2009), 2.95 },
         { Date(13, August, 2010), 2.93 },
@@ -858,7 +858,7 @@ void InflationTest::testYYTermStructure() {
     // now build the helpers ...
     std::vector<ext::shared_ptr<BootstrapHelper<YoYInflationTermStructure> > > helpers =
     makeHelpers<YoYInflationTermStructure,YearOnYearInflationSwapHelper,
-    YoYInflationIndex>(yyData, LENGTH(yyData), iir,
+    YoYInflationIndex>(yyData, iir,
                        observationLag,
                        calendar, bdc, dc,
                        Handle<YieldTermStructure>(nominalTS));
@@ -884,7 +884,7 @@ void InflationTest::testYYTermStructure() {
     // make sure that the index has the latest yoy term structure
     hy.linkTo(pYYTS);
 
-    for (Size j = 1; j < LENGTH(yyData); j++) {
+    for (Size j = 1; j < yyData.size(); j++) {
 
         from = nominalTS->referenceDate();
         to = yyData[j].date;
diff --git a/test-suite/inflationcapfloor.cpp b/test-suite/inflationcapfloor.cpp
index f89ac92656a..f3e7844262a 100644
--- a/test-suite/inflationcapfloor.cpp
+++ b/test-suite/inflationcapfloor.cpp
@@ -64,7 +64,7 @@ namespace inflation_capfloor_test {
 
     template <class T, class U, class I>
     std::vector<ext::shared_ptr<BootstrapHelper<T> > > makeHelpers(
-                 Datum iiData[], Size N,
+                 const std::vector<Datum>& iiData,
                  const ext::shared_ptr<I> &ii, const Period &observationLag,
                  const Calendar &calendar,
                  const BusinessDayConvention &bdc,
@@ -72,10 +72,10 @@ namespace inflation_capfloor_test {
                  const Handle<YieldTermStructure>& discountCurve) {
 
         std::vector<ext::shared_ptr<BootstrapHelper<T> > > instruments;
-        for (Size i=0; i<N; i++) {
-            Date maturity = iiData[i].date;
+        for (Datum datum : iiData) {
+            Date maturity = datum.date;
             Handle<Quote> quote(ext::shared_ptr<Quote>(
-                    new SimpleQuote(iiData[i].rate/100.0)));
+                    new SimpleQuote(datum.rate/100.0)));
             ext::shared_ptr<BootstrapHelper<T> > anInstrument(new U(
                     quote, observationLag, maturity,
                     calendar, bdc, dc, ii, discountCurve));
@@ -153,7 +153,7 @@ namespace inflation_capfloor_test {
             // now build the YoY inflation curve
             Period observationLag = Period(2,Months);
 
-            Datum yyData[] = {
+            std::vector<Datum> yyData = {
                 { Date(13, August, 2008), 2.95 },
                 { Date(13, August, 2009), 2.95 },
                 { Date(13, August, 2010), 2.93 },
@@ -174,7 +174,7 @@ namespace inflation_capfloor_test {
             // now build the helpers ...
             std::vector<ext::shared_ptr<BootstrapHelper<YoYInflationTermStructure> > > helpers =
             makeHelpers<YoYInflationTermStructure,YearOnYearInflationSwapHelper,
-            YoYInflationIndex>(yyData, LENGTH(yyData), iir,
+            YoYInflationIndex>(yyData, iir,
                                observationLag,
                                calendar, convention, dc,
                                Handle<YieldTermStructure>(nominalTS));
@@ -291,19 +291,19 @@ void InflationCapFloorTest::testConsistency() {
 
     for (Size whichPricer = 0; whichPricer < 3; whichPricer++) {
         for (int& length : lengths) {
-            for (Size j = 0; j < LENGTH(cap_rates); j++) {
+            for (double& cap_rate : cap_rates) {
                 for (double& floor_rate : floor_rates) {
                     for (double vol : vols) {
 
                         Leg leg = vars.makeYoYLeg(vars.evaluationDate, length);
 
                         ext::shared_ptr<YoYInflationCapFloor> cap = vars.makeYoYCapFloor(
-                            YoYInflationCapFloor::Cap, leg, cap_rates[j], vol, whichPricer);
+                            YoYInflationCapFloor::Cap, leg, cap_rate, vol, whichPricer);
 
                         ext::shared_ptr<YoYInflationCapFloor> floor = vars.makeYoYCapFloor(
                             YoYInflationCapFloor::Floor, leg, floor_rate, vol, whichPricer);
 
-                        YoYInflationCollar collar(leg, std::vector<Rate>(1, cap_rates[j]),
+                        YoYInflationCollar collar(leg, std::vector<Rate>(1, cap_rate),
                                                   std::vector<Rate>(1, floor_rate));
                         collar.setPricingEngine(vars.makeEngine(vol, whichPricer));
 
@@ -312,7 +312,7 @@ void InflationCapFloorTest::testConsistency() {
                                        << "    length:       " << length << " years\n"
                                        << "    volatility:   " << io::volatility(vol) << "\n"
                                        << "    cap value:    " << cap->NPV()
-                                       << " at strike: " << io::rate(cap_rates[j]) << "\n"
+                                       << " at strike: " << io::rate(cap_rate) << "\n"
                                        << "    floor value:  " << floor->NPV()
                                        << " at strike: " << io::rate(floor_rate) << "\n"
                                        << "    collar value: " << collar.NPV());
@@ -332,7 +332,7 @@ void InflationCapFloorTest::testConsistency() {
                                            << "    length:       " << length << " years\n"
                                            << "    volatility:   " << io::volatility(vol) << "\n"
                                            << "    cap value:    " << cap->NPV()
-                                           << " at strike: " << io::rate(cap_rates[j]) << "\n"
+                                           << " at strike: " << io::rate(cap_rate) << "\n"
                                            << "    sum of caplets value:  " << capletsNPV
                                            << " at strike (first): "
                                            << io::rate(caplets[0]->capRates()[0]) << "\n");
@@ -351,7 +351,7 @@ void InflationCapFloorTest::testConsistency() {
                                            << "    length:       " << length << " years\n"
                                            << "    volatility:   " << io::volatility(vol) << "\n"
                                            << "    cap value:    " << floor->NPV()
-                                           << " at strike: " << io::rate(floor_rates[j]) << "\n"
+                                           << " at strike: " << io::rate(floor_rate) << "\n"
                                            << "    sum of floorlets value:  " << floorletsNPV
                                            << " at strike (first): "
                                            << io::rate(floorlets[0]->floorRates()[0]) << "\n");
@@ -366,12 +366,12 @@ void InflationCapFloorTest::testConsistency() {
                             }
 
                             if (std::fabs(collar.NPV() - collarletsNPV) > 1e-6) {
-                                BOOST_FAIL("sum of collarlet NPVs does not equal floor NPV:\n"
+                                BOOST_FAIL("sum of collarlet NPVs does not equal collar NPV:\n"
                                            << "    length:       " << length << " years\n"
                                            << "    volatility:   " << io::volatility(vol) << "\n"
                                            << "    cap value:    " << collar.NPV()
-                                           << " at strike floor: " << io::rate(floor_rates[j])
-                                           << " at strike cap: " << io::rate(cap_rates[j]) << "\n"
+                                           << " at strike floor: " << io::rate(floor_rate)
+                                           << " at strike cap: " << io::rate(cap_rate) << "\n"
                                            << "    sum of collarlets value:  " << collarletsNPV
                                            << " at strike floor (first): "
                                            << io::rate(collarlets[0]->floorRates()[0])
diff --git a/test-suite/inflationcapflooredcoupon.cpp b/test-suite/inflationcapflooredcoupon.cpp
index 1c65c39414b..5e1767ea0e6 100644
--- a/test-suite/inflationcapflooredcoupon.cpp
+++ b/test-suite/inflationcapflooredcoupon.cpp
@@ -66,7 +66,7 @@ namespace inflation_capfloored_coupon_test {
 
     template <class T, class U, class I>
     std::vector<ext::shared_ptr<BootstrapHelper<T> > > makeHelpers(
-                        Datum iiData[], Size N,
+                        const std::vector<Datum>& iiData,
                         const ext::shared_ptr<I> &ii, const Period &observationLag,
                         const Calendar &calendar,
                         const BusinessDayConvention &bdc,
@@ -74,10 +74,10 @@ namespace inflation_capfloored_coupon_test {
                         const Handle<YieldTermStructure>& discountCurve) {
 
         std::vector<ext::shared_ptr<BootstrapHelper<T> > > instruments;
-        for (Size i=0; i<N; i++) {
-            Date maturity = iiData[i].date;
+        for (Datum datum : iiData) {
+            Date maturity = datum.date;
             Handle<Quote> quote(ext::shared_ptr<Quote>(
-                            new SimpleQuote(iiData[i].rate/100.0)));
+                            new SimpleQuote(datum.rate/100.0)));
             ext::shared_ptr<BootstrapHelper<T> > anInstrument(new U(
                             quote, observationLag, maturity,
                             calendar, bdc, dc, ii, discountCurve));
@@ -162,7 +162,7 @@ namespace inflation_capfloored_coupon_test {
             // now build the YoY inflation curve
             Period observationLag = Period(2,Months);
 
-            Datum yyData[] = {
+            std::vector<Datum> yyData = {
                 { Date(13, August, 2008), 2.95 },
                 { Date(13, August, 2009), 2.95 },
                 { Date(13, August, 2010), 2.93 },
@@ -183,7 +183,7 @@ namespace inflation_capfloored_coupon_test {
             // now build the helpers ...
             std::vector<ext::shared_ptr<BootstrapHelper<YoYInflationTermStructure> > > helpers =
             makeHelpers<YoYInflationTermStructure,YearOnYearInflationSwapHelper,
-            YoYInflationIndex>(yyData, LENGTH(yyData), iir,
+            YoYInflationIndex>(yyData, iir,
                                observationLag,
                                calendar, convention, dc,
                                Handle<YieldTermStructure>(nominalTS));
diff --git a/test-suite/inflationcpibond.cpp b/test-suite/inflationcpibond.cpp
index cf8f881e8cf..38f0985b731 100644
--- a/test-suite/inflationcpibond.cpp
+++ b/test-suite/inflationcpibond.cpp
@@ -52,7 +52,7 @@ namespace inflation_cpi_bond_test {
     typedef BootstrapHelper<ZeroInflationTermStructure> Helper;
 
     std::vector<ext::shared_ptr<Helper> > makeHelpers(
-        Datum iiData[], Size N,
+        const std::vector<Datum>& iiData,
         const ext::shared_ptr<ZeroInflationIndex>& ii,
         const Period& observationLag,
         const Calendar& calendar,
@@ -61,10 +61,10 @@ namespace inflation_cpi_bond_test {
         const Handle<YieldTermStructure>& yTS) {
 
         std::vector<ext::shared_ptr<Helper> > instruments;
-        for (Size i=0; i<N; i++) {
-            Date maturity = iiData[i].date;
+        for (Datum datum : iiData) {
+            Date maturity = datum.date;
             Handle<Quote> quote(ext::shared_ptr<Quote>(
-                                new SimpleQuote(iiData[i].rate/100.0)));
+                                new SimpleQuote(datum.rate/100.0)));
             ext::shared_ptr<Helper> h(
                       new ZeroCouponInflationSwapHelper(quote, observationLag,
                                                         maturity, calendar,
@@ -131,7 +131,7 @@ namespace inflation_cpi_bond_test {
             // now build the zero inflation curve
             observationLag = Period(2,Months);
 
-            Datum zciisData[] = {
+            std::vector<Datum> zciisData = {
                 { Date(25, November, 2010), 3.0495 },
                 { Date(25, November, 2011), 2.93 },
                 { Date(26, November, 2012), 2.9795 },
@@ -152,7 +152,7 @@ namespace inflation_cpi_bond_test {
             };
 
             std::vector<ext::shared_ptr<Helper> > helpers =
-                makeHelpers(zciisData, LENGTH(zciisData), ii,
+                makeHelpers(zciisData, ii,
                             observationLag, calendar, convention, dayCounter, yTS);
 
             Rate baseZeroRate = zciisData[0].rate/100.0;
diff --git a/test-suite/inflationcpiswap.cpp b/test-suite/inflationcpiswap.cpp
index c21619768d6..0dc0f6179b6 100644
--- a/test-suite/inflationcpiswap.cpp
+++ b/test-suite/inflationcpiswap.cpp
@@ -408,8 +408,7 @@ void CPISwapTest::zciisconsistency() {
     zciis.setPricingEngine(dse);
     QL_REQUIRE(fabs(zciis.NPV())<1e-3,"zciis does not reprice to zero");
 
-    std::vector<Date> oneDate;
-    oneDate.push_back(endDate);
+    std::vector<Date> oneDate = {endDate};
     Schedule schOneDate(oneDate, cal, paymentConvention);
 
     CPISwap::Type stype = CPISwap::Payer;
diff --git a/test-suite/inflationvolatility.cpp b/test-suite/inflationvolatility.cpp
index c3af1d03964..08c9ed6cc67 100644
--- a/test-suite/inflationvolatility.cpp
+++ b/test-suite/inflationvolatility.cpp
@@ -39,10 +39,6 @@
 #include <ql/indexes/inflation/euhicp.hpp>
 #include <ql/indexes/inflation/ukrpi.hpp>
 
-#ifndef LENGTH
-#define LENGTH(a) (sizeof(a)/sizeof(a[0]))
-#endif
-
 #include <iostream>
 
 
diff --git a/test-suite/interpolations.cpp b/test-suite/interpolations.cpp
index ba20261ea1a..0f1a1fd8d0e 100644
--- a/test-suite/interpolations.cpp
+++ b/test-suite/interpolations.cpp
@@ -53,9 +53,6 @@
 using namespace QuantLib;
 using namespace boost::unit_test_framework;
 
-#define BEGIN(x) (x+0)
-#define END(x) (x+LENGTH(x))
-
 namespace {
 
     std::vector<Real> xRange(Real start, Real finish, Size points) {
@@ -361,18 +358,18 @@ void InterpolationTest::testSplineOnRPN15AValues() {
 
     // Natural spline
     CubicInterpolation f = CubicInterpolation(
-                                    BEGIN(RPN15A_x), END(RPN15A_x),
-                                    BEGIN(RPN15A_y),
+                                    std::begin(RPN15A_x), std::end(RPN15A_x),
+                                    std::begin(RPN15A_y),
                                     CubicInterpolation::Spline, false,
                                     CubicInterpolation::SecondDerivative, 0.0,
                                     CubicInterpolation::SecondDerivative, 0.0);
     f.update();
     checkValues("Natural spline", f,
-                BEGIN(RPN15A_x), END(RPN15A_x), BEGIN(RPN15A_y));
+                std::begin(RPN15A_x), std::end(RPN15A_x), std::begin(RPN15A_y));
     check2ndDerivativeValue("Natural spline", f,
-                            *BEGIN(RPN15A_x), 0.0);
+                            *std::begin(RPN15A_x), 0.0);
     check2ndDerivativeValue("Natural spline", f,
-                            *(END(RPN15A_x)-1), 0.0);
+                            *(std::end(RPN15A_x)-1), 0.0);
     // poor performance
     Real x_bad = 11.0;
     interpolated = f(x_bad);
@@ -386,17 +383,17 @@ void InterpolationTest::testSplineOnRPN15AValues() {
 
 
     // Clamped spline
-    f = CubicInterpolation(BEGIN(RPN15A_x), END(RPN15A_x), BEGIN(RPN15A_y),
+    f = CubicInterpolation(std::begin(RPN15A_x), std::end(RPN15A_x), std::begin(RPN15A_y),
                            CubicInterpolation::Spline, false,
                            CubicInterpolation::FirstDerivative, 0.0,
                            CubicInterpolation::FirstDerivative, 0.0);
     f.update();
     checkValues("Clamped spline", f,
-                BEGIN(RPN15A_x), END(RPN15A_x), BEGIN(RPN15A_y));
+                std::begin(RPN15A_x), std::end(RPN15A_x), std::begin(RPN15A_y));
     check1stDerivativeValue("Clamped spline", f,
-                            *BEGIN(RPN15A_x), 0.0);
+                            *std::begin(RPN15A_x), 0.0);
     check1stDerivativeValue("Clamped spline", f,
-                            *(END(RPN15A_x)-1), 0.0);
+                            *(std::end(RPN15A_x)-1), 0.0);
     // poor performance
     interpolated = f(x_bad);
     if (interpolated<1.0) {
@@ -409,13 +406,13 @@ void InterpolationTest::testSplineOnRPN15AValues() {
 
 
     // Not-a-knot spline
-    f = CubicInterpolation(BEGIN(RPN15A_x), END(RPN15A_x), BEGIN(RPN15A_y),
+    f = CubicInterpolation(std::begin(RPN15A_x), std::end(RPN15A_x), std::begin(RPN15A_y),
                            CubicInterpolation::Spline, false,
                            CubicInterpolation::NotAKnot, Null<Real>(),
                            CubicInterpolation::NotAKnot, Null<Real>());
     f.update();
     checkValues("Not-a-knot spline", f,
-                BEGIN(RPN15A_x), END(RPN15A_x), BEGIN(RPN15A_y));
+                std::begin(RPN15A_x), std::end(RPN15A_x), std::begin(RPN15A_y));
     checkNotAKnotCondition("Not-a-knot spline", f);
     // poor performance
     interpolated = f(x_bad);
@@ -429,14 +426,14 @@ void InterpolationTest::testSplineOnRPN15AValues() {
 
 
     // MC natural spline values
-    f = CubicInterpolation(BEGIN(RPN15A_x), END(RPN15A_x),
-                           BEGIN(RPN15A_y),
+    f = CubicInterpolation(std::begin(RPN15A_x), std::end(RPN15A_x),
+                           std::begin(RPN15A_y),
                            CubicInterpolation::Spline, true,
                            CubicInterpolation::SecondDerivative, 0.0,
                            CubicInterpolation::SecondDerivative, 0.0);
     f.update();
     checkValues("MC natural spline", f,
-                BEGIN(RPN15A_x), END(RPN15A_x), BEGIN(RPN15A_y));
+                std::begin(RPN15A_x), std::end(RPN15A_x), std::begin(RPN15A_y));
     // good performance
     interpolated = f(x_bad);
     if (interpolated>1.0) {
@@ -449,17 +446,17 @@ void InterpolationTest::testSplineOnRPN15AValues() {
 
 
     // MC clamped spline values
-    f = CubicInterpolation(BEGIN(RPN15A_x), END(RPN15A_x), BEGIN(RPN15A_y),
+    f = CubicInterpolation(std::begin(RPN15A_x), std::end(RPN15A_x), std::begin(RPN15A_y),
                            CubicInterpolation::Spline, true,
                            CubicInterpolation::FirstDerivative, 0.0,
                            CubicInterpolation::FirstDerivative, 0.0);
     f.update();
     checkValues("MC clamped spline", f,
-                BEGIN(RPN15A_x), END(RPN15A_x), BEGIN(RPN15A_y));
+                std::begin(RPN15A_x), std::end(RPN15A_x), std::begin(RPN15A_y));
     check1stDerivativeValue("MC clamped spline", f,
-                            *BEGIN(RPN15A_x), 0.0);
+                            *std::begin(RPN15A_x), 0.0);
     check1stDerivativeValue("MC clamped spline", f,
-                            *(END(RPN15A_x)-1), 0.0);
+                            *(std::end(RPN15A_x)-1), 0.0);
     // good performance
     interpolated = f(x_bad);
     if (interpolated>1.0) {
@@ -472,13 +469,13 @@ void InterpolationTest::testSplineOnRPN15AValues() {
 
 
     // MC not-a-knot spline values
-    f = CubicInterpolation(BEGIN(RPN15A_x), END(RPN15A_x), BEGIN(RPN15A_y),
+    f = CubicInterpolation(std::begin(RPN15A_x), std::end(RPN15A_x), std::begin(RPN15A_y),
                            CubicInterpolation::Spline, true,
                            CubicInterpolation::NotAKnot, Null<Real>(),
                            CubicInterpolation::NotAKnot, Null<Real>());
     f.update();
     checkValues("MC not-a-knot spline", f,
-                BEGIN(RPN15A_x), END(RPN15A_x), BEGIN(RPN15A_y));
+                std::begin(RPN15A_x), std::end(RPN15A_x), std::begin(RPN15A_y));
     // good performance
     interpolated = f(x_bad);
     if (interpolated>1.0) {
@@ -507,8 +504,8 @@ void InterpolationTest::testSplineOnGenericValues() {
     std::vector<Real> x35(3);
 
     // Natural spline
-    CubicInterpolation f(BEGIN(generic_x), END(generic_x),
-                         BEGIN(generic_y),
+    CubicInterpolation f(std::begin(generic_x), std::end(generic_x),
+                         std::begin(generic_y),
                          CubicInterpolation::Spline, false,
                          CubicInterpolation::SecondDerivative,
                          generic_natural_y2[0],
@@ -516,7 +513,7 @@ void InterpolationTest::testSplineOnGenericValues() {
                          generic_natural_y2[n-1]);
     f.update();
     checkValues("Natural spline", f,
-                BEGIN(generic_x), END(generic_x), BEGIN(generic_y));
+                std::begin(generic_x), std::end(generic_x), std::begin(generic_y));
     // cached second derivative
     for (i=0; i<n; i++) {
         interpolated = f.secondDerivative(generic_x[i]);
@@ -534,28 +531,28 @@ void InterpolationTest::testSplineOnGenericValues() {
 
     // Clamped spline
     Real y1a = 0.0, y1b = 0.0;
-    f = CubicInterpolation(BEGIN(generic_x), END(generic_x), BEGIN(generic_y),
+    f = CubicInterpolation(std::begin(generic_x), std::end(generic_x), std::begin(generic_y),
                     CubicInterpolation::Spline, false,
                     CubicInterpolation::FirstDerivative, y1a,
                     CubicInterpolation::FirstDerivative, y1b);
     f.update();
     checkValues("Clamped spline", f,
-                BEGIN(generic_x), END(generic_x), BEGIN(generic_y));
+                std::begin(generic_x), std::end(generic_x), std::begin(generic_y));
     check1stDerivativeValue("Clamped spline", f,
-                            *BEGIN(generic_x), 0.0);
+                            *std::begin(generic_x), 0.0);
     check1stDerivativeValue("Clamped spline", f,
-                            *(END(generic_x)-1), 0.0);
+                            *(std::end(generic_x)-1), 0.0);
     x35[0] = f(3.5);
 
 
     // Not-a-knot spline
-    f = CubicInterpolation(BEGIN(generic_x), END(generic_x), BEGIN(generic_y),
+    f = CubicInterpolation(std::begin(generic_x), std::end(generic_x), std::begin(generic_y),
                            CubicInterpolation::Spline, false,
                            CubicInterpolation::NotAKnot, Null<Real>(),
                            CubicInterpolation::NotAKnot, Null<Real>());
     f.update();
     checkValues("Not-a-knot spline", f,
-                BEGIN(generic_x), END(generic_x), BEGIN(generic_y));
+                std::begin(generic_x), std::end(generic_x), std::begin(generic_y));
     checkNotAKnotCondition("Not-a-knot spline", f);
 
     x35[2] = f(3.5);
@@ -907,7 +904,7 @@ void InterpolationTest::testAsFunctor() {
     const Real x[] = { 0.0, 1.0, 2.0, 3.0, 4.0 };
     const Real y[] = { 5.0, 4.0, 3.0, 2.0, 1.0 };
 
-   Interpolation f = LinearInterpolation(BEGIN(x), END(x), BEGIN(y));
+   Interpolation f = LinearInterpolation(std::begin(x), std::end(x), std::begin(y));
     f.update();
 
     const Real x2[] = { -2.0, -1.0, 0.0, 1.0, 3.0, 4.0, 5.0, 6.0, 7.0 };
@@ -917,7 +914,7 @@ void InterpolationTest::testAsFunctor() {
 
     // case 1: extrapolation not allowed
     try {
-        std::transform(BEGIN(x2), END(x2), y2.begin(), f);
+        std::transform(std::begin(x2), std::end(x2), y2.begin(), f);
         throw NotThrown();
     }
     catch (Error&) {
@@ -930,7 +927,7 @@ void InterpolationTest::testAsFunctor() {
     // case 2: enable extrapolation
     f.enableExtrapolation();
     y2 = std::vector<Real>(N);
-    std::transform(BEGIN(x2), END(x2), y2.begin(), f);
+    std::transform(std::begin(x2), std::end(x2), y2.begin(), f);
     for (Size i=0; i<N; i++) {
         Real expected = 5.0-x2[i];
         if (std::fabs(y2[i]-expected) > tolerance)
@@ -966,7 +963,7 @@ void InterpolationTest::testFritschButland() {
 
     for (Size i=0; i<3; ++i) {
 
-        Interpolation f = FritschButlandCubic(BEGIN(x), END(x), BEGIN(y[i]));
+        Interpolation f = FritschButlandCubic(std::begin(x), std::end(x), std::begin(y[i]));
         f.update();
 
         for (Size j=0; j<4; ++j) {
@@ -998,7 +995,7 @@ void InterpolationTest::testBackwardFlat() {
     const Real x[] = { 0.0, 1.0, 2.0, 3.0, 4.0 };
     const Real y[] = { 5.0, 4.0, 3.0, 2.0, 1.0 };
 
-    Interpolation f = BackwardFlatInterpolation(BEGIN(x), END(x), BEGIN(y));
+    Interpolation f = BackwardFlatInterpolation(std::begin(x), std::end(x), std::begin(y));
     f.update();
 
     Size N = LENGTH(x);
@@ -1116,7 +1113,7 @@ void InterpolationTest::testForwardFlat() {
     const Real x[] = { 0.0, 1.0, 2.0, 3.0, 4.0 };
     const Real y[] = { 5.0, 4.0, 3.0, 2.0, 1.0 };
 
-    Interpolation f = ForwardFlatInterpolation(BEGIN(x), END(x), BEGIN(y));
+    Interpolation f = ForwardFlatInterpolation(std::begin(x), std::end(x), std::begin(y));
     f.update();
 
     Size N = LENGTH(x);
@@ -1297,9 +1294,10 @@ void InterpolationTest::testSabrInterpolation(){
 
     Real calibrationTolerance = 5.0e-8;
     // initialize optimization methods
-    std::vector<ext::shared_ptr<OptimizationMethod> > methods_;
-    methods_.push_back( ext::shared_ptr<OptimizationMethod>(new Simplex(0.01)));
-    methods_.push_back( ext::shared_ptr<OptimizationMethod>(new LevenbergMarquardt(1e-8, 1e-8, 1e-8)));
+    std::vector<ext::shared_ptr<OptimizationMethod>> methods_ = {
+        ext::shared_ptr<OptimizationMethod>(new Simplex(0.01)),
+        ext::shared_ptr<OptimizationMethod>(new LevenbergMarquardt(1e-8, 1e-8, 1e-8))
+    };
     // Initialize end criteria
     ext::shared_ptr<EndCriteria> endCriteria(new
                   EndCriteria(100000, 100, 1e-8, 1e-8, 1e-8));
@@ -1390,30 +1388,18 @@ void InterpolationTest::testKernelInterpolation() {
 
     BOOST_TEST_MESSAGE("Testing kernel 1D interpolation...");
 
-    std::vector<Real> deltaGrid(5); // x-values, here delta in FX
-    deltaGrid[0]=0.10; deltaGrid[1]=0.25; deltaGrid[2]=0.50;
-    deltaGrid[3]=0.75; deltaGrid[4]=0.90;
-
-    std::vector<Real> yd1(deltaGrid.size()); // test y-values 1
-    yd1[0]=11.275; yd1[1]=11.125; yd1[2]=11.250;
-    yd1[3]=11.825; yd1[4]=12.625;
+    std::vector<Real> deltaGrid = {0.10, 0.25, 0.50, 0.75, 0.90};
 
     std::vector<Real> yd2(deltaGrid.size()); // test y-values 2
-    yd2[0]=16.025; yd2[1]=13.450; yd2[2]=11.350;
-    yd2[3]=10.150; yd2[4]=10.075;
 
     std::vector<Real> yd3(deltaGrid.size()); // test y-values 3
-    yd3[0]=10.3000; yd3[1]=9.6375; yd3[2]=9.2000;
-    yd3[3]=9.1125; yd3[4]=9.4000;
-
-    std::vector<std::vector<Real> > yd;
-    yd.push_back(yd1);
-    yd.push_back(yd2);
-    yd.push_back(yd3);
 
-    std::vector<Real> lambdaVec(5);
-    lambdaVec[0]=0.05; lambdaVec[1]=0.50; lambdaVec[2]=0.75;
-    lambdaVec[3]=1.65; lambdaVec[4]=2.55;
+    std::vector<std::vector<Real>> yd = {
+        {11.275, 11.125, 11.250, 11.825, 12.625},
+        {16.025, 13.450, 11.350, 10.150, 10.075},
+        {10.300, 9.6375, 9.2000, 9.1125, 9.4000}
+    };
+    std::vector<Real> lambdaVec = {0.05, 0.50, 0.75, 1.65, 2.55};
 
     Real tolerance = 2.0e-5;
 
@@ -1453,30 +1439,17 @@ void InterpolationTest::testKernelInterpolation() {
         }
     }
 
-    std::vector<Real> testDeltaGrid(deltaGrid.size());
-    testDeltaGrid[0]=0.121; testDeltaGrid[1]=0.279; testDeltaGrid[2]=0.678;
-    testDeltaGrid[3]=0.790; testDeltaGrid[4]=0.980;
+    std::vector<Real> testDeltaGrid = {0.121, 0.279, 0.678, 0.790, 0.980};
 
     // Gaussian Kernel values for testDeltaGrid with a standard
     // deviation of 2.05 (the value is arbitrary.)  Source: parrallel
     // implementation in R, no literature sources found
 
-    std::vector<Real> ytd1(testDeltaGrid.size());
-    ytd1[0]=11.23847; ytd1[1]=11.12003; ytd1[2]=11.58932;
-    ytd1[3]=11.99168; ytd1[4]=13.29650;
-
-    std::vector<Real> ytd2(testDeltaGrid.size());
-    ytd2[0]=15.55922; ytd2[1]=13.11088; ytd2[2]=10.41615;
-    ytd2[3]=10.05153; ytd2[4]=10.50741;
-
-    std::vector<Real> ytd3(testDeltaGrid.size());
-    ytd3[0]= 10.17473; ytd3[1]= 9.557842; ytd3[2]= 9.09339;
-    ytd3[3]= 9.149687; ytd3[4]= 9.779971;
-
-    std::vector<std::vector<Real> > ytd;
-    ytd.push_back(ytd1);
-    ytd.push_back(ytd2);
-    ytd.push_back(ytd3);
+    std::vector<std::vector<Real>> ytd = {
+        {11.23847, 11.12003, 11.58932, 11.99168, 13.29650},
+        {15.55922, 13.11088, 10.41615, 10.05153, 10.50741},
+        {10.17473, 9.557842, 9.09339,  9.149687, 9.779971}
+    };
 
     GaussianKernel myKernel(0,2.05);
 
@@ -1910,9 +1883,10 @@ void InterpolationTest::testNoArbSabrInterpolation(){
 
     Real calibrationTolerance = 5.0e-6;
     // initialize optimization methods
-    std::vector<ext::shared_ptr<OptimizationMethod> > methods_;
-    methods_.push_back( ext::shared_ptr<OptimizationMethod>(new Simplex(0.01)));
-    methods_.push_back( ext::shared_ptr<OptimizationMethod>(new LevenbergMarquardt(1e-8, 1e-8, 1e-8)));
+    std::vector<ext::shared_ptr<OptimizationMethod>> methods_ = {
+        ext::shared_ptr<OptimizationMethod>(new Simplex(0.01)),
+        ext::shared_ptr<OptimizationMethod>(new LevenbergMarquardt(1e-8, 1e-8, 1e-8))
+    };
     // Initialize end criteria
     ext::shared_ptr<EndCriteria> endCriteria(new
                   EndCriteria(100000, 100, 1e-8, 1e-8, 1e-8));
@@ -2185,11 +2159,11 @@ void InterpolationTest::testLagrangeInterpolation() {
 
     BOOST_TEST_MESSAGE("Testing Lagrange interpolation...");
 
-    const Real x[] = {-1.0 , -0.5, -0.25, 0.1, 0.4, 0.75, 0.96};
-    Array y(LENGTH(x));
-    std::transform(x, x+LENGTH(x), y.begin(), &lagrangeTestFct);
+    const std::vector<Real> x = {-1.0 , -0.5, -0.25, 0.1, 0.4, 0.75, 0.96};
+    Array y(x.size());
+    std::transform(x.begin(), x.end(), y.begin(), &lagrangeTestFct);
 
-    LagrangeInterpolation interpl(&x[0], x+LENGTH(x), y.begin());
+    LagrangeInterpolation interpl(x.begin(), x.end(), y.begin());
 
     // reference results are taken from R package pracma
     const Real references[] = {
@@ -2364,18 +2338,18 @@ void InterpolationTest::testBSplines() {
     const Natural p = 2;
     const BSpline bspline(p, knots.size()-p-2, knots);
 
-    std::vector<ext::tuple<Natural, Real, Real> > referenceValues;
-    referenceValues += ext::make_tuple(0, -0.95, 9.5238095238e-04),
-        ext::make_tuple(0, -0.01, 0.37337142857),
-        ext::make_tuple(0, 0.49, 0.84575238095),
-        ext::make_tuple(0, 1.21, 0.0),
-        ext::make_tuple(1, 1.49, 0.562987654321),
-        ext::make_tuple(1, 1.59, 0.490888888889),
-        ext::make_tuple(2, 1.99, 0.62429409171),
-        ext::make_tuple(3, 1.19, 0.0),
-        ext::make_tuple(3, 1.99, 0.12382936508),
-        ext::make_tuple(3, 3.59, 0.765914285714);
-
+    std::vector<ext::tuple<Natural, Real, Real>> referenceValues = {
+        {0, -0.95, 9.5238095238e-04},
+        {0, -0.01, 0.37337142857},
+        {0, 0.49, 0.84575238095},
+        {0, 1.21, 0.0},
+        {1, 1.49, 0.562987654321},
+        {1, 1.59, 0.490888888889},
+        {2, 1.99, 0.62429409171},
+        {3, 1.19, 0.0},
+        {3, 1.99, 0.12382936508},
+        {3, 3.59, 0.765914285714}
+    };
 
     const Real tol = 1e-10;
     for (auto& referenceValue : referenceValues) {
diff --git a/test-suite/libormarketmodel.cpp b/test-suite/libormarketmodel.cpp
index ac39ddfd780..0bcd41ca775 100644
--- a/test-suite/libormarketmodel.cpp
+++ b/test-suite/libormarketmodel.cpp
@@ -77,12 +77,8 @@ namespace libor_market_model_test {
 
 
     ext::shared_ptr<IborIndex> makeIndex() {
-        std::vector<Date> dates;
-        std::vector<Rate> rates;
-        dates.emplace_back(4, September, 2005);
-        dates.emplace_back(4, September, 2018);
-        rates.push_back(0.039);
-        rates.push_back(0.041);
+        std::vector<Date> dates = {{4,September,2005}, {4,September,2018}};
+        std::vector<Rate> rates = {0.039, 0.041};
 
         return makeIndex(dates, rates);
     }
@@ -367,12 +363,8 @@ void LiborMarketModelTest::testSwaptionPricing() {
     else
         tolerance = 1e-12;
 
-    std::vector<Date> dates;
-    std::vector<Rate> rates;
-    dates.emplace_back(4, September, 2005);
-    dates.emplace_back(4, September, 2011);
-    rates.push_back(0.04);
-    rates.push_back(0.08);
+    std::vector<Date> dates = {{4,September,2005}, {4,September,2011}};
+    std::vector<Rate> rates = {0.04, 0.08};
 
     ext::shared_ptr<IborIndex> index = makeIndex(dates, rates);
 
diff --git a/test-suite/libormarketmodelprocess.cpp b/test-suite/libormarketmodelprocess.cpp
index 82d2b36f30a..3d7c2230b62 100644
--- a/test-suite/libormarketmodelprocess.cpp
+++ b/test-suite/libormarketmodelprocess.cpp
@@ -40,12 +40,8 @@ namespace libor_market_model_process_test {
 
     ext::shared_ptr<IborIndex> makeIndex() {
         DayCounter dayCounter = Actual360();
-        std::vector<Date> dates;
-        std::vector<Rate> rates;
-        dates.emplace_back(4, September, 2005);
-        dates.emplace_back(4, September, 2018);
-        rates.push_back(0.01);
-        rates.push_back(0.08);
+        std::vector<Date> dates = {{4,September,2005}, {4,September,2018}};
+        std::vector<Rate> rates = {0.01, 0.08};
 
         RelinkableHandle<YieldTermStructure> termStructure(
                       ext::shared_ptr<YieldTermStructure>(
diff --git a/test-suite/linearleastsquaresregression.cpp b/test-suite/linearleastsquaresregression.cpp
index 84aefdda559..0acfd50fe7d 100644
--- a/test-suite/linearleastsquaresregression.cpp
+++ b/test-suite/linearleastsquaresregression.cpp
@@ -48,21 +48,24 @@ void LinearLeastSquaresRegressionTest::testRegression() {
     const Size nr=100000;
     PseudoRandom::rng_type rng(PseudoRandom::urng_type(1234U));
 
-    std::vector<ext::function<Real(Real)> > v;
-    v.emplace_back(constant<Real, Real>(1.0));
-    v.emplace_back(identity<Real>());
-    v.emplace_back(square<Real>());
-    v.emplace_back(static_cast<Real (*)(Real)>(std::sin));
+    std::vector<ext::function<Real(Real)>> v = {
+        [](Real x){ return 1.0; },
+        [](Real x){ return x; },
+        [](Real x){ return x*x; },
+        [](Real x){ return std::sin(x); }
+    };
 
-    std::vector<ext::function<Real(Real)> > w(v);
-    w.emplace_back(square<Real>());
+    std::vector<ext::function<Real(Real)>> w(v);
+    w.emplace_back([](Real x){ return x*x; });
 
     for (Size k=0; k<3; ++k) {
         Size i;
-        const Real a[] = {rng.next().value,
+        const Real a[] = {
+            rng.next().value,
             rng.next().value,
             rng.next().value,
-            rng.next().value};
+            rng.next().value
+        };
 
         std::vector<Real> x(nr), y(nr);
         for (i=0; i<nr; ++i) {
@@ -205,16 +208,13 @@ void LinearLeastSquaresRegressionTest::test1dLinearRegression() {
 
     SavedSettings backup;
 
-    std::vector<Real> x(9),y(9);
-    x[0]=2.4; x[1]=1.8; x[2]=2.5; x[3]=3.0; 
-    x[4]=2.1; x[5]=1.2; x[6]=2.0; x[7]=2.7; x[8]=3.6;
+    std::vector<Real> x = {2.4, 1.8, 2.5, 3.0, 2.1, 1.2, 2.0, 2.7, 3.6};
+    std::vector<Real> y = {7.8, 5.5, 8.0, 9.0, 6.5, 4.0, 6.3, 8.4, 10.2};
 
-    y[0]=7.8; y[1]=5.5; y[2]=8.0; y[3]=9.0;
-    y[4]=6.5; y[5]=4.0; y[6]=6.3; y[7]=8.4; y[8]=10.2;
-
-    std::vector<ext::function<Real(Real)> > v;
-    v.emplace_back(constant<Real, Real>(1.0));
-    v.emplace_back(identity<Real>());
+    std::vector<ext::function<Real(Real)>> v = {
+        [](Real x) { return 1.0; },
+        [](Real x) { return x; }
+    };
 
     LinearRegression m(x, y);
 
diff --git a/test-suite/margrabeoption.cpp b/test-suite/margrabeoption.cpp
index b0fd0a837fd..76047374165 100644
--- a/test-suite/margrabeoption.cpp
+++ b/test-suite/margrabeoption.cpp
@@ -203,9 +203,7 @@ void MargrabeOptionTest::testEuroExchangeTwoAssets() {
                                       Handle<YieldTermStructure>(rTS),
                                       Handle<BlackVolTermStructure>(volTS2)));
 
-        std::vector<ext::shared_ptr<StochasticProcess1D> > procs;
-        procs.push_back(stochProcess1);
-        procs.push_back(stochProcess2);
+        std::vector<ext::shared_ptr<StochasticProcess1D> > procs = {stochProcess1, stochProcess2};
 
         Matrix correlationMatrix(2, 2, value.rho);
         for (Integer j=0; j < 2; j++) {
@@ -342,9 +340,7 @@ void MargrabeOptionTest::testGreeks() {
             Handle<Quote>(spot2), Handle<YieldTermStructure>(qTS2), Handle<YieldTermStructure>(rTS),
             Handle<BlackVolTermStructure>(volTS2)));
 
-        std::vector<ext::shared_ptr<StochasticProcess1D> > procs;
-        procs.push_back(stochProcess1);
-        procs.push_back(stochProcess2);
+        std::vector<ext::shared_ptr<StochasticProcess1D> > procs = {stochProcess1, stochProcess2};
 
         // The correlation -0.5 can be different real between -1 and 1 for more tests
         Real correlation = -0.5;
@@ -527,9 +523,7 @@ void MargrabeOptionTest::testAmericanExchangeTwoAssets() {
                                       Handle<YieldTermStructure>(rTS),
                                       Handle<BlackVolTermStructure>(volTS2)));
 
-        std::vector<ext::shared_ptr<StochasticProcess1D> > procs;
-        procs.push_back(stochProcess1);
-        procs.push_back(stochProcess2);
+        std::vector<ext::shared_ptr<StochasticProcess1D> > procs = {stochProcess1,stochProcess2};
 
         Matrix correlationMatrix(2, 2, value.rho);
         for (Integer j=0; j < 2; j++) {
diff --git a/test-suite/marketmodel.cpp b/test-suite/marketmodel.cpp
index aba9be8e284..13de7b5aa89 100644
--- a/test-suite/marketmodel.cpp
+++ b/test-suite/marketmodel.cpp
@@ -118,9 +118,6 @@ using namespace boost::unit_test_framework;
 using std::fabs;
 using std::sqrt;
 
-#define BEGIN(x) (x+0)
-#define END(x) (x+LENGTH(x))
-
 namespace market_model_test {
 
     Date todaysDate, startDate, endDate;
diff --git a/test-suite/marketmodel_cms.cpp b/test-suite/marketmodel_cms.cpp
index ab3b68e554c..3f67eda2340 100644
--- a/test-suite/marketmodel_cms.cpp
+++ b/test-suite/marketmodel_cms.cpp
@@ -52,9 +52,6 @@
 using namespace QuantLib;
 using namespace boost::unit_test_framework;
 
-#define BEGIN(x) (x+0)
-#define END(x) (x+LENGTH(x))
-
 namespace market_model_cms_test {
 
     Date todaysDate, startDate, endDate;
diff --git a/test-suite/marketmodel_smm.cpp b/test-suite/marketmodel_smm.cpp
index 7118df40bb9..073d18216f4 100644
--- a/test-suite/marketmodel_smm.cpp
+++ b/test-suite/marketmodel_smm.cpp
@@ -54,9 +54,6 @@
 using namespace QuantLib;
 using namespace boost::unit_test_framework;
 
-#define BEGIN(x) (x+0)
-#define END(x) (x+LENGTH(x))
-
 namespace market_model_smm_test {
 
     Date todaysDate, startDate, endDate;
diff --git a/test-suite/marketmodel_smmcapletalphacalibration.cpp b/test-suite/marketmodel_smmcapletalphacalibration.cpp
index 959e3bd46e3..8c1162b97c2 100644
--- a/test-suite/marketmodel_smmcapletalphacalibration.cpp
+++ b/test-suite/marketmodel_smmcapletalphacalibration.cpp
@@ -63,9 +63,6 @@
 using namespace QuantLib;
 using namespace boost::unit_test_framework;
 
-#define BEGIN(x) (x+0)
-#define END(x) (x+LENGTH(x))
-
 namespace market_model_smm_caplet_alpha_calibration_test {
 
     Date todaysDate_, startDate_, endDate_;
diff --git a/test-suite/marketmodel_smmcapletcalibration.cpp b/test-suite/marketmodel_smmcapletcalibration.cpp
index 561fe6c2a86..f8ffc7594bb 100644
--- a/test-suite/marketmodel_smmcapletcalibration.cpp
+++ b/test-suite/marketmodel_smmcapletcalibration.cpp
@@ -61,9 +61,6 @@
 using namespace QuantLib;
 using namespace boost::unit_test_framework;
 
-#define BEGIN(x) (x+0)
-#define END(x) (x+LENGTH(x))
-
 namespace market_model_smm_caplet_calibration_test {
 
     Date todaysDate_, startDate_, endDate_;
diff --git a/test-suite/marketmodel_smmcaplethomocalibration.cpp b/test-suite/marketmodel_smmcaplethomocalibration.cpp
index 787b589b1c7..6c3cf0e71ed 100644
--- a/test-suite/marketmodel_smmcaplethomocalibration.cpp
+++ b/test-suite/marketmodel_smmcaplethomocalibration.cpp
@@ -73,9 +73,6 @@ using namespace boost::unit_test_framework;
 using std::fabs;
 using std::sqrt;
 
-#define BEGIN(x) (x+0)
-#define END(x) (x+LENGTH(x))
-
 namespace market_model_smm_caplet_homo_calibration_test {
 
     Date todaysDate_, startDate_, endDate_;
diff --git a/test-suite/markovfunctional.cpp b/test-suite/markovfunctional.cpp
index fa78bd8e8de..1aa59190a25 100644
--- a/test-suite/markovfunctional.cpp
+++ b/test-suite/markovfunctional.cpp
@@ -284,23 +284,18 @@ namespace {
 
     Handle<SwaptionVolatilityStructure> md0SwaptionVts() {
 
-        std::vector<Period> optionTenors;
-        std::vector<Period> swapTenors;
-
-        Period optTen[] = { 1 * Months, 2 * Months, 3 * Months,  6 * Months,
+        std::vector<Period> optionTenors = {
+                            1 * Months, 2 * Months, 3 * Months,  6 * Months,
                             9 * Months, 1 * Years,  18 * Months, 2 * Years,
                             3 * Years,  4 * Years,  5 * Years,   6 * Years,
                             7 * Years,  8 * Years,  9 * Years,   10 * Years,
                             15 * Years, 20 * Years, 25 * Years,  30 * Years };
-        for (auto& i : optTen)
-            optionTenors.push_back(i);
 
-        Period swpTen[] = { 1 * Years,  2 * Years,  3 * Years,  4 * Years,
+        std::vector<Period> swapTenors = {
+                            1 * Years,  2 * Years,  3 * Years,  4 * Years,
                             5 * Years,  6 * Years,  7 * Years,  8 * Years,
                             9 * Years,  10 * Years, 15 * Years, 20 * Years,
                             25 * Years, 30 * Years };
-        for (auto& i : swpTen)
-            swapTenors.push_back(i);
 
         double qSwAtmh[] = {
             1.81,  0.897, 0.819, 0.692, 0.551, 0.47,  0.416, 0.379, 0.357,
@@ -354,23 +349,12 @@ namespace {
                                              optionTenors, swapTenors, qSwAtm,
                                              Actual365Fixed())));
 
-        std::vector<Period> optionTenorsSmile;
-        std::vector<Period> swapTenorsSmile;
-        std::vector<Real> strikeSpreads;
-
-        Period optTenSm[] = { 3 * Months, 1 * Years,  5 * Years,
-                              10 * Years, 20 * Years, 30 * Years };
-        Period swpTenSm[] = { 2 * Years,  5 * Years, 10 * Years,
-                              20 * Years, 30 * Years };
-        Real strksp[] = { -0.02,  -0.01,  -0.0050, -0.0025, 0.0,
-                          0.0025, 0.0050, 0.01,    0.02 };
-
-        for (auto& i : optTenSm)
-            optionTenorsSmile.push_back(i);
-        for (auto& i : swpTenSm)
-            swapTenorsSmile.push_back(i);
-        for (double& i : strksp)
-            strikeSpreads.push_back(i);
+        std::vector<Period> optionTenorsSmile = { 3 * Months, 1 * Years,  5 * Years,
+                                                  10 * Years, 20 * Years, 30 * Years };
+        std::vector<Period> swapTenorsSmile = { 2 * Years,  5 * Years, 10 * Years,
+                                                20 * Years, 30 * Years };
+        std::vector<Real> strikeSpreads = { -0.02,  -0.01,  -0.0050, -0.0025, 0.0,
+                                            0.0025, 0.0050, 0.01,    0.02 };
 
         std::vector<std::vector<Handle<Quote> > > qSwSmile;
 
@@ -439,11 +423,7 @@ namespace {
             0.01, 0.2, 0.8, -0.2, 0.01, 0.2, 0.8, -0.2, 0.01, 0.2, 0.8, -0.2
         };
 
-        std::vector<bool> parameterFixed;
-        parameterFixed.push_back(false);
-        parameterFixed.push_back(false); // beta could be fixed
-        parameterFixed.push_back(false);
-        parameterFixed.push_back(false);
+        std::vector<bool> parameterFixed = {false, false, false, false};
 
         std::vector<std::vector<Handle<Quote> > > parameterGuess;
         for (int i = 0; i < 30; i++) {
@@ -498,19 +478,15 @@ namespace {
         Size nStrikes = 12; // leave out last strike 10% because it causes an
                             // exception in bootstrapping
 
-        std::vector<Period> optionTenors;
-        Period optTen[] = { 1 * Years,  18 * Months, 2 * Years,  3 * Years,
+        std::vector<Period> optionTenors = {
+                            1 * Years,  18 * Months, 2 * Years,  3 * Years,
                             4 * Years,  5 * Years,   6 * Years,  7 * Years,
                             8 * Years,  9 * Years,   10 * Years, 12 * Years,
                             15 * Years, 20 * Years,  25 * Years, 30 * Years };
-        for (Size i = 0; i < nOptTen; i++)
-            optionTenors.push_back(optTen[i]);
 
-        std::vector<Real> strikes;
-        Real strk[] = { 0.0025, 0.0050, 0.0100, 0.0150, 0.0200, 0.0225, 0.0250,
-                        0.0300, 0.0350, 0.0400, 0.0500, 0.0600, 0.1000 };
-        for (Size i = 0; i < nStrikes; i++)
-            strikes.push_back(strk[i]);
+        std::vector<Real> strikes = {
+                        0.0025, 0.0050, 0.0100, 0.0150, 0.0200, 0.0225,
+                        0.0250, 0.0300, 0.0350, 0.0400, 0.0500, 0.0600 };
 
         Matrix vols(nOptTen, nStrikes);
         Real volsa[13][16] = { { 1.3378, 1.3032, 1.2514, 1.081, 1.019, 0.961,
@@ -595,19 +571,20 @@ namespace {
 
     Disposable<std::vector<Date> > expiriesCalBasket2() {
 
-        std::vector<Date> res;
         Date referenceDate_ = Settings::instance().evaluationDate();
 
-        res.push_back(TARGET().advance(referenceDate_, 6 * Months));
-        res.push_back(TARGET().advance(referenceDate_, 12 * Months));
-        res.push_back(TARGET().advance(referenceDate_, 18 * Months));
-        res.push_back(TARGET().advance(referenceDate_, 24 * Months));
-        res.push_back(TARGET().advance(referenceDate_, 30 * Months));
-        res.push_back(TARGET().advance(referenceDate_, 36 * Months));
-        res.push_back(TARGET().advance(referenceDate_, 42 * Months));
-        res.push_back(TARGET().advance(referenceDate_, 48 * Months));
-        res.push_back(TARGET().advance(referenceDate_, 54 * Months));
-        res.push_back(TARGET().advance(referenceDate_, 60 * Months));
+        std::vector<Date> res = {
+            TARGET().advance(referenceDate_, 6 * Months),
+            TARGET().advance(referenceDate_, 12 * Months),
+            TARGET().advance(referenceDate_, 18 * Months),
+            TARGET().advance(referenceDate_, 24 * Months),
+            TARGET().advance(referenceDate_, 30 * Months),
+            TARGET().advance(referenceDate_, 36 * Months),
+            TARGET().advance(referenceDate_, 42 * Months),
+            TARGET().advance(referenceDate_, 48 * Months),
+            TARGET().advance(referenceDate_, 54 * Months),
+            TARGET().advance(referenceDate_, 60 * Months)
+        };
 
         return res;
     }
@@ -616,34 +593,27 @@ namespace {
 
     Disposable<std::vector<Date> > expiriesCalBasket3() {
 
-        std::vector<Date> res;
         Date referenceDate_ = Settings::instance().evaluationDate();
 
-        res.push_back(TARGET().advance(referenceDate_, 1 * Years));
-        res.push_back(TARGET().advance(referenceDate_, 2 * Years));
-        res.push_back(TARGET().advance(referenceDate_, 3 * Years));
-        res.push_back(TARGET().advance(referenceDate_, 4 * Years));
-        res.push_back(TARGET().advance(referenceDate_, 5 * Years));
-        res.push_back(TARGET().advance(referenceDate_, 6 * Years));
-        res.push_back(TARGET().advance(referenceDate_, 7 * Years));
-        res.push_back(TARGET().advance(referenceDate_, 8 * Years));
-        res.push_back(TARGET().advance(referenceDate_, 9 * Years));
+        std::vector<Date> res = {
+            TARGET().advance(referenceDate_, 1 * Years),
+            TARGET().advance(referenceDate_, 2 * Years),
+            TARGET().advance(referenceDate_, 3 * Years),
+            TARGET().advance(referenceDate_, 4 * Years),
+            TARGET().advance(referenceDate_, 5 * Years),
+            TARGET().advance(referenceDate_, 6 * Years),
+            TARGET().advance(referenceDate_, 7 * Years),
+            TARGET().advance(referenceDate_, 8 * Years),
+            TARGET().advance(referenceDate_, 9 * Years)
+        };
 
         return res;
     }
 
     Disposable<std::vector<Period> > tenorsCalBasket3() {
 
-        std::vector<Period> res;
-        res.push_back(9 * Years);
-        res.push_back(8 * Years);
-        res.push_back(7 * Years);
-        res.push_back(6 * Years);
-        res.push_back(5 * Years);
-        res.push_back(4 * Years);
-        res.push_back(3 * Years);
-        res.push_back(2 * Years);
-        res.push_back(1 * Years);
+        std::vector<Period> res = {9 * Years, 8 * Years, 7 * Years, 6 * Years, 5 * Years,
+                                   4 * Years, 3 * Years, 2 * Years, 1 * Years};
         return res;
     }
 
@@ -896,21 +866,12 @@ void MarkovFunctionalTest::testCalibrationOneInstrumentSet() {
     ext::shared_ptr<IborIndex> iborIndex(new Euribor(6 * Months));
 
     std::vector<Date> volStepDates;
-    std::vector<Real> vols;
-    vols.push_back(1.0);
-
-    std::vector<Real> money; // use a grid with fewer points for smile arbitrage
-                             // testing and model outputs than the default grid
-                             // for the testing here
-    money.push_back(0.1);
-    money.push_back(0.25);
-    money.push_back(0.50);
-    money.push_back(0.75);
-    money.push_back(1.0);
-    money.push_back(1.25);
-    money.push_back(1.50);
-    money.push_back(2.0);
-    money.push_back(5.0);
+    std::vector<Real> vols = {1.0};
+
+    // use a grid with fewer points for smile arbitrage
+    // testing and model outputs than the default grid
+    // for the testing here
+    std::vector<Real> money = {0.1, 0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 2.0, 5.0};
 
     // Calibration Basket 1 / flat yts, vts
 
@@ -1133,22 +1094,10 @@ void MarkovFunctionalTest::testVanillaEngines() {
         new EuriborSwapIsdaFixA(1 * Years));
 
     std::vector<Date> volStepDates;
-    std::vector<Real> vols;
-    vols.push_back(1.0);
-
-    std::vector<Real> money; // use a grid with few points for the check here
-    money.push_back(0.1);
-    money.push_back(0.25);
-    money.push_back(0.50);
-    money.push_back(0.75);
-    money.push_back(1.0);
-    money.push_back(1.25);
-    money.push_back(1.50);
-    money.push_back(2.0);
-    money.push_back(5.0);
-    // money.push_back(10.0);
-    // money.push_back(20.0);
-    // money.push_back(50.0);
+    std::vector<Real> vols = {1.0};
+
+    // use a grid with few points for the check here
+    std::vector<Real> money = {0.1, 0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 2.0, 5.0};
 
     // Calibration Basket 1 / flat yts, vts
 
@@ -1238,21 +1187,22 @@ void MarkovFunctionalTest::testVanillaEngines() {
         new BlackCapFloorEngine(flatYts_, flatOptionletVts_));
     ext::shared_ptr<Gaussian1dCapFloorEngine> mfCapFloorEngine2(
         new Gaussian1dCapFloorEngine(mf2, 64, 7.0));
-    std::vector<CapFloor> c2;
-    c2.push_back(MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex2, 0.01));
-    c2.push_back(MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex2, 0.02));
-    c2.push_back(MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex2, 0.03));
-    c2.push_back(MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex2, 0.04));
-    c2.push_back(MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex2, 0.05));
-    c2.push_back(MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex2, 0.07));
-    c2.push_back(MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex2, 0.10));
-    c2.push_back(MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex2, 0.01));
-    c2.push_back(MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex2, 0.02));
-    c2.push_back(MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex2, 0.03));
-    c2.push_back(MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex2, 0.04));
-    c2.push_back(MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex2, 0.05));
-    c2.push_back(MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex2, 0.07));
-    c2.push_back(MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex2, 0.10));
+    std::vector<CapFloor> c2 = {
+        MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex2, 0.01),
+        MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex2, 0.02),
+        MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex2, 0.03),
+        MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex2, 0.04),
+        MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex2, 0.05),
+        MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex2, 0.07),
+        MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex2, 0.10),
+        MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex2, 0.01),
+        MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex2, 0.02),
+        MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex2, 0.03),
+        MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex2, 0.04),
+        MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex2, 0.05),
+        MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex2, 0.07),
+        MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex2, 0.10)
+    };
 
     for (auto& i : c2) {
         i.setPricingEngine(blackCapFloorEngine2);
@@ -1369,23 +1319,24 @@ void MarkovFunctionalTest::testVanillaEngines() {
     ext::shared_ptr<Gaussian1dCapFloorEngine> mfCapFloorEngine4(
         new Gaussian1dCapFloorEngine(mf4, 64, 7.0));
 
-    std::vector<CapFloor> c4;
-    c4.push_back(MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex4, 0.01));
-    c4.push_back(MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex4, 0.02));
-    c4.push_back(MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex4, 0.03));
-    c4.push_back(MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex4, 0.04));
-    c4.push_back(MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex4, 0.05));
-    c4.push_back(MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex4, 0.06));
-    // c4.push_back(MakeCapFloor(CapFloor::Cap,5*Years,iborIndex4,0.10));
-    // //exclude because caplet stripper fails for this strike
-    c4.push_back(MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex4, 0.01));
-    c4.push_back(MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex4, 0.02));
-    c4.push_back(MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex4, 0.03));
-    c4.push_back(MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex4, 0.04));
-    c4.push_back(MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex4, 0.05));
-    c4.push_back(MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex4, 0.06));
-    // c4.push_back(MakeCapFloor(CapFloor::Floor,5*Years,iborIndex4,0.10));
-    // //exclude because caplet stripper fails for this strike
+    std::vector<CapFloor> c4 = {
+        MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex4, 0.01),
+        MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex4, 0.02),
+        MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex4, 0.03),
+        MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex4, 0.04),
+        MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex4, 0.05),
+        MakeCapFloor(CapFloor::Cap, 5 * Years, iborIndex4, 0.06),
+        // //exclude because caplet stripper fails for this strike
+        // MakeCapFloor(CapFloor::Cap,5*Years,iborIndex4,0.10),
+        MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex4, 0.01),
+        MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex4, 0.02),
+        MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex4, 0.03),
+        MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex4, 0.04),
+        MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex4, 0.05),
+        MakeCapFloor(CapFloor::Floor, 5 * Years, iborIndex4, 0.06)
+        // //exclude because caplet stripper fails for this strike
+        // MakeCapFloor(CapFloor::Floor,5*Years,iborIndex4,0.10)
+    };
 
     for (auto& i : c4) {
         i.setPricingEngine(blackCapFloorEngine4);
@@ -1423,28 +1374,14 @@ void MarkovFunctionalTest::testCalibrationTwoInstrumentSets() {
     ext::shared_ptr<SwapIndex> swapIndexBase(
         new EuriborSwapIsdaFixA(1 * Years));
 
-    std::vector<Date> volStepDates;
-    std::vector<Real> vols;
-    volStepDates.push_back(TARGET().advance(referenceDate, 1 * Years));
-    volStepDates.push_back(TARGET().advance(referenceDate, 2 * Years));
-    volStepDates.push_back(TARGET().advance(referenceDate, 3 * Years));
-    volStepDates.push_back(TARGET().advance(referenceDate, 4 * Years));
-    vols.push_back(1.0);
-    vols.push_back(1.0);
-    vols.push_back(1.0);
-    vols.push_back(1.0);
-    vols.push_back(1.0);
-
-    std::vector<Real> money; // use a grid with few points for the check here
-    money.push_back(0.1);
-    money.push_back(0.25);
-    money.push_back(0.50);
-    money.push_back(0.75);
-    money.push_back(1.0);
-    money.push_back(1.25);
-    money.push_back(1.50);
-    money.push_back(2.0);
-    money.push_back(5.0);
+    std::vector<Date> volStepDates = {
+        TARGET().advance(referenceDate, 1 * Years),
+        TARGET().advance(referenceDate, 2 * Years),
+        TARGET().advance(referenceDate, 3 * Years),
+        TARGET().advance(referenceDate, 4 * Years)
+    };
+    std::vector<Real> vols = {1.0, 1.0, 1.0, 1.0, 1.0};
+    std::vector<Real> money = {0.1, 0.25, 0.50, 0.75, 1.0, 1.25, 1.50, 2.0, 5.0};
 
     LevenbergMarquardt om;
     // ConjugateGradient om;
@@ -1456,11 +1393,7 @@ void MarkovFunctionalTest::testCalibrationTwoInstrumentSets() {
     ext::shared_ptr<IborIndex> iborIndex1(new Euribor(6 * Months, flatYts_));
 
     std::vector<ext::shared_ptr<BlackCalibrationHelper> > calibrationHelper1;
-    std::vector<Real> calibrationHelperVols1;
-    calibrationHelperVols1.push_back(0.20);
-    calibrationHelperVols1.push_back(0.20);
-    calibrationHelperVols1.push_back(0.20);
-    calibrationHelperVols1.push_back(0.20);
+    std::vector<Real> calibrationHelperVols1 = {0.20, 0.20, 0.20, 0.20};
 
     calibrationHelper1.push_back(ext::shared_ptr<BlackCalibrationHelper>(
         new SwaptionHelper(1 * Years, 4 * Years,
@@ -1684,8 +1617,7 @@ void MarkovFunctionalTest::testBermudanSwaption() {
         new EuriborSwapIsdaFixA(1 * Years));
 
     std::vector<Date> volStepDates;
-    std::vector<Real> vols;
-    vols.push_back(1.0);
+    std::vector<Real> vols = {1.0};
 
     ext::shared_ptr<IborIndex> iborIndex1(new Euribor(6 * Months, md0Yts_));
 
diff --git a/test-suite/nthtodefault.cpp b/test-suite/nthtodefault.cpp
index eac48d13819..a8533f7d77a 100644
--- a/test-suite/nthtodefault.cpp
+++ b/test-suite/nthtodefault.cpp
@@ -134,11 +134,12 @@ void NthToDefaultTest::testGauss() {
 
     Settings::instance().evaluationDate() = asofDate;
 
-    vector<Date> gridDates;
-    gridDates.push_back (asofDate);
-    gridDates.push_back (TARGET().advance (asofDate, Period (1, Years)));
-    gridDates.push_back (TARGET().advance (asofDate, Period (5, Years)));
-    gridDates.push_back (TARGET().advance (asofDate, Period (7, Years)));
+    vector<Date> gridDates = {
+        asofDate,
+        TARGET().advance (asofDate, Period (1, Years)),
+        TARGET().advance (asofDate, Period (5, Years)),
+        TARGET().advance (asofDate, Period (7, Years))
+    };
 
     ext::shared_ptr<YieldTermStructure> yieldPtr (
                                    new FlatForward (asofDate, rate, dc, cmp));
@@ -280,11 +281,12 @@ void NthToDefaultTest::testStudent() {
 
     Settings::instance().evaluationDate() = asofDate;
 
-    vector<Date> gridDates;
-    gridDates.push_back (asofDate);
-    gridDates.push_back (TARGET().advance (asofDate, Period (1, Years)));
-    gridDates.push_back (TARGET().advance (asofDate, Period (5, Years)));
-    gridDates.push_back (TARGET().advance (asofDate, Period (7, Years)));
+    vector<Date> gridDates {
+        asofDate,
+        TARGET().advance (asofDate, Period (1, Years)),
+        TARGET().advance (asofDate, Period (5, Years)),
+        TARGET().advance (asofDate, Period (7, Years))
+    };
 
     ext::shared_ptr<YieldTermStructure> yieldPtr (
                                 new FlatForward (asofDate, rate, dc, cmp));
diff --git a/test-suite/observable.cpp b/test-suite/observable.cpp
index 68b46cbff3d..0d1be739695 100644
--- a/test-suite/observable.cpp
+++ b/test-suite/observable.cpp
@@ -276,16 +276,13 @@ void ObservableTest::testDeepUpdate() {
     Handle<YieldTermStructure> yts(
         ext::make_shared<FlatForward>(0, NullCalendar(), 0.02, Actual365Fixed()));
     ext::shared_ptr<IborIndex> ibor = ext::make_shared<Euribor>(3 * Months, yts);
-    std::vector<Real> strikes;
-    std::vector<Date> dates;
-    std::vector<std::vector<Handle<Quote> > > quotes;
-    strikes.push_back(0.01);
-    strikes.push_back(0.02);
-    dates.push_back(refDate + 90);
-    dates.push_back(refDate + 180);
     ext::shared_ptr<SimpleQuote> q = ext::make_shared<SimpleQuote>(0.20);
-    quotes.emplace_back(2, Handle<Quote>(q));
-    quotes.emplace_back(2, Handle<Quote>(q));
+    std::vector<Real> strikes = {0.01, 0.02};
+    std::vector<Date> dates = {refDate + 90, refDate + 180};
+    std::vector<std::vector<Handle<Quote> > > quotes = {
+        {Handle<Quote>(q), Handle<Quote>(q)},
+        {Handle<Quote>(q), Handle<Quote>(q)}
+    };
 
     ext::shared_ptr<StrippedOptionletAdapter> vol =
         ext::make_shared<StrippedOptionletAdapter>(ext::make_shared<StrippedOptionlet>(
diff --git a/test-suite/optimizers.cpp b/test-suite/optimizers.cpp
index 38c52919b26..0a61162a383 100644
--- a/test-suite/optimizers.cpp
+++ b/test-suite/optimizers.cpp
@@ -188,14 +188,13 @@ namespace {
 
 
     std::vector<NamedOptimizationMethod> makeOptimizationMethods(
-                             OptimizationMethodType optimizationMethodTypes[],
-                             Size optimizationMethodNb,
+                             const std::vector<OptimizationMethodType>& optimizationMethodTypes,
                              Real simplexLambda,
                              Real levenbergMarquardtEpsfcn,
                              Real levenbergMarquardtXtol,
                              Real levenbergMarquardtGtol) {
         std::vector<NamedOptimizationMethod> results;
-        for (Size i=0; i<optimizationMethodNb; ++i) {
+        for (Size i=0; i<optimizationMethodTypes.size(); ++i) {
             NamedOptimizationMethod namedOptimizationMethod;
             namedOptimizationMethod.optimizationMethod = makeOptimizationMethod(
                 optimizationMethodTypes[i],
@@ -249,7 +248,7 @@ namespace {
                             rootEpsilons_.back(), functionEpsilons_.back(),
                             gradientNormEpsilons_.back()));
         // Set optimization methods for optimizer
-        OptimizationMethodType optimizationMethodTypes[] = {
+        std::vector<OptimizationMethodType> optimizationMethodTypes = {
             simplex, levenbergMarquardt, levenbergMarquardt2, conjugateGradient,
             bfgs //, steepestDescent
         };
@@ -258,7 +257,7 @@ namespace {
         Real levenbergMarquardtXtol   = 1.0e-8;     //
         Real levenbergMarquardtGtol   = 1.0e-8;     //
         optimizationMethods_.push_back(makeOptimizationMethods(
-            optimizationMethodTypes, LENGTH(optimizationMethodTypes),
+            optimizationMethodTypes,
             simplexLambda, levenbergMarquardtEpsfcn, levenbergMarquardtXtol,
             levenbergMarquardtGtol));
         // Set expected results for optimizer
@@ -485,47 +484,53 @@ void OptimizersTest::testDifferentialEvolution() {
         .withSeed(3242);
     DifferentialEvolution deOptim2(conf2);
 
-    std::vector<DifferentialEvolution > diffEvolOptimisers;
-    diffEvolOptimisers.push_back(deOptim);
-    diffEvolOptimisers.push_back(deOptim);
-    diffEvolOptimisers.push_back(deOptim);
-    diffEvolOptimisers.push_back(deOptim);
-    diffEvolOptimisers.push_back(deOptim2);
-
-    std::vector<ext::shared_ptr<CostFunction> > costFunctions;
-    costFunctions.push_back(ext::shared_ptr<CostFunction>(new FirstDeJong));
-    costFunctions.push_back(ext::shared_ptr<CostFunction>(new SecondDeJong));
-    costFunctions.push_back(ext::shared_ptr<CostFunction>(new ModThirdDeJong));
-    costFunctions.push_back(ext::shared_ptr<CostFunction>(new ModFourthDeJong));
-    costFunctions.push_back(ext::shared_ptr<CostFunction>(new Griewangk));
-
-    std::vector<BoundaryConstraint> constraints;
-    constraints.emplace_back(-10.0, 10.0);
-    constraints.emplace_back(-10.0, 10.0);
-    constraints.emplace_back(-10.0, 10.0);
-    constraints.emplace_back(-10.0, 10.0);
-    constraints.emplace_back(-600.0, 600.0);
-
-    std::vector<Array> initialValues;
-    initialValues.emplace_back(3, 5.0);
-    initialValues.emplace_back(2, 5.0);
-    initialValues.emplace_back(5, 5.0);
-    initialValues.emplace_back(30, 5.0);
-    initialValues.emplace_back(10, 100.0);
-
-    std::vector<EndCriteria> endCriteria;
-    endCriteria.emplace_back(100, 10, 1e-10, 1e-8, Null<Real>());
-    endCriteria.emplace_back(100, 10, 1e-10, 1e-8, Null<Real>());
-    endCriteria.emplace_back(100, 10, 1e-10, 1e-8, Null<Real>());
-    endCriteria.emplace_back(500, 100, 1e-10, 1e-8, Null<Real>());
-    endCriteria.emplace_back(1000, 800, 1e-12, 1e-10, Null<Real>());
-
-    std::vector<Real> minima;
-    minima.push_back(0.0);
-    minima.push_back(0.0);
-    minima.push_back(0.0);
-    minima.push_back(10.9639796558);
-    minima.push_back(0.0);
+    std::vector<DifferentialEvolution > diffEvolOptimisers = {
+        deOptim,
+        deOptim,
+        deOptim,
+        deOptim,
+        deOptim2
+    };
+
+    std::vector<ext::shared_ptr<CostFunction> > costFunctions = {
+        ext::shared_ptr<CostFunction>(new FirstDeJong),
+        ext::shared_ptr<CostFunction>(new SecondDeJong),
+        ext::shared_ptr<CostFunction>(new ModThirdDeJong),
+        ext::shared_ptr<CostFunction>(new ModFourthDeJong),
+        ext::shared_ptr<CostFunction>(new Griewangk)
+    };
+
+    std::vector<BoundaryConstraint> constraints = {
+        {-10.0, 10.0},
+        {-10.0, 10.0},
+        {-10.0, 10.0},
+        {-10.0, 10.0},
+        {-600.0, 600.0}
+    };
+
+    std::vector<Array> initialValues = {
+        Array(3, 5.0),
+        Array(2, 5.0),
+        Array(5, 5.0),
+        Array(30, 5.0),
+        Array(10, 100.0)
+    };
+
+    std::vector<EndCriteria> endCriteria = {
+        {100, 10, 1e-10, 1e-8, Null<Real>()},
+        {100, 10, 1e-10, 1e-8, Null<Real>()},
+        {100, 10, 1e-10, 1e-8, Null<Real>()},
+        {500, 100, 1e-10, 1e-8, Null<Real>()},
+        {1000, 800, 1e-12, 1e-10, Null<Real>()}
+    };
+
+    std::vector<Real> minima = {
+        0.0,
+        0.0,
+        0.0,
+        10.9639796558,
+        0.0
+    };
 
     for (Size i = 0; i < costFunctions.size(); ++i) {
         Problem problem(*costFunctions[i], constraints[i], initialValues[i]);
diff --git a/test-suite/optionletstripper.cpp b/test-suite/optionletstripper.cpp
index 2cd3de77c41..5e87b787ada 100644
--- a/test-suite/optionletstripper.cpp
+++ b/test-suite/optionletstripper.cpp
@@ -193,42 +193,45 @@ struct CommonVars {
           setTermStructure();
 
           //atm cap volatility curve
-          optionTenors = std::vector<Period>();
-          optionTenors.emplace_back(1, Years);
-          optionTenors.emplace_back(18, Months);
-          optionTenors.emplace_back(2, Years);
-          optionTenors.emplace_back(3, Years);
-          optionTenors.emplace_back(4, Years);
-          optionTenors.emplace_back(5, Years);
-          optionTenors.emplace_back(6, Years);
-          optionTenors.emplace_back(7, Years);
-          optionTenors.emplace_back(8, Years);
-          optionTenors.emplace_back(9, Years);
-          optionTenors.emplace_back(10, Years);
-          optionTenors.emplace_back(12, Years);
-          optionTenors.emplace_back(15, Years);
-          optionTenors.emplace_back(20, Years);
-          optionTenors.emplace_back(25, Years);
-          optionTenors.emplace_back(30, Years);
+          optionTenors = {
+              {1, Years},
+              {18, Months},
+              {2, Years},
+              {3, Years},
+              {4, Years},
+              {5, Years},
+              {6, Years},
+              {7, Years},
+              {8, Years},
+              {9, Years},
+              {10, Years},
+              {12, Years},
+              {15, Years},
+              {20, Years},
+              {25, Years},
+              {30, Years}
+          };
 
           //atm capfloor vols from mkt vol matrix using flat yield curve
-          atmTermV = std::vector<Volatility>();
-          atmTermV.push_back(0.090304);
-          atmTermV.push_back(0.12180);
-          atmTermV.push_back(0.13077);
-          atmTermV.push_back(0.14832);
-          atmTermV.push_back(0.15570);
-          atmTermV.push_back(0.15816);
-          atmTermV.push_back(0.15932);
-          atmTermV.push_back(0.16035);
-          atmTermV.push_back(0.15951);
-          atmTermV.push_back(0.15855);
-          atmTermV.push_back(0.15754);
-          atmTermV.push_back(0.15459);
-          atmTermV.push_back(0.15163);
-          atmTermV.push_back(0.14575);
-          atmTermV.push_back(0.14175);
-          atmTermV.push_back(0.13889);
+          atmTermV = {
+              0.090304,
+              0.12180,
+              0.13077,
+              0.14832,
+              0.15570,
+              0.15816,
+              0.15932,
+              0.16035,
+              0.15951,
+              0.15855,
+              0.15754,
+              0.15459,
+              0.15163,
+              0.14575,
+              0.14175,
+              0.13889
+          };
+
           atmTermVolHandle.resize(optionTenors.size());
           for (Size i=0; i<optionTenors.size(); ++i) {
             atmTermVolHandle[i] = Handle<Quote>(ext::shared_ptr<Quote>(new
@@ -247,38 +250,40 @@ struct CommonVars {
             setTermStructure();
 
             //cap volatility smile matrix
-            optionTenors = std::vector<Period>();
-            optionTenors.emplace_back(1, Years);
-            optionTenors.emplace_back(18, Months);
-            optionTenors.emplace_back(2, Years);
-            optionTenors.emplace_back(3, Years);
-            optionTenors.emplace_back(4, Years);
-            optionTenors.emplace_back(5, Years);
-            optionTenors.emplace_back(6, Years);
-            optionTenors.emplace_back(7, Years);
-            optionTenors.emplace_back(8, Years);
-            optionTenors.emplace_back(9, Years);
-            optionTenors.emplace_back(10, Years);
-            optionTenors.emplace_back(12, Years);
-            optionTenors.emplace_back(15, Years);
-            optionTenors.emplace_back(20, Years);
-            optionTenors.emplace_back(25, Years);
-            optionTenors.emplace_back(30, Years);
-
-            strikes = std::vector<Rate>();
-            strikes.push_back(0.015);
-            strikes.push_back(0.0175);
-            strikes.push_back(0.02);
-            strikes.push_back(0.0225);
-            strikes.push_back(0.025);
-            strikes.push_back(0.03);
-            strikes.push_back(0.035);
-            strikes.push_back(0.04);
-            strikes.push_back(0.05);
-            strikes.push_back(0.06);
-            strikes.push_back(0.07);
-            strikes.push_back(0.08);
-            strikes.push_back(0.1);
+            optionTenors = {
+                {1, Years},
+                {18, Months},
+                {2, Years},
+                {3, Years},
+                {4, Years},
+                {5, Years},
+                {6, Years},
+                {7, Years},
+                {8, Years},
+                {9, Years},
+                {10, Years},
+                {12, Years},
+                {15, Years},
+                {20, Years},
+                {25, Years},
+                {30, Years}
+            };
+
+            strikes = {
+                0.015,
+                0.0175,
+                0.02,
+                0.0225,
+                0.025,
+                0.03,
+                0.035,
+                0.04,
+                0.05,
+                0.06,
+                0.07,
+                0.08,
+                0.1
+            };
 
             termV = Matrix(optionTenors.size(), strikes.size());
             termV[0][0]=0.287;  termV[0][1]=0.274;  termV[0][2]=0.256;  termV[0][3]=0.245;  termV[0][4]=0.227;  termV[0][5]=0.148;  termV[0][6]=0.096;  termV[0][7]=0.09;   termV[0][8]=0.11;   termV[0][9]=0.139;  termV[0][10]=0.166;  termV[0][11]=0.19;   termV[0][12]=0.214;
@@ -308,57 +313,59 @@ struct CommonVars {
             setRealTermStructure();
 
             // cap volatility smile matrix
-            optionTenors = std::vector< Period >();
-            optionTenors.emplace_back(1, Years);
-            optionTenors.emplace_back(18, Months);
-            optionTenors.emplace_back(2, Years);
-            optionTenors.emplace_back(3, Years);
-            optionTenors.emplace_back(4, Years);
-            optionTenors.emplace_back(5, Years);
-            optionTenors.emplace_back(6, Years);
-            optionTenors.emplace_back(7, Years);
-            optionTenors.emplace_back(8, Years);
-            optionTenors.emplace_back(9, Years);
-            optionTenors.emplace_back(10, Years);
-            optionTenors.emplace_back(12, Years);
-            optionTenors.emplace_back(15, Years);
-            optionTenors.emplace_back(20, Years);
-            optionTenors.emplace_back(25, Years);
-            optionTenors.emplace_back(30, Years);
+            optionTenors = {
+                {1, Years},
+                {18, Months},
+                {2, Years},
+                {3, Years},
+                {4, Years},
+                {5, Years},
+                {6, Years},
+                {7, Years},
+                {8, Years},
+                {9, Years},
+                {10, Years},
+                {12, Years},
+                {15, Years},
+                {20, Years},
+                {25, Years},
+                {30, Years}
+            };
             // 16
 
-            strikes = std::vector< Rate >();
-            strikes.push_back(-0.005);
-            strikes.push_back(-0.0025);
-            strikes.push_back(-0.00125);
-            strikes.push_back(0.0);
-            strikes.push_back(0.00125);
-            strikes.push_back(0.0025);
-            strikes.push_back(0.005);
-            strikes.push_back(0.01);
-            strikes.push_back(0.015);
-            strikes.push_back(0.02);
-            strikes.push_back(0.03);
-            strikes.push_back(0.05);
-            strikes.push_back(0.1);
+            strikes = {
+                -0.005,
+                -0.0025,
+                -0.00125,
+                0.0,
+                0.00125,
+                0.0025,
+                0.005,
+                0.01,
+                0.015,
+                0.02,
+                0.03,
+                0.05,
+                0.1
+            };
             // 13
 
             std::vector< Real > rawVols;
-            rawVols += 0.49, 0.39, 0.34, 0.31, 0.34, 0.37, 0.50, 0.75, 0.99, 1.21, 1.64, 2.44, 4.29, 
-                       0.44, 0.36, 0.33, 0.31, 0.33, 0.35,0.45, 0.65, 0.83, 1.00, 1.32, 1.93, 3.30, 
+            rawVols += 0.49, 0.39, 0.34, 0.31, 0.34, 0.37, 0.50, 0.75, 0.99, 1.21, 1.64, 2.44, 4.29,
+                       0.44, 0.36, 0.33, 0.31, 0.33, 0.35,0.45, 0.65, 0.83, 1.00, 1.32, 1.93, 3.30,
                        0.40, 0.35, 0.33,0.31, 0.33, 0.34, 0.41, 0.55, 0.69, 0.82, 1.08, 1.56, 2.68,
-                       0.42, 0.39, 0.38, 0.37, 0.38, 0.39, 0.43, 0.54, 0.64, 0.74,0.94, 1.31, 2.18, 
-                       0.46, 0.43, 0.42, 0.41, 0.42, 0.43, 0.47,0.56, 0.66, 0.75, 0.93, 1.28, 2.07, 
-                       0.49, 0.47, 0.46, 0.45,0.46, 0.47, 0.51, 0.59, 0.68, 0.76, 0.93, 1.25, 1.99, 
-                       0.51, 0.49, 0.49, 0.48, 0.49, 0.50, 0.54, 0.62, 0.70, 0.78, 0.94,1.24, 1.94, 
-                       0.52, 0.51, 0.51, 0.51, 0.52, 0.53, 0.56, 0.63,0.71, 0.79, 0.94, 1.23, 1.89, 
-                       0.53, 0.52, 0.52, 0.52, 0.53,0.54, 0.57, 0.65, 0.72, 0.79, 0.94, 1.21, 1.83, 
-                       0.55, 0.54, 0.54, 0.54, 0.55, 0.56, 0.59, 0.66, 0.72, 0.79, 0.91, 1.15,1.71, 
-                       0.56, 0.56, 0.56, 0.56, 0.57, 0.58, 0.61, 0.67, 0.72,0.78, 0.89, 1.09, 1.59, 
-                       0.59, 0.58, 0.58, 0.59, 0.59, 0.60,0.63, 0.68, 0.73, 0.78, 0.86, 1.03, 1.45, 
+                       0.42, 0.39, 0.38, 0.37, 0.38, 0.39, 0.43, 0.54, 0.64, 0.74,0.94, 1.31, 2.18,
+                       0.46, 0.43, 0.42, 0.41, 0.42, 0.43, 0.47,0.56, 0.66, 0.75, 0.93, 1.28, 2.07,
+                       0.49, 0.47, 0.46, 0.45,0.46, 0.47, 0.51, 0.59, 0.68, 0.76, 0.93, 1.25, 1.99,
+                       0.51, 0.49, 0.49, 0.48, 0.49, 0.50, 0.54, 0.62, 0.70, 0.78, 0.94,1.24, 1.94,
+                       0.52, 0.51, 0.51, 0.51, 0.52, 0.53, 0.56, 0.63,0.71, 0.79, 0.94, 1.23, 1.89,
+                       0.53, 0.52, 0.52, 0.52, 0.53,0.54, 0.57, 0.65, 0.72, 0.79, 0.94, 1.21, 1.83,
+                       0.55, 0.54, 0.54, 0.54, 0.55, 0.56, 0.59, 0.66, 0.72, 0.79, 0.91, 1.15,1.71,
+                       0.56, 0.56, 0.56, 0.56, 0.57, 0.58, 0.61, 0.67, 0.72,0.78, 0.89, 1.09, 1.59,
+                       0.59, 0.58, 0.58, 0.59, 0.59, 0.60,0.63, 0.68, 0.73, 0.78, 0.86, 1.03, 1.45,
                        0.61, 0.61, 0.61,0.61, 0.62, 0.62, 0.64, 0.69, 0.73, 0.77, 0.85, 1.02, 1.44,
-                       0.62, 0.62, 0.63, 0.63, 0.64, 0.64, 0.65, 0.69, 0.72, 0.76,0.82, 0.96, 1.32, 
-                       0.62, 0.63, 0.63, 0.63, 0.65, 0.66, 0.66,0.68, 0.72, 0.74, 0.80, 0.93, 1.25, 
+                       0.62, 0.62, 0.63, 0.63, 0.64, 0.64, 0.65, 0.69, 0.72, 0.76,0.82, 0.96, 1.32,
+                       0.62, 0.63, 0.63, 0.63, 0.65, 0.66, 0.66,0.68, 0.72, 0.74, 0.80, 0.93, 1.25,
                        0.62, 0.62, 0.62, 0.62,0.66, 0.67, 0.67, 0.67, 0.72, 0.72, 0.78, 0.90, 1.25;
 
             termV = Matrix(optionTenors.size(), strikes.size());
@@ -798,7 +805,7 @@ void OptionletStripperTest::testSwitchStrike() {
         expected = 0.02981258;
     else
         expected = 0.02981223;
-    
+
     Real error = std::fabs(optionletStripper1->switchStrike() - expected);
     if (error > vars.tolerance)
         BOOST_FAIL("\nSwitchstrike not correctly computed:  "
diff --git a/test-suite/piecewisezerospreadedtermstructure.cpp b/test-suite/piecewisezerospreadedtermstructure.cpp
index 320000a6c2e..54713b1a3d7 100644
--- a/test-suite/piecewisezerospreadedtermstructure.cpp
+++ b/test-suite/piecewisezerospreadedtermstructure.cpp
@@ -86,15 +86,12 @@ void PiecewiseZeroSpreadedTermStructureTest::testFlatInterpolationLeft() {
 
     CommonVars vars;
 
-    std::vector<Handle<Quote> > spreads;
     ext::shared_ptr<SimpleQuote> spread1 = ext::make_shared<SimpleQuote>(0.02);
     ext::shared_ptr<SimpleQuote> spread2 = ext::make_shared<SimpleQuote>(0.03);
-    spreads.emplace_back(spread1);
-    spreads.emplace_back(spread2);
+    std::vector<Handle<Quote> > spreads = { Handle<Quote>(spread1), Handle<Quote>(spread2) };
 
-    std::vector<Date> spreadDates;
-    spreadDates.push_back(vars.calendar.advance(vars.today, 8,  Months));
-    spreadDates.push_back(vars.calendar.advance(vars.today, 15, Months));
+    std::vector<Date> spreadDates = {vars.calendar.advance(vars.today, 8, Months),
+                                     vars.calendar.advance(vars.today, 15, Months)};
 
     Date interpolationDate = vars.calendar.advance(vars.today, 6, Months);
 
@@ -127,15 +124,12 @@ void PiecewiseZeroSpreadedTermStructureTest::testFlatInterpolationRight() {
 
     CommonVars vars;
 
-    std::vector<Handle<Quote> > spreads;
     ext::shared_ptr<SimpleQuote> spread1 = ext::make_shared<SimpleQuote>(0.02);
     ext::shared_ptr<SimpleQuote> spread2 = ext::make_shared<SimpleQuote>(0.03);
-    spreads.emplace_back(spread1);
-    spreads.emplace_back(spread2);
+    std::vector<Handle<Quote> > spreads = { Handle<Quote>(spread1), Handle<Quote>(spread2) };
 
-    std::vector<Date> spreadDates;
-    spreadDates.push_back(vars.calendar.advance(vars.today, 8,  Months));
-    spreadDates.push_back(vars.calendar.advance(vars.today, 15, Months));
+    std::vector<Date> spreadDates = {vars.calendar.advance(vars.today, 8, Months),
+                                     vars.calendar.advance(vars.today, 15, Months)};
 
     Date interpolationDate = vars.calendar.advance(vars.today, 20, Months);
 
@@ -169,21 +163,19 @@ void PiecewiseZeroSpreadedTermStructureTest::testLinearInterpolationMultipleSpre
 
     CommonVars vars;
 
-    std::vector<Handle<Quote> > spreads;
     ext::shared_ptr<SimpleQuote> spread1 = ext::make_shared<SimpleQuote>(0.02);
     ext::shared_ptr<SimpleQuote> spread2 = ext::make_shared<SimpleQuote>(0.02);
     ext::shared_ptr<SimpleQuote> spread3 = ext::make_shared<SimpleQuote>(0.035);
     ext::shared_ptr<SimpleQuote> spread4 = ext::make_shared<SimpleQuote>(0.04);
-    spreads.emplace_back(spread1);
-    spreads.emplace_back(spread2);
-    spreads.emplace_back(spread3);
-    spreads.emplace_back(spread4);
+    std::vector<Handle<Quote> > spreads = {
+        Handle<Quote>(spread1), Handle<Quote>(spread2),
+        Handle<Quote>(spread3), Handle<Quote>(spread4),
+    };
 
-    std::vector<Date> spreadDates;
-    spreadDates.push_back(vars.calendar.advance(vars.today, 90,  Days));
-    spreadDates.push_back(vars.calendar.advance(vars.today, 150, Days));
-    spreadDates.push_back(vars.calendar.advance(vars.today, 30, Months));
-    spreadDates.push_back(vars.calendar.advance(vars.today, 40, Months));
+    std::vector<Date> spreadDates = {vars.calendar.advance(vars.today, 90, Days),
+                                     vars.calendar.advance(vars.today, 150, Days),
+                                     vars.calendar.advance(vars.today, 30, Months),
+                                     vars.calendar.advance(vars.today, 40, Months)};
 
     Date interpolationDate = vars.calendar.advance(vars.today, 120, Days);
 
@@ -216,15 +208,12 @@ void PiecewiseZeroSpreadedTermStructureTest::testLinearInterpolation() {
 
     CommonVars vars;
 
-    std::vector<Handle<Quote> > spreads;
     ext::shared_ptr<SimpleQuote> spread1 = ext::make_shared<SimpleQuote>(0.02);
     ext::shared_ptr<SimpleQuote> spread2 = ext::make_shared<SimpleQuote>(0.03);
-    spreads.emplace_back(spread1);
-    spreads.emplace_back(spread2);
+    std::vector<Handle<Quote> > spreads = { Handle<Quote>(spread1), Handle<Quote>(spread2) };
 
-    std::vector<Date> spreadDates;
-    spreadDates.push_back(vars.calendar.advance(vars.today, 100,  Days));
-    spreadDates.push_back(vars.calendar.advance(vars.today, 150, Days));
+    std::vector<Date> spreadDates = {vars.calendar.advance(vars.today, 100, Days),
+                                     vars.calendar.advance(vars.today, 150, Days)};
 
     Date interpolationDate = vars.calendar.advance(vars.today, 120, Days);
 
@@ -262,15 +251,12 @@ void PiecewiseZeroSpreadedTermStructureTest::testForwardFlatInterpolation() {
 
     CommonVars vars;
 
-    std::vector<Handle<Quote> > spreads;
     ext::shared_ptr<SimpleQuote> spread1 = ext::make_shared<SimpleQuote>(0.02);
     ext::shared_ptr<SimpleQuote> spread2 = ext::make_shared<SimpleQuote>(0.03);
-    spreads.emplace_back(spread1);
-    spreads.emplace_back(spread2);
+    std::vector<Handle<Quote> > spreads = { Handle<Quote>(spread1), Handle<Quote>(spread2) };
 
-    std::vector<Date> spreadDates;
-    spreadDates.push_back(vars.calendar.advance(vars.today, 75,  Days));
-    spreadDates.push_back(vars.calendar.advance(vars.today, 260, Days));
+    std::vector<Date> spreadDates = {vars.calendar.advance(vars.today, 75, Days),
+                                     vars.calendar.advance(vars.today, 260, Days)};
 
     Date interpolationDate = vars.calendar.advance(vars.today, 100, Days);
 
@@ -303,18 +289,16 @@ void PiecewiseZeroSpreadedTermStructureTest::testBackwardFlatInterpolation() {
 
     CommonVars vars;
 
-    std::vector<Handle<Quote> > spreads;
     ext::shared_ptr<SimpleQuote> spread1 = ext::make_shared<SimpleQuote>(0.02);
     ext::shared_ptr<SimpleQuote> spread2 = ext::make_shared<SimpleQuote>(0.03);
     ext::shared_ptr<SimpleQuote> spread3 = ext::make_shared<SimpleQuote>(0.04);
-    spreads.emplace_back(spread1);
-    spreads.emplace_back(spread2);
-    spreads.emplace_back(spread3);
+    std::vector<Handle<Quote> > spreads = {
+        Handle<Quote>(spread1), Handle<Quote>(spread2), Handle<Quote>(spread3)
+    };
 
-    std::vector<Date> spreadDates;
-    spreadDates.push_back(vars.calendar.advance(vars.today, 100,  Days));
-    spreadDates.push_back(vars.calendar.advance(vars.today, 200, Days));
-    spreadDates.push_back(vars.calendar.advance(vars.today, 300, Days));
+    std::vector<Date> spreadDates = {vars.calendar.advance(vars.today, 100, Days),
+                                     vars.calendar.advance(vars.today, 200, Days),
+                                     vars.calendar.advance(vars.today, 300, Days)};
 
     Date interpolationDate = vars.calendar.advance(vars.today, 110, Days);
 
@@ -347,15 +331,12 @@ void PiecewiseZeroSpreadedTermStructureTest::testDefaultInterpolation() {
 
     CommonVars vars;
 
-    std::vector<Handle<Quote> > spreads;
     ext::shared_ptr<SimpleQuote> spread1 = ext::make_shared<SimpleQuote>(0.02);
     ext::shared_ptr<SimpleQuote> spread2 = ext::make_shared<SimpleQuote>(0.02);
-    spreads.emplace_back(spread1);
-    spreads.emplace_back(spread2);
+    std::vector<Handle<Quote> > spreads = { Handle<Quote>(spread1), Handle<Quote>(spread2) };
 
-    std::vector<Date> spreadDates;
-    spreadDates.push_back(vars.calendar.advance(vars.today, 75,  Days));
-    spreadDates.push_back(vars.calendar.advance(vars.today, 160, Days));
+    std::vector<Date> spreadDates = {vars.calendar.advance(vars.today, 75,  Days),
+                                     vars.calendar.advance(vars.today, 160, Days)};
 
     Date interpolationDate = vars.calendar.advance(vars.today, 100, Days);
 
@@ -388,18 +369,16 @@ void PiecewiseZeroSpreadedTermStructureTest::testSetInterpolationFactory() {
 
     CommonVars vars;
 
-    std::vector<Handle<Quote> > spreads;
     ext::shared_ptr<SimpleQuote> spread1 = ext::make_shared<SimpleQuote>(0.02);
     ext::shared_ptr<SimpleQuote> spread2 = ext::make_shared<SimpleQuote>(0.03);
     ext::shared_ptr<SimpleQuote> spread3 = ext::make_shared<SimpleQuote>(0.01);
-    spreads.emplace_back(spread1);
-    spreads.emplace_back(spread2);
-    spreads.emplace_back(spread3);
+    std::vector<Handle<Quote> > spreads = {
+        Handle<Quote>(spread1), Handle<Quote>(spread2), Handle<Quote>(spread3)
+    };
 
-    std::vector<Date> spreadDates;
-    spreadDates.push_back(vars.calendar.advance(vars.today, 8,  Months));
-    spreadDates.push_back(vars.calendar.advance(vars.today, 15, Months));
-    spreadDates.push_back(vars.calendar.advance(vars.today, 25, Months));
+    std::vector<Date> spreadDates = {vars.calendar.advance(vars.today, 8,  Months),
+                                     vars.calendar.advance(vars.today, 15, Months),
+                                     vars.calendar.advance(vars.today, 25, Months)};
 
     Date interpolationDate = vars.calendar.advance(vars.today, 11, Months);
 
@@ -440,15 +419,12 @@ void PiecewiseZeroSpreadedTermStructureTest::testMaxDate() {
 
     CommonVars vars;
 
-    std::vector<Handle<Quote> > spreads;
     ext::shared_ptr<SimpleQuote> spread1 = ext::make_shared<SimpleQuote>(0.02);
     ext::shared_ptr<SimpleQuote> spread2 = ext::make_shared<SimpleQuote>(0.03);
-    spreads.emplace_back(spread1);
-    spreads.emplace_back(spread2);
+    std::vector<Handle<Quote> > spreads = { Handle<Quote>(spread1), Handle<Quote>(spread2) };
 
-    std::vector<Date> spreadDates;
-    spreadDates.push_back(vars.calendar.advance(vars.today, 8,  Months));
-    spreadDates.push_back(vars.calendar.advance(vars.today, 15, Months));
+    std::vector<Date> spreadDates = {vars.calendar.advance(vars.today, 8,  Months),
+                                     vars.calendar.advance(vars.today, 15, Months)};
 
     ext::shared_ptr<ZeroYieldStructure> spreadedTermStructure =
         ext::make_shared<PiecewiseZeroSpreadedTermStructure>(
@@ -476,15 +452,12 @@ void PiecewiseZeroSpreadedTermStructureTest::testQuoteChanging() {
 
     CommonVars vars;
 
-    std::vector<Handle<Quote> > spreads;
     ext::shared_ptr<SimpleQuote> spread1 = ext::make_shared<SimpleQuote>(0.02);
     ext::shared_ptr<SimpleQuote> spread2 = ext::make_shared<SimpleQuote>(0.03);
-    spreads.emplace_back(spread1);
-    spreads.emplace_back(spread2);
+    std::vector<Handle<Quote> > spreads = { Handle<Quote>(spread1), Handle<Quote>(spread2) };
 
-    std::vector<Date> spreadDates;
-    spreadDates.push_back(vars.calendar.advance(vars.today, 100,  Days));
-    spreadDates.push_back(vars.calendar.advance(vars.today, 150, Days));
+    std::vector<Date> spreadDates = {vars.calendar.advance(vars.today, 100,  Days),
+                                     vars.calendar.advance(vars.today, 150, Days)};
 
     Date interpolationDate = vars.calendar.advance(vars.today, 120, Days);
 
diff --git a/test-suite/rangeaccrual.cpp b/test-suite/rangeaccrual.cpp
index df8d53c7c74..b7964f59dd1 100644
--- a/test-suite/rangeaccrual.cpp
+++ b/test-suite/rangeaccrual.cpp
@@ -109,78 +109,27 @@ namespace range_accrual_test {
         void createYieldCurve() {
 
             // Yield Curve
-            std::vector<Date> dates;
-            dates.emplace_back(39147);
-            dates.emplace_back(39148);
-            dates.emplace_back(39151);
-            dates.emplace_back(39153);
-            dates.emplace_back(39159);
-            dates.emplace_back(39166);
-            dates.emplace_back(39183);
-            dates.emplace_back(39294);
-            dates.emplace_back(39384);
-            dates.emplace_back(39474);
-            dates.emplace_back(39567);
-            dates.emplace_back(39658);
-            dates.emplace_back(39748);
-            dates.emplace_back(39839);
-            dates.emplace_back(39931);
-            dates.emplace_back(40250);
-            dates.emplace_back(40614);
-            dates.emplace_back(40978);
-            dates.emplace_back(41344);
-            dates.emplace_back(41709);
-            dates.emplace_back(42074);
-            dates.emplace_back(42441);
-            dates.emplace_back(42805);
-            dates.emplace_back(43170);
-            dates.emplace_back(43535);
-            dates.emplace_back(43900);
-            dates.emplace_back(44268);
-            dates.emplace_back(44632);
-            dates.emplace_back(44996);
-            dates.emplace_back(45361);
-            dates.emplace_back(45727);
-            dates.emplace_back(46092);
-            dates.emplace_back(46459);
-            dates.emplace_back(46823);
-            dates.emplace_back(47188);
-            dates.emplace_back(47553);
-            dates.emplace_back(47918);
-            dates.emplace_back(48283);
-            dates.emplace_back(48650);
-            dates.emplace_back(49014);
-            dates.emplace_back(49379);
-            dates.emplace_back(49744);
-            dates.emplace_back(50110);
-            dates.emplace_back(53762);
-            dates.emplace_back(57415);
-            dates.emplace_back(61068);
-
-            std::vector<Rate> zeroRates;
-            zeroRates.push_back(0.02676568527);    zeroRates.push_back(0.02676568527);
-            zeroRates.push_back(0.02676333038);    zeroRates.push_back(0.02682286201);
-            zeroRates.push_back(0.02682038347);    zeroRates.push_back(0.02683030208);
-            zeroRates.push_back(0.02700136766);    zeroRates.push_back(0.02932526033);
-            zeroRates.push_back(0.03085568949);    zeroRates.push_back(0.03216370631);
-            zeroRates.push_back(0.03321234116);    zeroRates.push_back(0.03404978072);
-            zeroRates.push_back(0.03471117149);    zeroRates.push_back(0.03527141916);
-            zeroRates.push_back(0.03574660393);    zeroRates.push_back(0.03691715582);
-            zeroRates.push_back(0.03796468718);    zeroRates.push_back(0.03876457629);
-            zeroRates.push_back(0.03942029708);    zeroRates.push_back(0.03999925325);
-            zeroRates.push_back(0.04056663618);    zeroRates.push_back(0.04108743922);
-            zeroRates.push_back(0.04156156761);    zeroRates.push_back(0.0419979179);
-            zeroRates.push_back(0.04239486483);    zeroRates.push_back(0.04273799032);
-            zeroRates.push_back(0.04305531203);    zeroRates.push_back(0.04336417578);
-            zeroRates.push_back(0.04364017665);    zeroRates.push_back(0.04388153459);
-            zeroRates.push_back(0.04408005012);    zeroRates.push_back(0.04424764425);
-            zeroRates.push_back(0.04437504759);    zeroRates.push_back(0.04447696334);
-            zeroRates.push_back(0.04456212318);    zeroRates.push_back(0.04464090072);
-            zeroRates.push_back(0.0447068707);     zeroRates.push_back(0.04475921774);
-            zeroRates.push_back(0.04477418345);    zeroRates.push_back(0.04477880755);
-            zeroRates.push_back(0.04476692489);    zeroRates.push_back(0.04473779454);
-            zeroRates.push_back(0.04468646066);    zeroRates.push_back(0.04430951558);
-            zeroRates.push_back(0.04363922313);    zeroRates.push_back(0.04363601992);
+            std::vector<Date> dates = {
+                Date(39147), Date(39148), Date(39151), Date(39153), Date(39159), Date(39166),
+                Date(39183), Date(39294), Date(39384), Date(39474), Date(39567), Date(39658),
+                Date(39748), Date(39839), Date(39931), Date(40250), Date(40614), Date(40978),
+                Date(41344), Date(41709), Date(42074), Date(42441), Date(42805), Date(43170),
+                Date(43535), Date(43900), Date(44268), Date(44632), Date(44996), Date(45361),
+                Date(45727), Date(46092), Date(46459), Date(46823), Date(47188), Date(47553),
+                Date(47918), Date(48283), Date(48650), Date(49014), Date(49379), Date(49744),
+                Date(50110), Date(53762), Date(57415), Date(61068)};
+
+            std::vector<Rate> zeroRates = {
+                0.02676568527, 0.02676568527, 0.02676333038, 0.02682286201, 0.02682038347,
+                0.02683030208, 0.02700136766, 0.02932526033, 0.03085568949, 0.03216370631,
+                0.03321234116, 0.03404978072, 0.03471117149, 0.03527141916, 0.03574660393,
+                0.03691715582, 0.03796468718, 0.03876457629, 0.03942029708, 0.03999925325,
+                0.04056663618, 0.04108743922, 0.04156156761, 0.0419979179,  0.04239486483,
+                0.04273799032, 0.04305531203, 0.04336417578, 0.04364017665, 0.04388153459,
+                0.04408005012, 0.04424764425, 0.04437504759, 0.04447696334, 0.04456212318,
+                0.04464090072, 0.0447068707,  0.04475921774, 0.04477418345, 0.04477880755,
+                0.04476692489, 0.04473779454, 0.04468646066, 0.04430951558, 0.04363922313,
+                0.04363601992};
 
             termStructure.linkTo( ext::shared_ptr<YieldTermStructure>(
                 new ZeroCurve(dates, zeroRates, Actual365Fixed())));
@@ -191,19 +140,10 @@ namespace range_accrual_test {
             // ATM swaptionvol matrix
             optionBDC = Following;
 
-            atmOptionTenors = std::vector<Period>();
-            atmOptionTenors.emplace_back(1, Months);
-            atmOptionTenors.emplace_back(6, Months);
-            atmOptionTenors.emplace_back(1, Years);
-            atmOptionTenors.emplace_back(5, Years);
-            atmOptionTenors.emplace_back(10, Years);
-            atmOptionTenors.emplace_back(30, Years);
+            atmOptionTenors = {1 * Months, 6 * Months, 1 * Years,
+                               5 * Years,  10 * Years, 30 * Years};
 
-            atmSwapTenors = std::vector<Period>();
-            atmSwapTenors.emplace_back(1, Years);
-            atmSwapTenors.emplace_back(5, Years);
-            atmSwapTenors.emplace_back(10, Years);
-            atmSwapTenors.emplace_back(30, Years);
+            atmSwapTenors = {1 * Years, 5 * Years, 10 * Years, 30 * Years};
 
             atmVolMatrix = Matrix(atmOptionTenors.size(), atmSwapTenors.size());
             //atmVolMatrix[0][0]=0.1300; atmVolMatrix[0][1]=0.1560; atmVolMatrix[0][2]=0.1390; atmVolMatrix[0][3]=0.1220;
@@ -224,23 +164,12 @@ namespace range_accrual_test {
             Size nColsAtmVols = atmVolMatrix.columns();
 
 
-            //swaptionvolcube
-            optionTenors = std::vector<Period>();
-            optionTenors.emplace_back(1, Years);
-            optionTenors.emplace_back(10, Years);
-            optionTenors.emplace_back(30, Years);
+            // swaptionvolcube
+            optionTenors = {Period(1, Years), Period(10, Years), Period(30, Years)};
 
-            swapTenors = std::vector<Period>();
-            swapTenors.emplace_back(2, Years);
-            swapTenors.emplace_back(10, Years);
-            swapTenors.emplace_back(30, Years);
+            swapTenors = {Period(2, Years), Period(10, Years), Period(30, Years)};
 
-            strikeSpreads = std::vector<Rate>();
-            strikeSpreads.push_back(-0.020);
-            strikeSpreads.push_back(-0.005);
-            strikeSpreads.push_back(+0.000);
-            strikeSpreads.push_back(+0.005);
-            strikeSpreads.push_back(+0.020);
+            strikeSpreads = {-0.020, -0.005, +0.000, +0.005, +0.020};
 
             Size nRows = optionTenors.size()*swapTenors.size();
             Size nCols = strikeSpreads.size();
@@ -410,11 +339,10 @@ namespace range_accrual_test {
             ext::shared_ptr<SwaptionVolatilityStructure>(swaptionVolatilityCubeBySabrPtr));
             swaptionVolatilityCubeBySabr->enableExtrapolation();
 
-            swaptionVolatilityStructures = std::vector<Handle<SwaptionVolatilityStructure> >();
-            //swaptionVolatilityStructures.push_back(atmVol);
-            //swaptionVolatilityStructures.push_back(flatSwaptionVolatilityCube1);
-            swaptionVolatilityStructures.push_back(flatSwaptionVolatilityCube2);
-            swaptionVolatilityStructures.push_back(swaptionVolatilityCubeBySabr);
+            swaptionVolatilityStructures = {// atmVol,
+                                            // flatSwaptionVolatilityCube1,
+                                            flatSwaptionVolatilityCube2,
+                                            swaptionVolatilityCubeBySabr};
         }
 
 
@@ -424,7 +352,7 @@ namespace range_accrual_test {
             for (Size i=0; i < 1000; ++i)
                 strikes[i] = 0.003+i/1000.0;
 
-            Real expiryBag[] = {
+            const std::vector<Rate> stdDevsOnExpiry = {
                     2.45489828353233, 2.10748097295326, 1.87317517200074, 1.69808302023488, 1.55911989073644, 1.44436083444893, 1.34687413874126, 1.26228953588707, 1.18769456816136, 1.12104324191799, 1.06085561121201, 1.00603120341767,
                     0.9557256903997, 0.90928131840481, 0.86618579845204, 0.82601854761258, 0.78844752673212, 0.75320077993188, 0.720053785498, 0.68882313132617, 0.65935702808872, 0.6315321469569, 0.60524729504558, 0.58041392858028, 0.55696247745247, 0.53482969610895,
                     0.51396815038482, 0.49433040611518, 0.47586902913511, 0.45854923439037, 0.44232991227137, 0.4271636286132, 0.41300927380629, 0.39981941368572, 0.38754661408661, 0.37613711628872, 0.3655403238495, 0.35570564032638, 0.34657298244381,
@@ -502,7 +430,7 @@ namespace range_accrual_test {
                     0.50112930308454, 0.50133801341011, 0.50154039918036, 0.50164475434315, 0.50172064900699, 0.50195465755384, 0.50209696004855, 0.50221080204432, 0.50240686325925, 0.50259659991886,
                     0.50265984547206, 0.50281163479975, 0.50290334085189, 0.50308359067852, 0.50330495011473, 0.50338400705624, 0.50352947182861, 0.5037128839329, 0.50385834870526, 0.50402911169891, 0.50412714230638, 0.50430106757769};
 
-            Real paymentBag[] = {
+            const std::vector<Rate> stdDevsOnPayment = {
                     1.6617526454415, 1.4669124167142, 1.32415790098, 1.2120961731935, 1.1201668663866, 1.0424206605982, 0.9751732547411, 0.9160138132757, 0.8632670647314, 0.8157437931899, 0.7725528968054, 0.7330333400265, 0.6966731443381, 0.6630705038169, 0.6319111025389,
                     0.6029486723577, 0.5759823103116, 0.5508499978832, 0.5274286009992, 0.5056047066973, 0.4852940653485, 0.4664189080644, 0.4489047063269, 0.4326866527292, 0.4176999398641, 0.4038765199544, 0.3911451048524, 0.3794344064103, 0.3686698961103, 0.3587770454342,
                     0.3496780854936, 0.3413049685113, 0.3335864063394, 0.3264575915712, 0.3198563090958, 0.3137287687655, 0.3080244208027, 0.3026982240597, 0.2977103219812, 0.2930253945303, 0.2886123341517, 0.2844432736605, 0.2804945583529, 0.2767441537107, 0.273174237697,
@@ -571,9 +499,6 @@ namespace range_accrual_test {
                     0.5025069126434, 0.5025684796801, 0.502827709308, 0.5029800067144, 0.503096660047, 0.503375331897, 0.5034239374523, 0.5036216000436, 0.5038063011535, 0.5039294352267, 0.5040784922628, 0.5041757033733, 0.5043701255942, 0.5044478944826, 0.5047136048513,
                     0.5047136048513, 0.504924228924, 0.5050959685525, 0.5051899392926, 0.5053908422542, 0.505611187438, 0.5056954370671, 0.5058185711403, 0.505964387806, 0.5061393678049 };
 
-            const std::vector<Rate> stdDevsOnExpiry(&expiryBag[0], &expiryBag[0]+LENGTH(expiryBag));
-            const std::vector<Rate> stdDevsOnPayment(&paymentBag[0], &paymentBag[0]+LENGTH(paymentBag));
-
             //Create smiles on Expiry Date
             smilesOnExpiry = std::vector<ext::shared_ptr<SmileSection> >();
             smilesOnExpiry.push_back(ext::shared_ptr<SmileSection>(
@@ -646,9 +571,7 @@ namespace range_accrual_test {
                                          observationsConvention,
                                          DateGeneration::Forward, false);
             // Range accrual pricers properties
-            byCallSpread = std::vector<bool>();
-            byCallSpread.push_back(true);
-            byCallSpread.push_back(false);
+            byCallSpread = {true, false};
 
             std::vector<Rate> strikes;
 
diff --git a/test-suite/riskneutraldensitycalculator.cpp b/test-suite/riskneutraldensitycalculator.cpp
index c5690dcbafe..05362635838 100644
--- a/test-suite/riskneutraldensitycalculator.cpp
+++ b/test-suite/riskneutraldensitycalculator.cpp
@@ -415,24 +415,23 @@ void RiskNeutralDensityCalculatorTest::testLocalVolatilityRND() {
             spot, rTS, qTS, localVolSurface, dumasTimeGrid, 401, 0.1, 1e-8));
 
     const Real strikes[] = { 25, 50, 95, 100, 105, 150, 200, 400 };
-    const Date maturityDates[] = {
+    const std::vector<Date> maturities = {
         todaysDate + Period(1, Weeks),   todaysDate + Period(1, Months),
         todaysDate + Period(3, Months),  todaysDate + Period(6, Months),
         todaysDate + Period(12, Months), todaysDate + Period(18, Months),
         todaysDate + Period(2, Years),   todaysDate + Period(3, Years) };
-    const std::vector<Date> maturities(
-        maturityDates, maturityDates + LENGTH(maturityDates));
 
 
-    for (auto maturitie : maturities) {
-        const Time expiry = rTS->dayCounter().yearFraction(todaysDate, maturitie);
+    for (auto maturity : maturities) {
+        const Time expiry
+            = rTS->dayCounter().yearFraction(todaysDate, maturity);
 
         const ext::shared_ptr<PricingEngine> engine(
             new FdBlackScholesVanillaEngine(
                 bsmProcess, std::max(Size(51), Size(expiry*101)),
                 201, 0, FdmSchemeDesc::Douglas(), true, b1));
 
-        const ext::shared_ptr<Exercise> exercise(new EuropeanExercise(maturitie));
+        const ext::shared_ptr<Exercise> exercise(new EuropeanExercise(maturity));
 
         for (double strike : strikes) {
             const ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(
@@ -721,10 +720,10 @@ void RiskNeutralDensityCalculatorTest::testMassAtZeroCEVProcessRND() {
     const Time t = 2.75;
 
     const std::pair<Real, Real> params[] = {
-      std::make_pair(0.1, 1.6),
-      std::make_pair(0.01, 2.0),
-      std::make_pair(10.0, 0.35),
-      std::make_pair(50.0, 0.1)
+        {0.1, 1.6},
+        {0.01, 2.0},
+        {10.0, 0.35},
+        {50.0, 0.1}
     };
 
     const Real tol = 1e-4;
diff --git a/test-suite/schedule.cpp b/test-suite/schedule.cpp
index 335f87ba6ac..7b07ef59336 100644
--- a/test-suite/schedule.cpp
+++ b/test-suite/schedule.cpp
@@ -807,11 +807,10 @@ void ScheduleTest::testDateConstructor() {
     BOOST_TEST_MESSAGE("Testing the constructor taking a vector of dates and "
                        "possibly additional meta information...");
 
-    std::vector<Date> dates;
-    dates.emplace_back(16, May, 2015);
-    dates.emplace_back(18, May, 2015);
-    dates.emplace_back(18, May, 2016);
-    dates.emplace_back(31, December, 2017);
+    std::vector<Date> dates = {Date(16, May, 2015),
+                               Date(18, May, 2015),
+                               Date(18, May, 2016),
+                               Date(31, December, 2017)};
 
     // schedule without any additional information
     Schedule schedule1(dates);
@@ -831,10 +830,7 @@ void ScheduleTest::testDateConstructor() {
                     << ", expected unadjusted");
 
     // schedule with metadata
-    std::vector<bool> regular;
-    regular.push_back(false);
-    regular.push_back(true);
-    regular.push_back(false);
+    std::vector<bool> regular = {false, true, false};
     Schedule schedule2(dates, TARGET(), Following, ModifiedPreceding, 1 * Years,
                        DateGeneration::Backward, true, regular);
     for (Size i = 1; i < dates.size(); ++i)
diff --git a/test-suite/shortratemodels.cpp b/test-suite/shortratemodels.cpp
index 82576d169ce..7df72dd4785 100644
--- a/test-suite/shortratemodels.cpp
+++ b/test-suite/shortratemodels.cpp
@@ -300,7 +300,7 @@ void ShortRateModelTest::testSwaps() {
 
     Date settlement = calendar.advance(today,2,Days);
 
-    Date dates[] = {
+    std::vector<Date> dates = {
         settlement,
         calendar.advance(settlement,1,Weeks),
         calendar.advance(settlement,1,Months),
@@ -314,7 +314,7 @@ void ShortRateModelTest::testSwaps() {
         calendar.advance(settlement,10,Years),
         calendar.advance(settlement,15,Years)
     };
-    DiscountFactor discounts[] = {
+    std::vector<DiscountFactor> discounts = {
         1.0,
         0.999258,
         0.996704,
@@ -331,11 +331,7 @@ void ShortRateModelTest::testSwaps() {
 
     Handle<YieldTermStructure> termStructure(
        ext::shared_ptr<YieldTermStructure>(
-           new DiscountCurve(
-               std::vector<Date>(dates,dates+LENGTH(dates)),
-               std::vector<DiscountFactor>(discounts,
-                                           discounts+LENGTH(discounts)),
-               Actual365Fixed())));
+           new DiscountCurve(dates, discounts, Actual365Fixed())));
 
     ext::shared_ptr<HullWhite> model(new HullWhite(termStructure));
 
diff --git a/test-suite/swapforwardmappings.cpp b/test-suite/swapforwardmappings.cpp
index 7c01ec40b6d..3ec2fe82ad9 100644
--- a/test-suite/swapforwardmappings.cpp
+++ b/test-suite/swapforwardmappings.cpp
@@ -50,9 +50,6 @@ using namespace boost::unit_test_framework;
 using std::fabs;
 using std::sqrt;
 
-#define BEGIN(x) (x+0)
-#define END(x) (x+LENGTH(x))
-
 namespace {
 
     class MarketModelData{
diff --git a/test-suite/termstructures.cpp b/test-suite/termstructures.cpp
index 29d1e2be7cf..de1aa0cd92b 100644
--- a/test-suite/termstructures.cpp
+++ b/test-suite/termstructures.cpp
@@ -362,82 +362,34 @@ void TermStructureTest::testCompositeZeroYieldStructures() {
     SavedSettings backup;
     Settings::instance().evaluationDate() = Date(10, Nov, 2017);
 
-    std::vector<Date> dates;
-    std::vector<Rate> rates;
-
     // First curve
-    dates.emplace_back(10, Nov, 2017);
-    dates.emplace_back(13, Nov, 2017);
-    dates.emplace_back(12, Feb, 2018);
-    dates.emplace_back(10, May, 2018);
-    dates.emplace_back(10, Aug, 2018);
-    dates.emplace_back(12, Nov, 2018);
-    dates.emplace_back(21, Dec, 2018);
-    dates.emplace_back(15, Jan, 2020);
-    dates.emplace_back(31, Mar, 2021);
-    dates.emplace_back(28, Feb, 2023);
-    dates.emplace_back(21, Dec, 2026);
-    dates.emplace_back(31, Jan, 2030);
-    dates.emplace_back(28, Feb, 2031);
-    dates.emplace_back(31, Mar, 2036);
-    dates.emplace_back(28, Feb, 2041);
-    dates.emplace_back(28, Feb, 2048);
-    dates.emplace_back(31, Dec, 2141);
-
-    rates.push_back(0.0655823213132524);
-    rates.push_back(0.0655823213132524);
-    rates.push_back(0.0699455024156877);
-    rates.push_back(0.0799107139233497);
-    rates.push_back(0.0813931951022577);
-    rates.push_back(0.0841615820666691);
-    rates.push_back(0.0501297919004145);
-    rates.push_back(0.0823483583439658);
-    rates.push_back(0.0860720030924466);
-    rates.push_back(0.0922887604375688);
-    rates.push_back(0.10588902278996);
-    rates.push_back(0.117021968693922);
-    rates.push_back(0.109824660896137);
-    rates.push_back(0.109231572878364);
-    rates.push_back(0.119218123236241);
-    rates.push_back(0.128647300167664);
-    rates.push_back(0.0506086995288751);
+    std::vector<Date> dates = {Date(10, Nov, 2017), Date(13, Nov, 2017), Date(12, Feb, 2018),
+                               Date(10, May, 2018), Date(10, Aug, 2018), Date(12, Nov, 2018),
+                               Date(21, Dec, 2018), Date(15, Jan, 2020), Date(31, Mar, 2021),
+                               Date(28, Feb, 2023), Date(21, Dec, 2026), Date(31, Jan, 2030),
+                               Date(28, Feb, 2031), Date(31, Mar, 2036), Date(28, Feb, 2041),
+                               Date(28, Feb, 2048), Date(31, Dec, 2141)};
+
+    std::vector<Rate> rates = {0.0655823213132524, 0.0655823213132524, 0.0699455024156877,
+                               0.0799107139233497, 0.0813931951022577, 0.0841615820666691,
+                               0.0501297919004145, 0.0823483583439658, 0.0860720030924466,
+                               0.0922887604375688, 0.10588902278996,   0.117021968693922,
+                               0.109824660896137,  0.109231572878364,  0.119218123236241,
+                               0.128647300167664,  0.0506086995288751};
 
     ext::shared_ptr<YieldTermStructure> termStructure1 = ext::shared_ptr<YieldTermStructure>(
         new ForwardCurve(dates, rates, Actual365Fixed(), NullCalendar()));
 
     // Second curve
-    dates.clear();
-    rates.clear();
-
-    dates.emplace_back(10, Nov, 2017);
-    dates.emplace_back(13, Nov, 2017);
-    dates.emplace_back(11, Dec, 2017);
-    dates.emplace_back(12, Feb, 2018);
-    dates.emplace_back(10, May, 2018);
-    dates.emplace_back(31, Jan, 2022);
-    dates.emplace_back(7, Dec, 2023);
-    dates.emplace_back(31, Jan, 2025);
-    dates.emplace_back(31, Mar, 2028);
-    dates.emplace_back(7, Dec, 2033);
-    dates.emplace_back(1, Feb, 2038);
-    dates.emplace_back(2, Apr, 2046);
-    dates.emplace_back(2, Jan, 2051);
-    dates.emplace_back(31, Dec, 2141);
-
-    rates.push_back(0.056656806197189);
-    rates.push_back(0.056656806197189);
-    rates.push_back(0.0419541633454473);
-    rates.push_back(0.0286681050019797);
-    rates.push_back(0.0148840226959593);
-    rates.push_back(0.0246680238374363);
-    rates.push_back(0.0255349067810599);
-    rates.push_back(0.0298907184711927);
-    rates.push_back(0.0263943927922053);
-    rates.push_back(0.0291924526539802);
-    rates.push_back(0.0270049276163556);
-    rates.push_back(0.028775807327614);
-    rates.push_back(0.0293567711641792);
-    rates.push_back(0.010518655099659);
+    dates = {Date(10, Nov, 2017), Date(13, Nov, 2017), Date(11, Dec, 2017), Date(12, Feb, 2018),
+             Date(10, May, 2018), Date(31, Jan, 2022), Date(7, Dec, 2023),  Date(31, Jan, 2025),
+             Date(31, Mar, 2028), Date(7, Dec, 2033),  Date(1, Feb, 2038),  Date(2, Apr, 2046),
+             Date(2, Jan, 2051),  Date(31, Dec, 2141)};
+
+    rates = {0.056656806197189,  0.056656806197189,  0.0419541633454473, 0.0286681050019797,
+             0.0148840226959593, 0.0246680238374363, 0.0255349067810599, 0.0298907184711927,
+             0.0263943927922053, 0.0291924526539802, 0.0270049276163556, 0.028775807327614,
+             0.0293567711641792, 0.010518655099659};
 
     ext::shared_ptr<YieldTermStructure> termStructure2 = ext::shared_ptr<YieldTermStructure>(
         new ForwardCurve(dates, rates, Actual365Fixed(), NullCalendar()));
@@ -448,24 +400,11 @@ void TermStructureTest::testCompositeZeroYieldStructures() {
         new CompositeZeroYieldStructure<binary_f>(Handle<YieldTermStructure>(termStructure1), Handle<YieldTermStructure>(termStructure2), sub));
 
     // Expected values
-    dates.clear();
-    rates.clear();
-
-    dates.emplace_back(10, Nov, 2017);
-    dates.emplace_back(15, Dec, 2017);
-    dates.emplace_back(15, Jun, 2018);
-    dates.emplace_back(15, Sep, 2029);
-    dates.emplace_back(15, Sep, 2038);
-    dates.emplace_back(15, Mar, 2046);
-    dates.emplace_back(15, Dec, 2141);
-
-    rates.push_back(0.00892551511527986);
-    rates.push_back(0.0278755322562788);
-    rates.push_back(0.0512001768603456);
-    rates.push_back(0.0729941474263546);
-    rates.push_back(0.0778333309498459);
-    rates.push_back(0.0828451659139004);
-    rates.push_back(0.0503573807521742);
+    dates = {Date(10, Nov, 2017), Date(15, Dec, 2017), Date(15, Jun, 2018), Date(15, Sep, 2029),
+             Date(15, Sep, 2038), Date(15, Mar, 2046), Date(15, Dec, 2141)};
+
+    rates = {0.00892551511527986, 0.0278755322562788, 0.0512001768603456, 0.0729941474263546,
+             0.0778333309498459,  0.0828451659139004, 0.0503573807521742};
 
     Real tolerance = 1.0e-10;
     for (Size i = 0; i < dates.size(); ++i) {
diff --git a/test-suite/timegrid.cpp b/test-suite/timegrid.cpp
index 045db3b7257..107babcf35d 100644
--- a/test-suite/timegrid.cpp
+++ b/test-suite/timegrid.cpp
@@ -28,37 +28,22 @@ using namespace boost::unit_test_framework;
 void TimeGridTest::testConstructorAdditionalSteps()
 {
     BOOST_TEST_MESSAGE("Testing TimeGrid construction with additional steps...");
-    std::vector<Time> test_times;
-    test_times.push_back(1.0);
-    test_times.push_back(2.0);
-    test_times.push_back(4.0);
+    std::vector<Time> test_times = {1.0, 2.0, 4.0};
     const TimeGrid tg(test_times.begin(), test_times.end(), 8);
-    
+
     // Expect 8 evenly sized steps over the interval [0, 4].
-    std::vector<Time> expected_times;
-    expected_times.push_back(0.0);
-    expected_times.push_back(0.5);
-    expected_times.push_back(1.0);
-    expected_times.push_back(1.5);
-    expected_times.push_back(2.0);
-    expected_times.push_back(2.5);
-    expected_times.push_back(3.0);
-    expected_times.push_back(3.5);
-    expected_times.push_back(4.0);
-    BOOST_CHECK_EQUAL_COLLECTIONS(
-        tg.begin(), tg.end(), expected_times.begin(), expected_times.end());
+    std::vector<Time> expected_times = {0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0};
+
+    BOOST_CHECK_EQUAL_COLLECTIONS(tg.begin(), tg.end(), expected_times.begin(),
+                                  expected_times.end());
 }
 
 void TimeGridTest::testConstructorMandatorySteps()
 {
     BOOST_TEST_MESSAGE("Testing TimeGrid construction with only mandatory points...");
-    std::vector<Time> test_times;
-    test_times.push_back(0.0);
-    test_times.push_back(1.0);
-    test_times.push_back(2.0);
-    test_times.push_back(4.0);
+    std::vector<Time> test_times = {0.0, 1.0, 2.0, 4.0};
     const TimeGrid tg(test_times.begin(), test_times.end());
-    
+
     // Time grid must include all times from passed iterator.
     // Further no additional times can be added.
     BOOST_CHECK_EQUAL_COLLECTIONS(
@@ -72,13 +57,7 @@ void TimeGridTest::testConstructorEvenSteps()
     Time end_time = 10;
     Size steps = 5;
     const TimeGrid tg(end_time, steps);
-    std::vector<Time> expected_times;
-    expected_times.push_back(0.0);
-    expected_times.push_back(2.0);
-    expected_times.push_back(4.0);
-    expected_times.push_back(6.0);
-    expected_times.push_back(8.0);
-    expected_times.push_back(10.0);
+    std::vector<Time> expected_times = {0.0, 2.0, 4.0, 6.0, 8.0, 10.0};
     
     BOOST_CHECK_EQUAL_COLLECTIONS(
         tg.begin(), tg.end(), expected_times.begin(), expected_times.end()
@@ -101,22 +80,14 @@ void TimeGridTest::testConstructorNegativeValuesInIterator()
         "Testing that the TimeGrid constructor raises an error for negative time values..."
     );
     
-    std::vector<Time> times;
-    times.push_back(-3.0);
-    times.push_back(1.0);
-    times.push_back(4.0);
-    times.push_back(5.0);
+    std::vector<Time> times = {-3.0, 1.0, 4.0, 5.0};
     BOOST_CHECK_THROW(const TimeGrid tg(times.begin(), times.end()), Error);
 }
 
 void TimeGridTest::testClosestIndex()
 {
-    BOOST_TEST_MESSAGE("Testing that the returned index is closest to the requested time..."
-    );
-    std::vector<Time> test_times;
-    test_times.push_back(1.0);
-    test_times.push_back(2.0);
-    test_times.push_back(5.0);
+    BOOST_TEST_MESSAGE("Testing that the returned index is closest to the requested time...");
+    std::vector<Time> test_times = {1.0, 2.0, 5.0};
     const TimeGrid tg(test_times.begin(), test_times.end());
     const Size expected_index = 3;
     
@@ -128,10 +99,7 @@ void TimeGridTest::testClosestIndex()
 void TimeGridTest::testClosestTime()
 {
     BOOST_TEST_MESSAGE("Testing that the returned time matches the requested index...");
-    std::vector<Time> test_times;
-    test_times.push_back(1.0);
-    test_times.push_back(2.0);
-    test_times.push_back(5.0);
+    std::vector<Time> test_times = {1.0, 2.0, 5.0};
     const TimeGrid tg(test_times.begin(), test_times.end());
     const Size expected_time = 5;
     
@@ -143,10 +111,7 @@ void TimeGridTest::testClosestTime()
 void TimeGridTest::testMandatoryTimes()
 {
     BOOST_TEST_MESSAGE("Testing that mandatory times are recalled correctly...");
-    std::vector<Time> test_times;
-    test_times.push_back(1.0);
-    test_times.push_back(2.0);
-    test_times.push_back(4.0);
+    std::vector<Time> test_times = {1.0, 2.0, 4.0};
     const TimeGrid tg(test_times.begin(), test_times.end(), 8);
     
     // Mandatory times are those provided by the original iterator.
diff --git a/test-suite/timeseries.cpp b/test-suite/timeseries.cpp
index 6cd6f745582..15f5598456f 100644
--- a/test-suite/timeseries.cpp
+++ b/test-suite/timeseries.cpp
@@ -71,22 +71,12 @@ void TimeSeriesTest::testConstruction() {
 void TimeSeriesTest::testIntervalPrice() {
     BOOST_TEST_MESSAGE("Testing time series interval price...");
 
-    std::vector<Date> date;
-    std::vector<Real> open, close, high, low;
-    date.emplace_back(25, March, 2005);
-    date.emplace_back(29, March, 2005);
+    std::vector<Date> date = {Date(25, March, 2005), Date(29, March, 2005)};
 
-    open.push_back(1.3);
-    open.push_back(2.3);
-
-    close.push_back(2.3);
-    close.push_back(3.4);
-
-    high.push_back(3.4);
-    high.push_back(3.5);
-
-    low.push_back(3.4);
-    low.push_back(3.2);
+    std::vector<Real> open = {1.3, 2.3},
+                      close = {2.3, 3.4},
+                      high = {3.4, 3.5},
+                      low = {3.4, 3.2};
 
     TimeSeries<IntervalPrice> tsiq = IntervalPrice::makeSeries(date,
                                                                open,
@@ -97,16 +87,12 @@ void TimeSeriesTest::testIntervalPrice() {
 
 void TimeSeriesTest::testIterators() {
     BOOST_TEST_MESSAGE("Testing time series iterators...");
-    std::vector<Date> dates;
-    std::vector<Real> prices;
 
-    dates.emplace_back(25, March, 2005);
-    dates.emplace_back(29, March, 2005);
-    dates.emplace_back(15, March, 2005);
+    std::vector<Date> dates = {Date(25, March, 2005),
+                               Date(29, March, 2005),
+                               Date(15, March, 2005)};
 
-    prices.push_back(25);
-    prices.push_back(23);
-    prices.push_back(20);
+    std::vector<Real> prices = {25, 23, 20};
 
     TimeSeries<Real> ts(dates.begin(), dates.end(), prices.begin());
 
diff --git a/test-suite/utilities.hpp b/test-suite/utilities.hpp
index f98d15ee113..1c30cf36d82 100644
--- a/test-suite/utilities.hpp
+++ b/test-suite/utilities.hpp
@@ -41,7 +41,7 @@
 #include <utility>
 #include <vector>
 
-// This makes it easier to use array literals (alas, no std::vector literals)
+// This makes it easier to use array literals (for new code, use std::vector though)
 #define LENGTH(a) (sizeof(a)/sizeof(a[0]))
 
 #define QUANTLIB_TEST_CASE(f) BOOST_TEST_CASE(QuantLib::detail::quantlib_test_case(f))
diff --git a/test-suite/vpp.cpp b/test-suite/vpp.cpp
index 52c1ed40d1e..d5e6236d497 100644
--- a/test-suite/vpp.cpp
+++ b/test-suite/vpp.cpp
@@ -145,9 +145,7 @@ void VPPTest::testGemanRoncoroniProcess() {
         new ExtendedOrnsteinUhlenbeckProcess(speed, vol, x0G, f,
                            ExtendedOrnsteinUhlenbeckProcess::Trapezodial));
 
-    std::vector<ext::shared_ptr<StochasticProcess1D> > processes;
-    processes.push_back(grProcess);
-    processes.push_back(eouProcess);
+    std::vector<ext::shared_ptr<StochasticProcess1D> > processes = {grProcess, eouProcess};
 
     Matrix correlation(2, 2, 1.0);
     correlation[0][1] = correlation[1][0] = 0.25;
@@ -353,7 +351,8 @@ void VPPTest::testKlugeExtOUSpreadOption() {
 namespace vpp_test {
     // for a "real" gas and power forward curve
     // please see. e.g. http://www.kyos.com/?content=64
-    const Real fuelPrices[] = {20.74,21.65,20.78,21.58,21.43,20.82,22.02,21.52,
+    const std::vector<Real> fuelPrices = {
+                              20.74,21.65,20.78,21.58,21.43,20.82,22.02,21.52,
                               21.02,21.46,21.75,20.69,22.16,20.38,20.82,20.68,
                               20.57,21.92,22.04,20.45,20.75,21.92,20.53,20.67,
                               20.88,21.02,20.82,21.67,21.82,22.12,20.45,20.74,
@@ -375,7 +374,8 @@ namespace vpp_test {
                               20.70,21.84,21.82,21.68,21.24,22.36,20.83,20.64,
                               21.03,20.57,22.34,20.96,21.54,21.26,21.43,22.39};
 
-    const Real powerPrices[]={40.40,36.71,31.87,25.81,31.61,35.00,46.22,60.68,
+    const std::vector<Real> powerPrices = {
+                              40.40,36.71,31.87,25.81,31.61,35.00,46.22,60.68,
                               42.45,38.01,33.84,29.79,31.84,38.53,49.23,59.92,
                               43.85,37.47,34.89,29.99,30.85,29.19,29.25,38.67,
                               36.90,25.93,22.12,20.19,17.19,19.29,13.51,18.14,
@@ -436,10 +436,8 @@ void VPPTest::testVPPIntrinsicValue() {
                                 startUpFuel, startUpFixCost, exercise);
 
         option.setPricingEngine(ext::shared_ptr<PricingEngine>(
-            new DynProgVPPIntrinsicValueEngine(
-                std::vector<Real>(fuelPrices,fuelPrices+LENGTH(fuelPrices)),
-                std::vector<Real>(powerPrices,powerPrices+LENGTH(powerPrices)),
-                fuelCostAddon, flatRate(0.0, dc))));
+            new DynProgVPPIntrinsicValueEngine(fuelPrices, powerPrices,
+                                               fuelCostAddon, flatRate(0.0, dc))));
 
         const Real calculated = option.NPV();
 
@@ -601,7 +599,7 @@ void VPPTest::testVPPPricing() {
     const ext::shared_ptr<YieldTermStructure> rTS
         = flatRate(today, irRate, dc);
 
-    const Size nHours = LENGTH(powerPrices);
+    const Size nHours = powerPrices.size();
 
     typedef FdSimpleKlugeExtOUVPPEngine::Shape Shape;
     ext::shared_ptr<Shape> fuelShape(new Shape(nHours));
@@ -625,10 +623,8 @@ void VPPTest::testVPPPricing() {
 
     // Test: intrinsic value
     vppOption.setPricingEngine(ext::shared_ptr<PricingEngine>(
-        new DynProgVPPIntrinsicValueEngine(
-            std::vector<Real>(fuelPrices, fuelPrices+nHours),
-            std::vector<Real>(powerPrices, powerPrices+nHours),
-            fuelCostAddon, flatRate(0.0, dc))));
+        new DynProgVPPIntrinsicValueEngine(fuelPrices, powerPrices,
+                                           fuelCostAddon, flatRate(0.0, dc))));
 
     const Real intrinsic = vppOption.NPV();
     const Real expectedIntrinsic = 2056.04;

From a426a0da1a476824646ccd0f8dbba00b357c3b72 Mon Sep 17 00:00:00 2001
From: Luigi Ballabio <luigi.ballabio@gmail.com>
Date: Sun, 21 Feb 2021 00:07:18 +0100
Subject: [PATCH 2/3] Replace uses of boost::assign

---
 Examples/BasketLosses/BasketLosses.cpp        |  12 +-
 ql/experimental/models/hestonslvfdmmodel.cpp  |  30 +-
 ql/experimental/volatility/noarbsabr.cpp      |  21 +-
 .../volatility/noarbsabrinterpolation.hpp     |   6 +-
 .../volatility/sviinterpolation.hpp           |   6 +-
 .../volatility/zabrinterpolation.hpp          |   6 +-
 ql/math/interpolations/sabrinterpolation.hpp  |   8 +-
 .../meshers/fdmmeshercomposite.cpp            |  48 +-
 ql/time/calendars/saudiarabia.cpp             | 117 ++---
 test-suite/andreasenhugevolatilityinterpl.cpp |  30 +-
 test-suite/creditdefaultswap.cpp              |  31 +-
 test-suite/defaultprobabilitycurves.cpp       | 130 ++---
 test-suite/fdcir.cpp                          |   2 -
 test-suite/fdheston.cpp                       |   3 -
 test-suite/hestonslvmodel.cpp                 |  36 +-
 test-suite/integrals.cpp                      |   6 +-
 test-suite/interpolations.cpp                 |  16 +-
 test-suite/noarbsabr.cpp                      |   7 +-
 test-suite/normalclvmodel.cpp                 |  40 +-
 test-suite/optionletstripper.cpp              |  69 +--
 test-suite/piecewiseyieldcurve.cpp            |  94 ++--
 test-suite/schedule.cpp                       | 456 +++++++++---------
 test-suite/squarerootclvmodel.cpp             |   5 -
 test-suite/zabr.cpp                           |  23 +-
 24 files changed, 571 insertions(+), 631 deletions(-)

diff --git a/Examples/BasketLosses/BasketLosses.cpp b/Examples/BasketLosses/BasketLosses.cpp
index 48d0f73aa0f..16c337fd4a2 100644
--- a/Examples/BasketLosses/BasketLosses.cpp
+++ b/Examples/BasketLosses/BasketLosses.cpp
@@ -32,16 +32,12 @@
 #include <ql/time/daycounters/actual365fixed.hpp>
 #include <ql/time/calendars/target.hpp>
 #include <ql/currencies/europe.hpp>
-
-#include <boost/assign/std/vector.hpp>
-
 #include <iostream>
 #include <iomanip>
 #include <string>
 
 using namespace std;
 using namespace QuantLib;
-using namespace boost::assign;
 
 #if defined(QL_ENABLE_SESSIONS)
 namespace QuantLib {
@@ -67,11 +63,9 @@ int main(int, char* []) {
                         SET UP BASKET PORTFOLIO
         -------------------------------------------------------------- */
         // build curves and issuers into a basket of ten names
-        std::vector<Real> hazardRates;
-        hazardRates += 
-        //  0.01, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9;        
-            0.001, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09;        
-        //  0.01,  0.01,  0.01,  0.01, 0.01,  0.01,  0.01,  0.01,  0.01,  0.01;        
+        std::vector<Real> hazardRates = {
+            0.001, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09
+        };
         std::vector<std::string> names;
         for(Size i=0; i<hazardRates.size(); i++)
             names.push_back(std::string("Acme") + 
diff --git a/ql/experimental/models/hestonslvfdmmodel.cpp b/ql/experimental/models/hestonslvfdmmodel.cpp
index 696e2add28d..8ac80753e69 100644
--- a/ql/experimental/models/hestonslvfdmmodel.cpp
+++ b/ql/experimental/models/hestonslvfdmmodel.cpp
@@ -43,13 +43,10 @@
 #include <ql/termstructures/volatility/equityfx/fixedlocalvolsurface.hpp>
 #include <ql/termstructures/volatility/equityfx/localvoltermstructure.hpp>
 #include <ql/timegrid.hpp>
-#include <boost/assign/std/vector.hpp>
 #include <boost/scoped_ptr.hpp>
 #include <functional>
 #include <utility>
 
-using namespace boost::assign;
-
 namespace QuantLib {
 
     namespace {
@@ -83,10 +80,11 @@ namespace QuantLib {
 
                     const Real v0Center = std::log(v0);
 
-                    cPoints +=
-                        ext::make_tuple(lowerBound, lowerBoundDensity, false),
-                        ext::make_tuple(v0Center, v0Density, true),
-                        ext::make_tuple(upperBound, upperBoundDensity, false);
+                    cPoints = {
+                        {lowerBound, lowerBoundDensity, false},
+                        {v0Center, v0Density, true},
+                        {upperBound, upperBoundDensity, false}
+                    };
 
                     return ext::make_shared<Concentrating1dMesher>(
                         lowerBound, upperBound, vGrid, cPoints, 1e-8);
@@ -96,10 +94,11 @@ namespace QuantLib {
                   {
                       const Real v0Center = v0;
 
-                      cPoints +=
-                          ext::make_tuple(lowerBound, lowerBoundDensity, false),
-                          ext::make_tuple(v0Center, v0Density, true),
-                          ext::make_tuple(upperBound, upperBoundDensity, false);
+                      cPoints = {
+                          {lowerBound, lowerBoundDensity, false},
+                          {v0Center, v0Density, true},
+                          {upperBound, upperBoundDensity, false}
+                      };
 
                       return ext::make_shared<Concentrating1dMesher>(
                           lowerBound, upperBound, vGrid, cPoints, 1e-8);
@@ -109,10 +108,11 @@ namespace QuantLib {
                 {
                     const Real v0Center = v0;
 
-                    cPoints +=
-                        ext::make_tuple(lowerBound, lowerBoundDensity, false),
-                        ext::make_tuple(v0Center, v0Density, true),
-                        ext::make_tuple(upperBound, upperBoundDensity, false);
+                    cPoints = {
+                        {lowerBound, lowerBoundDensity, false},
+                        {v0Center, v0Density, true},
+                        {upperBound, upperBoundDensity, false}
+                    };
 
                     return ext::make_shared<Concentrating1dMesher>(
                         lowerBound, upperBound, vGrid, cPoints, 1e-8);
diff --git a/ql/experimental/volatility/noarbsabr.cpp b/ql/experimental/volatility/noarbsabr.cpp
index b8b85e21e5c..0b06abe570f 100644
--- a/ql/experimental/volatility/noarbsabr.cpp
+++ b/ql/experimental/volatility/noarbsabr.cpp
@@ -22,7 +22,6 @@
 #include <ql/math/solvers1d/brent.hpp>
 #include <ql/math/modifiedbessel.hpp>
 #include <boost/math/special_functions/gamma.hpp>
-#include <boost/assign/std/vector.hpp>
 #include <boost/functional/hash.hpp>
 
 namespace QuantLib {
@@ -184,8 +183,6 @@ Real NoArbSabrModel::p(const Real f) const {
 
 namespace detail {
 
-using namespace boost::assign;
-
 D0Interpolator::D0Interpolator(const Real forward, const Real expiryTime,
                                const Real alpha, const Real beta, const Real nu,
                                const Real rho)
@@ -194,7 +191,8 @@ D0Interpolator::D0Interpolator(const Real forward, const Real expiryTime,
 
     sigmaI_ = alpha_ * std::pow(forward_, beta_ - 1.0);
 
-    tauG_ += 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0,
+    tauG_ = {
+        0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0,
         3.25, 3.5, 3.75, 4.0, 4.25, 4.5, 4.75, 5.0, 5.25, 5.5, 5.75, 6.0, 6.25,
         6.5, 6.75, 7.0, 7.25, 7.5, 7.75, 8.0, 8.25, 8.5, 8.75, 9.0, 9.25, 9.5,
         9.75, 10.0, 10.25, 10.5, 10.75, 11.0, 11.25, 11.5, 11.75, 12.0, 12.25,
@@ -204,16 +202,19 @@ D0Interpolator::D0Interpolator(const Real forward, const Real expiryTime,
         20.75, 21.0, 21.25, 21.5, 21.75, 22.0, 22.25, 22.5, 22.75, 23.0, 23.25,
         23.5, 23.75, 24.0, 24.25, 24.5, 24.75, 25.0, 25.25, 25.5, 25.75, 26.0,
         26.25, 26.5, 26.75, 27.0, 27.25, 27.5, 27.75, 28.0, 28.25, 28.5, 28.75,
-        29.0, 29.25, 29.5, 29.75, 30.0;
+        29.0, 29.25, 29.5, 29.75, 30.0
+    };
 
-    sigmaIG_ += 1.0, 0.8, 0.7, 0.6, 0.5, 0.45, 0.4, 0.35, 0.3, 0.27, 0.24, 0.21,
-        0.18, 0.15, 0.125, 0.1, 0.075, 0.05;
+    sigmaIG_ = {
+        1.0, 0.8, 0.7, 0.6, 0.5, 0.45, 0.4, 0.35, 0.3, 0.27, 0.24, 0.21,
+        0.18, 0.15, 0.125, 0.1, 0.075, 0.05
+    };
 
-    rhoG_ += 0.75, 0.50, 0.25, 0.00, -0.25, -0.50, -0.75;
+    rhoG_ = { 0.75, 0.50, 0.25, 0.00, -0.25, -0.50, -0.75 };
 
-    nuG_ += 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8;
+    nuG_ = { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8 };
 
-    betaG_ += 0.01, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9;
+    betaG_ = { 0.01, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 };
 }
 
 Real D0Interpolator::operator()() const {
diff --git a/ql/experimental/volatility/noarbsabrinterpolation.hpp b/ql/experimental/volatility/noarbsabrinterpolation.hpp
index efef0e250a5..4a0bc6274d0 100644
--- a/ql/experimental/volatility/noarbsabrinterpolation.hpp
+++ b/ql/experimental/volatility/noarbsabrinterpolation.hpp
@@ -26,7 +26,6 @@
 
 #include <ql/experimental/volatility/noarbsabrsmilesection.hpp>
 #include <ql/math/interpolations/sabrinterpolation.hpp>
-#include <boost/assign/list_of.hpp>
 #include <utility>
 
 namespace QuantLib {
@@ -214,9 +213,8 @@ class NoArbSabrInterpolation : public Interpolation {
         impl_ = ext::shared_ptr<Interpolation::Impl>(
             new detail::XABRInterpolationImpl<I1, I2, detail::NoArbSabrSpecs>(
                 xBegin, xEnd, yBegin, t, forward,
-                boost::assign::list_of(alpha)(beta)(nu)(rho),
-                boost::assign::list_of(alphaIsFixed)(betaIsFixed)(nuIsFixed)(
-                    rhoIsFixed),
+                {alpha, beta, nu, rho},
+                {alphaIsFixed, betaIsFixed, nuIsFixed, rhoIsFixed},
                 vegaWeighted, endCriteria, optMethod, errorAccept, useMaxError,
                 maxGuesses));
         coeffs_ = ext::dynamic_pointer_cast<
diff --git a/ql/experimental/volatility/sviinterpolation.hpp b/ql/experimental/volatility/sviinterpolation.hpp
index 370c18414a6..80018606eed 100644
--- a/ql/experimental/volatility/sviinterpolation.hpp
+++ b/ql/experimental/volatility/sviinterpolation.hpp
@@ -26,7 +26,6 @@
 
 #include <ql/experimental/volatility/svismilesection.hpp>
 #include <ql/math/interpolations/xabrinterpolation.hpp>
-#include <boost/assign/list_of.hpp>
 #include <utility>
 
 namespace QuantLib {
@@ -162,9 +161,8 @@ class SviInterpolation : public Interpolation {
         impl_ = ext::shared_ptr<Interpolation::Impl>(
             new detail::XABRInterpolationImpl<I1, I2, detail::SviSpecs>(
                 xBegin, xEnd, yBegin, t, forward,
-                boost::assign::list_of(a)(b)(sigma)(rho)(m),
-                boost::assign::list_of(aIsFixed)(bIsFixed)(sigmaIsFixed)(
-                    rhoIsFixed)(mIsFixed),
+                {a, b, sigma, rho, m},
+                {aIsFixed, bIsFixed, sigmaIsFixed, rhoIsFixed, mIsFixed},
                 vegaWeighted, endCriteria, optMethod, errorAccept, useMaxError,
                 maxGuesses));
         coeffs_ = ext::dynamic_pointer_cast<
diff --git a/ql/experimental/volatility/zabrinterpolation.hpp b/ql/experimental/volatility/zabrinterpolation.hpp
index eba81366c15..55794439ced 100644
--- a/ql/experimental/volatility/zabrinterpolation.hpp
+++ b/ql/experimental/volatility/zabrinterpolation.hpp
@@ -26,7 +26,6 @@
 
 #include <ql/experimental/volatility/zabrsmilesection.hpp>
 #include <ql/math/interpolations/xabrinterpolation.hpp>
-#include <boost/assign/list_of.hpp>
 #include <utility>
 
 namespace QuantLib {
@@ -140,9 +139,8 @@ template <class Evaluation> class ZabrInterpolation : public Interpolation {
                 I1, I2,
                 detail::ZabrSpecs<Evaluation> >(
                 xBegin, xEnd, yBegin, t, forward,
-                boost::assign::list_of(alpha)(beta)(nu)(rho)(gamma),
-                boost::assign::list_of(alphaIsFixed)(betaIsFixed)(nuIsFixed)(
-                    rhoIsFixed)(gammaIsFixed),
+                {alpha, beta, nu, rho, gamma},
+                {alphaIsFixed, betaIsFixed, nuIsFixed, rhoIsFixed, gammaIsFixed},
                 vegaWeighted, endCriteria, optMethod, errorAccept, useMaxError,
                 maxGuesses));
             coeffs_ = ext::dynamic_pointer_cast<detail::XABRCoeffHolder<
diff --git a/ql/math/interpolations/sabrinterpolation.hpp b/ql/math/interpolations/sabrinterpolation.hpp
index 639dac9241a..899218f58e3 100644
--- a/ql/math/interpolations/sabrinterpolation.hpp
+++ b/ql/math/interpolations/sabrinterpolation.hpp
@@ -32,7 +32,6 @@
 
 #include <ql/math/interpolations/xabrinterpolation.hpp>
 #include <ql/termstructures/volatility/sabr.hpp>
-#include <boost/assign/list_of.hpp>
 #include <utility>
 
 namespace QuantLib {
@@ -169,11 +168,10 @@ class SABRInterpolation : public Interpolation {
         impl_ = ext::shared_ptr<Interpolation::Impl>(
             new detail::XABRInterpolationImpl<I1, I2, detail::SABRSpecs>(
                 xBegin, xEnd, yBegin, t, forward,
-                boost::assign::list_of(alpha)(beta)(nu)(rho),
-                boost::assign::list_of(alphaIsFixed)(betaIsFixed)(nuIsFixed)(
-                    rhoIsFixed),
+                {alpha, beta, nu, rho},
+                {alphaIsFixed, betaIsFixed, nuIsFixed, rhoIsFixed},
                 vegaWeighted, endCriteria, optMethod, errorAccept, useMaxError,
-                maxGuesses, boost::assign::list_of(shift)));
+                maxGuesses, {shift}));
         coeffs_ = ext::dynamic_pointer_cast<
             detail::XABRCoeffHolder<detail::SABRSpecs> >(impl_);
     }
diff --git a/ql/methods/finitedifferences/meshers/fdmmeshercomposite.cpp b/ql/methods/finitedifferences/meshers/fdmmeshercomposite.cpp
index adf639df3a5..1c3ec110613 100644
--- a/ql/methods/finitedifferences/meshers/fdmmeshercomposite.cpp
+++ b/ql/methods/finitedifferences/meshers/fdmmeshercomposite.cpp
@@ -21,43 +21,12 @@
 
 #include <ql/methods/finitedifferences/operators/fdmlinearoplayout.hpp>
 #include <ql/methods/finitedifferences/meshers/fdmmeshercomposite.hpp>
-#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4))
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
-#endif
-#include <boost/assign/list_of.hpp>
-#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4))
-#pragma GCC diagnostic pop
-#endif
 
 namespace QuantLib {
 
     namespace {
         typedef ext::shared_ptr<Fdm1dMesher> T;
 
-        std::vector<T> build_vector(const T& m1) {
-            return std::vector<T>(1, m1);
-        }
-
-        std::vector<T> build_vector(const T& m1, const T& m2) {
-            std::vector<ext::shared_ptr<Fdm1dMesher> > retVal
-                = boost::assign::list_of(m1)(m2);
-            return retVal;
-        }
-
-        std::vector<T> build_vector(const T& m1, const T& m2, const T& m3) {
-            std::vector<ext::shared_ptr<Fdm1dMesher> > retVal
-                = boost::assign::list_of(m1)(m2)(m3);
-            return retVal;
-        }
-
-        std::vector<T> build_vector(const T& m1, const T& m2,
-                                    const T& m3, const T& m4) {
-            std::vector<ext::shared_ptr<Fdm1dMesher> > retVal
-                = boost::assign::list_of(m1)(m2)(m3)(m4);
-            return retVal;
-        }
-
         ext::shared_ptr<FdmLinearOpLayout> getLayoutFromMeshers(
                  const std::vector<ext::shared_ptr<Fdm1dMesher> > & meshers) {
             std::vector<Size> dim(meshers.size());
@@ -70,24 +39,24 @@ namespace QuantLib {
 
     FdmMesherComposite::FdmMesherComposite(
         const ext::shared_ptr<Fdm1dMesher>& mesher)
-    : FdmMesher(getLayoutFromMeshers(build_vector(mesher))),
-      mesher_(build_vector(mesher)) {
+    : FdmMesher(getLayoutFromMeshers({mesher})),
+      mesher_({mesher}) {
     }
 
 
     FdmMesherComposite::FdmMesherComposite(
         const ext::shared_ptr<Fdm1dMesher>& m1,
         const ext::shared_ptr<Fdm1dMesher>& m2)
-    : FdmMesher(getLayoutFromMeshers(build_vector(m1, m2))),
-      mesher_(build_vector(m1, m2)) {
+    : FdmMesher(getLayoutFromMeshers({m1, m2})),
+      mesher_({m1, m2}) {
     }
 
     FdmMesherComposite::FdmMesherComposite(
         const ext::shared_ptr<Fdm1dMesher>& m1,
         const ext::shared_ptr<Fdm1dMesher>& m2,
         const ext::shared_ptr<Fdm1dMesher>& m3)
-    : FdmMesher(getLayoutFromMeshers(build_vector(m1, m2, m3))),
-      mesher_(build_vector(m1, m2, m3)) {
+    : FdmMesher(getLayoutFromMeshers({m1, m2, m3})),
+      mesher_({m1, m2, m3}) {
     }
 
     FdmMesherComposite::FdmMesherComposite(
@@ -95,9 +64,10 @@ namespace QuantLib {
         const ext::shared_ptr<Fdm1dMesher>& m2,
         const ext::shared_ptr<Fdm1dMesher>& m3,
         const ext::shared_ptr<Fdm1dMesher>& m4)
-    : FdmMesher(getLayoutFromMeshers(build_vector(m1, m2, m3, m4))),
-      mesher_(build_vector(m1, m2, m3, m4)) {
+    : FdmMesher(getLayoutFromMeshers({m1, m2, m3, m4})),
+      mesher_({m1, m2, m3, m4}) {
     }
+
     FdmMesherComposite::FdmMesherComposite(
         const std::vector<ext::shared_ptr<Fdm1dMesher> > & mesher)
     : FdmMesher(getLayoutFromMeshers(mesher)), mesher_(mesher) {
diff --git a/ql/time/calendars/saudiarabia.cpp b/ql/time/calendars/saudiarabia.cpp
index 59d805163da..4fc5bf7324e 100644
--- a/ql/time/calendars/saudiarabia.cpp
+++ b/ql/time/calendars/saudiarabia.cpp
@@ -20,7 +20,6 @@
 
 #include <ql/time/calendars/saudiarabia.hpp>
 #include <ql/errors.hpp>
-#include <boost/assign/list_of.hpp> // for 'list_of()'
 
 namespace QuantLib {
 
@@ -52,33 +51,34 @@ namespace QuantLib {
         bool isEidAlAdha(Date d) {
             // Eid al Adha dates taken from:
             // https://en.wikipedia.org/wiki/Eid_al-Adha#Eid_al-Adha_in_the_Gregorian_calendar
-            static std::vector<Date> EidAlAdha =
-                boost::assign::list_of(Date(7, April, 1998))
-                                      (Date(27, March, 1999))
-                                      (Date(16, March, 2000))
-                                      (Date(5, March, 2001))
-                                      (Date(23, February, 2002))
-                                      (Date(12, February, 2003))
-                                      (Date(1, February, 2004))
-                                      (Date(21, January, 2005))
-                                      (Date(10, January, 2006))
-                                      (Date(31, December, 2006))
-                                      (Date(20, December, 2007))
-                                      (Date(8, December, 2008))
-                                      (Date(27, November, 2009))
-                                      (Date(16, November, 2010))
-                                      (Date(6, November, 2011))
-                                      (Date(26, October, 2012))
-                                      (Date(15, October, 2013))
-                                      (Date(4, October, 2014))
-                                      (Date(24, September, 2015))
-                                      (Date(11, September, 2016))
-                                      (Date(1, September, 2017))
-                                      (Date(23, August, 2018))
-                                      (Date(12, August, 2019))
-                                      (Date(31, July, 2020))
-                                      (Date(20, July, 2021))
-                                      (Date(10, July, 2022));
+            static std::vector<Date> EidAlAdha = {
+                Date(7, April, 1998),
+                Date(27, March, 1999),
+                Date(16, March, 2000),
+                Date(5, March, 2001),
+                Date(23, February, 2002),
+                Date(12, February, 2003),
+                Date(1, February, 2004),
+                Date(21, January, 2005),
+                Date(10, January, 2006),
+                Date(31, December, 2006),
+                Date(20, December, 2007),
+                Date(8, December, 2008),
+                Date(27, November, 2009),
+                Date(16, November, 2010),
+                Date(6, November, 2011),
+                Date(26, October, 2012),
+                Date(15, October, 2013),
+                Date(4, October, 2014),
+                Date(24, September, 2015),
+                Date(11, September, 2016),
+                Date(1, September, 2017),
+                Date(23, August, 2018),
+                Date(12, August, 2019),
+                Date(31, July, 2020),
+                Date(20, July, 2021),
+                Date(10, July, 2022)
+            };
 
             for (auto& p : EidAlAdha) {
                 if (d >= p - 1 && d <= p + 4) {
@@ -91,36 +91,37 @@ namespace QuantLib {
         bool isEidAlFitr(Date d) {
             // Eid al Fitr dates taken from:
             // https://en.wikipedia.org/wiki/Eid_al-Fitr#In_the_Gregorian_calendar
-            static std::vector<Date> EidAlFitr =
-                boost::assign::list_of(Date(16, Dec, 2001))
-                                      (Date(5, Dec, 2002))
-                                      (Date(25, Nov, 2003))
-                                      (Date(13, Nov, 2004))
-                                      (Date(3, Nov, 2005))
-                                      (Date(23, Oct, 2006))
-                                      (Date(12, Oct, 2007))
-                                      (Date(30, Sep, 2008))
-                                      (Date(20, Sep, 2009))
-                                      (Date(10, Sep, 2010))
-                                      (Date(30, Aug, 2011))
-                                      (Date(19, Aug, 2012))
-                                      (Date(8, Aug, 2013))
-                                      (Date(28, Jul, 2014))
-                                      (Date(17, Jul, 2015))
-                                      (Date(6, Jul, 2016))
-                                      (Date(25, Jun, 2017))
-                                      (Date(15, Jun, 2018))
-                                      (Date(4, Jun, 2019))
-                                      (Date(24, May, 2020))
-                                      (Date(13, May, 2021))
-                                      (Date(2, May, 2022))
-                                      (Date(21, Apr, 2023))
-                                      (Date(10, Apr, 2024))
-                                      (Date(30, Mar, 2025))
-                                      (Date(20, Mar, 2026))
-                                      (Date(9, Mar, 2027))
-                                      (Date(26, Feb, 2028))
-                                      (Date(14, Feb, 2029));
+            static std::vector<Date> EidAlFitr = {
+                Date(16, Dec, 2001),
+                Date(5, Dec, 2002),
+                Date(25, Nov, 2003),
+                Date(13, Nov, 2004),
+                Date(3, Nov, 2005),
+                Date(23, Oct, 2006),
+                Date(12, Oct, 2007),
+                Date(30, Sep, 2008),
+                Date(20, Sep, 2009),
+                Date(10, Sep, 2010),
+                Date(30, Aug, 2011),
+                Date(19, Aug, 2012),
+                Date(8, Aug, 2013),
+                Date(28, Jul, 2014),
+                Date(17, Jul, 2015),
+                Date(6, Jul, 2016),
+                Date(25, Jun, 2017),
+                Date(15, Jun, 2018),
+                Date(4, Jun, 2019),
+                Date(24, May, 2020),
+                Date(13, May, 2021),
+                Date(2, May, 2022),
+                Date(21, Apr, 2023),
+                Date(10, Apr, 2024),
+                Date(30, Mar, 2025),
+                Date(20, Mar, 2026),
+                Date(9, Mar, 2027),
+                Date(26, Feb, 2028),
+                Date(14, Feb, 2029)
+            };
 
             for (auto& p : EidAlFitr) {
                 if (d >= p - 1 && d <= p + 4) {
diff --git a/test-suite/andreasenhugevolatilityinterpl.cpp b/test-suite/andreasenhugevolatilityinterpl.cpp
index a1b779566b3..b3c5668b73a 100644
--- a/test-suite/andreasenhugevolatilityinterpl.cpp
+++ b/test-suite/andreasenhugevolatilityinterpl.cpp
@@ -19,7 +19,6 @@
 
 #include "andreasenhugevolatilityinterpl.hpp"
 #include "utilities.hpp"
-
 #include <ql/math/comparison.hpp>
 #include <ql/math/functional.hpp>
 #include <ql/math/interpolations/sabrinterpolation.hpp>
@@ -40,8 +39,6 @@
 #include <ql/termstructures/volatility/equityfx/andreasenhugelocalvoladapter.hpp>
 #include <ql/termstructures/volatility/equityfx/andreasenhugevolatilityinterpl.hpp>
 #include <ql/termstructures/volatility/equityfx/andreasenhugevolatilityadapter.hpp>
-
-#include <boost/assign/std/vector.hpp>
 #include <boost/math/special_functions/fpclassify.hpp>
 
 using namespace QuantLib;
@@ -459,16 +456,19 @@ void AndreasenHugeVolatilityInterplTest::testTimeDependentInterestRates() {
     const Date today = data.rTS->referenceDate();
     Settings::instance().evaluationDate() = today;
 
-    using namespace boost::assign;
-    std::vector<Real> r, q;
-    r += 0.0167, 0.023, 0.03234, 0.034, 0.038, 0.042, 0.047, 0.053;
-    q += 0.01, 0.011, 0.013, 0.014, 0.02, 0.025, 0.067, 0.072;
-
-    std::vector<Date> dates;
-    dates += today,                     today + Period(41, Days),
-             today + Period(75, Days),  today + Period(165, Days),
-             today + Period(256, Days), today + Period(345, Days),
-             today + Period(524, Days), today + Period(2190, Days);
+    std::vector<Real> r = { 0.0167, 0.023, 0.03234, 0.034, 0.038, 0.042, 0.047, 0.053 };
+    std::vector<Real> q = { 0.01, 0.011, 0.013, 0.014, 0.02, 0.025, 0.067, 0.072 };
+
+    std::vector<Date> dates = {
+        today,
+        today + Period(41, Days),
+        today + Period(75, Days),
+        today + Period(165, Days),
+        today + Period(256, Days),
+        today + Period(345, Days),
+        today + Period(524, Days),
+        today + Period(2190, Days)
+    };
 
     const Handle<YieldTermStructure> rTS(
         ext::make_shared<ZeroCurve>(dates, r, dc));
@@ -824,9 +824,7 @@ namespace andreasen_huge_volatility_interpl_test {
 
         const CalibrationData data = { spot, rTS, qTS, calibrationSet};
 
-        using namespace boost::assign;
-        std::vector<Real> parameter;
-        parameter += alpha, beta, nu, rho, forward, maturity;
+        std::vector<Real> parameter = { alpha, beta, nu, rho, forward, maturity };
 
         return std::make_pair(data, parameter);
     }
diff --git a/test-suite/creditdefaultswap.cpp b/test-suite/creditdefaultswap.cpp
index 759b292c084..501894e168c 100644
--- a/test-suite/creditdefaultswap.cpp
+++ b/test-suite/creditdefaultswap.cpp
@@ -39,16 +39,12 @@
 #include <ql/currencies/america.hpp>
 #include <ql/time/daycounters/actual360.hpp>
 #include <ql/time/daycounters/thirty360.hpp>
-#include <boost/assign/list_of.hpp>
-#include <boost/foreach.hpp>
 #include <map>
-
 #include <iomanip>
 #include <iostream>
 
 using namespace QuantLib;
 using namespace boost::unit_test_framework;
-using boost::assign::map_list_of;
 using std::map;
 
 void CreditDefaultSwapTest::testCachedValue() {
@@ -728,19 +724,20 @@ void CreditDefaultSwapTest::testAccrualRebateAmounts() {
 
     // key is trade date and value is expected accrual
     typedef map<Date, Real> InputData;
-    InputData inputs = map_list_of
-        (Date(18, Mar, 2009), 24166.67)
-        (Date(19, Mar, 2009), 0.00)
-        (Date(20, Mar, 2009), 277.78)
-        (Date(23, Mar, 2009), 1111.11)
-        (Date(19, Jun, 2009), 25555.56)
-        (Date(20, Jun, 2009), 25833.33)
-        (Date(21, Jun, 2009), 0.00)
-        (Date(22, Jun, 2009), 277.78)
-        (Date(18, Jun, 2014), 25277.78)
-        (Date(19, Jun, 2014), 25555.56);
-
-    BOOST_FOREACH(const InputData::value_type& input, inputs) {
+    InputData inputs = {
+        {Date(18, Mar, 2009), 24166.67},
+        {Date(19, Mar, 2009), 0.00},
+        {Date(20, Mar, 2009), 277.78},
+        {Date(23, Mar, 2009), 1111.11},
+        {Date(19, Jun, 2009), 25555.56},
+        {Date(20, Jun, 2009), 25833.33},
+        {Date(21, Jun, 2009), 0.00},
+        {Date(22, Jun, 2009), 277.78},
+        {Date(18, Jun, 2014), 25277.78},
+        {Date(19, Jun, 2014), 25555.56}
+    };
+
+    for (auto& input: inputs) {
         Settings::instance().evaluationDate() = input.first;
         CreditDefaultSwap cds = MakeCreditDefaultSwap(maturity, spread)
             .withNominal(notional);
diff --git a/test-suite/defaultprobabilitycurves.cpp b/test-suite/defaultprobabilitycurves.cpp
index 77820d8720a..b4279f3e0af 100644
--- a/test-suite/defaultprobabilitycurves.cpp
+++ b/test-suite/defaultprobabilitycurves.cpp
@@ -36,7 +36,6 @@
 #include <ql/time/daycounters/actual360.hpp>
 #include <ql/time/daycounters/thirty360.hpp>
 #include <ql/utilities/dataformatters.hpp>
-#include <boost/assign/list_of.hpp>
 #include <iomanip>
 #include <map>
 #include <string>
@@ -45,8 +44,6 @@
 
 using namespace QuantLib;
 using namespace boost::unit_test_framework;
-using boost::assign::list_of;
-using boost::assign::map_list_of;
 using std::map;
 using std::vector;
 using std::string;
@@ -426,73 +423,76 @@ void DefaultProbabilityCurveTest::testIterativeBootstrapRetries() {
     Actual365Fixed tsDayCounter;
 
     // USD discount curve built out of FedFunds OIS swaps.
-    vector<Date> usdCurveDates = list_of
-        (Date(1, Apr, 2020))
-        (Date(2, Apr, 2020))
-        (Date(14, Apr, 2020))
-        (Date(21, Apr, 2020))
-        (Date(28, Apr, 2020))
-        (Date(6, May, 2020))
-        (Date(5, Jun, 2020))
-        (Date(7, Jul, 2020))
-        (Date(5, Aug, 2020))
-        (Date(8, Sep, 2020))
-        (Date(7, Oct, 2020))
-        (Date(5, Nov, 2020))
-        (Date(7, Dec, 2020))
-        (Date(6, Jan, 2021))
-        (Date(5, Feb, 2021))
-        (Date(5, Mar, 2021))
-        (Date(7, Apr, 2021))
-        (Date(4, Apr, 2022))
-        (Date(3, Apr, 2023))
-        (Date(3, Apr, 2024))
-        (Date(3, Apr, 2025))
-        (Date(5, Apr, 2027))
-        (Date(3, Apr, 2030))
-        (Date(3, Apr, 2035))
-        (Date(3, Apr, 2040))
-        (Date(4, Apr, 2050));
-
-    vector<DiscountFactor> usdCurveDfs = list_of
-        (1.000000000)
-        (0.999955835)
-        (0.999931070)
-        (0.999914629)
-        (0.999902799)
-        (0.999887990)
-        (0.999825782)
-        (0.999764392)
-        (0.999709076)
-        (0.999647785)
-        (0.999594638)
-        (0.999536198)
-        (0.999483093)
-        (0.999419291)
-        (0.999379417)
-        (0.999324981)
-        (0.999262356)
-        (0.999575101)
-        (0.996135441)
-        (0.995228348)
-        (0.989366687)
-        (0.979271200)
-        (0.961150726)
-        (0.926265361)
-        (0.891640651)
-        (0.839314063);
+    vector<Date> usdCurveDates = {
+        Date(1, Apr, 2020),
+        Date(2, Apr, 2020),
+        Date(14, Apr, 2020),
+        Date(21, Apr, 2020),
+        Date(28, Apr, 2020),
+        Date(6, May, 2020),
+        Date(5, Jun, 2020),
+        Date(7, Jul, 2020),
+        Date(5, Aug, 2020),
+        Date(8, Sep, 2020),
+        Date(7, Oct, 2020),
+        Date(5, Nov, 2020),
+        Date(7, Dec, 2020),
+        Date(6, Jan, 2021),
+        Date(5, Feb, 2021),
+        Date(5, Mar, 2021),
+        Date(7, Apr, 2021),
+        Date(4, Apr, 2022),
+        Date(3, Apr, 2023),
+        Date(3, Apr, 2024),
+        Date(3, Apr, 2025),
+        Date(5, Apr, 2027),
+        Date(3, Apr, 2030),
+        Date(3, Apr, 2035),
+        Date(3, Apr, 2040),
+        Date(4, Apr, 2050)
+    };
+
+    vector<DiscountFactor> usdCurveDfs = {
+        1.000000000,
+        0.999955835,
+        0.999931070,
+        0.999914629,
+        0.999902799,
+        0.999887990,
+        0.999825782,
+        0.999764392,
+        0.999709076,
+        0.999647785,
+        0.999594638,
+        0.999536198,
+        0.999483093,
+        0.999419291,
+        0.999379417,
+        0.999324981,
+        0.999262356,
+        0.999575101,
+        0.996135441,
+        0.995228348,
+        0.989366687,
+        0.979271200,
+        0.961150726,
+        0.926265361,
+        0.891640651,
+        0.839314063
+    };
 
     Handle<YieldTermStructure> usdYts(ext::make_shared<InterpolatedDiscountCurve<LogLinear> >(
         usdCurveDates, usdCurveDfs, tsDayCounter));
 
     // CDS spreads
-    map<Period, Rate> cdsSpreads = map_list_of
-        (6 * Months, 2.957980250)
-        (1 * Years, 3.076933100)
-        (2 * Years, 2.944524520)
-        (3 * Years, 2.844498960)
-        (4 * Years, 2.769234420)
-        (5 * Years, 2.713474100);
+    map<Period, Rate> cdsSpreads = {
+        {6 * Months, 2.957980250},
+        {1 * Years, 3.076933100},
+        {2 * Years, 2.944524520},
+        {3 * Years, 2.844498960},
+        {4 * Years, 2.769234420},
+        {5 * Years, 2.713474100}
+    };
     Real recoveryRate = 0.035;
 
     // Conventions
diff --git a/test-suite/fdcir.cpp b/test-suite/fdcir.cpp
index 37b2924087d..4cf9f8ec165 100644
--- a/test-suite/fdcir.cpp
+++ b/test-suite/fdcir.cpp
@@ -32,10 +32,8 @@
 #include <ql/termstructures/volatility/equityfx/localconstantvol.hpp>
 #include <ql/termstructures/yield/flatforward.hpp>
 #include <ql/time/daycounters/actual365fixed.hpp>
-#include <boost/assign/std/vector.hpp>
 
 using namespace QuantLib;
-using namespace boost::assign;
 using boost::unit_test_framework::test_suite;
 
 void FdCIRTest::testFdmCIRConvergence() {
diff --git a/test-suite/fdheston.cpp b/test-suite/fdheston.cpp
index 33968d10dc4..19b4f12b8c4 100644
--- a/test-suite/fdheston.cpp
+++ b/test-suite/fdheston.cpp
@@ -41,12 +41,9 @@
 #include <ql/pricingengines/vanilla/fdhestonvanillaengine.hpp>
 #include <ql/pricingengines/barrier/fdblackscholesbarrierengine.hpp>
 #include <ql/pricingengines/vanilla/fdblackscholesvanillaengine.hpp>
-
-#include <boost/assign/std/vector.hpp>
 #include <ql/tuple.hpp>
 
 using namespace QuantLib;
-using namespace boost::assign;
 using boost::unit_test_framework::test_suite;
 
 
diff --git a/test-suite/hestonslvmodel.cpp b/test-suite/hestonslvmodel.cpp
index 703a7c973fd..3ecb73f3213 100644
--- a/test-suite/hestonslvmodel.cpp
+++ b/test-suite/hestonslvmodel.cpp
@@ -20,9 +20,6 @@
 
 #include "hestonslvmodel.hpp"
 #include "utilities.hpp"
-
-#include <iomanip>
-
 #include <ql/quotes/simplequote.hpp>
 #include <ql/time/calendars/target.hpp>
 #include <ql/time/daycounters/actualactual.hpp>
@@ -88,9 +85,9 @@
 #include <ql/experimental/processes/hestonslvprocess.hpp>
 #include <ql/experimental/barrieroption/doublebarrieroption.hpp>
 #include <ql/experimental/barrieroption/analyticdoublebarrierbinaryengine.hpp>
-
-#include <boost/assign/std/vector.hpp>
 #include <boost/math/special_functions/gamma.hpp>
+#include <iomanip>
+
 
 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4))
 #pragma GCC diagnostic push
@@ -102,7 +99,6 @@
 #endif
 
 using namespace QuantLib;
-using namespace boost::assign;
 using boost::unit_test_framework::test_suite;
 
 namespace {
@@ -702,10 +698,10 @@ namespace {
         const Date todaysDate = Date(28, Dec, 2014);
         Settings::instance().evaluationDate() = todaysDate;
 
-        std::vector<Period> maturities;
-        maturities+=Period(1, Months),
-                    Period(3, Months), Period(6, Months), Period(9, Months),
-                    Period(1, Years), Period(2, Years), Period(3, Years);
+        std::vector<Period> maturities = {
+            Period(1, Months), Period(3, Months), Period(6, Months), Period(9, Months),
+            Period(1, Years), Period(2, Years), Period(3, Years)
+        };
 
         const Date maturityDate = todaysDate + maturities.back();
         const Time maturity = dc.yearFraction(todaysDate, maturityDate);
@@ -754,9 +750,11 @@ namespace {
             const Real v0Density = 10.0;
             const Real upperBoundDensity = 100;
             const Real lowerBoundDensity = 1.0;
-            cPoints += ext::make_tuple(lowerBound, lowerBoundDensity, false),
-                       ext::make_tuple(v0Center, v0Density, true),
-                       ext::make_tuple(upperBound, upperBoundDensity, false);
+            cPoints = {
+                {lowerBound, lowerBoundDensity, false},
+                {v0Center, v0Density, true},
+                {upperBound, upperBoundDensity, false}
+            };
           }
         break;
         case FdmSquareRootFwdOp::Plain:
@@ -767,8 +765,10 @@ namespace {
             const Real v0Center = v0;
             const Real v0Density = 0.1;
             const Real lowerBoundDensity = 0.0001;
-            cPoints += ext::make_tuple(lowerBound, lowerBoundDensity, false),
-                       ext::make_tuple(v0Center, v0Density, true);
+            cPoints = {
+                {lowerBound, lowerBoundDensity, false},
+                {v0Center, v0Density, true}
+            };
           }
         break;
         case FdmSquareRootFwdOp::Power:
@@ -779,8 +779,10 @@ namespace {
             const Real v0Center = v0;
             const Real v0Density = 1.0;
             const Real lowerBoundDensity = 0.005;
-            cPoints += ext::make_tuple(lowerBound, lowerBoundDensity, false),
-                       ext::make_tuple(v0Center, v0Density, true);
+            cPoints = {
+                {lowerBound, lowerBoundDensity, false},
+                {v0Center, v0Density, true}
+            };
           }
         break;
         default:
diff --git a/test-suite/integrals.cpp b/test-suite/integrals.cpp
index 13b1d49e2a1..5627abddda5 100644
--- a/test-suite/integrals.cpp
+++ b/test-suite/integrals.cpp
@@ -35,10 +35,8 @@
 #include <ql/math/integrals/twodimensionalintegral.hpp>
 #include <ql/experimental/math/piecewisefunction.hpp>
 #include <ql/experimental/math/piecewiseintegral.hpp>
-#include <boost/assign/std/vector.hpp>
 
 using namespace QuantLib;
-using namespace boost::assign;
 using boost::unit_test_framework::test_suite;
 
 namespace integrals_test {
@@ -325,8 +323,8 @@ void IntegralTest::testPiecewiseIntegral() {
 
     using namespace integrals_test;
 
-    x += 1.0, 2.0, 3.0, 4.0, 5.0;
-    y += 1.0, 2.0, 3.0, 4.0, 5.0, 6.0;
+    x = { 1.0, 2.0, 3.0, 4.0, 5.0 };
+    y = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
     ext::shared_ptr<Integrator> segment =
         ext::make_shared<SegmentIntegral>(1);
     ext::shared_ptr<Integrator> piecewise =
diff --git a/test-suite/interpolations.cpp b/test-suite/interpolations.cpp
index 0f1a1fd8d0e..9065e511404 100644
--- a/test-suite/interpolations.cpp
+++ b/test-suite/interpolations.cpp
@@ -45,8 +45,6 @@
 #include <ql/tuple.hpp>
 #include <ql/utilities/dataformatters.hpp>
 #include <ql/utilities/null.hpp>
-#include <boost/assign/std/vector.hpp>
-#include <boost/foreach.hpp>
 #include <boost/math/special_functions/fpclassify.hpp>
 #include <utility>
 
@@ -1857,8 +1855,7 @@ void InterpolationTest::testNoArbSabrInterpolation(){
     Real initialRho = 0.01;
     // calculate SABR vols and compare with input vols
     NoArbSabrSmileSection noarbSabr(expiry, forward,
-                                    boost::assign::list_of(initialAlpha)(
-                                        initialBeta)(initialNu)(initialRho));
+                                    {initialAlpha, initialBeta, initialNu, initialRho});
     for (Size i = 0; i < strikes.size(); i++) {
         Real calculatedVol = noarbSabr.volatility(strikes[i]);
         if (std::fabs(volatilities[i]-calculatedVol) > tolerance)
@@ -1974,10 +1971,8 @@ void InterpolationTest::testSabrSingleCases() {
     // case #1
     // this fails with an exception thrown in 1.4, fixed in 1.5
 
-    using namespace boost::assign;
-    std::vector<Real> strikes, vols;
-    strikes += 0.01, 0.01125, 0.0125, 0.01375, 0.0150;
-    vols += 0.1667, 0.2020, 0.2785, 0.3279, 0.3727;
+    std::vector<Real> strikes = { 0.01, 0.01125, 0.0125, 0.01375, 0.0150 };
+    std::vector<Real> vols = { 0.1667, 0.2020, 0.2785, 0.3279, 0.3727 };
 
     Real tte = 0.3833;
     Real forward = 0.011025;
@@ -2330,10 +2325,7 @@ void InterpolationTest::testBSplines() {
     // reference values have been generate with the R package splines2
     // https://cran.r-project.org/web/packages/splines2/splines2.pdf
 
-    using namespace boost::assign;
-
-    std::vector<Real> knots;
-    knots += -1.0, 0.5, 0.75, 1.2, 3.0, 4.0, 5.0;
+    std::vector<Real> knots = { -1.0, 0.5, 0.75, 1.2, 3.0, 4.0, 5.0 };
 
     const Natural p = 2;
     const BSpline bspline(p, knots.size()-p-2, knots);
diff --git a/test-suite/noarbsabr.cpp b/test-suite/noarbsabr.cpp
index f1034b8a490..d2a17962174 100644
--- a/test-suite/noarbsabr.cpp
+++ b/test-suite/noarbsabr.cpp
@@ -19,9 +19,6 @@
 
 #include "noarbsabr.hpp"
 #include "utilities.hpp"
-
-#include <boost/assign/list_of.hpp>
-
 #include <ql/termstructures/volatility/sabrsmilesection.hpp>
 #include <ql/experimental/volatility/noarbsabrsmilesection.hpp>
 
@@ -85,8 +82,8 @@ void NoArbSabrTest::testConsistencyWithHagan() {
     Real nu = 0.4;
     Real f = 0.0488;
 
-    SabrSmileSection sabr(tau,f,boost::assign::list_of(alpha)(beta)(nu)(rho));
-    NoArbSabrSmileSection noarbsabr(tau,f,boost::assign::list_of(alpha)(beta)(nu)(rho));
+    SabrSmileSection sabr(tau, f, {alpha, beta, nu, rho});
+    NoArbSabrSmileSection noarbsabr(tau, f, {alpha, beta, nu, rho});
 
     Real absProb=noarbsabr.model()->absorptionProbability();
     if( absProb > 1E-10 || absProb < 0.0 )
diff --git a/test-suite/normalclvmodel.cpp b/test-suite/normalclvmodel.cpp
index d040016f9a9..41850a17c9b 100644
--- a/test-suite/normalclvmodel.cpp
+++ b/test-suite/normalclvmodel.cpp
@@ -46,11 +46,9 @@
 #include <ql/time/daycounters/actual360.hpp>
 #include <ql/time/daycounters/actual365fixed.hpp>
 #include <ql/time/daycounters/actualactual.hpp>
-#include <boost/assign/std/vector.hpp>
 #include <utility>
 
 using namespace QuantLib;
-using namespace boost::assign;
 using namespace boost::unit_test_framework;
 
 void NormalCLVModelTest::testBSCumlativeDistributionFunction() {
@@ -199,30 +197,33 @@ void NormalCLVModelTest::testIllustrative1DExample() {
         ext::make_shared<OrnsteinUhlenbeckProcess>(
             speed, vol, x0, level));
 
-    std::vector<Date> maturityDates;
-    maturityDates += (today + Period(18, Days)),
-        today + Period(90, Days)  , today + Period(180, Days),
-        today + Period(360, Days) , today + Period(720, Days);
+    std::vector<Date> maturityDates = {
+        today + Period(18, Days),
+        today + Period(90, Days),
+        today + Period(180, Days),
+        today + Period(360, Days),
+        today + Period(720, Days)
+    };
 
     const NormalCLVModel m(bsProcess, ouProcess, maturityDates, 4);
     const ext::function<Real(Real, Real)> g = m.g();
 
     // test collocation points in x_ij
-    std::vector<Date> maturities;
-    maturities += maturityDates[0], maturityDates[2], maturityDates[4];
+    std::vector<Date> maturities = { maturityDates[0], maturityDates[2], maturityDates[4] };
 
-    std::vector<std::vector<Real> > x(3);
-    x[0] += 1.070, 0.984, 0.903, 0.817;
-    x[1] += 0.879, 0.668, 0.472, 0.261;
-    x[2] += 0.528, 0.282, 0.052,-0.194;
+    std::vector<std::vector<Real> > x = {
+        { 1.070, 0.984, 0.903, 0.817 },
+        { 0.879, 0.668, 0.472, 0.261 },
+        { 0.528, 0.282, 0.052,-0.194 }
+    };
 
-    std::vector<std::vector<Real> > s(3);
-    s[0] += 1.104, 1.035, 0.969, 0.895;
-    s[1] += 1.328, 1.122, 0.911, 0.668;
-    s[2] += 1.657, 1.283, 0.854, 0.339;
+    std::vector<std::vector<Real> > s = {
+        {1.104, 1.035, 0.969, 0.895},
+        {1.328, 1.122, 0.911, 0.668},
+        {1.657, 1.283, 0.854, 0.339}
+    };
 
-    std::vector<Real> c;
-    c += 2.3344, 0.7420, -0.7420, -2.3344;
+    std::vector<Real> c = { 2.3344, 0.7420, -0.7420, -2.3344 };
 
     const Real tol = 0.001;
     for (Size i=0; i < maturities.size(); ++i) {
@@ -323,8 +324,7 @@ void NormalCLVModelTest::testMonteCarloBSOptionPricing() {
         ext::make_shared<OrnsteinUhlenbeckProcess>(
             speed, sigma, x0, level));
 
-    std::vector<Date> maturities;
-    maturities += today + Period(6, Months), maturity;
+    std::vector<Date> maturities = { today + Period(6, Months), maturity };
 
     const NormalCLVModel m(bsProcess, ouProcess, maturities, 8);
     const ext::function<Real(Real, Real)> g = m.g();
diff --git a/test-suite/optionletstripper.cpp b/test-suite/optionletstripper.cpp
index 5e87b787ada..f9da03fa991 100644
--- a/test-suite/optionletstripper.cpp
+++ b/test-suite/optionletstripper.cpp
@@ -34,12 +34,10 @@
 #include <ql/pricingengines/capfloor/bacheliercapfloorengine.hpp>
 #include <ql/instruments/makecapfloor.hpp>
 #include <ql/quotes/simplequote.hpp>
-#include <boost/assign/std/vector.hpp>
 #include <algorithm>
 #include <iterator>
 
 using namespace QuantLib;
-using namespace boost::assign;
 using namespace boost::unit_test_framework;
 
 namespace optionlet_stripper_test {
@@ -95,25 +93,26 @@ struct CommonVars {
             calendar = TARGET();
             dayCounter = Actual365Fixed();
 
-            std::vector< int > datesTmp;
-            std::vector< Date > dates;
-            std::vector< Rate > rates;
-
-            datesTmp += 42124, 42129, 42143, 42221, 42254, 42282, 42313, 42345,
+            std::vector< int > datesTmp = {
+                42124, 42129, 42143, 42221, 42254, 42282, 42313, 42345,
                 42374, 42405, 42465, 42495, 42587, 42681, 42772, 42860, 43227,
                 43956, 44321, 44686, 45051, 45418, 45782, 46147, 46512, 47609,
-                49436, 51263, 53087, 56739, 60392;
+                49436, 51263, 53087, 56739, 60392
+            };
 
+            std::vector< Date > dates;
             dates.reserve(datesTmp.size());
             for (int& it : datesTmp)
                 dates.emplace_back(it);
 
-            rates += -0.00292, -0.00292, -0.001441, -0.00117, -0.001204,
+            std::vector< Rate > rates = {
+                -0.00292, -0.00292, -0.001441, -0.00117, -0.001204,
                 -0.001212, -0.001223, -0.001236, -0.001221, -0.001238,
                 -0.001262, -0.00125, -0.001256, -0.001233, -0.00118, -0.001108,
                 -0.000619, 0.000833, 0.001617, 0.002414, 0.003183, 0.003883,
                 0.004514, 0.005074, 0.005606, 0.006856, 0.00813, 0.008709,
-                0.009136, 0.009601, 0.009384;
+                0.009136, 0.009601, 0.009384
+            };
 
             discountingYTS.linkTo(
                 ext::make_shared< InterpolatedZeroCurve< Linear > >(
@@ -124,27 +123,30 @@ struct CommonVars {
             dates.clear();
             rates.clear();
 
-            datesTmp += 42124, 42313, 42436, 42556, 42618, 42800, 42830, 42860,
+            datesTmp = {
+                42124, 42313, 42436, 42556, 42618, 42800, 42830, 42860,
                 43227, 43591, 43956, 44321, 44686, 45051, 45418, 45782, 46147,
                 46512, 46878, 47245, 47609, 47973, 48339, 48704, 49069, 49436,
                 49800, 50165, 50530, 50895, 51263, 51627, 51991, 52356, 52722,
-                53087, 54913, 56739, 60392, 64045;
+                53087, 54913, 56739, 60392, 64045
+            };
 
             for (int& it : datesTmp)
                 dates.emplace_back(it);
 
-            rates += 0.000649, 0.000649, 0.000684, 0.000717, 0.000745, 0.000872,
+            rates = {
+                0.000649, 0.000649, 0.000684, 0.000717, 0.000745, 0.000872,
                 0.000905, 0.000954, 0.001532, 0.002319, 0.003147, 0.003949,
                 0.004743, 0.00551, 0.006198, 0.006798, 0.007339, 0.007832,
                 0.008242, 0.008614, 0.008935, 0.009205, 0.009443, 0.009651,
                 0.009818, 0.009952, 0.010054, 0.010146, 0.010206, 0.010266,
                 0.010315, 0.010365, 0.010416, 0.010468, 0.010519, 0.010571,
-                0.010757, 0.010806, 0.010423, 0.010217;
+                0.010757, 0.010806, 0.010423, 0.010217
+            };
 
             forwardingYTS.linkTo(
                 ext::make_shared< InterpolatedZeroCurve< Linear > >(
-                    dates, rates,
-                                                        dayCounter, calendar));
+                    dates, rates, dayCounter, calendar));
         }
 
         void setFlatTermVolCurve() {
@@ -350,23 +352,24 @@ struct CommonVars {
             };
             // 13
 
-            std::vector< Real > rawVols;
-            rawVols += 0.49, 0.39, 0.34, 0.31, 0.34, 0.37, 0.50, 0.75, 0.99, 1.21, 1.64, 2.44, 4.29,
-                       0.44, 0.36, 0.33, 0.31, 0.33, 0.35,0.45, 0.65, 0.83, 1.00, 1.32, 1.93, 3.30,
-                       0.40, 0.35, 0.33,0.31, 0.33, 0.34, 0.41, 0.55, 0.69, 0.82, 1.08, 1.56, 2.68,
-                       0.42, 0.39, 0.38, 0.37, 0.38, 0.39, 0.43, 0.54, 0.64, 0.74,0.94, 1.31, 2.18,
-                       0.46, 0.43, 0.42, 0.41, 0.42, 0.43, 0.47,0.56, 0.66, 0.75, 0.93, 1.28, 2.07,
-                       0.49, 0.47, 0.46, 0.45,0.46, 0.47, 0.51, 0.59, 0.68, 0.76, 0.93, 1.25, 1.99,
-                       0.51, 0.49, 0.49, 0.48, 0.49, 0.50, 0.54, 0.62, 0.70, 0.78, 0.94,1.24, 1.94,
-                       0.52, 0.51, 0.51, 0.51, 0.52, 0.53, 0.56, 0.63,0.71, 0.79, 0.94, 1.23, 1.89,
-                       0.53, 0.52, 0.52, 0.52, 0.53,0.54, 0.57, 0.65, 0.72, 0.79, 0.94, 1.21, 1.83,
-                       0.55, 0.54, 0.54, 0.54, 0.55, 0.56, 0.59, 0.66, 0.72, 0.79, 0.91, 1.15,1.71,
-                       0.56, 0.56, 0.56, 0.56, 0.57, 0.58, 0.61, 0.67, 0.72,0.78, 0.89, 1.09, 1.59,
-                       0.59, 0.58, 0.58, 0.59, 0.59, 0.60,0.63, 0.68, 0.73, 0.78, 0.86, 1.03, 1.45,
-                       0.61, 0.61, 0.61,0.61, 0.62, 0.62, 0.64, 0.69, 0.73, 0.77, 0.85, 1.02, 1.44,
-                       0.62, 0.62, 0.63, 0.63, 0.64, 0.64, 0.65, 0.69, 0.72, 0.76,0.82, 0.96, 1.32,
-                       0.62, 0.63, 0.63, 0.63, 0.65, 0.66, 0.66,0.68, 0.72, 0.74, 0.80, 0.93, 1.25,
-                       0.62, 0.62, 0.62, 0.62,0.66, 0.67, 0.67, 0.67, 0.72, 0.72, 0.78, 0.90, 1.25;
+            std::vector< Real > rawVols = {
+                0.49, 0.39, 0.34, 0.31, 0.34, 0.37, 0.50, 0.75, 0.99, 1.21, 1.64, 2.44, 4.29,
+                0.44, 0.36, 0.33, 0.31, 0.33, 0.35,0.45, 0.65, 0.83, 1.00, 1.32, 1.93, 3.30,
+                0.40, 0.35, 0.33,0.31, 0.33, 0.34, 0.41, 0.55, 0.69, 0.82, 1.08, 1.56, 2.68,
+                0.42, 0.39, 0.38, 0.37, 0.38, 0.39, 0.43, 0.54, 0.64, 0.74,0.94, 1.31, 2.18,
+                0.46, 0.43, 0.42, 0.41, 0.42, 0.43, 0.47,0.56, 0.66, 0.75, 0.93, 1.28, 2.07,
+                0.49, 0.47, 0.46, 0.45,0.46, 0.47, 0.51, 0.59, 0.68, 0.76, 0.93, 1.25, 1.99,
+                0.51, 0.49, 0.49, 0.48, 0.49, 0.50, 0.54, 0.62, 0.70, 0.78, 0.94,1.24, 1.94,
+                0.52, 0.51, 0.51, 0.51, 0.52, 0.53, 0.56, 0.63,0.71, 0.79, 0.94, 1.23, 1.89,
+                0.53, 0.52, 0.52, 0.52, 0.53,0.54, 0.57, 0.65, 0.72, 0.79, 0.94, 1.21, 1.83,
+                0.55, 0.54, 0.54, 0.54, 0.55, 0.56, 0.59, 0.66, 0.72, 0.79, 0.91, 1.15,1.71,
+                0.56, 0.56, 0.56, 0.56, 0.57, 0.58, 0.61, 0.67, 0.72,0.78, 0.89, 1.09, 1.59,
+                0.59, 0.58, 0.58, 0.59, 0.59, 0.60,0.63, 0.68, 0.73, 0.78, 0.86, 1.03, 1.45,
+                0.61, 0.61, 0.61,0.61, 0.62, 0.62, 0.64, 0.69, 0.73, 0.77, 0.85, 1.02, 1.44,
+                0.62, 0.62, 0.63, 0.63, 0.64, 0.64, 0.65, 0.69, 0.72, 0.76,0.82, 0.96, 1.32,
+                0.62, 0.63, 0.63, 0.63, 0.65, 0.66, 0.66,0.68, 0.72, 0.74, 0.80, 0.93, 1.25,
+                0.62, 0.62, 0.62, 0.62,0.66, 0.67, 0.67, 0.67, 0.72, 0.72, 0.78, 0.90, 1.25
+            };
 
             termV = Matrix(optionTenors.size(), strikes.size());
             std::copy(rawVols.begin(), rawVols.end(), termV.begin());
diff --git a/test-suite/piecewiseyieldcurve.cpp b/test-suite/piecewiseyieldcurve.cpp
index ed2556c2ffc..45d149cf8ef 100644
--- a/test-suite/piecewiseyieldcurve.cpp
+++ b/test-suite/piecewiseyieldcurve.cpp
@@ -51,7 +51,6 @@
 #include <ql/time/daycounters/thirty360.hpp>
 #include <ql/time/imm.hpp>
 #include <ql/utilities/dataformatters.hpp>
-#include <boost/assign/list_of.hpp>
 #include <iomanip>
 #include <map>
 #include <string>
@@ -60,8 +59,6 @@
 
 using namespace QuantLib;
 using namespace boost::unit_test_framework;
-using boost::assign::list_of;
-using boost::assign::map_list_of;
 using std::map;
 using std::vector;
 using std::string;
@@ -1408,56 +1405,59 @@ void PiecewiseYieldCurveTest::testIterativeBootstrapRetries() {
     Actual365Fixed tsDayCounter;
 
     // USD discount curve built out of FedFunds OIS swaps.
-    vector<Date> usdCurveDates = list_of
-        (Date(25, Sep, 2019))
-        (Date(26, Sep, 2019))
-        (Date(8, Oct, 2019))
-        (Date(16, Oct, 2019))
-        (Date(22, Oct, 2019))
-        (Date(30, Oct, 2019))
-        (Date(2, Dec, 2019))
-        (Date(31, Dec, 2019))
-        (Date(29, Jan, 2020))
-        (Date(2, Mar, 2020))
-        (Date(31, Mar, 2020))
-        (Date(29, Apr, 2020))
-        (Date(29, May, 2020))
-        (Date(1, Jul, 2020))
-        (Date(29, Jul, 2020))
-        (Date(31, Aug, 2020))
-        (Date(30, Sep, 2020));
-
-    vector<DiscountFactor> usdCurveDfs = list_of
-        (1.000000000)
-        (0.999940837)
-        (0.999309357)
-        (0.998894646)
-        (0.998574816)
-        (0.998162528)
-        (0.996552511)
-        (0.995197584)
-        (0.993915264)
-        (0.992530008)
-        (0.991329696)
-        (0.990179606)
-        (0.989005698)
-        (0.987751691)
-        (0.986703371)
-        (0.985495036)
-        (0.984413446);
+    vector<Date> usdCurveDates = {
+        Date(25, Sep, 2019),
+        Date(26, Sep, 2019),
+        Date(8, Oct, 2019),
+        Date(16, Oct, 2019),
+        Date(22, Oct, 2019),
+        Date(30, Oct, 2019),
+        Date(2, Dec, 2019),
+        Date(31, Dec, 2019),
+        Date(29, Jan, 2020),
+        Date(2, Mar, 2020),
+        Date(31, Mar, 2020),
+        Date(29, Apr, 2020),
+        Date(29, May, 2020),
+        Date(1, Jul, 2020),
+        Date(29, Jul, 2020),
+        Date(31, Aug, 2020),
+        Date(30, Sep, 2020)
+    };
+
+    vector<DiscountFactor> usdCurveDfs = {
+        1.000000000,
+        0.999940837,
+        0.999309357,
+        0.998894646,
+        0.998574816,
+        0.998162528,
+        0.996552511,
+        0.995197584,
+        0.993915264,
+        0.992530008,
+        0.991329696,
+        0.990179606,
+        0.989005698,
+        0.987751691,
+        0.986703371,
+        0.985495036,
+        0.984413446
+    };
 
     Handle<YieldTermStructure> usdYts(ext::make_shared<InterpolatedDiscountCurve<LogLinear> >(
         usdCurveDates, usdCurveDfs, tsDayCounter));
 
     // USD/ARS forward points
     Handle<Quote> arsSpot(ext::make_shared<SimpleQuote>(56.881));
-    map<Period, Real> arsFwdPoints = map_list_of
-        (1 * Months, 8.5157)
-        (2 * Months, 12.7180)
-        (3 * Months, 17.8310)
-        (6 * Months, 30.3680)
-        (9 * Months, 45.5520)
-        (1 * Years, 60.7370);
+    map<Period, Real> arsFwdPoints = {
+        {1 * Months, 8.5157},
+        {2 * Months, 12.7180},
+        {3 * Months, 17.8310},
+        {6 * Months, 30.3680},
+        {9 * Months, 45.5520},
+        {1 * Years, 60.7370}
+    };
 
     // Create the FX swap rate helpers for the ARS in USD curve.
     vector<ext::shared_ptr<RateHelper> > instruments;
diff --git a/test-suite/schedule.cpp b/test-suite/schedule.cpp
index 7b07ef59336..bbe31cdaa88 100644
--- a/test-suite/schedule.cpp
+++ b/test-suite/schedule.cpp
@@ -25,16 +25,12 @@
 #include <ql/time/calendars/unitedstates.hpp>
 #include <ql/time/calendars/weekendsonly.hpp>
 #include <ql/instruments/creditdefaultswap.hpp>
-#include <boost/assign/list_of.hpp>
-#include <boost/foreach.hpp>
 #include <map>
 #include <vector>
 
 using namespace QuantLib;
 using namespace boost::unit_test_framework;
 
-using boost::assign::map_list_of;
-using boost::assign::list_of;
 using std::make_pair;
 using std::map;
 using std::pair;
@@ -274,7 +270,7 @@ namespace CdsTests {
     void testCDSConventions(const InputData& inputs, DateGeneration::Rule rule) {
 
         // Test the generated start and end date against the expected start and end date.
-        BOOST_FOREACH(const InputData::value_type& input, inputs) {
+        for (auto& input : inputs) {
 
             Date from = input.first.first;
             Period tenor = input.first.second;
@@ -365,73 +361,74 @@ void ScheduleTest::testCDS2015ConventionGrid() {
     // The map value is a pair with 1st and 2nd element equal to expected start and end date respectively.
     // The trade dates are from the transition dates in the doc i.e. 20th Mar, Jun, Sep and Dec in 2016 and a day 
     // either side. The tenors are selected tenors from the doc i.e. short quarterly tenors less than 1Y, 1Y and 5Y.
-    InputData inputs = map_list_of
-        (make_pair(Date(19, Mar, 2016), 3 * Months), make_pair(Date(21, Dec, 2015), Date(20, Mar, 2016)))
-        (make_pair(Date(20, Mar, 2016), 3 * Months), make_pair(Date(21, Dec, 2015), Date(20, Sep, 2016)))
-        (make_pair(Date(21, Mar, 2016), 3 * Months), make_pair(Date(21, Mar, 2016), Date(20, Sep, 2016)))
-        (make_pair(Date(19, Jun, 2016), 3 * Months), make_pair(Date(21, Mar, 2016), Date(20, Sep, 2016)))
-        (make_pair(Date(20, Jun, 2016), 3 * Months), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2016)))
-        (make_pair(Date(21, Jun, 2016), 3 * Months), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2016)))
-        (make_pair(Date(19, Sep, 2016), 3 * Months), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2016)))
-        (make_pair(Date(20, Sep, 2016), 3 * Months), make_pair(Date(20, Sep, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(21, Sep, 2016), 3 * Months), make_pair(Date(20, Sep, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(19, Dec, 2016), 3 * Months), make_pair(Date(20, Sep, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(20, Dec, 2016), 3 * Months), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(21, Dec, 2016), 3 * Months), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(19, Mar, 2016), 6 * Months), make_pair(Date(21, Dec, 2015), Date(20, Jun, 2016)))
-        (make_pair(Date(20, Mar, 2016), 6 * Months), make_pair(Date(21, Dec, 2015), Date(20, Dec, 2016)))
-        (make_pair(Date(21, Mar, 2016), 6 * Months), make_pair(Date(21, Mar, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(19, Jun, 2016), 6 * Months), make_pair(Date(21, Mar, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(20, Jun, 2016), 6 * Months), make_pair(Date(20, Jun, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(21, Jun, 2016), 6 * Months), make_pair(Date(20, Jun, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(19, Sep, 2016), 6 * Months), make_pair(Date(20, Jun, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(20, Sep, 2016), 6 * Months), make_pair(Date(20, Sep, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(21, Sep, 2016), 6 * Months), make_pair(Date(20, Sep, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(19, Dec, 2016), 6 * Months), make_pair(Date(20, Sep, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(20, Dec, 2016), 6 * Months), make_pair(Date(20, Dec, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(21, Dec, 2016), 6 * Months), make_pair(Date(20, Dec, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(19, Mar, 2016), 9 * Months), make_pair(Date(21, Dec, 2015), Date(20, Sep, 2016)))
-        (make_pair(Date(20, Mar, 2016), 9 * Months), make_pair(Date(21, Dec, 2015), Date(20, Mar, 2017)))
-        (make_pair(Date(21, Mar, 2016), 9 * Months), make_pair(Date(21, Mar, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(19, Jun, 2016), 9 * Months), make_pair(Date(21, Mar, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(20, Jun, 2016), 9 * Months), make_pair(Date(20, Jun, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(21, Jun, 2016), 9 * Months), make_pair(Date(20, Jun, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(19, Sep, 2016), 9 * Months), make_pair(Date(20, Jun, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(20, Sep, 2016), 9 * Months), make_pair(Date(20, Sep, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(21, Sep, 2016), 9 * Months), make_pair(Date(20, Sep, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(19, Dec, 2016), 9 * Months), make_pair(Date(20, Sep, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(20, Dec, 2016), 9 * Months), make_pair(Date(20, Dec, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(21, Dec, 2016), 9 * Months), make_pair(Date(20, Dec, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(19, Mar, 2016), 1 * Years), make_pair(Date(21, Dec, 2015), Date(20, Dec, 2016)))
-        (make_pair(Date(20, Mar, 2016), 1 * Years), make_pair(Date(21, Dec, 2015), Date(20, Jun, 2017)))
-        (make_pair(Date(21, Mar, 2016), 1 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(19, Jun, 2016), 1 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(20, Jun, 2016), 1 * Years), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(21, Jun, 2016), 1 * Years), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(19, Sep, 2016), 1 * Years), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(20, Sep, 2016), 1 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2017)))
-        (make_pair(Date(21, Sep, 2016), 1 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2017)))
-        (make_pair(Date(19, Dec, 2016), 1 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2017)))
-        (make_pair(Date(20, Dec, 2016), 1 * Years), make_pair(Date(20, Dec, 2016), Date(20, Dec, 2017)))
-        (make_pair(Date(21, Dec, 2016), 1 * Years), make_pair(Date(20, Dec, 2016), Date(20, Dec, 2017)))
-        (make_pair(Date(19, Mar, 2016), 5 * Years), make_pair(Date(21, Dec, 2015), Date(20, Dec, 2020)))
-        (make_pair(Date(20, Mar, 2016), 5 * Years), make_pair(Date(21, Dec, 2015), Date(20, Jun, 2021)))
-        (make_pair(Date(21, Mar, 2016), 5 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2021)))
-        (make_pair(Date(19, Jun, 2016), 5 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2021)))
-        (make_pair(Date(20, Jun, 2016), 5 * Years), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2021)))
-        (make_pair(Date(21, Jun, 2016), 5 * Years), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2021)))
-        (make_pair(Date(19, Sep, 2016), 5 * Years), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2021)))
-        (make_pair(Date(20, Sep, 2016), 5 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2021)))
-        (make_pair(Date(21, Sep, 2016), 5 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2021)))
-        (make_pair(Date(19, Dec, 2016), 5 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2021)))
-        (make_pair(Date(20, Dec, 2016), 5 * Years), make_pair(Date(20, Dec, 2016), Date(20, Dec, 2021)))
-        (make_pair(Date(21, Dec, 2016), 5 * Years), make_pair(Date(20, Dec, 2016), Date(20, Dec, 2021)))
-        (make_pair(Date(20, Mar, 2016), 0 * Months), make_pair(Date(21, Dec, 2015), Date(20, Jun, 2016)))
-        (make_pair(Date(21, Mar, 2016), 0 * Months), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2016)))
-        (make_pair(Date(19, Jun, 2016), 0 * Months), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2016)))
-        (make_pair(Date(20, Sep, 2016), 0 * Months), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(21, Sep, 2016), 0 * Months), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(19, Dec, 2016), 0 * Months), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2016)));
+    InputData inputs = {
+        { make_pair(Date(19, Mar, 2016), 3 * Months), make_pair(Date(21, Dec, 2015), Date(20, Mar, 2016)) },
+        { make_pair(Date(20, Mar, 2016), 3 * Months), make_pair(Date(21, Dec, 2015), Date(20, Sep, 2016)) },
+        { make_pair(Date(21, Mar, 2016), 3 * Months), make_pair(Date(21, Mar, 2016), Date(20, Sep, 2016)) },
+        { make_pair(Date(19, Jun, 2016), 3 * Months), make_pair(Date(21, Mar, 2016), Date(20, Sep, 2016)) },
+        { make_pair(Date(20, Jun, 2016), 3 * Months), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2016)) },
+        { make_pair(Date(21, Jun, 2016), 3 * Months), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2016)) },
+        { make_pair(Date(19, Sep, 2016), 3 * Months), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2016)) },
+        { make_pair(Date(20, Sep, 2016), 3 * Months), make_pair(Date(20, Sep, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(21, Sep, 2016), 3 * Months), make_pair(Date(20, Sep, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(19, Dec, 2016), 3 * Months), make_pair(Date(20, Sep, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(20, Dec, 2016), 3 * Months), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(21, Dec, 2016), 3 * Months), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(19, Mar, 2016), 6 * Months), make_pair(Date(21, Dec, 2015), Date(20, Jun, 2016)) },
+        { make_pair(Date(20, Mar, 2016), 6 * Months), make_pair(Date(21, Dec, 2015), Date(20, Dec, 2016)) },
+        { make_pair(Date(21, Mar, 2016), 6 * Months), make_pair(Date(21, Mar, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(19, Jun, 2016), 6 * Months), make_pair(Date(21, Mar, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(20, Jun, 2016), 6 * Months), make_pair(Date(20, Jun, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(21, Jun, 2016), 6 * Months), make_pair(Date(20, Jun, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(19, Sep, 2016), 6 * Months), make_pair(Date(20, Jun, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(20, Sep, 2016), 6 * Months), make_pair(Date(20, Sep, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(21, Sep, 2016), 6 * Months), make_pair(Date(20, Sep, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(19, Dec, 2016), 6 * Months), make_pair(Date(20, Sep, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(20, Dec, 2016), 6 * Months), make_pair(Date(20, Dec, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(21, Dec, 2016), 6 * Months), make_pair(Date(20, Dec, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(19, Mar, 2016), 9 * Months), make_pair(Date(21, Dec, 2015), Date(20, Sep, 2016)) },
+        { make_pair(Date(20, Mar, 2016), 9 * Months), make_pair(Date(21, Dec, 2015), Date(20, Mar, 2017)) },
+        { make_pair(Date(21, Mar, 2016), 9 * Months), make_pair(Date(21, Mar, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(19, Jun, 2016), 9 * Months), make_pair(Date(21, Mar, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(20, Jun, 2016), 9 * Months), make_pair(Date(20, Jun, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(21, Jun, 2016), 9 * Months), make_pair(Date(20, Jun, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(19, Sep, 2016), 9 * Months), make_pair(Date(20, Jun, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(20, Sep, 2016), 9 * Months), make_pair(Date(20, Sep, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(21, Sep, 2016), 9 * Months), make_pair(Date(20, Sep, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(19, Dec, 2016), 9 * Months), make_pair(Date(20, Sep, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(20, Dec, 2016), 9 * Months), make_pair(Date(20, Dec, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(21, Dec, 2016), 9 * Months), make_pair(Date(20, Dec, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(19, Mar, 2016), 1 * Years), make_pair(Date(21, Dec, 2015), Date(20, Dec, 2016)) },
+        { make_pair(Date(20, Mar, 2016), 1 * Years), make_pair(Date(21, Dec, 2015), Date(20, Jun, 2017)) },
+        { make_pair(Date(21, Mar, 2016), 1 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(19, Jun, 2016), 1 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(20, Jun, 2016), 1 * Years), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(21, Jun, 2016), 1 * Years), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(19, Sep, 2016), 1 * Years), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(20, Sep, 2016), 1 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2017)) },
+        { make_pair(Date(21, Sep, 2016), 1 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2017)) },
+        { make_pair(Date(19, Dec, 2016), 1 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2017)) },
+        { make_pair(Date(20, Dec, 2016), 1 * Years), make_pair(Date(20, Dec, 2016), Date(20, Dec, 2017)) },
+        { make_pair(Date(21, Dec, 2016), 1 * Years), make_pair(Date(20, Dec, 2016), Date(20, Dec, 2017)) },
+        { make_pair(Date(19, Mar, 2016), 5 * Years), make_pair(Date(21, Dec, 2015), Date(20, Dec, 2020)) },
+        { make_pair(Date(20, Mar, 2016), 5 * Years), make_pair(Date(21, Dec, 2015), Date(20, Jun, 2021)) },
+        { make_pair(Date(21, Mar, 2016), 5 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2021)) },
+        { make_pair(Date(19, Jun, 2016), 5 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2021)) },
+        { make_pair(Date(20, Jun, 2016), 5 * Years), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2021)) },
+        { make_pair(Date(21, Jun, 2016), 5 * Years), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2021)) },
+        { make_pair(Date(19, Sep, 2016), 5 * Years), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2021)) },
+        { make_pair(Date(20, Sep, 2016), 5 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2021)) },
+        { make_pair(Date(21, Sep, 2016), 5 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2021)) },
+        { make_pair(Date(19, Dec, 2016), 5 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2021)) },
+        { make_pair(Date(20, Dec, 2016), 5 * Years), make_pair(Date(20, Dec, 2016), Date(20, Dec, 2021)) },
+        { make_pair(Date(21, Dec, 2016), 5 * Years), make_pair(Date(20, Dec, 2016), Date(20, Dec, 2021)) },
+        { make_pair(Date(20, Mar, 2016), 0 * Months), make_pair(Date(21, Dec, 2015), Date(20, Jun, 2016)) },
+        { make_pair(Date(21, Mar, 2016), 0 * Months), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2016)) },
+        { make_pair(Date(19, Jun, 2016), 0 * Months), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2016)) },
+        { make_pair(Date(20, Sep, 2016), 0 * Months), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(21, Sep, 2016), 0 * Months), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(19, Dec, 2016), 0 * Months), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2016)) }
+    };
 
     CdsTests::testCDSConventions(inputs, DateGeneration::CDS2015);
 }
@@ -449,79 +446,80 @@ void ScheduleTest::testCDSConventionGrid() {
     // The map value is a pair with 1st and 2nd element equal to expected start and end date respectively.
     // The trade dates are from the transition dates in the doc i.e. 20th Mar, Jun, Sep and Dec in 2016 and a day 
     // either side. The tenors are selected tenors from the doc i.e. short quarterly tenors less than 1Y, 1Y and 5Y.
-    InputData inputs = map_list_of
-        (make_pair(Date(19, Mar, 2016), 3 * Months), make_pair(Date(21, Dec, 2015), Date(20, Jun, 2016)))
-        (make_pair(Date(20, Mar, 2016), 3 * Months), make_pair(Date(21, Dec, 2015), Date(20, Sep, 2016)))
-        (make_pair(Date(21, Mar, 2016), 3 * Months), make_pair(Date(21, Mar, 2016), Date(20, Sep, 2016)))
-        (make_pair(Date(19, Jun, 2016), 3 * Months), make_pair(Date(21, Mar, 2016), Date(20, Sep, 2016)))
-        (make_pair(Date(20, Jun, 2016), 3 * Months), make_pair(Date(20, Jun, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(21, Jun, 2016), 3 * Months), make_pair(Date(20, Jun, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(19, Sep, 2016), 3 * Months), make_pair(Date(20, Jun, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(20, Sep, 2016), 3 * Months), make_pair(Date(20, Sep, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(21, Sep, 2016), 3 * Months), make_pair(Date(20, Sep, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(19, Dec, 2016), 3 * Months), make_pair(Date(20, Sep, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(20, Dec, 2016), 3 * Months), make_pair(Date(20, Dec, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(21, Dec, 2016), 3 * Months), make_pair(Date(20, Dec, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(19, Mar, 2016), 6 * Months), make_pair(Date(21, Dec, 2015), Date(20, Sep, 2016)))
-        (make_pair(Date(20, Mar, 2016), 6 * Months), make_pair(Date(21, Dec, 2015), Date(20, Dec, 2016)))
-        (make_pair(Date(21, Mar, 2016), 6 * Months), make_pair(Date(21, Mar, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(19, Jun, 2016), 6 * Months), make_pair(Date(21, Mar, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(20, Jun, 2016), 6 * Months), make_pair(Date(20, Jun, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(21, Jun, 2016), 6 * Months), make_pair(Date(20, Jun, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(19, Sep, 2016), 6 * Months), make_pair(Date(20, Jun, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(20, Sep, 2016), 6 * Months), make_pair(Date(20, Sep, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(21, Sep, 2016), 6 * Months), make_pair(Date(20, Sep, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(19, Dec, 2016), 6 * Months), make_pair(Date(20, Sep, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(20, Dec, 2016), 6 * Months), make_pair(Date(20, Dec, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(21, Dec, 2016), 6 * Months), make_pair(Date(20, Dec, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(19, Mar, 2016), 9 * Months), make_pair(Date(21, Dec, 2015), Date(20, Dec, 2016)))
-        (make_pair(Date(20, Mar, 2016), 9 * Months), make_pair(Date(21, Dec, 2015), Date(20, Mar, 2017)))
-        (make_pair(Date(21, Mar, 2016), 9 * Months), make_pair(Date(21, Mar, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(19, Jun, 2016), 9 * Months), make_pair(Date(21, Mar, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(20, Jun, 2016), 9 * Months), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(21, Jun, 2016), 9 * Months), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(19, Sep, 2016), 9 * Months), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(20, Sep, 2016), 9 * Months), make_pair(Date(20, Sep, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(21, Sep, 2016), 9 * Months), make_pair(Date(20, Sep, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(19, Dec, 2016), 9 * Months), make_pair(Date(20, Sep, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(20, Dec, 2016), 9 * Months), make_pair(Date(20, Dec, 2016), Date(20, Dec, 2017)))
-        (make_pair(Date(21, Dec, 2016), 9 * Months), make_pair(Date(20, Dec, 2016), Date(20, Dec, 2017)))
-        (make_pair(Date(19, Mar, 2016), 1 * Years), make_pair(Date(21, Dec, 2015), Date(20, Mar, 2017)))
-        (make_pair(Date(20, Mar, 2016), 1 * Years), make_pair(Date(21, Dec, 2015), Date(20, Jun, 2017)))
-        (make_pair(Date(21, Mar, 2016), 1 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(19, Jun, 2016), 1 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(20, Jun, 2016), 1 * Years), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(21, Jun, 2016), 1 * Years), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(19, Sep, 2016), 1 * Years), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(20, Sep, 2016), 1 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2017)))
-        (make_pair(Date(21, Sep, 2016), 1 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2017)))
-        (make_pair(Date(19, Dec, 2016), 1 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2017)))
-        (make_pair(Date(20, Dec, 2016), 1 * Years), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2018)))
-        (make_pair(Date(21, Dec, 2016), 1 * Years), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2018)))
-        (make_pair(Date(19, Mar, 2016), 5 * Years), make_pair(Date(21, Dec, 2015), Date(20, Mar, 2021)))
-        (make_pair(Date(20, Mar, 2016), 5 * Years), make_pair(Date(21, Dec, 2015), Date(20, Jun, 2021)))
-        (make_pair(Date(21, Mar, 2016), 5 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2021)))
-        (make_pair(Date(19, Jun, 2016), 5 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2021)))
-        (make_pair(Date(20, Jun, 2016), 5 * Years), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2021)))
-        (make_pair(Date(21, Jun, 2016), 5 * Years), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2021)))
-        (make_pair(Date(19, Sep, 2016), 5 * Years), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2021)))
-        (make_pair(Date(20, Sep, 2016), 5 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2021)))
-        (make_pair(Date(21, Sep, 2016), 5 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2021)))
-        (make_pair(Date(19, Dec, 2016), 5 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2021)))
-        (make_pair(Date(20, Dec, 2016), 5 * Years), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2022)))
-        (make_pair(Date(21, Dec, 2016), 5 * Years), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2022)))
-        (make_pair(Date(19, Mar, 2016), 0 * Months), make_pair(Date(21, Dec, 2015), Date(20, Mar, 2016)))
-        (make_pair(Date(20, Mar, 2016), 0 * Months), make_pair(Date(21, Dec, 2015), Date(20, Jun, 2016)))
-        (make_pair(Date(21, Mar, 2016), 0 * Months), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2016)))
-        (make_pair(Date(19, Jun, 2016), 0 * Months), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2016)))
-        (make_pair(Date(20, Jun, 2016), 0 * Months), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2016)))
-        (make_pair(Date(21, Jun, 2016), 0 * Months), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2016)))
-        (make_pair(Date(19, Sep, 2016), 0 * Months), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2016)))
-        (make_pair(Date(20, Sep, 2016), 0 * Months), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(21, Sep, 2016), 0 * Months), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(19, Dec, 2016), 0 * Months), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(20, Dec, 2016), 0 * Months), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(21, Dec, 2016), 0 * Months), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2017)));
+    InputData inputs = {
+        { make_pair(Date(19, Mar, 2016), 3 * Months), make_pair(Date(21, Dec, 2015), Date(20, Jun, 2016)) },
+        { make_pair(Date(20, Mar, 2016), 3 * Months), make_pair(Date(21, Dec, 2015), Date(20, Sep, 2016)) },
+        { make_pair(Date(21, Mar, 2016), 3 * Months), make_pair(Date(21, Mar, 2016), Date(20, Sep, 2016)) },
+        { make_pair(Date(19, Jun, 2016), 3 * Months), make_pair(Date(21, Mar, 2016), Date(20, Sep, 2016)) },
+        { make_pair(Date(20, Jun, 2016), 3 * Months), make_pair(Date(20, Jun, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(21, Jun, 2016), 3 * Months), make_pair(Date(20, Jun, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(19, Sep, 2016), 3 * Months), make_pair(Date(20, Jun, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(20, Sep, 2016), 3 * Months), make_pair(Date(20, Sep, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(21, Sep, 2016), 3 * Months), make_pair(Date(20, Sep, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(19, Dec, 2016), 3 * Months), make_pair(Date(20, Sep, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(20, Dec, 2016), 3 * Months), make_pair(Date(20, Dec, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(21, Dec, 2016), 3 * Months), make_pair(Date(20, Dec, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(19, Mar, 2016), 6 * Months), make_pair(Date(21, Dec, 2015), Date(20, Sep, 2016)) },
+        { make_pair(Date(20, Mar, 2016), 6 * Months), make_pair(Date(21, Dec, 2015), Date(20, Dec, 2016)) },
+        { make_pair(Date(21, Mar, 2016), 6 * Months), make_pair(Date(21, Mar, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(19, Jun, 2016), 6 * Months), make_pair(Date(21, Mar, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(20, Jun, 2016), 6 * Months), make_pair(Date(20, Jun, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(21, Jun, 2016), 6 * Months), make_pair(Date(20, Jun, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(19, Sep, 2016), 6 * Months), make_pair(Date(20, Jun, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(20, Sep, 2016), 6 * Months), make_pair(Date(20, Sep, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(21, Sep, 2016), 6 * Months), make_pair(Date(20, Sep, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(19, Dec, 2016), 6 * Months), make_pair(Date(20, Sep, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(20, Dec, 2016), 6 * Months), make_pair(Date(20, Dec, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(21, Dec, 2016), 6 * Months), make_pair(Date(20, Dec, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(19, Mar, 2016), 9 * Months), make_pair(Date(21, Dec, 2015), Date(20, Dec, 2016)) },
+        { make_pair(Date(20, Mar, 2016), 9 * Months), make_pair(Date(21, Dec, 2015), Date(20, Mar, 2017)) },
+        { make_pair(Date(21, Mar, 2016), 9 * Months), make_pair(Date(21, Mar, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(19, Jun, 2016), 9 * Months), make_pair(Date(21, Mar, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(20, Jun, 2016), 9 * Months), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(21, Jun, 2016), 9 * Months), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(19, Sep, 2016), 9 * Months), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(20, Sep, 2016), 9 * Months), make_pair(Date(20, Sep, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(21, Sep, 2016), 9 * Months), make_pair(Date(20, Sep, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(19, Dec, 2016), 9 * Months), make_pair(Date(20, Sep, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(20, Dec, 2016), 9 * Months), make_pair(Date(20, Dec, 2016), Date(20, Dec, 2017)) },
+        { make_pair(Date(21, Dec, 2016), 9 * Months), make_pair(Date(20, Dec, 2016), Date(20, Dec, 2017)) },
+        { make_pair(Date(19, Mar, 2016), 1 * Years), make_pair(Date(21, Dec, 2015), Date(20, Mar, 2017)) },
+        { make_pair(Date(20, Mar, 2016), 1 * Years), make_pair(Date(21, Dec, 2015), Date(20, Jun, 2017)) },
+        { make_pair(Date(21, Mar, 2016), 1 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(19, Jun, 2016), 1 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(20, Jun, 2016), 1 * Years), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(21, Jun, 2016), 1 * Years), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(19, Sep, 2016), 1 * Years), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(20, Sep, 2016), 1 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2017)) },
+        { make_pair(Date(21, Sep, 2016), 1 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2017)) },
+        { make_pair(Date(19, Dec, 2016), 1 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2017)) },
+        { make_pair(Date(20, Dec, 2016), 1 * Years), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2018)) },
+        { make_pair(Date(21, Dec, 2016), 1 * Years), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2018)) },
+        { make_pair(Date(19, Mar, 2016), 5 * Years), make_pair(Date(21, Dec, 2015), Date(20, Mar, 2021)) },
+        { make_pair(Date(20, Mar, 2016), 5 * Years), make_pair(Date(21, Dec, 2015), Date(20, Jun, 2021)) },
+        { make_pair(Date(21, Mar, 2016), 5 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2021)) },
+        { make_pair(Date(19, Jun, 2016), 5 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2021)) },
+        { make_pair(Date(20, Jun, 2016), 5 * Years), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2021)) },
+        { make_pair(Date(21, Jun, 2016), 5 * Years), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2021)) },
+        { make_pair(Date(19, Sep, 2016), 5 * Years), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2021)) },
+        { make_pair(Date(20, Sep, 2016), 5 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2021)) },
+        { make_pair(Date(21, Sep, 2016), 5 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2021)) },
+        { make_pair(Date(19, Dec, 2016), 5 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2021)) },
+        { make_pair(Date(20, Dec, 2016), 5 * Years), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2022)) },
+        { make_pair(Date(21, Dec, 2016), 5 * Years), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2022)) },
+        { make_pair(Date(19, Mar, 2016), 0 * Months), make_pair(Date(21, Dec, 2015), Date(20, Mar, 2016)) },
+        { make_pair(Date(20, Mar, 2016), 0 * Months), make_pair(Date(21, Dec, 2015), Date(20, Jun, 2016)) },
+        { make_pair(Date(21, Mar, 2016), 0 * Months), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2016)) },
+        { make_pair(Date(19, Jun, 2016), 0 * Months), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2016)) },
+        { make_pair(Date(20, Jun, 2016), 0 * Months), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2016)) },
+        { make_pair(Date(21, Jun, 2016), 0 * Months), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2016)) },
+        { make_pair(Date(19, Sep, 2016), 0 * Months), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2016)) },
+        { make_pair(Date(20, Sep, 2016), 0 * Months), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(21, Sep, 2016), 0 * Months), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(19, Dec, 2016), 0 * Months), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(20, Dec, 2016), 0 * Months), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(21, Dec, 2016), 0 * Months), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2017)) }
+    };
 
     CdsTests::testCDSConventions(inputs, DateGeneration::CDS);
 }
@@ -539,67 +537,68 @@ void ScheduleTest::testOldCDSConventionGrid() {
     // The map value is a pair with 1st and 2nd element equal to expected start and end date respectively.
     // The trade dates are from the transition dates in the doc i.e. 20th Mar, Jun, Sep and Dec in 2016 and a day 
     // either side. The tenors are selected tenors from the doc i.e. short quarterly tenors less than 1Y, 1Y and 5Y.
-    InputData inputs = map_list_of
-        (make_pair(Date(19, Mar, 2016), 3 * Months), make_pair(Date(19, Mar, 2016), Date(20, Jun, 2016)))
-        (make_pair(Date(20, Mar, 2016), 3 * Months), make_pair(Date(20, Mar, 2016), Date(20, Sep, 2016)))
-        (make_pair(Date(21, Mar, 2016), 3 * Months), make_pair(Date(21, Mar, 2016), Date(20, Sep, 2016)))
-        (make_pair(Date(19, Jun, 2016), 3 * Months), make_pair(Date(19, Jun, 2016), Date(20, Sep, 2016)))
-        (make_pair(Date(20, Jun, 2016), 3 * Months), make_pair(Date(20, Jun, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(21, Jun, 2016), 3 * Months), make_pair(Date(21, Jun, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(19, Sep, 2016), 3 * Months), make_pair(Date(19, Sep, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(20, Sep, 2016), 3 * Months), make_pair(Date(20, Sep, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(21, Sep, 2016), 3 * Months), make_pair(Date(21, Sep, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(19, Dec, 2016), 3 * Months), make_pair(Date(19, Dec, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(20, Dec, 2016), 3 * Months), make_pair(Date(20, Dec, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(21, Dec, 2016), 3 * Months), make_pair(Date(21, Dec, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(19, Mar, 2016), 6 * Months), make_pair(Date(19, Mar, 2016), Date(20, Sep, 2016)))
-        (make_pair(Date(20, Mar, 2016), 6 * Months), make_pair(Date(20, Mar, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(21, Mar, 2016), 6 * Months), make_pair(Date(21, Mar, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(19, Jun, 2016), 6 * Months), make_pair(Date(19, Jun, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(20, Jun, 2016), 6 * Months), make_pair(Date(20, Jun, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(21, Jun, 2016), 6 * Months), make_pair(Date(21, Jun, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(19, Sep, 2016), 6 * Months), make_pair(Date(19, Sep, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(20, Sep, 2016), 6 * Months), make_pair(Date(20, Sep, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(21, Sep, 2016), 6 * Months), make_pair(Date(21, Sep, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(19, Dec, 2016), 6 * Months), make_pair(Date(19, Dec, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(20, Dec, 2016), 6 * Months), make_pair(Date(20, Dec, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(21, Dec, 2016), 6 * Months), make_pair(Date(21, Dec, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(19, Mar, 2016), 9 * Months), make_pair(Date(19, Mar, 2016), Date(20, Dec, 2016)))
-        (make_pair(Date(20, Mar, 2016), 9 * Months), make_pair(Date(20, Mar, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(21, Mar, 2016), 9 * Months), make_pair(Date(21, Mar, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(19, Jun, 2016), 9 * Months), make_pair(Date(19, Jun, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(20, Jun, 2016), 9 * Months), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(21, Jun, 2016), 9 * Months), make_pair(Date(21, Jun, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(19, Sep, 2016), 9 * Months), make_pair(Date(19, Sep, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(20, Sep, 2016), 9 * Months), make_pair(Date(20, Sep, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(21, Sep, 2016), 9 * Months), make_pair(Date(21, Sep, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(19, Dec, 2016), 9 * Months), make_pair(Date(19, Dec, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(20, Dec, 2016), 9 * Months), make_pair(Date(20, Dec, 2016), Date(20, Dec, 2017)))
-        (make_pair(Date(21, Dec, 2016), 9 * Months), make_pair(Date(21, Dec, 2016), Date(20, Dec, 2017)))
-        (make_pair(Date(19, Mar, 2016), 1 * Years), make_pair(Date(19, Mar, 2016), Date(20, Mar, 2017)))
-        (make_pair(Date(20, Mar, 2016), 1 * Years), make_pair(Date(20, Mar, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(21, Mar, 2016), 1 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(19, Jun, 2016), 1 * Years), make_pair(Date(19, Jun, 2016), Date(20, Jun, 2017)))
-        (make_pair(Date(20, Jun, 2016), 1 * Years), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(21, Jun, 2016), 1 * Years), make_pair(Date(21, Jun, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(19, Sep, 2016), 1 * Years), make_pair(Date(19, Sep, 2016), Date(20, Sep, 2017)))
-        (make_pair(Date(20, Sep, 2016), 1 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2017)))
-        (make_pair(Date(21, Sep, 2016), 1 * Years), make_pair(Date(21, Sep, 2016), Date(20, Dec, 2017)))
-        (make_pair(Date(19, Dec, 2016), 1 * Years), make_pair(Date(19, Dec, 2016), Date(20, Dec, 2017)))
-        (make_pair(Date(20, Dec, 2016), 1 * Years), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2018)))
-        (make_pair(Date(21, Dec, 2016), 1 * Years), make_pair(Date(21, Dec, 2016), Date(20, Mar, 2018)))
-        (make_pair(Date(19, Mar, 2016), 5 * Years), make_pair(Date(19, Mar, 2016), Date(20, Mar, 2021)))
-        (make_pair(Date(20, Mar, 2016), 5 * Years), make_pair(Date(20, Mar, 2016), Date(20, Jun, 2021)))
-        (make_pair(Date(21, Mar, 2016), 5 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2021)))
-        (make_pair(Date(19, Jun, 2016), 5 * Years), make_pair(Date(19, Jun, 2016), Date(20, Jun, 2021)))
-        (make_pair(Date(20, Jun, 2016), 5 * Years), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2021)))
-        (make_pair(Date(21, Jun, 2016), 5 * Years), make_pair(Date(21, Jun, 2016), Date(20, Sep, 2021)))
-        (make_pair(Date(19, Sep, 2016), 5 * Years), make_pair(Date(19, Sep, 2016), Date(20, Sep, 2021)))
-        (make_pair(Date(20, Sep, 2016), 5 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2021)))
-        (make_pair(Date(21, Sep, 2016), 5 * Years), make_pair(Date(21, Sep, 2016), Date(20, Dec, 2021)))
-        (make_pair(Date(19, Dec, 2016), 5 * Years), make_pair(Date(19, Dec, 2016), Date(20, Dec, 2021)))
-        (make_pair(Date(20, Dec, 2016), 5 * Years), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2022)))
-        (make_pair(Date(21, Dec, 2016), 5 * Years), make_pair(Date(21, Dec, 2016), Date(20, Mar, 2022)));
+    InputData inputs = {
+        { make_pair(Date(19, Mar, 2016), 3 * Months), make_pair(Date(19, Mar, 2016), Date(20, Jun, 2016)) },
+        { make_pair(Date(20, Mar, 2016), 3 * Months), make_pair(Date(20, Mar, 2016), Date(20, Sep, 2016)) },
+        { make_pair(Date(21, Mar, 2016), 3 * Months), make_pair(Date(21, Mar, 2016), Date(20, Sep, 2016)) },
+        { make_pair(Date(19, Jun, 2016), 3 * Months), make_pair(Date(19, Jun, 2016), Date(20, Sep, 2016)) },
+        { make_pair(Date(20, Jun, 2016), 3 * Months), make_pair(Date(20, Jun, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(21, Jun, 2016), 3 * Months), make_pair(Date(21, Jun, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(19, Sep, 2016), 3 * Months), make_pair(Date(19, Sep, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(20, Sep, 2016), 3 * Months), make_pair(Date(20, Sep, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(21, Sep, 2016), 3 * Months), make_pair(Date(21, Sep, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(19, Dec, 2016), 3 * Months), make_pair(Date(19, Dec, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(20, Dec, 2016), 3 * Months), make_pair(Date(20, Dec, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(21, Dec, 2016), 3 * Months), make_pair(Date(21, Dec, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(19, Mar, 2016), 6 * Months), make_pair(Date(19, Mar, 2016), Date(20, Sep, 2016)) },
+        { make_pair(Date(20, Mar, 2016), 6 * Months), make_pair(Date(20, Mar, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(21, Mar, 2016), 6 * Months), make_pair(Date(21, Mar, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(19, Jun, 2016), 6 * Months), make_pair(Date(19, Jun, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(20, Jun, 2016), 6 * Months), make_pair(Date(20, Jun, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(21, Jun, 2016), 6 * Months), make_pair(Date(21, Jun, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(19, Sep, 2016), 6 * Months), make_pair(Date(19, Sep, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(20, Sep, 2016), 6 * Months), make_pair(Date(20, Sep, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(21, Sep, 2016), 6 * Months), make_pair(Date(21, Sep, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(19, Dec, 2016), 6 * Months), make_pair(Date(19, Dec, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(20, Dec, 2016), 6 * Months), make_pair(Date(20, Dec, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(21, Dec, 2016), 6 * Months), make_pair(Date(21, Dec, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(19, Mar, 2016), 9 * Months), make_pair(Date(19, Mar, 2016), Date(20, Dec, 2016)) },
+        { make_pair(Date(20, Mar, 2016), 9 * Months), make_pair(Date(20, Mar, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(21, Mar, 2016), 9 * Months), make_pair(Date(21, Mar, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(19, Jun, 2016), 9 * Months), make_pair(Date(19, Jun, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(20, Jun, 2016), 9 * Months), make_pair(Date(20, Jun, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(21, Jun, 2016), 9 * Months), make_pair(Date(21, Jun, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(19, Sep, 2016), 9 * Months), make_pair(Date(19, Sep, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(20, Sep, 2016), 9 * Months), make_pair(Date(20, Sep, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(21, Sep, 2016), 9 * Months), make_pair(Date(21, Sep, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(19, Dec, 2016), 9 * Months), make_pair(Date(19, Dec, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(20, Dec, 2016), 9 * Months), make_pair(Date(20, Dec, 2016), Date(20, Dec, 2017)) },
+        { make_pair(Date(21, Dec, 2016), 9 * Months), make_pair(Date(21, Dec, 2016), Date(20, Dec, 2017)) },
+        { make_pair(Date(19, Mar, 2016), 1 * Years), make_pair(Date(19, Mar, 2016), Date(20, Mar, 2017)) },
+        { make_pair(Date(20, Mar, 2016), 1 * Years), make_pair(Date(20, Mar, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(21, Mar, 2016), 1 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(19, Jun, 2016), 1 * Years), make_pair(Date(19, Jun, 2016), Date(20, Jun, 2017)) },
+        { make_pair(Date(20, Jun, 2016), 1 * Years), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(21, Jun, 2016), 1 * Years), make_pair(Date(21, Jun, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(19, Sep, 2016), 1 * Years), make_pair(Date(19, Sep, 2016), Date(20, Sep, 2017)) },
+        { make_pair(Date(20, Sep, 2016), 1 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2017)) },
+        { make_pair(Date(21, Sep, 2016), 1 * Years), make_pair(Date(21, Sep, 2016), Date(20, Dec, 2017)) },
+        { make_pair(Date(19, Dec, 2016), 1 * Years), make_pair(Date(19, Dec, 2016), Date(20, Dec, 2017)) },
+        { make_pair(Date(20, Dec, 2016), 1 * Years), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2018)) },
+        { make_pair(Date(21, Dec, 2016), 1 * Years), make_pair(Date(21, Dec, 2016), Date(20, Mar, 2018)) },
+        { make_pair(Date(19, Mar, 2016), 5 * Years), make_pair(Date(19, Mar, 2016), Date(20, Mar, 2021)) },
+        { make_pair(Date(20, Mar, 2016), 5 * Years), make_pair(Date(20, Mar, 2016), Date(20, Jun, 2021)) },
+        { make_pair(Date(21, Mar, 2016), 5 * Years), make_pair(Date(21, Mar, 2016), Date(20, Jun, 2021)) },
+        { make_pair(Date(19, Jun, 2016), 5 * Years), make_pair(Date(19, Jun, 2016), Date(20, Jun, 2021)) },
+        { make_pair(Date(20, Jun, 2016), 5 * Years), make_pair(Date(20, Jun, 2016), Date(20, Sep, 2021)) },
+        { make_pair(Date(21, Jun, 2016), 5 * Years), make_pair(Date(21, Jun, 2016), Date(20, Sep, 2021)) },
+        { make_pair(Date(19, Sep, 2016), 5 * Years), make_pair(Date(19, Sep, 2016), Date(20, Sep, 2021)) },
+        { make_pair(Date(20, Sep, 2016), 5 * Years), make_pair(Date(20, Sep, 2016), Date(20, Dec, 2021)) },
+        { make_pair(Date(21, Sep, 2016), 5 * Years), make_pair(Date(21, Sep, 2016), Date(20, Dec, 2021)) },
+        { make_pair(Date(19, Dec, 2016), 5 * Years), make_pair(Date(19, Dec, 2016), Date(20, Dec, 2021)) },
+        { make_pair(Date(20, Dec, 2016), 5 * Years), make_pair(Date(20, Dec, 2016), Date(20, Mar, 2022)) },
+        { make_pair(Date(21, Dec, 2016), 5 * Years), make_pair(Date(21, Dec, 2016), Date(20, Mar, 2022)) }
+    };
 
     CdsTests::testCDSConventions(inputs, DateGeneration::OldCDS);
 }
@@ -617,8 +616,10 @@ void ScheduleTest::testCDS2015ConventionSampleDates() {
     Date tradeDate(18, Sep, 2015);
     Date maturity = cdsMaturity(tradeDate, tenor, rule);
     Schedule s = makeCdsSchedule(tradeDate, maturity, rule);
-    vector<Date> expDates = list_of(Date(22, Jun, 2015))(Date(21, Sep, 2015))(Date(21, Dec, 2015))
-        (Date(21, Mar, 2016))(Date(20, Jun, 2016));
+    vector<Date> expDates = {
+        Date(22, Jun, 2015), Date(21, Sep, 2015), Date(21, Dec, 2015),
+        Date(21, Mar, 2016), Date(20, Jun, 2016)
+    };
     check_dates(s, expDates);
 
     // trade date = Sat 19 Sep 2015, no change.
@@ -647,7 +648,9 @@ void ScheduleTest::testCDS2015ConventionSampleDates() {
     tradeDate = Date(20, Jun, 2009);
     maturity = Date(20, Dec, 2009);
     s = makeCdsSchedule(tradeDate, maturity, rule);
-    vector<Date> tmp = list_of(Date(20, Mar, 2009))(Date(22, Jun, 2009))(Date(21, Sep, 2009))(Date(20, Dec, 2009));
+    vector<Date> tmp = {
+        Date(20, Mar, 2009), Date(22, Jun, 2009), Date(21, Sep, 2009), Date(20, Dec, 2009)
+    };
     expDates.assign(tmp.begin(), tmp.end());
     check_dates(s, expDates);
 
@@ -676,8 +679,10 @@ void ScheduleTest::testCDSConventionSampleDates() {
     Date tradeDate(18, Sep, 2015);
     Date maturity = cdsMaturity(tradeDate, tenor, rule);
     Schedule s = makeCdsSchedule(tradeDate, maturity, rule);
-    vector<Date> expDates = list_of(Date(22, Jun, 2015))(Date(21, Sep, 2015))(Date(21, Dec, 2015))
-        (Date(21, Mar, 2016))(Date(20, Jun, 2016))(Date(20, Sep, 2016));
+    vector<Date> expDates = {
+        Date(22, Jun, 2015), Date(21, Sep, 2015), Date(21, Dec, 2015),
+        Date(21, Mar, 2016), Date(20, Jun, 2016), Date(20, Sep, 2016)
+    };
     check_dates(s, expDates);
 
     // trade date = Sat 19 Sep 2015, no change.
@@ -705,7 +710,7 @@ void ScheduleTest::testCDSConventionSampleDates() {
     tradeDate = Date(20, Jun, 2009);
     maturity = Date(20, Dec, 2009);
     s = makeCdsSchedule(tradeDate, maturity, rule);
-    vector<Date> tmp = list_of(Date(20, Mar, 2009))(Date(22, Jun, 2009))(Date(21, Sep, 2009))(Date(20, Dec, 2009));
+    vector<Date> tmp = { Date(20, Mar, 2009), Date(22, Jun, 2009), Date(21, Sep, 2009), Date(20, Dec, 2009) };
     expDates.assign(tmp.begin(), tmp.end());
     check_dates(s, expDates);
 
@@ -734,8 +739,10 @@ void ScheduleTest::testOldCDSConventionSampleDates() {
     Date tradeDatePlusOne(18, Sep, 2015);
     Date maturity = cdsMaturity(tradeDatePlusOne, tenor, rule);
     Schedule s = makeCdsSchedule(tradeDatePlusOne, maturity, rule);
-    vector<Date> expDates = list_of(Date(18, Sep, 2015))(Date(21, Dec, 2015))
-        (Date(21, Mar, 2016))(Date(20, Jun, 2016))(Date(20, Sep, 2016));
+    vector<Date> expDates = {
+        Date(18, Sep, 2015), Date(21, Dec, 2015),
+        Date(21, Mar, 2016), Date(20, Jun, 2016), Date(20, Sep, 2016)
+    };
     check_dates(s, expDates);
 
     // trade date plus 1D = Sat 19 Sep 2015, no change.
@@ -789,16 +796,17 @@ void ScheduleTest::testCDS2015ZeroMonthsMatured() {
     Period tenor(0, Months);
 
     // Move through selected trade dates from 20 Dec 2015 to 20 Dec 2016 checking that the 0M CDS is matured.
-    vector<Date> inputs = list_of
-        (Date(20, Dec, 2015))
-        (Date(15, Feb, 2016))
-        (Date(19, Mar, 2016))
-        (Date(20, Jun, 2016))
-        (Date(15, Aug, 2016))
-        (Date(19, Sep, 2016))
-        (Date(20, Dec, 2016));
-
-    BOOST_FOREACH(const Date& input, inputs) {
+    vector<Date> inputs = {
+        Date(20, Dec, 2015),
+        Date(15, Feb, 2016),
+        Date(19, Mar, 2016),
+        Date(20, Jun, 2016),
+        Date(15, Aug, 2016),
+        Date(19, Sep, 2016),
+        Date(20, Dec, 2016)
+    };
+
+    for (const Date& input: inputs) {
         BOOST_CHECK_EQUAL(cdsMaturity(input, tenor, rule), Null<Date>());
     }
 }
diff --git a/test-suite/squarerootclvmodel.cpp b/test-suite/squarerootclvmodel.cpp
index 4d96b010325..a7fa80796bc 100644
--- a/test-suite/squarerootclvmodel.cpp
+++ b/test-suite/squarerootclvmodel.cpp
@@ -20,7 +20,6 @@
 
 #include "utilities.hpp"
 #include "squarerootclvmodel.hpp"
-
 #include <ql/quotes/simplequote.hpp>
 #include <ql/time/daycounters/actualactual.hpp>
 #include <ql/time/daycounters/actual365fixed.hpp>
@@ -42,7 +41,6 @@
 #include <ql/methods/montecarlo/pathgenerator.hpp>
 #include <ql/termstructures/volatility/equityfx/hestonblackvolsurface.hpp>
 #include <ql/termstructures/volatility/equityfx/noexceptlocalvolsurface.hpp>
-
 #include <ql/experimental/models/squarerootclvmodel.hpp>
 #include <ql/experimental/models/hestonslvfdmmodel.hpp>
 #include <ql/experimental/processes/hestonslvprocess.hpp>
@@ -50,8 +48,6 @@
 #include <ql/experimental/barrieroption/analyticdoublebarrierbinaryengine.hpp>
 #include <ql/experimental/volatility/sabrvoltermstructure.hpp>
 
-#include <boost/assign/std/vector.hpp>
-
 #if defined(__GNUC__) && !defined(__clang__) && BOOST_VERSION > 106300
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
@@ -65,7 +61,6 @@
 #include <utility>
 
 using namespace QuantLib;
-using namespace boost::assign;
 using namespace boost::unit_test_framework;
 
 
diff --git a/test-suite/zabr.cpp b/test-suite/zabr.cpp
index 0d376bd4f5a..8ba60b18879 100644
--- a/test-suite/zabr.cpp
+++ b/test-suite/zabr.cpp
@@ -19,9 +19,6 @@
 
 #include "zabr.hpp"
 #include "utilities.hpp"
-
-#include <boost/assign/list_of.hpp>
-
 #include <ql/termstructures/volatility/sabrsmilesection.hpp>
 #include <ql/experimental/volatility/zabrsmilesection.hpp>
 
@@ -40,22 +37,22 @@ void ZabrTest::testConsistency() {
     Real forward = 0.03;
 
     SabrSmileSection sabr(tau, forward,
-                          boost::assign::list_of(alpha)(beta)(nu)(rho));
+                          {alpha, beta, nu, rho});
 
-    ZabrSmileSection<ZabrShortMaturityLognormal> zabr0(
-        tau, forward, boost::assign::list_of(alpha)(beta)(nu)(rho)(1.0));
+    ZabrSmileSection<ZabrShortMaturityLognormal> zabr0(tau, forward,
+                                                       {alpha, beta, nu, rho, 1.0});
 
-    ZabrSmileSection<ZabrShortMaturityNormal> zabr1(
-        tau, forward, boost::assign::list_of(alpha)(beta)(nu)(rho)(1.0));
+    ZabrSmileSection<ZabrShortMaturityNormal> zabr1(tau, forward,
+                                                    {alpha, beta, nu, rho, 1.0});
 
-    ZabrSmileSection<ZabrLocalVolatility> zabr2(
-        tau, forward, boost::assign::list_of(alpha)(beta)(nu)(rho)(1.0));
+    ZabrSmileSection<ZabrLocalVolatility> zabr2(tau, forward,
+                                                {alpha, beta, nu, rho, 1.0});
 
     // for full finite prices reduce the number of intermediate points here
     // below the recommended value to speed up the test
-    ZabrSmileSection<ZabrFullFd> zabr3(
-        tau, forward, boost::assign::list_of(alpha)(beta)(nu)(rho)(1.0),
-        std::vector<Real>(), 2);
+    ZabrSmileSection<ZabrFullFd> zabr3(tau, forward,
+                                       {alpha, beta, nu, rho, 1.0},
+                                       std::vector<Real>(), 2);
 
     Real k = 0.0001;
     while (k <= 0.70) {

From afbb15ebeeb5200d6221cf587c062d43a5a85d57 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 21 Feb 2021 02:20:51 +0000
Subject: [PATCH 3/3] Automated fixes by clang-tidy

---
 test-suite/inflation.cpp  | 15 ++++++++-------
 test-suite/optimizers.cpp | 12 ++++--------
 test-suite/schedule.cpp   |  3 +--
 3 files changed, 13 insertions(+), 17 deletions(-)

diff --git a/test-suite/inflation.cpp b/test-suite/inflation.cpp
index 888d2269266..3c5fb71d240 100644
--- a/test-suite/inflation.cpp
+++ b/test-suite/inflation.cpp
@@ -73,13 +73,14 @@ namespace inflation_test {
     }
 
     template <class T, class U, class I>
-    std::vector<ext::shared_ptr<BootstrapHelper<T> > > makeHelpers(
-            const std::vector<Datum> iiData,
-            const ext::shared_ptr<I> &ii, const Period &observationLag,
-            const Calendar &calendar,
-            const BusinessDayConvention &bdc,
-            const DayCounter &dc,
-            const Handle<YieldTermStructure>& yTS) {
+    std::vector<ext::shared_ptr<BootstrapHelper<T> > >
+    makeHelpers(const std::vector<Datum>& iiData,
+                const ext::shared_ptr<I>& ii,
+                const Period& observationLag,
+                const Calendar& calendar,
+                const BusinessDayConvention& bdc,
+                const DayCounter& dc,
+                const Handle<YieldTermStructure>& yTS) {
 
         std::vector<ext::shared_ptr<BootstrapHelper<T> > > instruments;
         for (Datum datum : iiData) {
diff --git a/test-suite/optimizers.cpp b/test-suite/optimizers.cpp
index 0a61162a383..10bdf99b174 100644
--- a/test-suite/optimizers.cpp
+++ b/test-suite/optimizers.cpp
@@ -194,16 +194,12 @@ namespace {
                              Real levenbergMarquardtXtol,
                              Real levenbergMarquardtGtol) {
         std::vector<NamedOptimizationMethod> results;
-        for (Size i=0; i<optimizationMethodTypes.size(); ++i) {
+        for (auto optimizationMethodType : optimizationMethodTypes) {
             NamedOptimizationMethod namedOptimizationMethod;
             namedOptimizationMethod.optimizationMethod = makeOptimizationMethod(
-                optimizationMethodTypes[i],
-                simplexLambda,
-                levenbergMarquardtEpsfcn,
-                levenbergMarquardtXtol,
-                levenbergMarquardtGtol);
-            namedOptimizationMethod.name
-                = optimizationMethodTypeToString(optimizationMethodTypes[i]);
+                optimizationMethodType, simplexLambda, levenbergMarquardtEpsfcn,
+                levenbergMarquardtXtol, levenbergMarquardtGtol);
+            namedOptimizationMethod.name = optimizationMethodTypeToString(optimizationMethodType);
             results.push_back(namedOptimizationMethod);
         }
         return results;
diff --git a/test-suite/schedule.cpp b/test-suite/schedule.cpp
index bbe31cdaa88..6f0be3329e4 100644
--- a/test-suite/schedule.cpp
+++ b/test-suite/schedule.cpp
@@ -270,7 +270,7 @@ namespace CdsTests {
     void testCDSConventions(const InputData& inputs, DateGeneration::Rule rule) {
 
         // Test the generated start and end date against the expected start and end date.
-        for (auto& input : inputs) {
+        for (const auto& input : inputs) {
 
             Date from = input.first.first;
             Period tenor = input.first.second;
@@ -287,7 +287,6 @@ namespace CdsTests {
             BOOST_CHECK_EQUAL(start, expStart);
             BOOST_CHECK_EQUAL(end, expEnd);
         }
-
     }
 }