diff --git a/src/widgets/kernel/qlayout.cpp b/src/widgets/kernel/qlayout.cpp
index ec28581b041..c8b87540bfc 100644
--- a/src/widgets/kernel/qlayout.cpp
+++ b/src/widgets/kernel/qlayout.cpp
@@ -109,7 +109,7 @@ QLayout::QLayout(QLayoutPrivate &dd, QLayout *lay, QWidget *w)
 QLayoutPrivate::QLayoutPrivate()
     : QObjectPrivate(), insideSpacing(-1), userLeftMargin(-1), userTopMargin(-1), userRightMargin(-1),
       userBottomMargin(-1), topLevel(false), enabled(true), activated(true), autoNewChild(false),
-      constraint(QLayout::SetDefaultConstraint), menubar(nullptr)
+      horizontalConstraint(QLayout::SetDefaultConstraint), verticalConstraint(QLayout::SetDefaultConstraint), menubar(nullptr)
 {
 }
 
@@ -841,13 +841,6 @@ void QLayout::addChildWidget(QWidget *w)
         QMetaObject::invokeMethod(w, "_q_showIfNotHidden", Qt::QueuedConnection); //show later
 }
 
-
-
-
-
-
-
-
 /*!
     Tells the geometry manager to place the menu bar \a widget at the
     top of parentWidget(), outside QWidget::contentsMargins(). All
@@ -987,43 +980,127 @@ bool QLayout::activate()
     uint explMin = md->extra ? md->extra->explicitMinSize : 0;
     uint explMax = md->extra ? md->extra->explicitMaxSize : 0;
 
-    switch (d->constraint) {
-    case SetFixedSize:
-        // will trigger resize
-        mw->setFixedSize(totalSizeHint());
-        break;
-    case SetMinimumSize:
-        mw->setMinimumSize(totalMinimumSize());
-        break;
-    case SetMaximumSize:
-        mw->setMaximumSize(totalMaximumSize());
-        break;
-    case SetMinAndMaxSize:
-        mw->setMinimumSize(totalMinimumSize());
-        mw->setMaximumSize(totalMaximumSize());
-        break;
-    case SetDefaultConstraint: {
-        bool widthSet = explMin & Qt::Horizontal;
-        bool heightSet = explMin & Qt::Vertical;
-        if (mw->isWindow()) {
-            QSize ms = totalMinimumSize();
-            if (widthSet)
-                ms.setWidth(mw->minimumSize().width());
-            if (heightSet)
-                ms.setHeight(mw->minimumSize().height());
-            mw->setMinimumSize(ms);
-        } else if (!widthSet || !heightSet) {
-            QSize ms = mw->minimumSize();
-            if (!widthSet)
-                ms.setWidth(0);
-            if (!heightSet)
-                ms.setHeight(0);
-            mw->setMinimumSize(ms);
+    // Do actual calculation
+    // Result values (needs to be zero or greater to be considered valid/set)
+    // We make some illegal values different from each other due a later compare.
+    // ### In the future we may want minSize(0, 0) and maxSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX)
+    // ### Also see comment below.
+    QSize minSize(-1, -1);
+    QSize maxSize(-2, -2);
+
+    // Potentially cached values to avoid calling the same function more times.
+    constexpr QSize empty(0, 0);
+    QSize totalSzH = empty;
+    QSize totalMinSz = empty;
+    QSize totalMaxSz = empty;
+
+    switch (d->verticalConstraint) {
+        case SetFixedSize:
+            totalSzH = totalSizeHint();
+            minSize.setHeight(totalSzH.height());
+            maxSize.setHeight(totalSzH.height());
+            break;
+        case SetMinimumSize:
+            totalMinSz = totalMinimumSize();
+            minSize.setHeight(totalMinSz.height());
+            break;
+        case SetMaximumSize:
+            totalMaxSz = totalMaximumSize();
+            maxSize.setHeight(totalMaxSz.height());
+            break;
+        case SetMinAndMaxSize:
+            totalMinSz = totalMinimumSize();
+            totalMaxSz = totalMaximumSize();
+            minSize.setHeight(totalMinSz.height());
+            maxSize.setHeight(totalMaxSz.height());
+            break;
+        case SetDefaultConstraint: {
+            bool heightSet = explMin & Qt::Vertical;
+            if (mw->isWindow()) {
+                if (!heightSet) {
+                    totalMinSz = totalMinimumSize();
+                    minSize.setHeight(totalMinSz.height());
+                } else {
+                    minSize.setHeight(mw->minimumHeight());
+                }
+            } else {
+                minSize.setHeight(heightSet ? mw->minimumHeight() : 0);
+            }
+            break;
         }
-        break;
+        case SetNoConstraint:
+            break;
     }
-    case SetNoConstraint:
-        break;
+    switch (d->horizontalConstraint) {
+        case SetFixedSize:
+            if (totalSzH == empty)
+                totalSzH = totalSizeHint();
+            minSize.setWidth(totalSzH.width());
+            maxSize.setWidth(totalSzH.width());
+            break;
+        case SetMinimumSize:
+            if (totalMinSz == empty)
+                totalMinSz = totalMinimumSize();
+            minSize.setWidth(totalMinSz.width());
+            break;
+        case SetMaximumSize:
+            if (totalMaxSz == empty)
+                totalMaxSz = totalMaximumSize();
+            maxSize.setWidth(totalMaxSz.width());
+            break;
+        case SetMinAndMaxSize:
+            if (totalMinSz == empty)
+                totalMinSz = totalMinimumSize();
+            if (totalMaxSz == empty)
+                totalMaxSz = totalMaximumSize();
+
+            minSize.setWidth(totalMinSz.width());
+            maxSize.setWidth(totalMaxSz.width());
+            break;
+        case SetDefaultConstraint: {
+            const bool widthSet = explMin & Qt::Horizontal;
+            if (mw->isWindow()) {
+                if (!widthSet) {
+                    if (totalMinSz == empty)
+                        totalMinSz = totalMinimumSize();
+                    minSize.setWidth(totalMinSz.width());
+                } else {
+                    minSize.setWidth(mw->minimumWidth());
+                }
+            } else {
+                minSize.setWidth(widthSet ? mw->minimumWidth() : 0);
+            }
+            break;
+        }
+        case SetNoConstraint:
+            break;
+    }
+    if (minSize == maxSize) {
+        mw->setFixedSize(minSize);
+    }
+    else {
+        // ### To preserve backward compatibility with behavior prior to introducing separate
+        // ### horizontal and vertical constraints, we only update the specific size properties
+        // ### dictated by the constraints. For example, if only minimum width is specified
+        // ### by the constraint, we leave the minimum height untouched.
+        // ### Like before we leave unconstrained values unchanged though it can
+        // ### (unintentionally?) retain stale values.
+
+        // handle min-size
+        if (minSize.isValid())
+            mw->setMinimumSize(minSize);
+        else if (minSize.width() >= 0)
+            mw->setMinimumWidth(minSize.width());
+        else if (minSize.height() >= 0)
+            mw->setMinimumHeight(minSize.height());
+
+        // handle max-size
+        if (maxSize.isValid())
+            mw->setMaximumSize(maxSize);
+        else if (maxSize.width() >= 0)
+            mw->setMaximumWidth(maxSize.width());
+        else if (maxSize.height() >= 0)
+            mw->setMaximumHeight(maxSize.height());
     }
 
     d->doResize();
@@ -1181,51 +1258,127 @@ int QLayout::indexOf(const QLayoutItem *layoutItem) const
 
 /*!
     \enum QLayout::SizeConstraint
+    Describes how the layout constrains the size of the widget.
+
+    A vertical constraint affects the widget's height, while a horizontal constraint affects its width.
 
     The possible values are:
 
-    \value SetDefaultConstraint The main widget's minimum size is set
-                    to minimumSize(), unless the widget already has
-                    a minimum size.
+    \value SetDefaultConstraint
+           In the constrained orientation(s), the widget’s minimum extent
+           is set to \l minimumSize(), unless a minimum size has already been set.
 
-    \value SetFixedSize The main widget's size is set to sizeHint(); it
-                    cannot be resized at all.
-    \value SetMinimumSize  The main widget's minimum size is set to
-                    minimumSize(); it cannot be smaller.
+    \value SetFixedSize
+           In the constrained orientation(s), the widget’s extent is set to
+           \l sizeHint(), and it cannot be resized in that direction.
 
-    \value SetMaximumSize  The main widget's maximum size is set to
-                    maximumSize(); it cannot be larger.
+    \value SetMinimumSize
+           In the constrained orientation(s), the widget’s minimum extent
+           is set to \l minimumSize().
 
-    \value SetMinAndMaxSize  The main widget's minimum size is set to
-                    minimumSize() and its maximum size is set to
-                    maximumSize().
+    \value SetMaximumSize
+           In the constrained orientation(s), the widget’s maximum extent
+           is set to \l maximumSize().
 
-    \value SetNoConstraint  The widget is not constrained.
+    \value SetMinAndMaxSize
+           In the constrained orientation(s), the widget’s minimum extent
+           is set to \l minimumSize(), and the maximum extent is set to \l maximumSize().
 
-    \sa setSizeConstraint()
+    \value SetNoConstraint
+           No size constraints are applied to the widget.
+
+    \sa setSizeConstraint(), setSizeConstraints(), horizontalSizeConstraint(), setHorizontalSizeConstraint(), setVerticalSizeConstraint()
 */
 
 /*!
     \property QLayout::sizeConstraint
-    \brief the resize mode of the layout
+    \brief the resize mode of the layout.
+    Setting the size constraint for the dialog.
+    Setting a vertical or horizontal size constraint will override this.
 
     The default mode is \l {QLayout::SetDefaultConstraint}
     {SetDefaultConstraint}.
+
+    \sa horizontalSizeConstraint(), verticalSizeConstraint()
 */
+
 void QLayout::setSizeConstraint(SizeConstraint constraint)
 {
-    Q_D(QLayout);
-    if (constraint == d->constraint)
-        return;
+    setSizeConstraints(constraint, constraint);
+}
 
-    d->constraint = constraint;
+/*!
+ *    \brief the resize mode of the layout.
+ *    \since 6.10
+ *    Sets both the \a horizontal and \a vertical size constraint.
+ *    Provided for convenience.
+ *    \sa sizeConstraint(), horizontalSizeConstraint(), verticalSizeConstraint()
+ */
+void QLayout::setSizeConstraints(SizeConstraint horizontal, SizeConstraint vertical)
+{
+    Q_D(QLayout);
+    if (horizontal == d->horizontalConstraint && vertical == d->verticalConstraint)
+        return;
+    d->horizontalConstraint = horizontal;
+    d->verticalConstraint = vertical;
     invalidate();
 }
 
 QLayout::SizeConstraint QLayout::sizeConstraint() const
 {
     Q_D(const QLayout);
-    return d->constraint;
+    return d->horizontalConstraint;
+}
+
+/*!
+    \property QLayout::horizontalSizeConstraint
+    \since 6.10
+    \brief The horizontal size constraint.
+
+    The default mode is \l {QLayout::SetDefaultConstraint}
+
+    \sa verticalSizeConstraint(), sizeConstraint()
+*/
+
+void QLayout::setHorizontalSizeConstraint(SizeConstraint constraint)
+{
+    Q_D(QLayout);
+    if (constraint == d->horizontalConstraint)
+        return;
+    d->horizontalConstraint = constraint;
+    invalidate();
+}
+
+
+QLayout::SizeConstraint QLayout::horizontalSizeConstraint() const
+{
+    Q_D(const QLayout);
+    return d->horizontalConstraint;
+}
+
+/*!
+    \property QLayout::verticalSizeConstraint
+    \since 6.10
+    \brief The vertical size constraint.
+
+    The default mode is \l {QLayout::SetDefaultConstraint}
+
+    \sa horizontalSizeConstraint(), sizeConstraint()
+*/
+
+void QLayout::setVerticalSizeConstraint(SizeConstraint constraint)
+{
+    Q_D(QLayout);
+    if (constraint == d->verticalConstraint)
+        return;
+    d->verticalConstraint = constraint;
+    invalidate();
+}
+
+QLayout::SizeConstraint QLayout::verticalSizeConstraint() const
+{
+    Q_D(const QLayout);
+    return d->verticalConstraint;
 }
 
 /*!
diff --git a/src/widgets/kernel/qlayout.h b/src/widgets/kernel/qlayout.h
index ee7b5e047cf..3d0560fd78e 100644
--- a/src/widgets/kernel/qlayout.h
+++ b/src/widgets/kernel/qlayout.h
@@ -30,7 +30,11 @@ class Q_WIDGETS_EXPORT QLayout : public QObject, public QLayoutItem
     Q_PROPERTY(int spacing READ spacing WRITE setSpacing)
     Q_PROPERTY(QMargins contentsMargins READ contentsMargins WRITE setContentsMargins
                RESET unsetContentsMargins)
+
     Q_PROPERTY(SizeConstraint sizeConstraint READ sizeConstraint WRITE setSizeConstraint)
+    Q_PROPERTY(SizeConstraint horizontalSizeConstraint READ horizontalSizeConstraint WRITE setHorizontalSizeConstraint)
+    Q_PROPERTY(SizeConstraint verticalSizeConstraint READ verticalSizeConstraint WRITE setVerticalSizeConstraint)
+
 public:
     enum SizeConstraint {
         SetDefaultConstraint,
@@ -59,8 +63,17 @@ public:
     bool setAlignment(QLayout *l, Qt::Alignment alignment);
     using QLayoutItem::setAlignment;
 
-    void setSizeConstraint(SizeConstraint);
+    void setSizeConstraint(SizeConstraint constraint);
     SizeConstraint sizeConstraint() const;
+
+    void setSizeConstraints(SizeConstraint horizontal, SizeConstraint vertical);
+
+    void setHorizontalSizeConstraint(SizeConstraint constraint);
+    SizeConstraint horizontalSizeConstraint() const;
+
+    void setVerticalSizeConstraint(SizeConstraint constraint);
+    SizeConstraint verticalSizeConstraint() const;
+
     void setMenuBar(QWidget *w);
     QWidget *menuBar() const;
 
diff --git a/src/widgets/kernel/qlayout_p.h b/src/widgets/kernel/qlayout_p.h
index cd40a98fb7d..c1f0288c94d 100644
--- a/src/widgets/kernel/qlayout_p.h
+++ b/src/widgets/kernel/qlayout_p.h
@@ -58,7 +58,8 @@ public:
     uint enabled : 1;
     uint activated : 1;
     uint autoNewChild : 1;
-    QLayout::SizeConstraint constraint;
+    QLayout::SizeConstraint horizontalConstraint;
+    QLayout::SizeConstraint verticalConstraint;
     QRect rect;
     QWidget *menubar;
 };
diff --git a/tests/auto/widgets/kernel/qlayout/tst_qlayout.cpp b/tests/auto/widgets/kernel/qlayout/tst_qlayout.cpp
index ff19d4ff657..a5a146c1486 100644
--- a/tests/auto/widgets/kernel/qlayout/tst_qlayout.cpp
+++ b/tests/auto/widgets/kernel/qlayout/tst_qlayout.cpp
@@ -24,6 +24,62 @@
 
 #include <QtCore/qscopeguard.h>
 
+namespace {
+    class LayoutWithContent : public QGridLayout
+    {
+    public:
+        LayoutWithContent(QWidget *parentWdg) : QGridLayout(parentWdg)
+        {
+            QWidget *minMaxSizeWdg = new QWidget();
+            minMaxSizeWdg->setMinimumSize(40, 40);
+            minMaxSizeWdg->setMaximumSize(140, 140);
+            QLabel *label1 = new QLabel(QStringLiteral("This is a qt label 1"));
+            QLabel *label2 = new QLabel(QStringLiteral("This is a qt label 2"));
+            addWidget(minMaxSizeWdg, 0, 0);
+            label1->setMaximumHeight(100);
+            label2->setMaximumHeight(100);
+            label1->setMaximumWidth(100);
+            label2->setMaximumWidth(100);
+            addWidget(label1, 1, 0);
+            addWidget(label2, 0, 1);
+        }
+
+        void applySizeConstraint(SizeConstraint sc)
+        {
+            setSizeConstraint(sc);
+            activate();
+        }
+
+        void applyVerticalSizeConstraint(SizeConstraint sc)
+        {
+            setVerticalSizeConstraint(sc);
+            activate();
+        }
+
+        void applyHorizontalSizeConstraint(SizeConstraint sc)
+        {
+            setHorizontalSizeConstraint(sc);
+            activate();
+        }
+
+        void clearConstraintAndResize(QSize sz, Qt::Orientations o = Qt::Horizontal | Qt::Vertical)
+        {
+            if (o == (Qt::Horizontal | Qt::Vertical))
+                setSizeConstraint(QLayout::SizeConstraint::SetNoConstraint);
+            else if (o == Qt::Vertical)
+                setVerticalSizeConstraint(QLayout::SizeConstraint::SetNoConstraint);
+            else if (o == Qt::Horizontal)
+                setHorizontalSizeConstraint(QLayout::SizeConstraint::SetNoConstraint);
+
+            // Make sure we can always remove any set constraint as they are not removed by a change of the constraint.
+            parentWidget()->setMinimumSize(0, 0);
+            parentWidget()->setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
+            parentWidget()->resize(sz);
+            activate();
+        }
+    };
+}
+
 using namespace QTestPrivate;
 
 class tst_QLayout : public QObject
@@ -48,6 +104,14 @@ private slots:
     void adjustSizeShouldMakeSureLayoutIsActivated();
     void testRetainSizeWhenHidden();
     void removeWidget();
+    void sizeConstraints();
+
+    void checkVerticalSizeConstraint_data();
+    void checkVerticalSizeConstraint();
+    void checkHorizontalSizeConstraint_data();
+    void checkHorizontalSizeConstraint();
+private:
+    void setupDataSizeConstraint();
 };
 
 tst_QLayout::tst_QLayout()
@@ -79,9 +143,6 @@ public:
     : QFrame(0), sh(sh), msh(msh) {
         setFrameStyle(QFrame::Box | QFrame::Plain);
     }
-
-
-
     void setSizeHint(const QSize &s) { sh = s; }
     QSize sizeHint() const override { return sh; }
     QSize minimumSizeHint() const override { return msh; }
@@ -406,5 +467,223 @@ void tst_QLayout::removeWidget()
     layout.setEnabled(true);
 }
 
+void tst_QLayout::sizeConstraints()
+{
+    QWidget windowWdg;
+    auto *layout = new LayoutWithContent(&windowWdg);
+
+    // Check fixed size
+    layout->applySizeConstraint(QLayout::SizeConstraint::SetFixedSize);
+    QCOMPARE(windowWdg.size(), layout->totalSizeHint());
+    layout->clearConstraintAndResize(QSize(100, 100));
+
+    const QSize verySmall(5, 5);
+    const QSize veryBig(1500, 1500);
+
+    // Check minimumSize changes
+    layout->clearConstraintAndResize(verySmall);
+    layout->applySizeConstraint(QLayout::SizeConstraint::SetMinimumSize);
+    QCOMPARE(windowWdg.size(), layout->minimumSize());
+
+    // Check no-max on minimumSize changes
+    layout->clearConstraintAndResize(veryBig);
+    layout->applySizeConstraint(QLayout::SizeConstraint::SetMinimumSize);
+    QCOMPARE(windowWdg.size(), veryBig);
+
+    // Check maximumSize
+    layout->clearConstraintAndResize(veryBig);
+    layout->applySizeConstraint(QLayout::SizeConstraint::SetMaximumSize);
+    QCOMPARE(windowWdg.size(), layout->maximumSize());
+
+    // Check no-max on minimumSize changes
+    layout->clearConstraintAndResize(verySmall);
+    layout->applySizeConstraint(QLayout::SizeConstraint::SetMaximumSize);
+    QCOMPARE(windowWdg.size(), verySmall);
+
+    // Check min on MinMax
+    layout->clearConstraintAndResize(verySmall);
+    layout->applySizeConstraint(QLayout::SizeConstraint::SetMinAndMaxSize);
+    QCOMPARE(windowWdg.size(), layout->minimumSize());
+
+    // Check max on MinMax
+    layout->clearConstraintAndResize(veryBig);
+    layout->applySizeConstraint(QLayout::SizeConstraint::SetMinAndMaxSize);
+    QCOMPARE(windowWdg.size(), layout->maximumSize());
+
+    // Default size constaint with window
+    layout->clearConstraintAndResize(verySmall);
+    layout->applySizeConstraint(QLayout::SizeConstraint::SetDefaultConstraint);
+    QCOMPARE(windowWdg.size(), layout->totalMinimumSize());
+
+    // Default size constaint without window.
+    // It can appear weird that the default constraint removes earlier constraints in
+    // non-window mode when nothing similar happens for other constraints.
+    // So this part could *maybe* be a subject for a change.
+    // However, we need to be extremely careful as about every widget application
+    // uses layouts.
+    QWidget windowWidget;
+    QHBoxLayout *topLayout = new QHBoxLayout(&windowWidget);
+    QWidget *innerWidget = new QWidget();
+    topLayout->addWidget(innerWidget);
+    auto *layout2 = new LayoutWithContent(innerWidget);
+    // make sure we set a minimumSize (that shouldn't be explicit) here.
+    layout2->applySizeConstraint(QLayout::SizeConstraint::SetMinimumSize);
+    QCOMPARE(innerWidget->minimumSize(), layout2->totalMinimumSize());
+    // Only set here as we actually like to keep the size we had from minimumSize
+    layout2->setSizeConstraint(QLayout::SizeConstraint::SetDefaultConstraint);
+    QCOMPARE(innerWidget->minimumSize(), layout2->totalMinimumSize());
+    layout2->activate();
+    QCOMPARE(innerWidget->minimumSize(), QSize(0, 0));
+}
+
+void tst_QLayout::setupDataSizeConstraint()
+{
+    QTest::addColumn<QLayout::SizeConstraint>("constraint");
+
+    const auto constraints = {
+        QLayout::SetFixedSize,
+        QLayout::SetMinimumSize,
+        QLayout::SetMaximumSize,
+        QLayout::SetMinAndMaxSize,
+        QLayout::SetDefaultConstraint,
+        QLayout::SetNoConstraint
+    };
+
+    for (auto c : constraints) {
+        const QString desc = QLatin1String("Constraint_") + QTest::toString(c);
+        QTest::addRow("%s", qPrintable(desc)) << c;
+    }
+}
+
+void tst_QLayout::checkVerticalSizeConstraint_data()
+{
+    setupDataSizeConstraint();
+}
+
+void tst_QLayout::checkVerticalSizeConstraint()
+{
+    QFETCH(QLayout::SizeConstraint, constraint);
+
+    QWidget windowWdg;
+    auto *layout = new LayoutWithContent(&windowWdg);
+    layout->setHorizontalSizeConstraint(constraint);
+
+    // Check fixed size
+    layout->applyVerticalSizeConstraint(QLayout::SetFixedSize);
+    QCOMPARE(windowWdg.height(), layout->totalSizeHint().height());
+    layout->clearConstraintAndResize(QSize(100, 100), Qt::Vertical);
+
+    const QSize verySmall(5, 5);
+    const QSize veryBig(1500, 1500);
+
+    layout->clearConstraintAndResize(verySmall, Qt::Vertical);
+    layout->applyVerticalSizeConstraint(QLayout::SetMinimumSize);
+    QCOMPARE(windowWdg.size().height(), layout->minimumSize().height());
+
+    layout->clearConstraintAndResize(veryBig, Qt::Vertical);
+    layout->applyVerticalSizeConstraint(QLayout::SetMinimumSize);
+    QCOMPARE(windowWdg.size().height(), veryBig.height());
+
+    layout->clearConstraintAndResize(veryBig, Qt::Vertical);
+    layout->applyVerticalSizeConstraint(QLayout::SetMaximumSize);
+    QCOMPARE(windowWdg.size().height(), layout->maximumSize().height());
+
+    layout->clearConstraintAndResize(verySmall, Qt::Vertical);
+    layout->applyVerticalSizeConstraint(QLayout::SetMaximumSize);
+    QCOMPARE(windowWdg.size().height(), verySmall.height());
+
+    layout->clearConstraintAndResize(verySmall, Qt::Vertical);
+    layout->applyVerticalSizeConstraint(QLayout::SetMinAndMaxSize);
+    QCOMPARE(windowWdg.size().height(), layout->minimumSize().height());
+
+    layout->clearConstraintAndResize(veryBig, Qt::Vertical);
+    layout->applyVerticalSizeConstraint(QLayout::SetMinAndMaxSize);
+    QCOMPARE(windowWdg.size().height(), layout->maximumSize().height());
+
+    layout->clearConstraintAndResize(verySmall, Qt::Vertical);
+    layout->applyVerticalSizeConstraint(QLayout::SetDefaultConstraint);
+    QCOMPARE(windowWdg.size().height(), layout->totalMinimumSize().height());
+
+    // Inner widget check
+    QWidget windowWidget;
+    QHBoxLayout *topLayout = new QHBoxLayout(&windowWidget);
+    QWidget *innerWidget = new QWidget();
+    topLayout->addWidget(innerWidget);
+    auto *layout2 = new LayoutWithContent(innerWidget);
+    layout2->applyVerticalSizeConstraint(QLayout::SetMinimumSize);
+    QCOMPARE(innerWidget->minimumSize().height(), layout2->totalMinimumSize().height());
+    layout2->setVerticalSizeConstraint(QLayout::SetDefaultConstraint);
+    QCOMPARE(innerWidget->minimumSize().height(), layout2->totalMinimumSize().height());
+    layout2->activate();
+    QCOMPARE(innerWidget->minimumSize().height(), 0);
+}
+
+void tst_QLayout::checkHorizontalSizeConstraint_data()
+{
+    setupDataSizeConstraint();
+}
+
+void tst_QLayout::checkHorizontalSizeConstraint()
+{
+    QFETCH(QLayout::SizeConstraint, constraint);
+
+    QWidget windowWdg;
+    auto *layout = new LayoutWithContent(&windowWdg);
+    layout->setVerticalSizeConstraint(constraint);
+
+    // Fixed size
+    layout->applyHorizontalSizeConstraint(QLayout::SetFixedSize);
+    QCOMPARE(windowWdg.width(), layout->totalSizeHint().width());
+    layout->clearConstraintAndResize(QSize(100, 100), Qt::Horizontal);
+
+    const QSize verySmall(5, 5);
+    const QSize veryBig(1500, 1500);
+
+    // Minimum size
+    layout->clearConstraintAndResize(verySmall, Qt::Horizontal);
+    layout->applyHorizontalSizeConstraint(QLayout::SetMinimumSize);
+    QCOMPARE(windowWdg.size().width(), layout->minimumSize().width());
+
+    layout->clearConstraintAndResize(veryBig, Qt::Horizontal);
+    layout->applyHorizontalSizeConstraint(QLayout::SetMinimumSize);
+    QCOMPARE(windowWdg.size().width(), veryBig.width());
+
+    // Maximum size
+    layout->clearConstraintAndResize(veryBig, Qt::Horizontal);
+    layout->applyHorizontalSizeConstraint(QLayout::SetMaximumSize);
+    QCOMPARE(windowWdg.size().width(), layout->maximumSize().width());
+
+    layout->clearConstraintAndResize(verySmall, Qt::Horizontal);
+    layout->applyHorizontalSizeConstraint(QLayout::SetMaximumSize);
+    QCOMPARE(windowWdg.size().width(), verySmall.width());
+
+    // Min and Max
+    layout->clearConstraintAndResize(verySmall, Qt::Horizontal);
+    layout->applyHorizontalSizeConstraint(QLayout::SetMinAndMaxSize);
+    QCOMPARE(windowWdg.size().width(), layout->minimumSize().width());
+
+    layout->clearConstraintAndResize(veryBig, Qt::Horizontal);
+    layout->applyHorizontalSizeConstraint(QLayout::SetMinAndMaxSize);
+    QCOMPARE(windowWdg.size().width(), layout->maximumSize().width());
+
+    // Default constraint
+    layout->clearConstraintAndResize(verySmall, Qt::Horizontal);
+    layout->applyHorizontalSizeConstraint(QLayout::SetDefaultConstraint);
+    QCOMPARE(windowWdg.size().width(), layout->totalMinimumSize().width());
+
+    // Final innerWidget check
+    QWidget windowWidget;
+    QHBoxLayout *topLayout = new QHBoxLayout(&windowWidget);
+    QWidget *innerWidget = new QWidget();
+    topLayout->addWidget(innerWidget);
+    auto *layout2 = new LayoutWithContent(innerWidget);
+    layout2->applyHorizontalSizeConstraint(QLayout::SetMinimumSize);
+    QCOMPARE(innerWidget->minimumSize().width(), layout2->totalMinimumSize().width());
+    layout2->setHorizontalSizeConstraint(QLayout::SetDefaultConstraint);
+    QCOMPARE(innerWidget->minimumSize().width(), layout2->totalMinimumSize().width());
+    layout2->activate();
+    QCOMPARE(innerWidget->minimumSize().width(), 0);
+}
+
 QTEST_MAIN(tst_QLayout)
 #include "tst_qlayout.moc"