Use maximum/minimum instead of max/min

This change is based on the feedback from API review.

Change-Id: Ia17d061c60fcf7aa4da38542d96d75ae621f657a
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

5 files changed, 62 insertions, 62 deletions

diff --git a/src/coap/qcoapclient.cpp b/src/coap/qcoapclient.cpp
index 372128a..5469ef2 100644
--- a/src/coap/qcoapclient.cpp
+++ b/src/coap/qcoapclient.cpp
@@ -626,10 +626,10 @@ void QCoapClient::setSocketOption(QAbstractSocket::SocketOption option, const QV
     As defined in \l {RFC 7390 - Section 2.5}, \c MAX_SERVER_RESPONSE_DELAY is the expected
     maximum response delay over all servers that the client can send a multicast request to.
 */
-void QCoapClient::setMaxServerResponseDelay(uint responseDelay)
+void QCoapClient::setMaximumServerResponseDelay(uint responseDelay)
 {
     Q_D(QCoapClient);
-    QMetaObject::invokeMethod(d->protocol, "setMaxServerResponseDelay", Qt::QueuedConnection,
+    QMetaObject::invokeMethod(d->protocol, "setMaximumServerResponseDelay", Qt::QueuedConnection,
                               Q_ARG(uint, responseDelay));
 }
 
@@ -666,14 +666,14 @@ void QCoapClient::setAckRandomFactor(double ackRandomFactor)
 
 /*!
     Sets the \c MAX_RETRANSMIT value defined in \l {RFC 7252 - Section 4.2}
-    to \a maxRetransmit. This value should be less than or equal to 25.
+    to \a maximumRetransmitCount. This value should be less than or equal to 25.
     The default is 4.
 */
-void QCoapClient::setMaxRetransmit(uint maxRetransmit)
+void QCoapClient::setMaximumRetransmitCount(uint maximumRetransmitCount)
 {
     Q_D(QCoapClient);
-    QMetaObject::invokeMethod(d->protocol, "setMaxRetransmit", Qt::QueuedConnection,
-                              Q_ARG(uint, maxRetransmit));
+    QMetaObject::invokeMethod(d->protocol, "setMaximumRetransmitCount", Qt::QueuedConnection,
+                              Q_ARG(uint, maximumRetransmitCount));
 }
 
 QT_END_NAMESPACE
diff --git a/src/coap/qcoapclient.h b/src/coap/qcoapclient.h
index b64905b..7171b59 100644
--- a/src/coap/qcoapclient.h
+++ b/src/coap/qcoapclient.h
@@ -85,10 +85,10 @@ public:
     void setSecurityConfiguration(const QCoapSecurityConfiguration &configuration);
     void setBlockSize(quint16 blockSize);
     void setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value);
-    void setMaxServerResponseDelay(uint responseDelay);
+    void setMaximumServerResponseDelay(uint responseDelay);
     void setAckTimeout(uint ackTimeout);
     void setAckRandomFactor(double ackRandomFactor);
-    void setMaxRetransmit(uint maxRetransmit);
+    void setMaximumRetransmitCount(uint maximumRetransmitCount);
 
 Q_SIGNALS:
     void finished(QCoapReply *reply);
diff --git a/src/coap/qcoapprotocol.cpp b/src/coap/qcoapprotocol.cpp
index 28ee7e8..46f420c 100644
--- a/src/coap/qcoapprotocol.cpp
+++ b/src/coap/qcoapprotocol.cpp
@@ -145,7 +145,7 @@ void QCoapProtocol::sendRequest(QPointer<QCoapReply> reply, QCoapConnection *con
     });
 
     auto internalRequest = QSharedPointer<QCoapInternalRequest>::create(reply->request(), this);
-    internalRequest->setMaxTransmissionWait(maxTransmitWait());
+    internalRequest->setMaxTransmissionWait(maximumTransmitWait());
     connect(reply, &QCoapReply::finished, this, &QCoapProtocol::finished);
 
     if (internalRequest->isMulticast()) {
@@ -157,8 +157,8 @@ void QCoapProtocol::sendRequest(QPointer<QCoapReply> reply, QCoapConnection *con
         // The timeout interval is chosen based on
         // https://tools.ietf.org/html/rfc7390#section-2.5
         internalRequest->setMulticastTimeout(nonConfirmLifetime()
-                                             + maxLatency()
-                                             + maxServerResponseDelay());
+                                             + maximumLatency()
+                                             + maximumServerResponseDelay());
     }
 
     // Set a unique Message Id and Token
@@ -181,9 +181,9 @@ void QCoapProtocol::sendRequest(QPointer<QCoapReply> reply, QCoapConnection *con
     }
 
     if (requestMessage->type() == QCoapMessage::Type::Confirmable)
-        internalRequest->setTimeout(QtCoap::randomGenerator().bounded(minTimeout(), maxTimeout()));
+        internalRequest->setTimeout(QtCoap::randomGenerator().bounded(minimumTimeout(), maximumTimeout()));
     else
-        internalRequest->setTimeout(maxTimeout());
+        internalRequest->setTimeout(maximumTimeout());
 
     connect(internalRequest.data(), &QCoapInternalRequest::timeout,
             [this](QCoapInternalRequest *request) {
@@ -242,7 +242,7 @@ void QCoapProtocolPrivate::onRequestTimeout(QCoapInternalRequest *request)
         return;
 
     if (request->message()->type() == QCoapMessage::Type::Confirmable
-            && request->retransmissionCounter() < maxRetransmit) {
+            && request->retransmissionCounter() < maximumRetransmitCount) {
         sendRequest(request);
     } else {
         onRequestError(request, QtCoap::Error::TimeOut);
@@ -894,7 +894,7 @@ bool QCoapProtocolPrivate::isMessageIdRegistered(quint16 id) const
     Returns the ACK_TIMEOUT value in milliseconds.
     The default is 2000.
 
-    \sa minTimeout(), setAckTimeout()
+    \sa minimumTimeout(), setAckTimeout()
 */
 uint QCoapProtocol::ackTimeout() const
 {
@@ -923,18 +923,18 @@ double QCoapProtocol::ackRandomFactor() const
     retransmissions of a message, before notifying a timeout error.
     The default is 4.
 
-    \sa setMaxRetransmit()
+    \sa setMaximumRetransmitCount()
 */
-uint QCoapProtocol::maxRetransmit() const
+uint QCoapProtocol::maximumRetransmitCount() const
 {
     Q_D(const QCoapProtocol);
-    return d->maxRetransmit;
+    return d->maximumRetransmitCount;
 }
 
 /*!
     \internal
 
-    Returns the max block size wanted.
+    Returns the maximum block size wanted.
     The default is 0, which invites the server to choose the block size.
 
     \sa setBlockSize()
@@ -954,9 +954,9 @@ quint16 QCoapProtocol::blockSize() const
     It is the maximum time from the first transmission of a Confirmable
     message to its last retransmission.
 */
-uint QCoapProtocol::maxTransmitSpan() const
+uint QCoapProtocol::maximumTransmitSpan() const
 {
-    return static_cast<uint>(ackTimeout() * (1u << (maxRetransmit() - 1)) * ackRandomFactor());
+    return static_cast<uint>(ackTimeout() * (1u << (maximumRetransmitCount() - 1)) * ackRandomFactor());
 }
 
 /*!
@@ -969,9 +969,9 @@ uint QCoapProtocol::maxTransmitSpan() const
     message to the time when the sender gives up on receiving an
     acknowledgment or reset.
 */
-uint QCoapProtocol::maxTransmitWait() const
+uint QCoapProtocol::maximumTransmitWait() const
 {
-    return static_cast<uint>(ackTimeout() * ((1u << (maxRetransmit() + 1)) - 1)
+    return static_cast<uint>(ackTimeout() * ((1u << (maximumRetransmitCount() + 1)) - 1)
                              * ackRandomFactor());
 }
 
@@ -985,7 +985,7 @@ uint QCoapProtocol::maxTransmitWait() const
     It is the maximum time a datagram is expected to take from the start of
     its transmission to the completion of its reception.
 */
-constexpr uint QCoapProtocol::maxLatency()
+uint QCoapProtocol::maximumLatency() const
 {
     return 100 * 1000;
 }
@@ -994,12 +994,12 @@ constexpr uint QCoapProtocol::maxLatency()
     \internal
 
     Returns the minimum duration for messages timeout. The timeout is defined
-    as a random value between minTimeout() and maxTimeout(). This is a
+    as a random value between minimumTimeout() and maximumTimeout(). This is a
     convenience method identical to ackTimeout().
 
     \sa ackTimeout(), setAckTimeout()
 */
-uint QCoapProtocol::minTimeout() const
+uint QCoapProtocol::minimumTimeout() const
 {
     Q_D(const QCoapProtocol);
     return d->ackTimeout;
@@ -1010,9 +1010,9 @@ uint QCoapProtocol::minTimeout() const
 
     Returns the maximum duration for messages timeout in milliseconds.
 
-    \sa maxTimeout(), setAckTimeout(), setAckRandomFactor()
+    \sa maximumTimeout(), setAckTimeout(), setAckRandomFactor()
 */
-uint QCoapProtocol::maxTimeout() const
+uint QCoapProtocol::maximumTimeout() const
 {
     Q_D(const QCoapProtocol);
     return static_cast<uint>(d->ackTimeout * d->ackRandomFactor);
@@ -1029,7 +1029,7 @@ uint QCoapProtocol::maxTimeout() const
 */
 uint QCoapProtocol::nonConfirmLifetime() const
 {
-    return maxTransmitSpan() + maxLatency();
+    return maximumTransmitSpan() + maximumLatency();
 }
 
 /*!
@@ -1041,12 +1041,12 @@ uint QCoapProtocol::nonConfirmLifetime() const
     It is the expected maximum response delay over all servers that the client
     can send a multicast request to.
 
-    \sa setMaxServerResponseDelay()
+    \sa setMaximumServerResponseDelay()
 */
-uint QCoapProtocol::maxServerResponseDelay() const
+uint QCoapProtocol::maximumServerResponseDelay() const
 {
     Q_D(const QCoapProtocol);
-    return d->maxServerResponseDelay;
+    return d->maximumServerResponseDelay;
 }
 
 /*!
@@ -1059,7 +1059,7 @@ uint QCoapProtocol::maxServerResponseDelay() const
     reliable transmissions is a random value between ackTimeout() and
     ackTimeout() * ackRandomFactor().
 
-    \sa ackTimeout(), setAckRandomFactor(), minTimeout(), maxTimeout()
+    \sa ackTimeout(), setAckRandomFactor(), minimumTimeout(), maximumTimeout()
 */
 void QCoapProtocol::setAckTimeout(uint ackTimeout)
 {
@@ -1088,28 +1088,28 @@ void QCoapProtocol::setAckRandomFactor(double ackRandomFactor)
 /*!
     \internal
 
-    Sets the MAX_RETRANSMIT value to \a maxRetransmit, but never
+    Sets the MAX_RETRANSMIT value to \a maximumRetransmitCount, but never
     to more than 25.
     The default is 4.
 
-    \sa maxRetransmit()
+    \sa maximumRetransmitCount()
 */
-void QCoapProtocol::setMaxRetransmit(uint maxRetransmit)
+void QCoapProtocol::setMaximumRetransmitCount(uint maximumRetransmitCount)
 {
     Q_D(QCoapProtocol);
 
-    if (maxRetransmit > 25) {
-        qCWarning(lcCoapProtocol, "Max retransmit count is capped at 25.");
-        maxRetransmit = 25;
+    if (maximumRetransmitCount > 25) {
+        qCWarning(lcCoapProtocol, "Maximum retransmit count is capped at 25.");
+        maximumRetransmitCount = 25;
     }
 
-    d->maxRetransmit = maxRetransmit;
+    d->maximumRetransmitCount = maximumRetransmitCount;
 }
 
 /*!
     \internal
 
-    Sets the max block size wanted to \a blockSize.
+    Sets the maximum block size wanted to \a blockSize.
 
     The \a blockSize should be zero, or range from 16 to 1024 and be a
     power of 2. A size of 0 invites the server to choose the block size.
@@ -1143,12 +1143,12 @@ void QCoapProtocol::setBlockSize(quint16 blockSize)
     As defined in \l {RFC 7390 - Section 2.5}, \c MAX_SERVER_RESPONSE_DELAY is the expected
     maximum response delay over all servers that the client can send a multicast request to.
 
-    \sa maxServerResponseDelay()
+    \sa maximumServerResponseDelay()
 */
-void QCoapProtocol::setMaxServerResponseDelay(uint responseDelay)
+void QCoapProtocol::setMaximumServerResponseDelay(uint responseDelay)
 {
     Q_D(QCoapProtocol);
-    d->maxServerResponseDelay = responseDelay;
+    d->maximumServerResponseDelay = responseDelay;
 }
 
 QT_END_NAMESPACE
diff --git a/src/coap/qcoapprotocol_p.h b/src/coap/qcoapprotocol_p.h
index b50453f..4bd61c8 100644
--- a/src/coap/qcoapprotocol_p.h
+++ b/src/coap/qcoapprotocol_p.h
@@ -66,17 +66,17 @@ public:
 
     uint ackTimeout() const;
     double ackRandomFactor() const;
-    uint maxRetransmit() const;
+    uint maximumRetransmitCount() const;
     quint16 blockSize() const;
-    uint maxTransmitSpan() const;
-    uint maxTransmitWait() const;
-    static constexpr uint maxLatency();
+    uint maximumTransmitSpan() const;
+    uint maximumTransmitWait() const;
+    uint maximumLatency() const;
 
-    uint minTimeout() const;
-    uint maxTimeout() const;
+    uint minimumTimeout() const;
+    uint maximumTimeout() const;
 
     uint nonConfirmLifetime() const;
-    uint maxServerResponseDelay() const;
+    uint maximumServerResponseDelay() const;
 
 Q_SIGNALS:
     void finished(QCoapReply *reply);
@@ -87,9 +87,9 @@ Q_SIGNALS:
 public:
     Q_INVOKABLE void setAckTimeout(uint ackTimeout);
     Q_INVOKABLE void setAckRandomFactor(double ackRandomFactor);
-    Q_INVOKABLE void setMaxRetransmit(uint maxRetransmit);
+    Q_INVOKABLE void setMaximumRetransmitCount(uint maximumRetransmitCount);
     Q_INVOKABLE void setBlockSize(quint16 blockSize);
-    Q_INVOKABLE void setMaxServerResponseDelay(uint responseDelay);
+    Q_INVOKABLE void setMaximumServerResponseDelay(uint responseDelay);
 
 private:
     Q_INVOKABLE void sendRequest(QPointer<QCoapReply> reply, QCoapConnection *connection);
@@ -157,9 +157,9 @@ public:
     CoapExchangeMap exchangeMap;
     quint16 blockSize = 0;
 
-    uint maxRetransmit = 4;
+    uint maximumRetransmitCount = 4;
     uint ackTimeout = 2000;
-    uint maxServerResponseDelay = 250 * 1000;
+    uint maximumServerResponseDelay = 250 * 1000;
     double ackRandomFactor = 1.5;
 
     Q_DECLARE_PUBLIC(QCoapProtocol)
diff --git a/tests/auto/qcoapclient/tst_qcoapclient.cpp b/tests/auto/qcoapclient/tst_qcoapclient.cpp
index 2b914ab..6f66346 100644
--- a/tests/auto/qcoapclient/tst_qcoapclient.cpp
+++ b/tests/auto/qcoapclient/tst_qcoapclient.cpp
@@ -478,7 +478,7 @@ void tst_QCoapClient::socketError()
 void tst_QCoapClient::timeout_data()
 {
     QTest::addColumn<int>("timeout");
-    QTest::addColumn<int>("maxRetransmit");
+    QTest::addColumn<int>("maximumRetransmitCount");
 
     QTest::newRow("2000/0") << 2000 << 0;
     QTest::newRow("2000/2") << 2000 << 2;
@@ -489,13 +489,13 @@ void tst_QCoapClient::timeout()
 {
 #ifdef QT_BUILD_INTERNAL
     QFETCH(int, timeout);
-    QFETCH(int, maxRetransmit);
+    QFETCH(int, maximumRetransmitCount);
 
     QCoapClientForTests client;
     // Trigger a network timeout
     client.protocol()->setAckTimeout(timeout);
     client.protocol()->setAckRandomFactor(1);
-    client.protocol()->setMaxRetransmit(maxRetransmit);
+    client.protocol()->setMaximumRetransmitCount(maximumRetransmitCount);
     QUrl url = QUrl("coap://192.0.2.0:5683/"); // Need an url that returns nothing
 
     QElapsedTimer timeoutTimer;
@@ -508,20 +508,20 @@ void tst_QCoapClient::timeout()
     QSignalSpy spyReplyFinished(reply.data(), &QCoapReply::finished);
 
     // Check timeout upper limit
-    int transmissions = maxRetransmit + 1;
+    int transmissions = maximumRetransmitCount + 1;
 
     // 10% Precision expected at least, plus timer precision
     QTRY_COMPARE_WITH_TIMEOUT(spyReplyError.count(), 1, static_cast<int>(
-                                  1.1 * client.protocol()->maxTransmitWait() + 20 * transmissions));
+                                  1.1 * client.protocol()->maximumTransmitWait() + 20 * transmissions));
 
     // Check timeout lower limit
     qint64 elapsedTime = timeoutTimer.elapsed();
     QString errorMessage = QString("Timeout was triggered after %1ms, while expecting about %2ms")
                            .arg(QString::number(elapsedTime),
-                                QString::number(client.protocol()->maxTransmitWait()));
+                                QString::number(client.protocol()->maximumTransmitWait()));
 
     // 10% Precision expected at least, minus timer precision
-    QVERIFY2(elapsedTime > 0.9 * client.protocol()->maxTransmitWait() - 20 * transmissions,
+    QVERIFY2(elapsedTime > 0.9 * client.protocol()->maximumTransmitWait() - 20 * transmissions,
              qPrintable(errorMessage));
 
     QCOMPARE(qvariant_cast<QtCoap::Error>(spyReplyError.first().at(1)),