Index: unittests/tst_utilities.cpp
===================================================================
diff -u -re02b2d465b145702dc41965b2e7da154857eea75 -rf724589acaa51725f5e5f8a746404d01804efbcf
--- unittests/tst_utilities.cpp	(.../tst_utilities.cpp)	(revision e02b2d465b145702dc41965b2e7da154857eea75)
+++ unittests/tst_utilities.cpp	(.../tst_utilities.cpp)	(revision f724589acaa51725f5e5f8a746404d01804efbcf)
@@ -1,14 +1,15 @@
 /*!
  *
- * Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved.
- * copyright
- *          THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM,
- *          IN PART OR IN WHOLE,
- *          WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER.
+ * Copyright (c) 2020-2024 Diality Inc. - All Rights Reserved.
+ * \copyright
+ * THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN
+ * WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER.
  *
- * file    tst_utilities.cpp
- * date    01/08/2020
- * author  Behrouz NematiPour
+ * \file    tst_utilities.cpp
+ * \author  (last)      Dara Navaei
+ * \date    (last)      05-Feb-2024
+ * \author  (original)  Behrouz NematiPour
+ * \date    (original)  08-Jan-2020
  *
  */
 #include "tst_utilities.h"
@@ -18,34 +19,299 @@
 // Project
 #include "types.h"
 
+/*!
+ * \brief tst_utilities::tst_utilities
+ * \details Constructor
+ * \param   parent - QObject parent owner object.
+ *          Qt handles the children destruction by their parent objects life-cycle.
+ */
 tst_utilities::tst_utilities(QObject *parent) : QObject(parent) { }
 
-// void tst_utilities::initTestCase_data()
-// {
-// }
+void tst_utilities::tst_floatCompare_noMatch()
+{
+    QVERIFY( ! Types::floatCompare(1.002,1.003));
+}
 
-//void tst_utilities::initTestCase()
-//{
-//}
+void tst_utilities::tst_floatCompare_isMatch()
+{
+    QVERIFY(   Types::floatCompare(1.354,1.354));
+}
 
-// void tst_utilities::init()
-// {
-// }
+void tst_utilities::tst_getbits_NoError()
+{
+    QByteArray ba = QByteArray::fromHex("a5");
+    Types::Flags flg;
+    int i = 0;
+    QVERIFY(   Types::getBits(ba,i,flg,8));
+}
 
-//void tst_utilities::cleanup()
-//{
-//}
+void tst_utilities::tst_getbits_IsError()
+{
+    QByteArray ba = QByteArray::fromHex("a5");
+    Types::Flags flg;
+    int i = 0;
+    QVERIFY( ! Types::getBits(ba,i,flg,9));
+}
 
-//void tst_utilities::cleanupTestCase()
-//{
-//}
+void tst_utilities::tst_fromvariant_NoString()
+{
+    char c = 64;
+    QByteArray ba;
+    ba += '@';
+    ba += '\0';
+    ba += '\0';
+    ba += '\0';
+    QCOMPARE(Format::fromVariant(c), ba);
+}
 
-void tst_utilities::getValue_len()
+void tst_utilities::tst_fromvariant_IsString()
 {
-    Types::S32 vFlowSetPoint;
+    QCOMPARE(Format::fromVariant("@"), "@");
+}
+
+void tst_utilities::tst_fromvariant_ByteArray()
+{
+    QByteArray ba;
+    ba +=  '@';
+    ba += '\0';
+    ba += '\0';
+    ba += '\0';
+    QVariant var(ba);
+    QCOMPARE(Format::fromVariant(var), ba);
+}
+
+void tst_utilities::tst_fromvariant_Float()
+{
+    float f = 12.5;
+    QByteArray ba;
+    ba += '\0';
+    ba += '\0';
+    ba += 0x48;
+    ba += 0x41;
+    QCOMPARE(Format::fromVariant(f).toHex(), ba.toHex());
+}
+
+void tst_utilities::tst_fromvariant_UInt()
+{
+    quint32 ui = 65500;
+    QByteArray ba;
+    ba += 0xDC;
+    ba += 0xFF;
+    ba += '\0';
+    ba += '\0';
+    QCOMPARE(Format::fromVariant(ui).toHex(), ba.toHex());
+}
+
+void tst_utilities::tst_fromvariant_Int_Pos()
+{
+    qint32 pi = 32700;
+    QByteArray ba;
+    ba += 0xBC;
+    ba += 0x7F;
+    ba += '\0';
+    ba += '\0';
+    QCOMPARE(Format::fromVariant(pi).toHex(), ba.toHex());
+}
+
+void tst_utilities::tst_fromvariant_Int_Neg()
+{
+    qint32 ni = -32700;
+    QByteArray ba;
+    ba += 0x44;
+    ba += 0x80;
+    ba += 0xFF;
+    ba += 0xFF;
+    QCOMPARE(Format::fromVariant(ni).toHex(), ba.toHex());
+}
+
+void tst_utilities::tst_fromvariant_List()
+{
+    quint32      ui =  65500    ;
+    float         f =     12.5  ;
+    qint32       pi =  32700    ;
+    qint32       ni = -32700    ;
+    QVariantList vl;
+    vl +=  12.5; // float with no type is double in QVariant
+    vl +=  f;
+    vl += ui;
+    vl += pi;
+    vl += ni;
+
+    QByteArray ba;
+    ba += '\0';
+    ba += '\0';
+    ba += 0x48;
+    ba += 0x41;
+    ba += '\0';
+    ba += '\0';
+    ba += 0x48;
+    ba += 0x41;
+    ba += 0xDC;
+    ba += 0xFF;
+    ba += '\0';
+    ba += '\0';
+    ba += 0xBC;
+    ba += 0x7F;
+    ba += '\0';
+    ba += '\0';
+    ba += 0x44;
+    ba += 0x80;
+    ba += 0xFF;
+    ba += 0xFF;
+    QCOMPARE(Format::fromVariant(vl).toHex(), ba.toHex());
+}
+
+void tst_utilities::tst_fromvariant_Bool_True()
+{
+    bool b = true;
+    QByteArray ba;
+    ba += 0x01;
+    QCOMPARE(Format::fromVariant(b).toHex(), ba.toHex());
+}
+
+void tst_utilities::tst_fromvariant_Bool_False()
+{
+    bool b = false;
+    QByteArray ba;
+    ba += '\0';
+    QCOMPARE(Format::fromVariant(b).toHex(), ba.toHex());
+}
+
+void tst_utilities::tst_fromvariant_Undefined()
+{
+    QTime t; // Any undefined type which is not defined in the Format::fromVariant
+    QByteArray ba;
+    ba += '\0';
+    QCOMPARE(Format::fromVariant(t.currentTime()).toHex(), ba.toHex());
+}
+
+void tst_utilities::tst_toStringList_Default()
+{
+    const QList<const char *> data {
+        "A",
+        "B",
+        "C",
+    };
+    QStringList  mActual  = Format::toStringList(data);
+    QStringList mExpected = {
+        "A",
+        "B",
+        "C",
+    };
+    QCOMPARE(mActual, mExpected);
+}
+
+void tst_utilities::tst_toStringList_RemoveDuplicate()
+{
+    const QList<const char *> data {
+        "A",
+        "B",
+        "B",
+        "C",
+    };
+    QStringList  mActual  = Format::toStringList(data, true);
+    QStringList mExpected = {
+        "A",
+        "B",
+        "C",
+    };
+    QCOMPARE(mActual, mExpected);
+}
+
+void tst_utilities::tst_toStringList_Prefix()
+{
+    const QList<const char *> data {
+        "A",
+        "B",
+        "B",
+        "C",
+    };
+    QStringList  mActual  = Format::toStringList(data, true, "*");
+    QStringList mExpected = {
+        "*A",
+        "*B",
+        "*C",
+    };
+    QCOMPARE(mActual, mExpected);
+}
+
+void tst_utilities::tst_getValue_len_log()
+{
+    bool ok = true;
     int index = 0;
+    Types::S32 vFlowSetPoint;
     QByteArray data;
     data += 0xFF;
-    QVERIFY( ! Types::getValue<>( data, index, vFlowSetPoint   ) );
+    ok = ! GetValue( data, index, vFlowSetPoint ) && ok;
+    QVERIFY( ok );
 }
 
+void tst_utilities::tst_getValue_len_lt()
+{
+    bool ok = true;
+    int index = 0;
+    Types::S32 vP1;
+    QByteArray data;
+    data += 0x01;
+    data += 0x02;
+    data += 0x03;
+    data += 0x04;
+    data += 0x05;
+    ok = GetValue( data, index, vP1 ) && ( vP1.value == 67305985 ) && ok;
+    QVERIFY( ok );
+}
+
+void tst_utilities::tst_getValue_len_eq()
+{
+    bool ok = true;
+    int index = 0;
+    Types::S32 vP1;
+    Types::U08 vP2;
+    QByteArray data;
+    data += 0x01;
+    data += 0x02;
+    data += 0x03;
+    data += 0x04;
+    data += 0x05;
+    ok = GetValue( data, index, vP1 ) && ( vP1.value == 67305985 ) && ok;
+    ok = GetValue( data, index, vP2 ) && ( vP2.value ==        5 ) && ok;
+    QVERIFY( ok );
+}
+
+void tst_utilities::tst_getValue_len_gt()
+{
+    bool ok = true;
+    int index = 0;
+    Types::S32 vP1;
+    Types::U16 vP2;
+    QByteArray data;
+    data += 0x01;
+    data += 0x02;
+    data += 0x03;
+    data += 0x04;
+    data += 0x05;
+    ok =   GetValue( data, index, vP1 ) && ( vP1.value == 67305985 ) && ok;
+    ok = ! GetValue( data, index, vP2 ) && ( vP2.value ==        0 ) && ok;
+    QVERIFY( ok );
+}
+
+void tst_utilities::tst_safeIncrement_StepZero()
+{
+    uchar c = 0;
+    Types::safeIncrement(c, 0);
+    QCOMPARE(c, 1);
+}
+
+void tst_utilities::tst_safeIncrement_GtMaxValue_Step10()
+{
+    uchar c = 250;
+    Types::safeIncrement(c, 10);
+    QCOMPARE(c, 4);
+}
+
+void tst_utilities::tst_safeIncrement_GtMaxValue_Step1()
+{
+    uchar c = 255;
+    Types::safeIncrement(c);
+    QCOMPARE(c, 0);
+}