diff --git a/Examples/BermudanSwaption/BermudanSwaption.cpp b/Examples/BermudanSwaption/BermudanSwaption.cpp
index 113b1f8a973..f59383b3f43 100644
--- a/Examples/BermudanSwaption/BermudanSwaption.cpp
+++ b/Examples/BermudanSwaption/BermudanSwaption.cpp
@@ -23,6 +23,7 @@
 #if !defined(BOOST_ALL_NO_LIB) && defined(BOOST_MSVC)
 #  include <ql/auto_link.hpp>
 #endif
+#include <ql/instruments/vanillaswap.hpp>
 #include <ql/instruments/swaption.hpp>
 #include <ql/pricingengines/swap/discountingswapengine.hpp>
 #include <ql/pricingengines/swaption/treeswaptionengine.hpp>
diff --git a/ql/cashflows/overnightindexedcoupon.cpp b/ql/cashflows/overnightindexedcoupon.cpp
index 877ce8422b3..03c0af0a4b6 100644
--- a/ql/cashflows/overnightindexedcoupon.cpp
+++ b/ql/cashflows/overnightindexedcoupon.cpp
@@ -153,7 +153,7 @@ namespace QuantLib {
                          overnightIndex,
                          gearing, spread,
                          refPeriodStart, refPeriodEnd,
-                         dayCounter, false) {
+                         dayCounter, false), averagingMethod_(averagingMethod) {
 
         // value dates
         Date tmpEndDate = endDate;
diff --git a/ql/cashflows/overnightindexedcoupon.hpp b/ql/cashflows/overnightindexedcoupon.hpp
index c13113996f6..8c0d2cf6b6d 100644
--- a/ql/cashflows/overnightindexedcoupon.hpp
+++ b/ql/cashflows/overnightindexedcoupon.hpp
@@ -71,6 +71,8 @@ namespace QuantLib {
         const std::vector<Rate>& indexFixings() const;
         //! value dates for the rates to be compounded
         const std::vector<Date>& valueDates() const { return valueDates_; }
+        //! averaging method
+        const RateAveraging::Type averagingMethod() const { return averagingMethod_; }
         //@}
         //! \name FloatingRateCoupon interface
         //@{
@@ -87,6 +89,7 @@ namespace QuantLib {
         mutable std::vector<Rate> fixings_;
         Size n_;
         std::vector<Time> dt_;
+        RateAveraging::Type averagingMethod_;
 
         Rate averageRate(const Date& date) const;
     };
diff --git a/ql/experimental/basismodels/swaptioncfs.cpp b/ql/experimental/basismodels/swaptioncfs.cpp
index 9831f852f7b..f17c005d105 100644
--- a/ql/experimental/basismodels/swaptioncfs.cpp
+++ b/ql/experimental/basismodels/swaptioncfs.cpp
@@ -91,7 +91,7 @@ namespace QuantLib {
             floatWeights_.push_back(k->amount());
     }
 
-    SwapCashFlows::SwapCashFlows(const ext::shared_ptr<VanillaSwap>& swap,
+    SwapCashFlows::SwapCashFlows(const ext::shared_ptr<FixedVsFloatingSwap>& swap,
                                  const Handle<YieldTermStructure>& discountCurve,
                                  bool contTenorSpread)
     : IborLegCashFlows(swap->floatingLeg(), discountCurve, contTenorSpread) {
diff --git a/ql/experimental/basismodels/swaptioncfs.hpp b/ql/experimental/basismodels/swaptioncfs.hpp
index a50b41119e5..77a76101098 100644
--- a/ql/experimental/basismodels/swaptioncfs.hpp
+++ b/ql/experimental/basismodels/swaptioncfs.hpp
@@ -59,7 +59,7 @@ namespace QuantLib {
         std::vector<Real> annuityWeights_;
 
       public:
-        SwapCashFlows(const ext::shared_ptr<VanillaSwap>& swap,
+        SwapCashFlows(const ext::shared_ptr<FixedVsFloatingSwap>& swap,
                       const Handle<YieldTermStructure>& discountCurve,
                       bool contTenorSpread = true);
         SwapCashFlows() = default;
diff --git a/ql/experimental/basismodels/tenorswaptionvts.cpp b/ql/experimental/basismodels/tenorswaptionvts.cpp
index e801b26d0aa..d25653e6787 100644
--- a/ql/experimental/basismodels/tenorswaptionvts.cpp
+++ b/ql/experimental/basismodels/tenorswaptionvts.cpp
@@ -24,6 +24,7 @@ FOR A PARTICULAR PURPOSE.  See the license for more details.
 
 #include <ql/experimental/basismodels/tenorswaptionvts.hpp>
 #include <ql/experimental/basismodels/swaptioncfs.hpp>
+#include <ql/instruments/vanillaswap.hpp>
 #include <ql/exercise.hpp>
 #include <ql/indexes/iborindex.hpp>
 #include <ql/math/rounding.hpp>
@@ -60,15 +61,15 @@ namespace QuantLib {
                                    volTS.baseIndex_->fixingCalendar(), ModifiedFollowing,
                                    Unadjusted, DateGeneration::Backward, false);
         // and swaps
-        ext::shared_ptr<VanillaSwap> baseSwap(new VanillaSwap(
+        auto baseSwap = ext::make_shared<VanillaSwap>(
             Swap::Payer, 1.0, baseFixedSchedule, 1.0, volTS.baseFixedDC_, baseFloatSchedule,
-            volTS.baseIndex_, 0.0, volTS.baseIndex_->dayCounter()));
-        ext::shared_ptr<VanillaSwap> targSwap(new VanillaSwap(
+            volTS.baseIndex_, 0.0, volTS.baseIndex_->dayCounter());
+        auto targSwap = ext::make_shared<VanillaSwap>(
             Swap::Payer, 1.0, baseFixedSchedule, 1.0, volTS.baseFixedDC_, targFloatSchedule,
-            volTS.targIndex_, 0.0, volTS.targIndex_->dayCounter()));
-        ext::shared_ptr<VanillaSwap> finlSwap(new VanillaSwap(
+            volTS.targIndex_, 0.0, volTS.targIndex_->dayCounter());
+        auto finlSwap = ext::make_shared<VanillaSwap>(
             Swap::Payer, 1.0, finlFixedSchedule, 1.0, volTS.targFixedDC_, targFloatSchedule,
-            volTS.targIndex_, 0.0, volTS.targIndex_->dayCounter()));
+            volTS.targIndex_, 0.0, volTS.targIndex_->dayCounter());
         // adding engines
         baseSwap->setPricingEngine(
             ext::shared_ptr<PricingEngine>(new DiscountingSwapEngine(volTS.discountCurve_)));
diff --git a/ql/instruments/makeswaption.cpp b/ql/instruments/makeswaption.cpp
index bbbe3736267..9b044d5153c 100644
--- a/ql/instruments/makeswaption.cpp
+++ b/ql/instruments/makeswaption.cpp
@@ -21,6 +21,7 @@
 #include <ql/cashflows/cashflows.hpp>
 #include <ql/exercise.hpp>
 #include <ql/indexes/swapindex.hpp>
+#include <ql/instruments/makeois.hpp>
 #include <ql/instruments/makeswaption.hpp>
 #include <ql/instruments/makevanillaswap.hpp>
 #include <ql/pricingengines/swap/discountingswapengine.hpp>
@@ -71,39 +72,73 @@ namespace QuantLib {
                 EuropeanExercise(exerciseDate_));
         }
 
-        Rate usedStrike = strike_;
+        Rate usedStrike;
+        ext::shared_ptr<OvernightIndexedSwapIndex> OIswap_index = ext::dynamic_pointer_cast<OvernightIndexedSwapIndex>(swapIndex_);
         if (strike_ == Null<Rate>()) {
             // ATM on curve(s) attached to index
             QL_REQUIRE(!swapIndex_->forwardingTermStructure().empty(),
                        "null term structure set to this instance of " <<
                        swapIndex_->name());
-            ext::shared_ptr<VanillaSwap> temp =
-                swapIndex_->underlyingSwap(fixingDate_);
-            temp->setPricingEngine(
-                ext::shared_ptr<PricingEngine>(new DiscountingSwapEngine(
-                    swapIndex_->exogenousDiscount()
+            if (OIswap_index) {
+                auto temp = OIswap_index->underlyingSwap(fixingDate_);
+                temp->setPricingEngine(
+                    ext::make_shared<DiscountingSwapEngine>(
+                        swapIndex_->exogenousDiscount()
                         ? swapIndex_->discountingTermStructure()
                         : swapIndex_->forwardingTermStructure(),
-                    false)));
-            usedStrike = temp->fairRate();
+                        false
+                    )
+                );
+                usedStrike = temp->fairRate();
+            } else {
+                auto temp = swapIndex_->underlyingSwap(fixingDate_);
+                temp->setPricingEngine(
+                    ext::make_shared<DiscountingSwapEngine>(
+                        swapIndex_->exogenousDiscount()
+                        ? swapIndex_->discountingTermStructure()
+                        : swapIndex_->forwardingTermStructure(),
+                        false
+                    )
+                );
+                usedStrike = temp->fairRate();
+            }
+        } else {
+            usedStrike = strike_;
         }
 
         BusinessDayConvention bdc = swapIndex_->fixedLegConvention();
-        underlyingSwap_ =
-            MakeVanillaSwap(swapIndex_->tenor(),
-                            swapIndex_->iborIndex(), usedStrike)
-            .withEffectiveDate(swapIndex_->valueDate(fixingDate_))
-            .withFixedLegCalendar(swapIndex_->fixingCalendar())
-            .withFixedLegDayCount(swapIndex_->dayCounter())
-            .withFixedLegTenor(swapIndex_->fixedLegTenor())
-            .withFixedLegConvention(bdc)
-            .withFixedLegTerminationDateConvention(bdc)
-            .withType(underlyingType_)
-            .withNominal(nominal_)
-            .withIndexedCoupons(useIndexedCoupons_);
-
-        ext::shared_ptr<Swaption> swaption(new Swaption(
-            underlyingSwap_, exercise_, delivery_, settlementMethod_));
+        if (OIswap_index) {
+            underlyingSwap_ =
+                (ext::shared_ptr<OvernightIndexedSwap>)(
+                    MakeOIS(swapIndex_->tenor(),
+                            OIswap_index->overnightIndex(), usedStrike)
+                    .withEffectiveDate(swapIndex_->valueDate(fixingDate_))
+                    .withPaymentCalendar(swapIndex_->fixingCalendar())
+                    .withFixedLegDayCount(swapIndex_->dayCounter())
+                    .withPaymentAdjustment(bdc)
+                    .withFixedLegConvention(bdc)
+                    .withFixedLegTerminationDateConvention(bdc)
+                    .withType(underlyingType_)
+                    .withNominal(nominal_)
+                    );
+        } else {
+            underlyingSwap_ =
+                (ext::shared_ptr<VanillaSwap>)(
+                    MakeVanillaSwap(swapIndex_->tenor(),
+                                    swapIndex_->iborIndex(), usedStrike)
+                    .withEffectiveDate(swapIndex_->valueDate(fixingDate_))
+                    .withFixedLegCalendar(swapIndex_->fixingCalendar())
+                    .withFixedLegDayCount(swapIndex_->dayCounter())
+                    .withFixedLegTenor(swapIndex_->fixedLegTenor())
+                    .withFixedLegConvention(bdc)
+                    .withFixedLegTerminationDateConvention(bdc)
+                    .withType(underlyingType_)
+                    .withNominal(nominal_)
+                    .withIndexedCoupons(useIndexedCoupons_)
+                    );
+        }
+        ext::shared_ptr<Swaption> swaption = ext::make_shared<Swaption>(
+            underlyingSwap_, exercise_, delivery_, settlementMethod_);
         swaption->setPricingEngine(engine_);
         return swaption;
     }
diff --git a/ql/instruments/makeswaption.hpp b/ql/instruments/makeswaption.hpp
index 08802daf7df..7667d68722f 100644
--- a/ql/instruments/makeswaption.hpp
+++ b/ql/instruments/makeswaption.hpp
@@ -70,7 +70,7 @@ namespace QuantLib {
         ext::shared_ptr<SwapIndex> swapIndex_;
         Settlement::Type delivery_;
         Settlement::Method settlementMethod_;
-        mutable ext::shared_ptr<VanillaSwap> underlyingSwap_;
+        mutable ext::shared_ptr<FixedVsFloatingSwap> underlyingSwap_;
 
         Period optionTenor_;
         BusinessDayConvention optionConvention_;
diff --git a/ql/instruments/nonstandardswap.cpp b/ql/instruments/nonstandardswap.cpp
index bf7f7cfd237..4c0cc7a0f75 100644
--- a/ql/instruments/nonstandardswap.cpp
+++ b/ql/instruments/nonstandardswap.cpp
@@ -33,7 +33,7 @@
 
 namespace QuantLib {
 
-    NonstandardSwap::NonstandardSwap(const VanillaSwap &fromVanilla)
+    NonstandardSwap::NonstandardSwap(const FixedVsFloatingSwap &fromVanilla)
         : Swap(2), type_(fromVanilla.type()),
           fixedNominal_(std::vector<Real>(fromVanilla.fixedLeg().size(),
                                           fromVanilla.nominal())),
diff --git a/ql/instruments/nonstandardswap.hpp b/ql/instruments/nonstandardswap.hpp
index e2ac0ac0dae..72d6c07d299 100644
--- a/ql/instruments/nonstandardswap.hpp
+++ b/ql/instruments/nonstandardswap.hpp
@@ -25,7 +25,7 @@
 #define quantlib_nonstandard_swap_hpp
 
 #include <ql/instruments/swap.hpp>
-#include <ql/instruments/vanillaswap.hpp>
+#include <ql/instruments/fixedvsfloatingswap.hpp>
 #include <ql/time/daycounter.hpp>
 #include <ql/time/schedule.hpp>
 #include <ql/optional.hpp>
@@ -42,7 +42,7 @@ namespace QuantLib {
         class arguments;
         class results;
         class engine;
-        NonstandardSwap(const VanillaSwap &fromVanilla);
+        explicit NonstandardSwap(const FixedVsFloatingSwap &fromVanilla);
         NonstandardSwap(Swap::Type type,
                         std::vector<Real> fixedNominal,
                         const std::vector<Real>& floatingNominal,
diff --git a/ql/instruments/swaption.cpp b/ql/instruments/swaption.cpp
index 2e41c685df6..1505631dbc6 100644
--- a/ql/instruments/swaption.cpp
+++ b/ql/instruments/swaption.cpp
@@ -130,7 +130,7 @@ namespace QuantLib {
         }
     }
 
-    Swaption::Swaption(ext::shared_ptr<VanillaSwap> swap,
+    Swaption::Swaption(ext::shared_ptr<FixedVsFloatingSwap> swap,
                        const ext::shared_ptr<Exercise>& exercise,
                        Settlement::Type delivery,
                        Settlement::Method settlementMethod)
@@ -160,7 +160,6 @@ namespace QuantLib {
     void Swaption::setupArguments(PricingEngine::arguments* args) const {
 
         swap_->setupArguments(args);
-
         auto* arguments = dynamic_cast<Swaption::arguments*>(args);
 
         QL_REQUIRE(arguments != nullptr, "wrong argument type");
@@ -172,11 +171,10 @@ namespace QuantLib {
     }
 
     void Swaption::arguments::validate() const {
-        VanillaSwap::arguments::validate();
-        QL_REQUIRE(swap, "vanilla swap not set");
+        FixedVsFloatingSwap::arguments::validate();
+        QL_REQUIRE(swap, "swap not set");
         QL_REQUIRE(exercise, "exercise not set");
-        Settlement::checkTypeAndMethodConsistency(settlementType,
-                                                  settlementMethod);
+        Settlement::checkTypeAndMethodConsistency(settlementType, settlementMethod);
     }
 
     Volatility Swaption::impliedVolatility(Real targetValue,
diff --git a/ql/instruments/swaption.hpp b/ql/instruments/swaption.hpp
index adf9478fca9..5d6c1cdf3cf 100644
--- a/ql/instruments/swaption.hpp
+++ b/ql/instruments/swaption.hpp
@@ -30,7 +30,7 @@
 #define quantlib_instruments_swaption_hpp
 
 #include <ql/option.hpp>
-#include <ql/instruments/vanillaswap.hpp>
+#include <ql/instruments/fixedvsfloatingswap.hpp>
 #include <ql/termstructures/yieldtermstructure.hpp>
 #include <ql/termstructures/volatility/volatilitytype.hpp>
 
@@ -59,6 +59,12 @@ namespace QuantLib {
     //! %Swaption class
     /*! \ingroup instruments
 
+        \warning it's possible to pass an overnight-indexed swap to
+                 the constructor, but the only engine to fully support
+                 it is BlackSwaptionEngine; other engines will treat
+                 it as a vanilla swap.  This is at best a decent
+                 proxy, at worst simply wrong.  Use with caution.
+
         \test
         - the correctness of the returned value is tested by checking
           that the price of a payer (resp. receiver) swaption
@@ -82,7 +88,7 @@ namespace QuantLib {
       public:
         class arguments;
         class engine;
-        Swaption(ext::shared_ptr<VanillaSwap> swap,
+        Swaption(ext::shared_ptr<FixedVsFloatingSwap> swap,
                  const ext::shared_ptr<Exercise>& exercise,
                  Settlement::Type delivery = Settlement::Physical,
                  Settlement::Method settlementMethod = Settlement::PhysicalOTC);
@@ -102,7 +108,7 @@ namespace QuantLib {
             return settlementMethod_;
         }
         Swap::Type type() const { return swap_->type(); }
-        const ext::shared_ptr<VanillaSwap>& underlyingSwap() const {
+        const ext::shared_ptr<FixedVsFloatingSwap>& underlyingSwap() const {
             return swap_;
         }
         //@}
@@ -119,18 +125,18 @@ namespace QuantLib {
                               Real displacement = 0.0) const;
       private:
         // arguments
-        ext::shared_ptr<VanillaSwap> swap_;
+        ext::shared_ptr<FixedVsFloatingSwap> swap_;
         //Handle<YieldTermStructure> termStructure_;
         Settlement::Type settlementType_;
         Settlement::Method settlementMethod_;
     };
 
     //! %Arguments for swaption calculation
-    class Swaption::arguments : public VanillaSwap::arguments,
+    class Swaption::arguments : public FixedVsFloatingSwap::arguments,
                                 public Option::arguments {
       public:
         arguments() = default;
-        ext::shared_ptr<VanillaSwap> swap;
+        ext::shared_ptr<FixedVsFloatingSwap> swap;
         Settlement::Type settlementType = Settlement::Physical;
         Settlement::Method settlementMethod;
         void validate() const override;
diff --git a/ql/legacy/libormarketmodels/lfmswaptionengine.cpp b/ql/legacy/libormarketmodels/lfmswaptionengine.cpp
index 0e7571ab582..14fd3bf93d1 100644
--- a/ql/legacy/libormarketmodels/lfmswaptionengine.cpp
+++ b/ql/legacy/libormarketmodels/lfmswaptionengine.cpp
@@ -39,14 +39,14 @@ namespace QuantLib {
 
         static const Spread basisPoint = 1.0e-4;
 
-        VanillaSwap swap = *arguments_.swap;
-        swap.setPricingEngine(ext::shared_ptr<PricingEngine>(
-                           new DiscountingSwapEngine(discountCurve_, false)));
+        auto swap = arguments_.swap;
+        swap->setPricingEngine(ext::shared_ptr<PricingEngine>(
+                                  new DiscountingSwapEngine(discountCurve_, false)));
 
-        Spread correction = swap.spread() *
-            std::fabs(swap.floatingLegBPS()/swap.fixedLegBPS());
-        Rate fixedRate = swap.fixedRate() - correction;
-        Rate fairRate = swap.fairRate() - correction;
+        Spread correction = swap->spread() *
+            std::fabs(swap->floatingLegBPS()/swap->fixedLegBPS());
+        Rate fixedRate = swap->fixedRate() - correction;
+        Rate fairRate = swap->fairRate() - correction;
 
         ext::shared_ptr<SwaptionVolatilityMatrix> volatility =
             model_->getSwaptionVolatilityMatrix();
@@ -65,9 +65,8 @@ namespace QuantLib {
         Option::Type w = arguments_.type==Swap::Payer ? Option::Call : Option::Put;
         Volatility vol = volatility->volatility(exercise, swapLength,
                                                 fairRate, true);
-        results_.value = (swap.fixedLegBPS()/basisPoint) *
+        results_.value = (swap->fixedLegBPS()/basisPoint) *
             blackFormula(w, fixedRate, fairRate, vol*std::sqrt(exercise));
     }
 
 }
-
diff --git a/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.hpp b/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.hpp
index c433fb6f379..64a3425ea4b 100644
--- a/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.hpp
+++ b/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.hpp
@@ -41,7 +41,7 @@ namespace QuantLib {
       public:
         FdmAffineModelSwapInnerValue(ext::shared_ptr<ModelType> disModel,
                                      ext::shared_ptr<ModelType> fwdModel,
-                                     const ext::shared_ptr<VanillaSwap>& swap,
+                                     const ext::shared_ptr<FixedVsFloatingSwap>& swap,
                                      std::map<Time, Date> exerciseDates,
                                      ext::shared_ptr<FdmMesher> mesher,
                                      Size direction);
@@ -58,7 +58,7 @@ namespace QuantLib {
         const ext::shared_ptr<ModelType> disModel_, fwdModel_;
 
         const ext::shared_ptr<IborIndex> index_;
-        const ext::shared_ptr<VanillaSwap> swap_;
+        const ext::shared_ptr<FixedVsFloatingSwap> swap_;
         const std::map<Time, Date> exerciseDates_;
         const ext::shared_ptr<FdmMesher> mesher_;
         const Size direction_;
@@ -68,21 +68,21 @@ namespace QuantLib {
     inline FdmAffineModelSwapInnerValue<ModelType>::FdmAffineModelSwapInnerValue(
         ext::shared_ptr<ModelType> disModel,
         ext::shared_ptr<ModelType> fwdModel,
-        const ext::shared_ptr<VanillaSwap>& swap,
+        const ext::shared_ptr<FixedVsFloatingSwap>& swap,
         std::map<Time, Date> exerciseDates,
         ext::shared_ptr<FdmMesher> mesher,
         Size direction)
     : disModel_(std::move(disModel)), fwdModel_(std::move(fwdModel)), index_(swap->iborIndex()),
-      swap_(ext::shared_ptr<VanillaSwap>(new VanillaSwap(swap->type(),
-                                                         swap->nominal(),
-                                                         swap->fixedSchedule(),
-                                                         swap->fixedRate(),
-                                                         swap->fixedDayCount(),
-                                                         swap->floatingSchedule(),
-                                                         swap->iborIndex()->clone(fwdTs_),
-                                                         swap->spread(),
-                                                         swap->floatingDayCount(),
-                                                         swap->paymentConvention()))),
+      swap_(ext::make_shared<VanillaSwap>(swap->type(),
+                                          swap->nominal(),
+                                          swap->fixedSchedule(),
+                                          swap->fixedRate(),
+                                          swap->fixedDayCount(),
+                                          swap->floatingSchedule(),
+                                          swap->iborIndex()->clone(fwdTs_),
+                                          swap->spread(),
+                                          swap->floatingDayCount(),
+                                          swap->paymentConvention())),
       exerciseDates_(std::move(exerciseDates)), mesher_(std::move(mesher)), direction_(direction) {}
 
     template <class ModelType> inline
diff --git a/ql/models/shortrate/calibrationhelpers/swaptionhelper.cpp b/ql/models/shortrate/calibrationhelpers/swaptionhelper.cpp
index dbcaa7841ce..314d6872a69 100644
--- a/ql/models/shortrate/calibrationhelpers/swaptionhelper.cpp
+++ b/ql/models/shortrate/calibrationhelpers/swaptionhelper.cpp
@@ -20,6 +20,8 @@
 */
 
 #include <ql/indexes/iborindex.hpp>
+#include <ql/instruments/overnightindexedswap.hpp>
+#include <ql/instruments/vanillaswap.hpp>
 #include <ql/models/shortrate/calibrationhelpers/swaptionhelper.hpp>
 #include <ql/pricingengines/swap/discountingswapengine.hpp>
 #include <ql/pricingengines/swaption/blackswaptionengine.hpp>
@@ -38,16 +40,19 @@ namespace QuantLib {
                                    DayCounter fixedLegDayCounter,
                                    DayCounter floatingLegDayCounter,
                                    Handle<YieldTermStructure> termStructure,
-                                   BlackCalibrationHelper::CalibrationErrorType errorType,
+                                   CalibrationErrorType errorType,
                                    const Real strike,
                                    const Real nominal,
                                    const VolatilityType type,
-                                   const Real shift)
+                                   const Real shift,
+                                   Natural settlementDays,
+                                   RateAveraging::Type averagingMethod)
     : BlackCalibrationHelper(volatility, errorType, type, shift), exerciseDate_(Null<Date>()),
       endDate_(Null<Date>()), maturity_(maturity), length_(length), fixedLegTenor_(fixedLegTenor),
       index_(std::move(index)), termStructure_(std::move(termStructure)),
       fixedLegDayCounter_(std::move(fixedLegDayCounter)),
-      floatingLegDayCounter_(std::move(floatingLegDayCounter)), strike_(strike), nominal_(nominal) {
+      floatingLegDayCounter_(std::move(floatingLegDayCounter)), strike_(strike), nominal_(nominal),
+      settlementDays_(settlementDays), averagingMethod_(averagingMethod) {
         registerWith(index_);
         registerWith(termStructure_);
     }
@@ -60,16 +65,19 @@ namespace QuantLib {
                                    DayCounter fixedLegDayCounter,
                                    DayCounter floatingLegDayCounter,
                                    Handle<YieldTermStructure> termStructure,
-                                   BlackCalibrationHelper::CalibrationErrorType errorType,
+                                   CalibrationErrorType errorType,
                                    const Real strike,
                                    const Real nominal,
                                    const VolatilityType type,
-                                   const Real shift)
+                                   const Real shift,
+                                   Natural settlementDays,
+                                   RateAveraging::Type averagingMethod)
     : BlackCalibrationHelper(volatility, errorType, type, shift), exerciseDate_(exerciseDate),
       endDate_(Null<Date>()), maturity_(0 * Days), length_(length), fixedLegTenor_(fixedLegTenor),
       index_(std::move(index)), termStructure_(std::move(termStructure)),
       fixedLegDayCounter_(std::move(fixedLegDayCounter)),
-      floatingLegDayCounter_(std::move(floatingLegDayCounter)), strike_(strike), nominal_(nominal) {
+      floatingLegDayCounter_(std::move(floatingLegDayCounter)), strike_(strike), nominal_(nominal),
+      settlementDays_(settlementDays), averagingMethod_(averagingMethod) {
         registerWith(index_);
         registerWith(termStructure_);
     }
@@ -82,16 +90,19 @@ namespace QuantLib {
                                    DayCounter fixedLegDayCounter,
                                    DayCounter floatingLegDayCounter,
                                    Handle<YieldTermStructure> termStructure,
-                                   BlackCalibrationHelper::CalibrationErrorType errorType,
+                                   CalibrationErrorType errorType,
                                    const Real strike,
                                    const Real nominal,
                                    const VolatilityType type,
-                                   const Real shift)
+                                   const Real shift,
+                                   Natural settlementDays,
+                                   RateAveraging::Type averagingMethod)
     : BlackCalibrationHelper(volatility, errorType, type, shift), exerciseDate_(exerciseDate),
       endDate_(endDate), maturity_(0 * Days), length_(0 * Days), fixedLegTenor_(fixedLegTenor),
       index_(std::move(index)), termStructure_(std::move(termStructure)),
       fixedLegDayCounter_(std::move(fixedLegDayCounter)),
-      floatingLegDayCounter_(std::move(floatingLegDayCounter)), strike_(strike), nominal_(nominal) {
+      floatingLegDayCounter_(std::move(floatingLegDayCounter)), strike_(strike), nominal_(nominal),
+      settlementDays_(settlementDays), averagingMethod_(averagingMethod) {
         registerWith(index_);
         registerWith(termStructure_);
     }
@@ -141,20 +152,24 @@ namespace QuantLib {
     void SwaptionHelper::performCalculations() const {
 
         Calendar calendar = index_->fixingCalendar();
-
         Date exerciseDate = exerciseDate_;
         if (exerciseDate == Null<Date>())
             exerciseDate = calendar.advance(termStructure_->referenceDate(),
                                             maturity_,
                                             index_->businessDayConvention());
-
-        Date startDate = index_->valueDate(index_->fixingCalendar().adjust(exerciseDate));
+        Date startDate;
+        if (settlementDays_ == Null<Size>()) {
+            startDate = index_->valueDate(index_->fixingCalendar().adjust(exerciseDate));
+        } else {
+            startDate = calendar.advance(exerciseDate,
+                                         index_->fixingDays(), Days,
+                                         index_->businessDayConvention());
+        }
 
         Date endDate = endDate_;
         if (endDate == Null<Date>())
             endDate = calendar.advance(startDate, length_,
                                        index_->businessDayConvention());
-
         Schedule fixedSchedule(startDate, endDate, fixedLegTenor_, calendar,
                                index_->businessDayConvention(),
                                index_->businessDayConvention(),
@@ -164,36 +179,40 @@ namespace QuantLib {
                                index_->businessDayConvention(),
                                DateGeneration::Forward, false);
 
-        ext::shared_ptr<PricingEngine> swapEngine(
-                             new DiscountingSwapEngine(termStructure_, false));
+        auto swapEngine = ext::make_shared<DiscountingSwapEngine>(termStructure_, false);
 
         Swap::Type type = Swap::Receiver;
-
-        VanillaSwap temp(Swap::Receiver, nominal_,
-                            fixedSchedule, 0.0, fixedLegDayCounter_,
-                            floatSchedule, index_, 0.0, floatingLegDayCounter_);
-        temp.setPricingEngine(swapEngine);
-        Real forward = temp.fairRate();
-        if(strike_ == Null<Real>()) {
+        ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exerciseDate));
+        auto temp = makeSwap(fixedSchedule, floatSchedule, 0.0, type);
+        temp->setPricingEngine(swapEngine);
+        Real forward = temp->fairRate();
+        if (strike_ == Null<Real>()) {
             exerciseRate_ = forward;
-        }
-        else {
+        } else {
             exerciseRate_ = strike_;
             type = strike_ <= forward ? Swap::Receiver : Swap::Payer;
-            // ensure that calibration instrument is out of the money
         }
-        swap_ = ext::make_shared<VanillaSwap>(
-            type, nominal_,
-                            fixedSchedule, exerciseRate_, fixedLegDayCounter_,
-                            floatSchedule, index_, 0.0, floatingLegDayCounter_);
+        swap_ = makeSwap(fixedSchedule, floatSchedule, exerciseRate_, type);
         swap_->setPricingEngine(swapEngine);
-
-        ext::shared_ptr<Exercise> exercise(new EuropeanExercise(exerciseDate));
-
         swaption_ = ext::make_shared<Swaption>(swap_, exercise);
-
         BlackCalibrationHelper::performCalculations();
+    }
 
+    ext::shared_ptr<FixedVsFloatingSwap> SwaptionHelper::makeSwap(const Schedule& fixedSchedule,
+                                                                  const Schedule& floatSchedule,
+                                                                  Rate exerciseRate,
+                                                                  Swap::Type type) const {
+        auto onIndex = ext::dynamic_pointer_cast<OvernightIndex>(index_);
+        if (onIndex) {
+            return ext::make_shared<OvernightIndexedSwap>(
+                type, nominal_, fixedSchedule, exerciseRate, fixedLegDayCounter_,
+                floatSchedule, onIndex, 0.0, 0, Following,
+                Calendar(), true, averagingMethod_);
+        } else {
+            return ext::make_shared<VanillaSwap>(type, nominal_, fixedSchedule, exerciseRate,
+                                                 fixedLegDayCounter_, floatSchedule, index_, 0.0,
+                                                 floatingLegDayCounter_);
+        }
     }
 
 }
diff --git a/ql/models/shortrate/calibrationhelpers/swaptionhelper.hpp b/ql/models/shortrate/calibrationhelpers/swaptionhelper.hpp
index 8587c75406d..a5a4f9a81fe 100644
--- a/ql/models/shortrate/calibrationhelpers/swaptionhelper.hpp
+++ b/ql/models/shortrate/calibrationhelpers/swaptionhelper.hpp
@@ -28,11 +28,17 @@
 #include <ql/models/calibrationhelper.hpp>
 #include <ql/instruments/swaption.hpp>
 #include <ql/termstructures/volatility/volatilitytype.hpp>
+#include <ql/cashflows/rateaveraging.hpp>
 
 namespace QuantLib {
 
-    //! calibration helper for ATM swaption
-
+    //! calibration helper for interest-rate swaptions
+    /*! \warning passing an overnight index to the constructor will
+                 result in an overnight-indexed swap being built, but
+                 model-based engines will treat it as a vanilla swap.
+                 This is at best a decent proxy, at worst simply wrong.
+                 Use with caution.
+    */
     class SwaptionHelper : public BlackCalibrationHelper {
       public:
         SwaptionHelper(const Period& maturity,
@@ -43,12 +49,13 @@ namespace QuantLib {
                        DayCounter fixedLegDayCounter,
                        DayCounter floatingLegDayCounter,
                        Handle<YieldTermStructure> termStructure,
-                       BlackCalibrationHelper::CalibrationErrorType errorType =
-                           BlackCalibrationHelper::RelativePriceError,
+                       CalibrationErrorType errorType = RelativePriceError,
                        Real strike = Null<Real>(),
                        Real nominal = 1.0,
                        VolatilityType type = ShiftedLognormal,
-                       Real shift = 0.0);
+                       Real shift = 0.0,
+                       Natural settlementDays = Null<Size>(),
+                       RateAveraging::Type averagingMethod = RateAveraging::Compound);
 
         SwaptionHelper(const Date& exerciseDate,
                        const Period& length,
@@ -58,12 +65,13 @@ namespace QuantLib {
                        DayCounter fixedLegDayCounter,
                        DayCounter floatingLegDayCounter,
                        Handle<YieldTermStructure> termStructure,
-                       BlackCalibrationHelper::CalibrationErrorType errorType =
-                           BlackCalibrationHelper::RelativePriceError,
+                       CalibrationErrorType errorType = RelativePriceError,
                        Real strike = Null<Real>(),
                        Real nominal = 1.0,
                        VolatilityType type = ShiftedLognormal,
-                       Real shift = 0.0);
+                       Real shift = 0.0,
+                       Natural settlementDays = Null<Size>(),
+                       RateAveraging::Type averagingMethod = RateAveraging::Compound);
 
         SwaptionHelper(const Date& exerciseDate,
                        const Date& endDate,
@@ -73,30 +81,40 @@ namespace QuantLib {
                        DayCounter fixedLegDayCounter,
                        DayCounter floatingLegDayCounter,
                        Handle<YieldTermStructure> termStructure,
-                       BlackCalibrationHelper::CalibrationErrorType errorType =
-                           BlackCalibrationHelper::RelativePriceError,
+                       CalibrationErrorType errorType = RelativePriceError,
                        Real strike = Null<Real>(),
                        Real nominal = 1.0,
                        VolatilityType type = ShiftedLognormal,
-                       Real shift = 0.0);
+                       Real shift = 0.0,
+                       Natural settlementDays = Null<Size>(),
+                       RateAveraging::Type averagingMethod = RateAveraging::Compound);
 
         void addTimesTo(std::list<Time>& times) const override;
         Real modelValue() const override;
         Real blackPrice(Volatility volatility) const override;
 
-        ext::shared_ptr<VanillaSwap> underlyingSwap() const { calculate(); return swap_; }
+        ext::shared_ptr<FixedVsFloatingSwap> underlyingSwap() const {
+            calculate();
+            return swap_;
+        }
         ext::shared_ptr<Swaption> swaption() const { calculate(); return swaption_; }
 
       private:
         void performCalculations() const override;
+        ext::shared_ptr<FixedVsFloatingSwap> makeSwap(const Schedule& fixedSchedule,
+                                                      const Schedule& floatSchedule,
+                                                      Rate exerciseRate,
+                                                      Swap::Type type) const;
         mutable Date exerciseDate_, endDate_;
         const Period maturity_, length_, fixedLegTenor_;
         const ext::shared_ptr<IborIndex> index_;
         const Handle<YieldTermStructure> termStructure_;
         const DayCounter fixedLegDayCounter_, floatingLegDayCounter_;
         const Real strike_, nominal_;
+        const Natural settlementDays_;
+        const RateAveraging::Type averagingMethod_;
         mutable Rate exerciseRate_;
-        mutable ext::shared_ptr<VanillaSwap> swap_;
+        mutable ext::shared_ptr<FixedVsFloatingSwap> swap_;
         mutable ext::shared_ptr<Swaption> swaption_;
     };
 
diff --git a/ql/pricingengines/swaption/blackswaptionengine.hpp b/ql/pricingengines/swaption/blackswaptionengine.hpp
index 6ac9c175ff4..43e8e7f4c0f 100644
--- a/ql/pricingengines/swaption/blackswaptionengine.hpp
+++ b/ql/pricingengines/swaption/blackswaptionengine.hpp
@@ -227,28 +227,33 @@ namespace QuantLib {
         // account unwanted cashflows. For the moment we add a check avoiding this situation.
         // Furthermore, we take a copy of the underlying swap. This avoids notifying the swaption
         // when we set a pricing engine on the swap below.
-        VanillaSwap swap = *arguments_.swap;
-        const Leg& fixedLeg = swap.fixedLeg();
+        auto swap = arguments_.swap;
+
+        const Leg& fixedLeg = swap->fixedLeg();
         ext::shared_ptr<FixedRateCoupon> firstCoupon =
             ext::dynamic_pointer_cast<FixedRateCoupon>(fixedLeg[0]);
         QL_REQUIRE(firstCoupon->accrualStartDate() >= exerciseDate,
                    "swap start (" << firstCoupon->accrualStartDate() << ") before exercise date ("
                                   << exerciseDate << ") not supported in Black swaption engine");
 
-        Rate strike = swap.fixedRate();
+        Rate strike = swap->fixedRate();
 
         // using the discounting curve
         // swap.iborIndex() might be using a different forwarding curve
-        swap.setPricingEngine(ext::shared_ptr<PricingEngine>(new
-            DiscountingSwapEngine(discountCurve_, false)));
-        Rate atmForward = swap.fairRate();
+        auto engine = ext::make_shared<DiscountingSwapEngine>(discountCurve_, false);
+        ObservableSettings::instance().disableUpdates();
+        swap->setPricingEngine(engine);
+        ObservableSettings::instance().enableUpdates();
+        Date valuation_date = results_.valuationDate  = swap->valuationDate();
+        Rate atmForward = swap->fairRate();
 
         // Volatilities are quoted for zero-spreaded swaps.
         // Therefore, any spread on the floating leg must be removed
         // with a corresponding correction on the fixed leg.
-        if (swap.spread()!=0.0) {
-            Spread correction = swap.spread() *
-                std::fabs(swap.floatingLegBPS()/swap.fixedLegBPS());
+        Real spread = swap->spread();
+        if (spread!=0.0) {
+            Spread correction =
+                spread * std::fabs(swap->floatingLegBPS() / swap->fixedLegBPS());
             strike -= correction;
             atmForward -= correction;
             results_.additionalResults["spreadCorrection"] = correction;
@@ -258,15 +263,12 @@ namespace QuantLib {
         results_.additionalResults["strike"] = strike;
         results_.additionalResults["atmForward"] = atmForward;
 
-        // using the discounting curve
-        swap.setPricingEngine(ext::shared_ptr<PricingEngine>(
-                           new DiscountingSwapEngine(discountCurve_, false)));
         Real annuity;
         if (arguments_.settlementType == Settlement::Physical ||
             (arguments_.settlementType == Settlement::Cash &&
              arguments_.settlementMethod ==
                  Settlement::CollateralizedCashPrice)) {
-            annuity = std::fabs(swap.fixedLegBPS()) / basisPoint;
+            annuity = std::fabs(swap->fixedLegBPS()) / basisPoint;
         } else if (arguments_.settlementType == Settlement::Cash &&
                    arguments_.settlementMethod == Settlement::ParYieldCurve) {
             DayCounter dayCount = firstCoupon->dayCounter();
@@ -274,11 +276,16 @@ namespace QuantLib {
             // to the swap start date
             Date discountDate = model_ == DiscountCurve
                                     ? firstCoupon->accrualStartDate()
-                                    : discountCurve_->referenceDate();
-            Real fixedLegCashBPS = CashFlows::bps(
-                fixedLeg,
-                InterestRate(atmForward, dayCount, Compounded, Annual), false,
-                discountDate);
+                                    : valuation_date;
+            Frequency freq = Annual;
+            const Schedule& fixedSchedule = swap->fixedSchedule();
+            if (fixedSchedule.hasTenor()) {
+                freq = fixedSchedule.tenor().frequency();
+            }
+            Real fixedLegCashBPS =
+                CashFlows::bps(fixedLeg,
+                        InterestRate(atmForward, dayCount, Compounded, freq),
+                        false, discountDate);
             annuity = std::fabs(fixedLegCashBPS / basisPoint) *
                       discountCurve_->discount(discountDate);
         } else {
@@ -286,8 +293,9 @@ namespace QuantLib {
         }
         results_.additionalResults["annuity"] = annuity;
 
-        Time swapLength =  vol_->swapLength(swap.floatingSchedule().dates().front(),
-                                            swap.floatingSchedule().dates().back());
+        const Schedule& floatingSchedule = swap->floatingSchedule();
+        Time swapLength =  vol_->swapLength(floatingSchedule.dates().front(),
+                                            floatingSchedule.dates().back());
 
         // swapLength is rounded to whole months. To ensure we can read a variance
         // and a shift from vol_ we floor swapLength at 1/12 here therefore.
@@ -302,9 +310,9 @@ namespace QuantLib {
 
         Real stdDev = std::sqrt(variance);
         results_.additionalResults["stdDev"] = stdDev;
-        Option::Type w = (arguments_.type==Swap::Payer) ? Option::Call : Option::Put;
+        Option::Type w = (swap->type() == Swap::Payer) ? Option::Call : Option::Put;
         results_.value = Spec().value(w, strike, atmForward, stdDev, annuity, displacement);
-        
+
         Time exerciseTime = vol_->timeFromReference(exerciseDate);
         results_.additionalResults["vega"] = Spec().vega(
             strike, atmForward, stdDev, exerciseTime, annuity, displacement);
diff --git a/ql/pricingengines/swaption/g2swaptionengine.hpp b/ql/pricingengines/swaption/g2swaptionengine.hpp
index 25dce0d13c0..53d3743095a 100644
--- a/ql/pricingengines/swaption/g2swaptionengine.hpp
+++ b/ql/pricingengines/swaption/g2swaptionengine.hpp
@@ -55,11 +55,11 @@ namespace QuantLib {
             // adjust the fixed rate of the swap for the spread on the
             // floating leg (which is not taken into account by the
             // model)
-            VanillaSwap swap = *arguments_.swap;
-            swap.setPricingEngine(ext::make_shared<DiscountingSwapEngine>(model_->termStructure(), false));
-            Spread correction = swap.spread() *
-                std::fabs(swap.floatingLegBPS() / swap.fixedLegBPS());
-            Rate fixedRate = swap.fixedRate() - correction;
+            auto swap = arguments_.swap;
+            swap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(model_->termStructure(), false));
+            Spread correction = swap->spread() *
+                std::fabs(swap->floatingLegBPS() / swap->fixedLegBPS());
+            Rate fixedRate = swap->fixedRate() - correction;
 
             results_.value =  model_->swaption(arguments_, fixedRate,
                                                range_, intervals_);
diff --git a/ql/pricingengines/swaption/gaussian1dswaptionengine.cpp b/ql/pricingengines/swaption/gaussian1dswaptionengine.cpp
index a7790294fbe..f07e21d5c3b 100644
--- a/ql/pricingengines/swaption/gaussian1dswaptionengine.cpp
+++ b/ql/pricingengines/swaption/gaussian1dswaptionengine.cpp
@@ -47,11 +47,11 @@ namespace QuantLib {
                              arguments_.exercise->dates().end(), settlement) -
             arguments_.exercise->dates().begin());
 
-        VanillaSwap swap = *arguments_.swap;
+        auto swap = arguments_.swap;
         Option::Type type =
             arguments_.type == Swap::Payer ? Option::Call : Option::Put;
-        const Schedule& fixedSchedule = swap.fixedSchedule();
-        const Schedule& floatSchedule = swap.floatingSchedule();
+        const Schedule& fixedSchedule = swap->fixedSchedule();
+        const Schedule& floatSchedule = swap->floatingSchedule();
 
         Array npv0(2 * integrationPoints_ + 1, 0.0),
             npv1(2 * integrationPoints_ + 1, 0.0);
diff --git a/test-suite/basismodels.cpp b/test-suite/basismodels.cpp
index 3a85a06526e..b04bf8afaaf 100644
--- a/test-suite/basismodels.cpp
+++ b/test-suite/basismodels.cpp
@@ -25,6 +25,7 @@
 #include <ql/experimental/basismodels/tenoroptionletvts.hpp>
 #include <ql/experimental/basismodels/tenorswaptionvts.hpp>
 #include <ql/indexes/ibor/euribor.hpp>
+#include <ql/instruments/vanillaswap.hpp>
 #include <ql/instruments/swaption.hpp>
 #include <ql/pricingengines/swap/discountingswapengine.hpp>
 #include <ql/termstructures/volatility/optionlet/strippedoptionlet.hpp>
diff --git a/test-suite/libormarketmodel.cpp b/test-suite/libormarketmodel.cpp
index ba61ab296e8..d6d0b619448 100644
--- a/test-suite/libormarketmodel.cpp
+++ b/test-suite/libormarketmodel.cpp
@@ -22,6 +22,7 @@
 #include "utilities.hpp"
 #include <ql/indexes/ibor/euribor.hpp>
 #include <ql/instruments/capfloor.hpp>
+#include <ql/instruments/vanillaswap.hpp>
 #include <ql/legacy/libormarketmodels/lfmcovarproxy.hpp>
 #include <ql/legacy/libormarketmodels/lfmhullwhiteparam.hpp>
 #include <ql/legacy/libormarketmodels/lfmswaptionengine.hpp>
diff --git a/test-suite/swaption.cpp b/test-suite/swaption.cpp
index e2d2f5edcc9..553ccfd7ba7 100644
--- a/test-suite/swaption.cpp
+++ b/test-suite/swaption.cpp
@@ -28,8 +28,11 @@
 #include <ql/cashflows/iborcoupon.hpp>
 #include <ql/instruments/swaption.hpp>
 #include <ql/instruments/makevanillaswap.hpp>
+#include <ql/instruments/makeois.hpp>
 #include <ql/termstructures/yield/flatforward.hpp>
+#include <ql/termstructures/yield/zerospreadedtermstructure.hpp>
 #include <ql/indexes/ibor/euribor.hpp>
+#include <ql/indexes/ibor/eonia.hpp>
 #include <ql/time/daycounters/actual365fixed.hpp>
 #include <ql/time/daycounters/thirty360.hpp>
 #include <ql/time/schedule.hpp>
@@ -65,6 +68,7 @@ struct CommonVars {
     BusinessDayConvention floatingConvention;
     Period floatingTenor;
     ext::shared_ptr<IborIndex> index;
+    ext::shared_ptr<OvernightIndex> oisIndex;
 
     Natural settlementDays;
     RelinkableHandle<YieldTermStructure> termStructure;
@@ -89,13 +93,29 @@ struct CommonVars {
         result->setPricingEngine(engine);
         return result;
     }
+    ext::shared_ptr<Swaption> makeOISwaption(
+            const ext::shared_ptr<OvernightIndexedSwap>& swap,
+            const Date& exercise,
+            Volatility volatility,
+            Settlement::Type settlementType = Settlement::Physical,
+            Settlement::Method settlementMethod = Settlement::PhysicalOTC,
+            BlackSwaptionEngine::CashAnnuityModel model = BlackSwaptionEngine::SwapRate) const {
+        Handle<Quote> vol(ext::make_shared<SimpleQuote>(volatility));
+        auto engine = ext::make_shared<BlackSwaptionEngine>(termStructure, vol, Actual365Fixed(), 0.0, model);
+
+        auto result = ext::make_shared<Swaption>(
+                swap,
+                ext::make_shared<EuropeanExercise>(exercise),
+                settlementType, settlementMethod);
+        result->setPricingEngine(engine);
+        return result;
+    }
 
     ext::shared_ptr<PricingEngine> makeEngine(
                                               Volatility volatility,
                                               BlackSwaptionEngine::CashAnnuityModel model = BlackSwaptionEngine::SwapRate) const {
-        Handle<Quote> h(ext::shared_ptr<Quote>(new SimpleQuote(volatility)));
-        return ext::shared_ptr<PricingEngine>(
-                new BlackSwaptionEngine(termStructure, h, Actual365Fixed(), 0.0, model));
+        Handle<Quote> h(ext::make_shared<SimpleQuote>(volatility));
+        return ext::make_shared<BlackSwaptionEngine>(termStructure, h, Actual365Fixed(), 0.0, model);
     }
 
     CommonVars() {
@@ -106,6 +126,11 @@ struct CommonVars {
         fixedDayCount = Thirty360(Thirty360::BondBasis);
 
         index = ext::shared_ptr<IborIndex>(new Euribor6M(termStructure));
+        oisIndex = ext::make_shared<Eonia>(
+                Handle<YieldTermStructure>(
+                    ext::make_shared<ZeroSpreadedTermStructure>(
+                        termStructure,
+                        Handle<Quote>(ext::make_shared<SimpleQuote>(-0.01)))));
         floatingConvention = index->businessDayConvention();
         floatingTenor = index->tenor();
         calendar = index->fixingCalendar();
@@ -383,7 +408,7 @@ BOOST_AUTO_TEST_CASE(testSpreadTreatment) {
 
 BOOST_AUTO_TEST_CASE(testCachedValue) {
 
-    BOOST_TEST_MESSAGE("Testing swaption value against cached value...");
+    BOOST_TEST_MESSAGE("Testing swaption values against cached values...");
 
     bool usingAtParCoupons = IborCoupon::Settings::instance().usingAtParCoupons();
 
@@ -412,6 +437,24 @@ BOOST_AUTO_TEST_CASE(testCachedValue) {
                     std::fixed << std::setprecision(12) <<
                     "\ncalculated: " << swaption->NPV() <<
                     "\nexpected:   " << cachedNPV);
+
+    ext::shared_ptr<OvernightIndexedSwap> oiswap =
+        MakeOIS(10*Years, vars.oisIndex, 0.06)
+        .withEffectiveDate(startDate)
+        .withPaymentFrequency(Annual)
+        .withFixedLegDayCount(vars.fixedDayCount);
+
+    ext::shared_ptr<Swaption> oiswaption =
+        vars.makeOISwaption(oiswap, exerciseDate, 0.20);
+
+    cachedNPV = 0.014101075767;
+
+    if (std::fabs(oiswaption->NPV()-cachedNPV) > 1.0e-12)
+        BOOST_ERROR("failed to reproduce cached overnight-indexed swaption value:\n" <<
+                    std::fixed << std::setprecision(12) <<
+                    "\ncalculated: " << oiswaption->NPV() <<
+                    "\nexpected:   " << cachedNPV);
+
 }
 
 BOOST_AUTO_TEST_CASE(testVega) {
@@ -777,7 +820,7 @@ BOOST_AUTO_TEST_CASE(testCashSettledSwaptions) {
     }
 }
 
-BOOST_AUTO_TEST_CASE(testImpliedVolatility, *precondition(if_speed(Fast))) {
+BOOST_AUTO_TEST_CASE(testImpliedVolatility, *precondition(if_speed(Faster))) {
 
     BOOST_TEST_MESSAGE("Testing implied volatility for swaptions...");
 
@@ -868,6 +911,97 @@ BOOST_AUTO_TEST_CASE(testImpliedVolatility, *precondition(if_speed(Fast))) {
     }
 }
 
+
+BOOST_AUTO_TEST_CASE(testImpliedVolatilityOis, *precondition(if_speed(Fast))) {
+
+    BOOST_TEST_MESSAGE("Testing implied volatility for overnight-indexed swaptions...");
+
+    CommonVars vars;
+
+    Size maxEvaluations = 100;
+    Real tolerance = 1.0e-08;
+
+    Settlement::Type types[] = { Settlement::Physical, Settlement::Cash };
+    Settlement::Method methods[] = { Settlement::PhysicalOTC, Settlement::ParYieldCurve };
+    // test data
+    Rate strikes[] = { 0.02, 0.03, 0.04, 0.05, 0.06, 0.07 };
+    Volatility vols[] = { 0.01, 0.05, 0.10, 0.20, 0.30, 0.70, 0.90 };
+
+    for (auto& exercise : exercises) {
+        for (auto& length : lengths) {
+            Date exerciseDate = vars.calendar.advance(vars.today, exercise);
+            Date startDate = vars.calendar.advance(exerciseDate,
+                                                   vars.settlementDays, Days);
+
+            for (Real& strike : strikes) {
+                for (auto& k : type) {
+                    ext::shared_ptr<OvernightIndexedSwap> swap =
+                        MakeOIS(length, vars.oisIndex, strike)
+                            .withEffectiveDate(startDate)
+                            .withPaymentFrequency(Annual)
+                            .withFixedLegDayCount(vars.fixedDayCount)
+                            .withType(k);
+                    for (Size h=0; h<LENGTH(types); h++) {
+                        for (Real vol : vols) {
+                            ext::shared_ptr<Swaption> swaption =
+                                vars.makeOISwaption(swap, exerciseDate, vol, types[h], methods[h],
+                                                    BlackSwaptionEngine::DiscountCurve);
+                            // Black price
+                            Real value = swaption->NPV();
+                            Volatility implVol = 0.0;
+                            try {
+                                implVol =
+                                  swaption->impliedVolatility(value,
+                                                              vars.termStructure,
+                                                              0.10,
+                                                              tolerance,
+                                                              maxEvaluations,
+                                                              1.0e-7,
+                                                              4.0,
+                                                              ShiftedLognormal,
+                                                              0.0);
+                            } catch (std::exception& e) {
+                                // couldn't bracket?
+                                swaption->setPricingEngine(vars.makeEngine(0.0, BlackSwaptionEngine::DiscountCurve));
+                                Real value2 = swaption->NPV();
+                                if (std::fabs(value-value2) < tolerance) {
+                                    // ok, just skip:
+                                    continue;
+                                }
+                                // otherwise, report error
+                                BOOST_ERROR("implied vol failure: "
+                                            << exercise << "x" << length << " " << k
+                                            << "\nsettlement: " << types[h] << "\nstrike      "
+                                            << strike
+                                            << "\natm level:  " << io::rate(swap->fairRate())
+                                            << "\nvol:        " << io::volatility(vol)
+                                            << "\nprice:      " << value << "\n"
+                                            << e.what());
+                            }
+                            if (std::fabs(implVol - vol) > tolerance) {
+                                // the difference might not matter
+                                swaption->setPricingEngine(vars.makeEngine(implVol, BlackSwaptionEngine::DiscountCurve));
+                                Real value2 = swaption->NPV();
+                                if (std::fabs(value-value2) > tolerance) {
+                                    BOOST_ERROR("implied vol failure: "
+                                                << exercise << "x" << length << " " << k
+                                                << "\nsettlement:    " << types[h]
+                                                << "\nstrike         " << strike
+                                                << "\natm level:     " << io::rate(swap->fairRate())
+                                                << "\nvol:           " << io::volatility(vol)
+                                                << "\nprice:         " << value
+                                                << "\nimplied vol:   " << io::volatility(implVol)
+                                                << "\nimplied price: " << value2);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
 template <typename Engine>
 ext::shared_ptr<Engine> makeConstVolEngine(
     const Handle<YieldTermStructure> &discountCurve,