Diff: TESTS/Value_unit_tests.cpp

Revision:

22:a5929d3668b6

Child:

24:92c30dabfda4

diff -r 8524d815c587 -r a5929d3668b6 TESTS/Value_unit_tests.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TESTS/Value_unit_tests.cpp	Wed Sep 05 21:58:07 2018 +0000
@@ -0,0 +1,766 @@
+#include <iostream>
+#include <cstdlib>
+#include <string>
+#include <string.h>
+
+#include "Context.h"
+
+#include "Value.hpp"
+
+
+using namespace misnet;
+
+
+typedef struct {
+  Value *         value;
+  Value *         value_to_substract;
+  Value *         delta;
+  bool            expected_result;
+  bool *          flag_erreur;
+} IDGTD_struct;
+
+
+typedef struct {
+  Value *         value;
+  const char *   chaine;
+  bool *          flag_erreur;
+} GVAS_struct;
+
+
+static void testDifferencesWithDelta() {
+    Value value_1, value_to_substract, delta;
+
+    value_1.setUint8Value(220);
+    value_to_substract.setUint8Value(218);
+    delta.setUint8Value(1);
+
+    if (value_1.isAbsoluteDifferenceValueGreaterThanDelta(value_to_substract, delta) == false) {
+        DEBUG("ERREUR sur isAbsoluteDifferenceValueGreaterThanDelta de valeurs uint8 !\n");
+    }
+    else {
+        DEBUG("isAbsoluteDifferenceValueGreaterThanDelta de valeurs uint8 OK\n");
+    }
+
+    delta.setUint8Value(3);
+
+    if (value_1.isAbsoluteDifferenceValueGreaterThanDelta(value_to_substract, delta) == true) {
+        DEBUG("ERREUR sur isAbsoluteDifferenceValueGreaterThanDelta de valeurs uint8 !\n");
+    }
+    else {
+        DEBUG("isAbsoluteDifferenceValueGreaterThanDelta de valeurs uint8 OK\n");
+    }
+
+    bool erreur_bool = false;
+  bool erreur_char = false;
+  bool erreur_uint8 = false;
+  bool erreur_int8 = false;
+  bool erreur_uint16 = false;
+  bool erreur_int16 = false;
+  bool erreur_uint32 = false;
+  bool erreur_int32 = false;
+  bool erreur_float = false;
+  bool erreur_double = false;
+  bool erreur_time = false;
+
+  Value bool_value, bool_value_to_substract, bool_delta;
+  bool_value.setBoolValue(false);
+  bool_value_to_substract.setBoolValue(false);
+  bool_delta.setBoolValue(true);
+
+  Value char_value, char_value_to_substract, char_delta;
+  char_value.setCharValue('r');
+  char_value_to_substract.setCharValue('0');
+  char_delta.setCharValue('0');
+
+  Value uint8_value, uint8_value_to_substract, uint8_delta;
+  uint8_value.setUint8Value(219);
+  uint8_value_to_substract.setUint8Value(212);
+  uint8_delta.setUint8Value(5);
+
+  Value int8_value, int8_value_to_substract, int8_delta;
+  int8_value.setInt8Value(-110);
+  int8_value_to_substract.setInt8Value(-112);
+  int8_delta.setInt8Value(3);
+
+  Value uint16_value, uint16_value_to_substract, uint16_delta;
+  uint16_value.setUint16Value(1016);
+  uint16_value_to_substract.setUint16Value(12);
+  uint16_delta.setUint16Value(15);
+
+  Value int16_value, int16_value_to_substract, int16_delta;
+  int16_value.setInt16Value(1016);
+  int16_value_to_substract.setInt16Value(1015);
+  int16_delta.setInt16Value(2);
+
+  Value uint32_value, uint32_value_to_substract, uint32_delta;
+  uint32_value.setUint32Value(10161016);
+  uint32_value_to_substract.setUint32Value(10161116);
+  uint32_delta.setUint32Value(100);
+
+  Value int32_value, int32_value_to_substract, int32_delta;
+  int32_value.setInt32Value(-10160000);
+  int32_value_to_substract.setInt32Value(-10160001);
+  int32_delta.setInt32Value(15);
+
+  Value float_value, float_value_to_substract, float_delta;
+  float_value.setFloatValue(-1010.876);
+  float_value_to_substract.setFloatValue(-1010.77);
+  float_delta.setFloatValue(0.2);
+
+  Value double_value, double_value_to_substract, double_delta;
+  double_value.setDoubleValue(-1010.876543);
+  double_value_to_substract.setDoubleValue(-1010.876);
+  double_delta.setDoubleValue(0.00001);
+
+  Value time_value, time_value_to_substract, time_delta;
+  time_value.setTimeValue(1010101010);
+  time_value_to_substract.setTimeValue(1010101010);
+  time_delta.setTimeValue(10);
+
+  IDGTD_struct   tableau[50] = {
+    { &bool_value, &bool_value_to_substract, &bool_delta, false, &erreur_bool },
+    { &char_value, &char_value_to_substract, &char_delta, true, &erreur_char },
+    { &uint8_value, &uint8_value_to_substract, &uint8_delta, true, &erreur_uint8 },
+    { &int8_value, &int8_value_to_substract, &int8_delta, false, &erreur_int8 },
+    { &uint16_value, &uint16_value_to_substract, &uint16_delta, true, &erreur_uint16 },
+    { &int16_value, &int16_value_to_substract, &int16_delta, false, &erreur_int16 },
+    { &uint32_value, &uint32_value_to_substract, &uint32_delta, false, &erreur_uint32 },
+    { &int32_value, &int32_value_to_substract, &int32_delta, false, &erreur_int32 },
+    { &float_value, &float_value_to_substract, &float_delta, false, &erreur_float },
+    { &double_value, &double_value_to_substract, &double_delta, true, &erreur_double },
+    { &time_value, &time_value_to_substract, &time_delta, false, &erreur_time },
+  };
+
+  for (int i = 0; i < 11; i++) {
+    //DEBUG("Value[%d]= %s\n", i, tableau[i].value->getValueAsString().c_str());
+    if (tableau[i].value->isAbsoluteDifferenceValueGreaterThanDelta(*(tableau[i].value_to_substract),
+    *(tableau[i].delta)) != tableau[i].expected_result) {
+        DEBUG("Expected : %s, obtained : %s\n", tableau[i].expected_result ? "true" : "false",
+        tableau[i].value->isAbsoluteDifferenceValueGreaterThanDelta(*(tableau[i].value_to_substract), *(tableau[i].delta)) ? "true" : "false");
+      *(tableau[i].flag_erreur) = true;
+    }
+  }
+
+
+  if (erreur_bool) {
+    DEBUG("ERREUR sur isAbsoluteDifferenceValueGreaterThanDelta de valeurs bool !\n");
+  }
+  else {
+    DEBUG("isAbsoluteDifferenceValueGreaterThanDelta de valeurs bool OK\n");
+  }
+
+  if (erreur_char) {
+    DEBUG("ERREUR sur isAbsoluteDifferenceValueGreaterThanDelta de valeurs char !\n");
+  }
+  else {
+    DEBUG("isAbsoluteDifferenceValueGreaterThanDelta de valeurs char OK\n");
+  }
+
+  if (erreur_uint8) {
+    DEBUG("ERREUR sur isAbsoluteDifferenceValueGreaterThanDelta de valeurs uint8 !\n");
+  }
+  else {
+    DEBUG("isAbsoluteDifferenceValueGreaterThanDelta de valeurs uint8 OK\n");
+  }
+
+  if (erreur_int8) {
+    DEBUG("ERREUR sur isAbsoluteDifferenceValueGreaterThanDelta de valeurs int8 !\n");
+  }
+  else {
+    DEBUG("isAbsoluteDifferenceValueGreaterThanDelta de valeurs int8 OK\n");
+  }
+
+  if (erreur_uint16) {
+    DEBUG("ERREUR sur isAbsoluteDifferenceValueGreaterThanDelta de valeurs uint16 !\n");
+  }
+  else {
+    DEBUG("isAbsoluteDifferenceValueGreaterThanDelta de valeurs uint16 OK\n");
+  }
+
+  if (erreur_int16) {
+    DEBUG("ERREUR sur isAbsoluteDifferenceValueGreaterThanDelta de valeurs int16 !\n");
+  }
+  else {
+    DEBUG("isAbsoluteDifferenceValueGreaterThanDelta de valeurs int16 OK\n");
+  }
+
+  if (erreur_uint32) {
+    DEBUG("ERREUR sur isAbsoluteDifferenceValueGreaterThanDelta de valeurs uint32 !\n");
+  }
+  else {
+    DEBUG("isAbsoluteDifferenceValueGreaterThanDelta de valeurs uint32 OK\n");
+  }
+
+  if (erreur_int32) {
+    DEBUG("ERREUR sur isAbsoluteDifferenceValueGreaterThanDelta de valeurs int32 !\n");
+  }
+  else {
+    DEBUG("isAbsoluteDifferenceValueGreaterThanDelta de valeurs int32 OK\n");
+  }
+
+  if (erreur_float) {
+    DEBUG("ERREUR sur isAbsoluteDifferenceValueGreaterThanDelta de valeurs float !\n");
+  }
+  else {
+    DEBUG("isAbsoluteDifferenceValueGreaterThanDelta de valeurs float OK\n");
+  }
+
+  if (erreur_double) {
+    DEBUG("ERREUR sur isAbsoluteDifferenceValueGreaterThanDelta de valeurs double !\n");
+  }
+  else {
+    DEBUG("isAbsoluteDifferenceValueGreaterThanDelta de valeurs double OK\n");
+  }
+
+  if (erreur_time) {
+    DEBUG("ERREUR sur isAbsoluteDifferenceValueGreaterThanDelta de valeurs time !\n");
+  }
+  else {
+    DEBUG("isAbsoluteDifferenceValueGreaterThanDelta de valeurs time OK\n");
+  }
+}
+
+
+static void testGetValueAsString() {
+  bool erreur_bool = false;
+  bool erreur_char = false;
+  bool erreur_uint8 = false;
+  bool erreur_int8 = false;
+  bool erreur_uint16 = false;
+  bool erreur_int16 = false;
+  bool erreur_uint32 = false;
+  bool erreur_int32 = false;
+  bool erreur_float = false;
+  bool erreur_double = false;
+  bool erreur_time = false;
+
+  Value bool_val_1;
+  bool_val_1.setBoolValue(false);
+
+  Value bool_val_2;
+  bool_val_2.setBoolValue(true);
+
+  Value char_val_1;
+  char_val_1.setCharValue('r');
+
+  Value char_val_2;
+  char_val_2.setCharValue('u');
+
+  Value uint8_val_1;
+  uint8_val_1.setUint8Value(219);
+
+  Value uint8_val_2;
+  uint8_val_2.setUint8Value(100);
+
+  Value int8_val_1;
+  int8_val_1.setInt8Value(-110);
+
+  Value int8_val_2;
+  int8_val_2.setInt8Value(-7);
+
+  Value uint16_val_1;
+  uint16_val_1.setUint16Value(21905);
+
+  Value uint16_val_2;
+  uint16_val_2.setUint16Value(10098);
+
+  Value int16_val_1;
+  int16_val_1.setInt16Value(-11000);
+
+  Value int16_val_2;
+  int16_val_2.setInt16Value(-7654);
+
+  Value uint32_val_1;
+  uint32_val_1.setUint32Value(1905765786);
+
+  Value uint32_val_2;
+  uint32_val_2.setUint32Value(10098654);
+
+  Value int32_val_1;
+  int32_val_1.setInt32Value(-1010000005);
+
+  Value int32_val_2;
+  int32_val_2.setInt32Value(-76543210);
+
+  Value float_val_1;
+  float_val_1.setFloatValue(-1010.876);
+
+  Value float_val_2;
+  float_val_2.setFloatValue(-7.0/5);
+
+  Value double_val_1;
+  double_val_1.setDoubleValue(-1010.876543);
+
+  Value double_val_2;
+  double_val_2.setDoubleValue(-7.0/3);
+
+  Value time_val_1;
+  time_val_1.setTimeValue(1010101010);
+
+  GVAS_struct   tableau[50] = {
+    { &bool_val_1, "false", &erreur_bool },
+    { &bool_val_2, "true", &erreur_bool },
+    { &char_val_1, "r", &erreur_char },
+    { &char_val_2, "u", &erreur_char },
+    { &uint8_val_1, "219", &erreur_uint8 },
+    { &uint8_val_2, "100", &erreur_uint8 },
+    { &int8_val_1, "-110", &erreur_int8 },
+    { &int8_val_2, "-7", &erreur_int8 },
+    { &uint16_val_1, "21905", &erreur_uint16 },
+    { &uint16_val_2, "10098", &erreur_uint16 },
+    { &int16_val_1, "-11000", &erreur_int16 },
+    { &int16_val_2, "-7654", &erreur_int16 },
+    { &uint32_val_1, "1905765786", &erreur_uint32 },
+    { &uint32_val_2, "10098654", &erreur_uint32 },
+    { &int32_val_1, "-1010000005", &erreur_int32 },
+    { &int32_val_2, "-76543210", &erreur_int32 },
+    { &float_val_1, "-1010.876", &erreur_float },
+    { &float_val_2, "-1.4", &erreur_float },
+    { &double_val_1, "-1010.876543", &erreur_double },
+    { &double_val_2, "-2.33333", &erreur_double },
+    { &time_val_1, "1010101010", &erreur_time }
+  };
+
+  for (int i = 0; i < 21; i++) {
+    //DEBUG("Value[%d]= %s\n", i, tableau[i].value->getValueAsString().c_str());
+    if (strcmp(tableau[i].value->getValueAsString().c_str(), tableau[i].chaine) != 0) {
+        DEBUG("Expected : %s, obtained : %s\n", tableau[i].chaine, tableau[i].value->getValueAsString().c_str());
+      *(tableau[i].flag_erreur) = true;
+    }
+  }
+
+
+  if (erreur_bool) {
+    DEBUG("ERREUR sur getValueAsString de valeurs bool !\n");
+  }
+  else {
+    DEBUG("getValueAsString de valeurs bool OK\n");
+  }
+
+  if (erreur_char) {
+    DEBUG("ERREUR sur getValueAsString de valeurs char !\n");
+  }
+  else {
+    DEBUG("getValueAsString de valeurs char OK\n");
+  }
+
+  if (erreur_uint8) {
+    DEBUG("ERREUR sur getValueAsString de valeurs uint8 !\n");
+  }
+  else {
+    DEBUG("getValueAsString de valeurs uint8 OK\n");
+  }
+
+  if (erreur_int8) {
+    DEBUG("ERREUR sur getValueAsString de valeurs int8 !\n");
+  }
+  else {
+    DEBUG("getValueAsString de valeurs int8 OK\n");
+  }
+
+  if (erreur_uint16) {
+    DEBUG("ERREUR sur getValueAsString de valeurs uint16 !\n");
+  }
+  else {
+    DEBUG("getValueAsString de valeurs uint16 OK\n");
+  }
+
+  if (erreur_int16) {
+    DEBUG("ERREUR sur getValueAsString de valeurs int16 !\n");
+  }
+  else {
+    DEBUG("getValueAsString de valeurs int16 OK\n");
+  }
+
+  if (erreur_uint32) {
+    DEBUG("ERREUR sur getValueAsString de valeurs uint32 !\n");
+  }
+  else {
+    DEBUG("getValueAsString de valeurs uint32 OK\n");
+  }
+
+  if (erreur_int32) {
+    DEBUG("ERREUR sur getValueAsString de valeurs int32 !\n");
+  }
+  else {
+    DEBUG("getValueAsString de valeurs int32 OK\n");
+  }
+
+  if (erreur_float) {
+    DEBUG("ERREUR sur getValueAsString de valeurs float !\n");
+  }
+  else {
+    DEBUG("getValueAsString de valeurs float OK\n");
+  }
+
+  if (erreur_double) {
+    DEBUG("ERREUR sur getValueAsString de valeurs double !\n");
+  }
+  else {
+    DEBUG("getValueAsString de valeurs double OK\n");
+  }
+
+  if (erreur_time) {
+    DEBUG("ERREUR sur getValueAsString de valeurs time !\n");
+  }
+  else {
+    DEBUG("getValueAsString de valeurs time OK\n");
+  }
+}
+
+
+static void testSetGetValues() {
+    Value value;
+    bool erreur_bool = false;
+    bool erreur_char = false;
+    bool erreur_uint8 = false;
+    bool erreur_int8 = false;
+    bool erreur_uint16 = false;
+    bool erreur_int16 = false;
+    bool erreur_uint32 = false;
+    bool erreur_int32 = false;
+    bool erreur_float = false;
+    bool erreur_double = false;
+    bool erreur_time = false;
+
+    // Valeurs booléennes
+    value.setBoolValue(true);
+    if (value.getBoolValue() != true) {
+        erreur_bool = true;
+    }
+
+    value.setBoolValue(false);
+    if (value.getBoolValue() != false) {
+        erreur_bool = true;
+    }
+
+    if (erreur_bool) {
+        DEBUG("ERREUR sur set/get de valeurs booleennes !\n");
+    }
+    else {
+        DEBUG("Set/get de valeurs booleennes OK\n");
+    }
+
+    // Valeurs char
+    value.setCharValue('r');
+    if (value.getCharValue() != 'r') {
+        erreur_char = true;
+    }
+
+    value.setCharValue(65);
+    if (value.getCharValue() != 65) {
+        erreur_char = true;
+    }
+
+    if (erreur_char) {
+        DEBUG("ERREUR sur set/get de valeurs char !\n");
+    }
+    else {
+        DEBUG("Set/get de valeurs char OK\n");
+    }
+
+    // Valeurs uint8
+    value.setUint8Value(67);
+    if (value.getUint8Value() != 67) {
+        erreur_uint8 = true;
+    }
+
+    value.setUint8Value(0);
+    if (value.getUint8Value() != 0) {
+        erreur_uint8 = true;
+    }
+
+    if (erreur_uint8) {
+        DEBUG("ERREUR sur set/get de valeurs uint8 !\n");
+    }
+    else {
+        DEBUG("Set/get de valeurs char uint8 OK\n");
+    }
+
+    // Valeurs int8
+    value.setInt8Value(-67);
+    if (value.getInt8Value() != -67) {
+        erreur_int8 = true;
+    }
+
+    value.setInt8Value(35);
+    if (value.getInt8Value() != 35) {
+        erreur_int8 = true;
+    }
+
+    if (erreur_int8) {
+        DEBUG("ERREUR sur set/get de valeurs int8 !\n");
+    }
+    else {
+        DEBUG("Set/get de valeurs char int8\n");
+    }
+
+    // Valeurs uint16
+    value.setUint16Value(62075);
+    if (value.getUint16Value() != 62075) {
+        erreur_uint16 = true;
+    }
+
+    value.setUint16Value(133);
+    if (value.getUint16Value() != 133) {
+        erreur_uint16 = true;
+    }
+
+    if (erreur_uint16) {
+        DEBUG("ERREUR sur set/get de valeurs uint16 !\n");
+    }
+    else {
+        DEBUG("Set/get de valeurs char uint16 OK\n");
+    }
+
+    // Valeurs int16
+    value.setInt16Value(-6376);
+    if (value.getInt16Value() != -6376) {
+        erreur_int16 = true;
+    }
+
+    value.setInt16Value(3500);
+    if (value.getInt16Value() != 3500) {
+        erreur_int16 = true;
+    }
+
+    if (erreur_int16) {
+        DEBUG("ERREUR sur set/get de valeurs int16 !\n");
+    }
+    else {
+        DEBUG("Set/get de valeurs int16 OK\n");
+    }
+
+    // Valeurs uint32
+    value.setUint32Value(207576544);
+    if (value.getUint32Value() != 207576544) {
+        erreur_uint32 = true;
+    }
+
+    value.setUint32Value(3345678901);
+    if (value.getUint32Value() != 3345678901) {
+        erreur_uint32 = true;
+    }
+
+    if (erreur_uint32) {
+        DEBUG("ERREUR sur set/get de valeurs uint32 !\n");
+    }
+    else {
+        DEBUG("Set/get de valeurs char uint32 OK\n");
+    }
+
+    // Valeurs int32
+    value.setInt32Value(-620757654);
+    if (value.getInt32Value() != -620757654) {
+        erreur_int32 = true;
+    }
+
+    value.setInt32Value(1207576544);
+    if (value.getInt32Value() != 1207576544) {
+        erreur_int32 = true;
+    }
+
+    if (erreur_int32) {
+        DEBUG("ERREUR sur set/get de valeurs int32 !\n");
+    }
+    else {
+        DEBUG("Set/get de valeurs int32 OK\n");
+    }
+
+    // Valeurs float
+    value.setFloatValue(-620.7);
+    if ((value.getFloatValue() + 620.7) > 0.0001) {
+        erreur_float = true;
+    }
+
+    value.setFloatValue(12075765.1);
+    if ((value.getFloatValue() - 12075765.1) > 0.0001) {
+        erreur_float = true;
+    }
+
+    if (erreur_float) {
+        DEBUG("ERREUR sur set/get de valeurs float !\n");
+    }
+    else {
+        DEBUG("Set/get de valeurs float OK\n");
+    }
+
+    // Valeurs double
+    value.setDoubleValue(-6207854.7);
+    //DEBUG("Valeur double 1 : %f\n", value._value.value.double_value);
+    if ((value.getDoubleValue() + 6207854.7) > 0.000001) {
+        erreur_double = true;
+    }
+
+    value.setDoubleValue(1207545765.1);
+    //DEBUG("Valeur double 2 : %f\n", value._value.value.double_value);
+    if ((value.getDoubleValue() - 1207545765.1) > 0.000001) {
+        erreur_double = true;
+    }
+
+    value.setDoubleValue(-1.0 / 9);
+    //DEBUG("Valeur double 3 : %f\n", value._value.value.double_value);
+    if ((value.getDoubleValue() + (1.0 / 9)) > 0.000001) {
+        erreur_double = true;
+    }
+
+    if (erreur_double) {
+        DEBUG("ERREUR sur set/get de valeurs double !\n");
+    }
+    else {
+        DEBUG("Set/get de valeurs double OK\n");
+    }
+
+    // Valeurs time
+    value.setTimeValue(207576544);
+    if (value.getTimeValue() != 207576544) {
+        erreur_time = true;
+    }
+
+    value.setTimeValue(3345678901);
+    if (value.getTimeValue() != 3345678901) {
+        erreur_time = true;
+    }
+
+    if (erreur_time) {
+        DEBUG("ERREUR sur set/get de valeurs time !\n");
+    }
+    else {
+        DEBUG("Set/get de valeurs char time OK\n");
+    }
+}
+
+
+static void testValueComparisons() {
+  Value value1, value2;
+  value1.setBoolValue(true);
+  value2.setBoolValue(false);
+
+  if (value1.compareTo(value2) != 1) {
+    DEBUG("ERREUR sur comparaison de valeurs booleennes !\n");
+  }
+  else {
+    DEBUG("Comparaison de valeurs booleennes OK\n");
+  }
+
+  value1.setCharValue(65);
+  value2.setCharValue(64);
+
+  if (value1.compareTo(value2) != 1) {
+    DEBUG("ERREUR sur comparaison de valeurs char !\n");
+  }
+  else {
+    DEBUG("Comparaison de valeurs char OK\n");
+  }
+
+  value1.setUint8Value(0);
+  value2.setUint8Value(3);
+
+  if (value1.compareTo(value2) != -1) {
+    DEBUG("ERREUR sur comparaison de valeurs uint8 !\n");
+  }
+  else {
+    DEBUG("Comparaison de valeurs uint8 OK\n");
+  }
+
+  value1.setInt8Value(-117);
+  value2.setInt8Value(-116);
+
+  if (value1.compareTo(value2) != -1) {
+    DEBUG("ERREUR sur comparaison de valeurs int8 !\n");
+  }
+  else {
+    DEBUG("Comparaison de valeurs int8 OK\n");
+  }
+
+  value1.setUint16Value(8764);
+  value2.setUint16Value(8760);
+
+  if (value1.compareTo(value2) != 1) {
+    DEBUG("ERREUR sur comparaison de valeurs uint16 !\n");
+  }
+  else {
+    DEBUG("Comparaison de valeurs uint16 OK\n");
+  }
+
+  value1.setInt16Value(-11740);
+  value2.setInt16Value(-11664);
+
+  if (value1.compareTo(value2) != -1) {
+    DEBUG("ERREUR sur comparaison de valeurs int16 !\n");
+  }
+  else {
+    DEBUG("Comparaison de valeurs int16 OK\n");
+  }
+
+  value1.setUint32Value(87619874);
+  value2.setUint32Value(87619874);
+
+  if (value1.compareTo(value2) != 0) {
+    DEBUG("ERREUR sur comparaison de valeurs uint32 !\n");
+  }
+  else {
+    DEBUG("Comparaison de valeurs uint32 OK\n");
+  }
+
+  value1.setInt32Value(-11740765);
+  value2.setInt32Value(-11740766);
+
+  if (value1.compareTo(value2) != 1) {
+    DEBUG("ERREUR sur comparaison de valeurs int32 !\n");
+  }
+  else {
+    DEBUG("Comparaison de valeurs int32 OK\n");
+  }
+
+  value1.setFloatValue(-1174.75);
+  //DEBUG("Valeur float 1 : %f\n", value1._value.value.float_value);
+  value2.setFloatValue(-1174.74);
+  //DEBUG("Valeur float 2 : %f\n", value2._value.value.float_value);
+
+  if (value1.compareTo(value2) != -1) {
+    DEBUG("ERREUR sur comparaison de valeurs float !\n");
+  }
+  else {
+    DEBUG("Comparaison de valeurs float OK\n");
+  }
+
+  value1.setDoubleValue(0.6545);
+  value2.setDoubleValue(1.8765);
+
+  if (value1.compareTo(value2) != -1) {
+    DEBUG("ERREUR sur comparaison de valeurs double !\n");
+  }
+  else {
+    DEBUG("Comparaison de valeurs double OK\n");
+  }
+
+  value1.setTimeValue(6545);
+  value2.setTimeValue(8765);
+
+  if (value1.compareTo(value2) != -1) {
+    DEBUG("ERREUR sur comparaison de valeurs time !\n");
+  }
+  else {
+    DEBUG("Comparaison de valeurs time OK\n");
+  }
+
+  value1.setTimeValue(6545);
+  value2.setFloatValue(8765.543);
+
+  if (value1.compareTo(value2) != -2) {
+    DEBUG("ERREUR sur comparaison de valeurs de types differents !\n");
+  }
+  else {
+    DEBUG("Comparaison de valeurs de types differents OK\n");
+  }
+}
+
+
+int main(int argc, char** argv) {
+  testSetGetValues();
+  testValueComparisons();
+  testGetValueAsString();
+  testDifferencesWithDelta();
+  return 0;
+}