VesAgent VES7.0 updates

Issue-ID: VNFSDK-328
Change-Id: I7e06286e0f058be9b851225055f7b74dbd71ceee
Signed-off-by: PATRACHARI, GAYATHRI (gp2421) <gp2421@att.com>

2 files changed, 1022 insertions, 487 deletions

diff --git a/veslibrary/ves_clibrary/evel/evel-library/code/evel_unit/Makefile b/veslibrary/ves_clibrary/evel/evel-library/code/evel_unit/Makefile
new file mode 100644
index 0000000..1187670
--- /dev/null
+++ b/veslibrary/ves_clibrary/evel/evel-library/code/evel_unit/Makefile
@@ -0,0 +1,44 @@
+#############################################################################
+#
+# Copyright © 2017 AT&T Intellectual Property. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#############################################################################
+
+CC=gcc
+ARCH=$(shell getconf LONG_BIT)
+CODE_ROOT=$(CURDIR)/../..
+LIBS_DIR=$(CODE_ROOT)/libs/x86_$(ARCH)
+INCLUDE_DIR=$(CODE_ROOT)/code/evel_library
+
+#******************************************************************************
+# Standard compiler flags.                                                    *
+#******************************************************************************
+CPPFLAGS=
+CFLAGS=-Wall -g -fPIC
+
+all:	evel_unit
+
+clean:
+	rm -f evel_unit
+
+evel_unit: evel_unit.c
+	$(CC) $(CPPFLAGS) $(CFLAGS) -o evel_unit \
+                                    -L $(LIBS_DIR) \
+                                    -I $(INCLUDE_DIR) \
+                               evel_unit.c \
+                              -lpthread \
+                              -level \
+                              -lcurl
+
+
diff --git a/veslibrary/ves_clibrary/evel/evel-library/code/evel_unit/evel_unit.c b/veslibrary/ves_clibrary/evel/evel-library/code/evel_unit/evel_unit.c
index 3cfb66b..affb88a 100644
--- a/veslibrary/ves_clibrary/evel/evel-library/code/evel_unit/evel_unit.c
+++ b/veslibrary/ves_clibrary/evel/evel-library/code/evel_unit/evel_unit.c
@@ -30,6 +30,7 @@
 #include <assert.h>
 #include <stdlib.h>
 #include <sys/time.h>
+#include <unistd.h>
 
 #include "evel.h"
 #include "evel_internal.h"
@@ -49,35 +50,39 @@ typedef enum {
 /* Local prototypes.                                                         */
 /*****************************************************************************/
 static void test_encode_heartbeat();
-static void test_encode_header_overrides();
+//static void test_encode_header_overrides();
 static void test_encode_fault();
-static void test_encode_fault_with_escaping();
+//static void test_encode_fault_with_escaping();
 static void test_encode_measurement();
 static void test_encode_mobile_mand();
-static void test_encode_mobile_opts();
+//static void test_encode_mobile_opts();
 static void test_encode_other();
-static void test_encode_report();
-static void test_encode_service();
-static void test_encode_service_subset(const SERVICE_TEST service_test);
+static void test_encode_pnfreg();
+static void test_encode_tca();
+//static void test_encode_report();
+//static void test_encode_service();
+//static void test_encode_service_subset(const SERVICE_TEST service_test);
 static void test_encode_signaling();
+static void test_encode_voiceQ();
+static void test_encode_notif();
 static void test_encode_state_change();
 static void test_encode_syslog();
-static void test_json_response_junk();
-static void test_json_provide_throttle_state();
-static void test_json_measurement_interval();
-static void test_json_throttle_spec_field();
-static void test_json_throttle_spec_nv_pair();
-static void test_json_throttle_spec_two_domains();
-static void test_json_throttle_spec_bad_command_type();
-static void test_encode_fault_throttled();
-static void test_encode_measurement_throttled();
-static void test_encode_mobile_throttled();
-static void test_encode_other_throttled();
-static void test_encode_report_throttled();
-static void test_encode_service_throttled();
-static void test_encode_signaling_throttled();
-static void test_encode_state_change_throttled();
-static void test_encode_syslog_throttled();
+//static void test_json_response_junk();
+//static void test_json_provide_throttle_state();
+//static void test_json_measurement_interval();
+//static void test_json_throttle_spec_field();
+//static void test_json_throttle_spec_nv_pair();
+//static void test_json_throttle_spec_two_domains();
+//static void test_json_throttle_spec_bad_command_type();
+//static void test_encode_fault_throttled();
+//static void test_encode_measurement_throttled();
+//static void test_encode_mobile_throttled();
+//static void test_encode_other_throttled();
+//static void test_encode_report_throttled();
+//static void test_encode_service_throttled();
+//static void test_encode_signaling_throttled();
+//static void test_encode_state_change_throttled();
+//static void test_encode_syslog_throttled();
 static void compare_strings(char * expected,
                             char * actual,
                             int max_size,
@@ -93,9 +98,11 @@ static void compare_strings(char * expected,
  *****************************************************************************/
 int main(int argc, char ** argv)
 {
+  char * fqdn = "127.0.0.1";
+  int port = 30000;
   assert(argc >= 0);
   assert(argv != NULL);
-
+  
   /***************************************************************************/
   /* Fix our timezone to UTC.                                                */
   /***************************************************************************/
@@ -112,25 +119,65 @@ int main(int argc, char ** argv)
   functional_role = "UNIT TEST";
   log_initialize(EVEL_LOG_DEBUG, "EVEL");
 
+  /**************************************************************************/
+  /* Initialize                                                             */
+  /**************************************************************************/
+  if(evel_initialize(fqdn,                         /* FQDN                  */
+                     port,                         /* Port                  */
+                     NULL,                         /* Backup FQDN           */
+                     0,                            /* Backup port           */
+                     NULL,                         /* optional path         */
+                     NULL,                         /* optional topic        */
+                     100,                          /* Ring Buffer size      */
+                     0,                            /* HTTPS?                */
+                     0,                            /* active mode?          */
+                     NULL,                         /* cert file             */
+                     NULL,                         /* key  file             */
+                     NULL,                         /* ca   info             */
+                     NULL,                         /* ca   file             */
+                     0,                            /* verify peer           */
+                     0,                            /* verify host           */
+                     "will",                       /* Username              */
+                     "pill",                       /* Password              */
+                     "",                           /* Username2             */
+                     "",                           /* Password2             */
+                     NULL,                         /* Source ip             */
+                     NULL,                         /* Source ip2            */
+                     EVEL_SOURCE_VIRTUAL_MACHINE,  /* Source type           */
+                     "UNIT Test",                  /* Role                  */
+                     1))                           /* Verbosity             */
+  {
+    fprintf(stderr, "\nFailed to initialize the EVEL library!!!\n");
+    exit(-1);
+  }
+  else
+  {
+    printf("\nInitialization completed\n");
+  }
+
   /***************************************************************************/
   /* Test each encoder.                                                      */
   /***************************************************************************/
-  test_encode_heartbeat();
-  test_encode_header_overrides();
-  test_encode_fault();
-  test_encode_measurement();
-  test_encode_mobile_mand();
-  test_encode_mobile_opts();
-  test_encode_other();
-  test_encode_report();
-  test_encode_service();
-  test_encode_signaling();
-  test_encode_state_change();
-  test_encode_syslog();
-
+  test_encode_heartbeat(); // Done
+//  test_encode_header_overrides(); // Done
+  test_encode_fault(); // Done
+  test_encode_measurement(); //Done
+  test_encode_mobile_mand(); // Done
+//  test_encode_mobile_opts(); // Done
+  test_encode_other();  // Done
+  test_encode_pnfreg();  // Done
+  test_encode_tca(); // Done
+//  test_encode_report();
+//  test_encode_service();
+  test_encode_signaling(); // Done - sip signaling
+  test_encode_voiceQ(); //Done
+  test_encode_notif(); //Done`
+  test_encode_state_change(); //Done
+  test_encode_syslog(); // Done
   /***************************************************************************/
   /* Test JSON Throttle.                                                     */
   /***************************************************************************/
+/*************
   test_json_response_junk();
   test_json_provide_throttle_state();
   test_json_measurement_interval();
@@ -138,27 +185,27 @@ int main(int argc, char ** argv)
   test_json_throttle_spec_nv_pair();
   test_json_throttle_spec_two_domains();
   test_json_throttle_spec_bad_command_type();
-
+*************/
   /***************************************************************************/
   /* Test each encoder with throttling applied.                              */
   /***************************************************************************/
-  test_encode_fault_throttled();
-  test_encode_measurement_throttled();
-  test_encode_mobile_throttled();
-  test_encode_other_throttled();
-  test_encode_report_throttled();
-  test_encode_service_throttled();
-  test_encode_signaling_throttled();
-  test_encode_state_change_throttled();
-  test_encode_syslog_throttled();
-
+//  test_encode_fault_throttled(); // done
+//  test_encode_measurement_throttled();
+//  test_encode_mobile_throttled(); //done
+//  test_encode_other_throttled();
+//  test_encode_report_throttled();
+//  test_encode_service_throttled();
+//  test_encode_signaling_throttled();
+//  test_encode_state_change_throttled();
+//  test_encode_syslog_throttled();
   /***************************************************************************/
   /* Test character escaping.                                                */
   /***************************************************************************/
+/********
   test_encode_fault_with_escaping();
-
+*******/
   printf ("\nAll Tests Passed\n");
-
+  evel_terminate();
   return 0;
 }
 
@@ -179,15 +226,16 @@ void test_encode_heartbeat()
     "{\"event\": {"
     "\"commonEventHeader\": {"
     "\"domain\": \"heartbeat\", "
-    "\"eventId\": \"121\", "
+    "\"eventId\": \"heartbeat000000001\", "
+    "\"eventName\": \"heartbeat_VM\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 121, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
-    "\"version\": 1.2, "
+    "\"version\": 3.0, "
     "\"eventType\": \"Autonomous heartbeat\", "
     "\"reportingEntityId\": \"Dummy VM UUID - No Metadata available\", "
     "\"sourceId\": \"Dummy VM UUID - No Metadata available\""
@@ -199,7 +247,7 @@ void test_encode_heartbeat()
   /***************************************************************************/
   /* Test the VM name/uuid once.                                             */
   /***************************************************************************/
-  evel_set_next_event_sequence(121);
+//  evel_set_next_event_sequence(121);
 
   EVENT_HEADER * heartbeat = evel_new_heartbeat();
   assert(heartbeat != NULL);
@@ -209,7 +257,16 @@ void test_encode_heartbeat()
   compare_strings(expected, json_body, EVEL_MAX_JSON_BODY, "Heartbeat");
   assert((json_size == strlen(json_body)) && "Bad size returned");
 
-  evel_free_event(heartbeat);
+  if(evel_post_event(heartbeat) == EVEL_SUCCESS)
+  {
+    printf("Message sent to Collector successfully\n");
+  }
+  else
+  {
+    printf("Message sending Error\n");
+  }
+
+//  evel_free_event(heartbeat);
 }
 
 void test_encode_header_overrides()
@@ -219,17 +276,15 @@ void test_encode_header_overrides()
     "\"commonEventHeader\": {"
     "\"domain\": \"heartbeat\", "
     "\"eventId\": \"121\", "
-    "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000, "
     "\"priority\": \"Normal\", "
     "\"reportingEntityName\": \"entity_name_override\", "
     "\"sequence\": 121, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1001, "
     "\"version\": 1.2, "
     "\"eventType\": \"Autonomous heartbeat\", "
-    "\"reportingEntityId\": \"entity_id_override\", "
-    "\"sourceId\": \"Dummy VM UUID - No Metadata available\""
+    "\"reportingEntityId\": \"entity_id_override\" "
     "}}}";
 
   size_t json_size = 0;
@@ -238,7 +293,7 @@ void test_encode_header_overrides()
   /***************************************************************************/
   /* Test the VM name/uuid once.                                             */
   /***************************************************************************/
-  evel_set_next_event_sequence(121);
+//  evel_set_next_event_sequence(121);
 
   EVENT_HEADER * heartbeat = evel_new_heartbeat();
   assert(heartbeat != NULL);
@@ -247,6 +302,8 @@ void test_encode_header_overrides()
   evel_last_epoch_set(heartbeat, 1000);
   evel_reporting_entity_name_set(heartbeat, "entity_name_override");
   evel_reporting_entity_id_set(heartbeat, "entity_id_override");
+  evel_event_sequence_set(heartbeat, 121);
+  evel_time_zone_offset_set(heartbeat, "UTC+5:30");
 
   json_size = evel_json_encode_event(
     json_body, EVEL_MAX_JSON_BODY, (EVENT_HEADER *) heartbeat);
@@ -262,13 +319,13 @@ void test_encode_fault()
     "{\"event\": {"
     "\"commonEventHeader\": {"
     "\"domain\": \"fault\", "
-    "\"eventId\": \"122\", "
-    "\"functionalRole\": \"UNIT TEST\", "
+    "\"eventId\": \"fault000000001\", "
+    "\"eventName\": \"fault_eNodeB_alarm\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 122, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2, "
     "\"eventType\": \"Bad things happen...\", "
@@ -293,40 +350,52 @@ void test_encode_fault()
 
   size_t json_size = 0;
   char json_body[EVEL_MAX_JSON_BODY];
-  evel_set_next_event_sequence(122);
-  EVENT_FAULT * fault = evel_new_fault("My alarm condition",
+//  evel_set_next_event_sequence(122);
+  EVENT_FAULT * fault = evel_new_fault("fault_eNodeB_alarm", 
+                                       "fault000000001", 
+                                       "My alarm condition",
                                        "It broke very badly",
                                        EVEL_PRIORITY_NORMAL,
                                        EVEL_SEVERITY_MAJOR,
 					EVEL_SOURCE_HOST,
-                             EVEL_VF_STATUS_PREP_TERMINATE);
+                             EVEL_VF_STATUS_READY_TERMINATE);
   assert(fault != NULL);
   evel_fault_type_set(fault, "Bad things happen...");
   evel_fault_interface_set(fault, "My Interface Card");
   evel_fault_addl_info_add(fault, "name1", "value1");
   evel_fault_addl_info_add(fault, "name2", "value2");
+evel_fault_category_set(fault, "link");
 
   json_size = evel_json_encode_event(
     json_body, EVEL_MAX_JSON_BODY, (EVENT_HEADER *) fault);
   compare_strings(expected, json_body, EVEL_MAX_JSON_BODY, "Fault");
   assert((json_size == strlen(json_body)) && "Bad size returned");
 
-  evel_free_event(fault);
-}
+  if(evel_post_event((EVENT_HEADER *)fault) == EVEL_SUCCESS)
+  {
+    printf("Message sent to Collector successfully\n");
+  }
+  else
+  {
+    printf("Message sending Error\n");
+  }
 
+ // evel_free_event(fault);
+}
 void test_encode_measurement()
 {
   char * expected =
     "{\"event\": "
     "{\"commonEventHeader\": {"
     "\"domain\": \"measurementsForVfScaling\", "
-    "\"eventId\": \"123\", "
+    "\"eventId\": \"mvfs000000001\", "
+    "\"eventName\": \"mvfs_perfUnit_issue\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 3000, "
     "\"priority\": \"Normal\", "
     "\"reportingEntityName\": \"entity_name\", "
     "\"sequence\": 123, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 2000, "
     "\"version\": 1.2, "
     "\"eventType\": \"Perf management...\", "
@@ -424,18 +493,21 @@ void test_encode_measurement()
   char json_body[EVEL_MAX_JSON_BODY];
   EVENT_MEASUREMENT * measurement = NULL;
   MEASUREMENT_LATENCY_BUCKET * bucket = NULL;
-  MEASUREMENT_VNIC_PERFORMANCE * vnic_use = NULL;
   MEASUREMENT_CPU_USE *cpu_use;
-
-  /***************************************************************************/
-  /* Measurement.                                                            */
-  /***************************************************************************/
-  evel_set_next_event_sequence(123);
-  measurement = evel_new_measurement(5.5);
+  MEASUREMENT_MEM_USE * mem_use;
+  MEASUREMENT_DISK_USE * disk_use;
+//  evel_set_next_event_sequence(123);
+  measurement = evel_new_measurement(5.5,"mvfs_perfUnit_issue", "mvfs000000001");
   assert(measurement != NULL);
   evel_measurement_type_set(measurement, "Perf management...");
+  evel_measurement_addl_info_add(measurement, "name1", "value1");
+//  evel_measurement_addl_info_add(measurement, "name2", "value2");
+//  evel_measurement_addl_info_add(measurement, "name3", "value3");
+//  evel_measurement_addl_info_add(measurement, "name4", "value4");
+
   evel_measurement_conc_sess_set(measurement, 1);
   evel_measurement_cfg_ents_set(measurement, 2);
+
   evel_measurement_mean_req_lat_set(measurement, 4.4);
   evel_measurement_request_rate_set(measurement, 7);
 
@@ -448,7 +520,14 @@ void test_encode_measurement()
   evel_measurement_cpu_use_system_set(cpu_use,77.77);
   evel_measurement_cpu_use_usageuser_set(cpu_use,88.88);
   evel_measurement_cpu_use_wait_set(cpu_use,99.99);
-
+  evel_measurement_cpu_use_cpuCapacityContention_set(cpu_use,12.2);
+  evel_measurement_cpu_use_cpuDemandAvg_set(cpu_use,14.4);
+  evel_measurement_cpu_use_cpuDemandMhz_set(cpu_use,15.4);
+  evel_measurement_cpu_use_cpuDemandPct_set(cpu_use,16.4);
+  evel_measurement_cpu_use_cpuLatencyAvg_set(cpu_use,17.4);
+  evel_measurement_cpu_use_cpuOverheadAvg_set(cpu_use,18.4);
+  evel_measurement_cpu_use_cpuSwapWaitTime_set(cpu_use,19.4);
+/**************
   cpu_use = evel_measurement_new_cpu_use_add(measurement, "cpu2", 22.22);
   evel_measurement_cpu_use_idle_set(cpu_use,12.22);
   evel_measurement_cpu_use_interrupt_set(cpu_use,33.33);
@@ -458,74 +537,294 @@ void test_encode_measurement()
   evel_measurement_cpu_use_system_set(cpu_use,77.77);
   evel_measurement_cpu_use_usageuser_set(cpu_use,88.88);
   evel_measurement_cpu_use_wait_set(cpu_use,19.99);
-
+  evel_measurement_cpu_use_cpuCapacityContention_set(cpu_use,22.2);
+  evel_measurement_cpu_use_cpuDemandAvg_set(cpu_use,24.4);
+  evel_measurement_cpu_use_cpuDemandMhz_set(cpu_use,25.4);
+  evel_measurement_cpu_use_cpuDemandPct_set(cpu_use,26.4);
+  evel_measurement_cpu_use_cpuLatencyAvg_set(cpu_use,27.4);
+  evel_measurement_cpu_use_cpuOverheadAvg_set(cpu_use,28.4);
+  evel_measurement_cpu_use_cpuSwapWaitTime_set(cpu_use,29.4);
+***************/
+  mem_use = evel_measurement_new_mem_use_add(measurement, "VMID", 120, 150);
+  evel_measurement_mem_use_memcache_set(mem_use, 121.7);
+  evel_measurement_mem_use_memconfig_set(mem_use, 122.7);
+  evel_measurement_mem_use_slab_reclaimed_set(mem_use, 123.7);
+  evel_measurement_mem_use_slab_unreclaimable_set(mem_use, 124.7);
+  evel_measurement_mem_use_memoryDemand_set(mem_use, 125.7);
+  evel_measurement_mem_use_memoryLatencyAvg_set(mem_use, 126.7);
+  evel_measurement_mem_use_memorySharedAvg_set(mem_use, 127.7);
+  evel_measurement_mem_use_memorySwapInAvg_set(mem_use, 128.7);
+  evel_measurement_mem_use_memorySwapInRateAvg_set(mem_use, 129.7);
+  evel_measurement_mem_use_memorySwapOutAvg_set(mem_use, 130.7);
+  evel_measurement_mem_use_memorySwapOutRateAvg_set(mem_use, 131.7);
+  evel_measurement_mem_use_memorySwapUsedAvg_set(mem_use, 132.7);
+  evel_measurement_mem_use_percentMemoryUsage_set(mem_use, 133.7);
+  
+  mem_use = evel_measurement_new_mem_use_add(measurement, "VMID2", 220, 250);
+  evel_measurement_mem_use_mem_buffered_set(mem_use, 100.4);
+  evel_measurement_mem_use_memcache_set(mem_use, 221.7);
+  evel_measurement_mem_use_memconfig_set(mem_use, 222.7);
+  evel_measurement_mem_use_slab_reclaimed_set(mem_use, 223.7);
+  evel_measurement_mem_use_slab_unreclaimable_set(mem_use, 224.7);
+  evel_measurement_mem_use_memoryDemand_set(mem_use, 225.7);
+  evel_measurement_mem_use_memoryLatencyAvg_set(mem_use, 226.7);
+  evel_measurement_mem_use_memorySharedAvg_set(mem_use, 227.7);
+  evel_measurement_mem_use_memorySwapInAvg_set(mem_use, 228.7);
+  evel_measurement_mem_use_memorySwapInRateAvg_set(mem_use, 229.7);
+  evel_measurement_mem_use_memorySwapOutAvg_set(mem_use, 230.7);
+  evel_measurement_mem_use_memorySwapOutRateAvg_set(mem_use, 231.7);
+  evel_measurement_mem_use_memorySwapUsedAvg_set(mem_use, 232.7);
+  evel_measurement_mem_use_percentMemoryUsage_set(mem_use, 233.7);
+
+  disk_use = evel_measurement_new_disk_use_add(measurement, "Disk1");
+  evel_measurement_disk_use_iotimeavg_set(disk_use, 11.1);
+  evel_measurement_disk_use_iotimelast_set(disk_use, 12.1);
+  evel_measurement_disk_use_iotimemax_set(disk_use, 13.1);
+  evel_measurement_disk_use_iotimemin_set(disk_use, 14.1);
+  evel_measurement_disk_use_mergereadavg_set(disk_use, 15.1);
+  evel_measurement_disk_use_mergereadlast_set(disk_use, 16.1);
+  evel_measurement_disk_use_mergereadmax_set(disk_use, 17.1);
+  evel_measurement_disk_use_mergereadmin_set(disk_use, 18.1);
+  evel_measurement_disk_use_mergewritelast_set(disk_use, 19.1);
+  evel_measurement_disk_use_mergewritemax_set(disk_use, 20.1);
+  evel_measurement_disk_use_mergewriteavg_set(disk_use, 30.1);
+  evel_measurement_disk_use_mergewritemin_set(disk_use, 40.1);
+  evel_measurement_disk_use_octetsreadavg_set(disk_use, 50.1);
+  evel_measurement_disk_use_octetsreadlast_set(disk_use, 60.1);
+  evel_measurement_disk_use_octetsreadmax_set(disk_use, 70.1);
+  evel_measurement_disk_use_octetsreadmin_set(disk_use, 80.1);
+  evel_measurement_disk_use_octetswriteavg_set(disk_use, 90.1);
+  evel_measurement_disk_use_octetswritelast_set(disk_use,110.1);
+  evel_measurement_disk_use_octetswritemax_set(disk_use, 120.1);
+  evel_measurement_disk_use_octetswritemin_set(disk_use, 130.1);
+  evel_measurement_disk_use_opsreadavg_set(disk_use, 140.1);
+  evel_measurement_disk_use_opsreadlast_set(disk_use, 150.1);
+  evel_measurement_disk_use_opsreadmax_set(disk_use, 160.1);
+  evel_measurement_disk_use_opsreadmin_set(disk_use, 170.1);
+  evel_measurement_disk_use_opswriteavg_set(disk_use, 180.1);
+  evel_measurement_disk_use_opswritelast_set(disk_use, 190.1);
+  evel_measurement_disk_use_opswritemax_set(disk_use, 210.1);
+  evel_measurement_disk_use_opswritemin_set(disk_use, 310.1);
+  evel_measurement_disk_use_pendingopsavg_set(disk_use, 410.1);
+  evel_measurement_disk_use_pendingopslast_set(disk_use, 610.1);
+  evel_measurement_disk_use_pendingopsmax_set(disk_use, 710.1);
+  evel_measurement_disk_use_pendingopsmin_set(disk_use, 810.1);
+  evel_measurement_disk_use_timereadavg_set(disk_use, 910.1);
+  evel_measurement_disk_use_timereadlast_set(disk_use, 10.2);
+  evel_measurement_disk_use_timereadmax_set(disk_use, 10.33);
+  evel_measurement_disk_use_timereadmin_set(disk_use, 10.4);
+  evel_measurement_disk_use_timewriteavg_set(disk_use, 10.5);
+  evel_measurement_disk_use_timewritelast_set(disk_use, 10.6);
+  evel_measurement_disk_use_timewritemax_set(disk_use, 10.7);
+  evel_measurement_disk_use_timewritemin_set(disk_use, 10.8);
+  evel_measurement_disk_use_diskBusResets_set(disk_use, 10.9);
+  evel_measurement_disk_use_diskCommandsAborted_set(disk_use, 10.1);
+  evel_measurement_disk_use_diskTime_set(disk_use, 10.1);
+  evel_measurement_disk_use_diskFlushRequests_set(disk_use, 10.1);
+  evel_measurement_disk_use_diskFlushTime_set(disk_use, 10.1);
+  evel_measurement_disk_use_diskCommandsAvg_set(disk_use, 10.1);
+  evel_measurement_disk_use_diskReadCommandsAvg_set(disk_use, 10.1);
+  evel_measurement_disk_use_diskWriteCommandsAvg_set(disk_use, 10.1);
+  evel_measurement_disk_use_diskTotalReadLatencyAvg_set(disk_use, 10.1);
+  evel_measurement_disk_use_diskTotalWriteLatencyAvg_set(disk_use, 10.1);
+  evel_measurement_disk_use_diskWeightedIoTimeAvg_set(disk_use, 10.1);
+  evel_measurement_disk_use_diskWeightedIoTimeLast_set(disk_use, 10.1);
+  evel_measurement_disk_use_diskWeightedIoTimeMax_set(disk_use, 10.1);
+  evel_measurement_disk_use_diskWeightedIoTimeMin_set(disk_use, 10.1);
+ 
 
   evel_measurement_fsys_use_add(measurement,"00-11-22",100.11, 100.22, 33,
                                 200.11, 200.22, 44);
   evel_measurement_fsys_use_add(measurement,"33-44-55",300.11, 300.22, 55,
                                 400.11, 400.22, 66);
-  evel_start_epoch_set(&measurement->header, 2000);
-  evel_last_epoch_set(&measurement->header, 3000);
-  evel_reporting_entity_name_set(&measurement->header, "entity_name");
-  evel_reporting_entity_id_set(&measurement->header, "entity_id");
+  evel_measurement_feature_use_add(measurement, "FeatureA", "123");
+  evel_measurement_feature_use_add(measurement, "FeatureB", "567");
+
+  HASHTABLE_T *ht1;
+  ht1 = evel_measurement_new_addl_measurement(measurement, "hmNam1");
+  evel_measurement_addl_measurement_set(ht1, "hmkey1", "hmVal1");
+  evel_measurement_addl_measurement_set(ht1, "hmkey2", "hmVal2");
+  evel_measurement_addl_measurement_set(ht1, "hmkey3", "hmVal3");
+  evel_measurement_addl_measurement_set(ht1, "hmkey4", "hmVal4");
+
+  ht1 = evel_measurement_new_addl_measurement(measurement, "hmNam2");
+  evel_measurement_addl_measurement_set(ht1, "hmkey21", "hmVal21");
+  evel_measurement_addl_measurement_set(ht1, "hmkey22", "hmVal22");
+  evel_measurement_addl_measurement_set(ht1, "hmkey23", "hmVal23");
+  evel_measurement_addl_measurement_set(ht1, "hmkey24", "hmVal24");
+
+  evel_measurement_codec_use_add(measurement, "G711a", 91);
+  evel_measurement_codec_use_add(measurement, "G729ab", 92);
+  
+  evel_measurement_media_port_use_set(measurement, 55);
+  evel_measurement_vnfc_scaling_metric_set(measurement, 66);
 
-  /***************************************************************************/
-  /* Latency Bucket with no optional parameters.                             */
-  /***************************************************************************/
   bucket = evel_new_meas_latency_bucket(20);
+  evel_meas_latency_bucket_low_end_set(bucket, 50.0);
+  evel_meas_latency_bucket_high_end_set(bucket, 60.0);
   evel_meas_latency_bucket_add(measurement, bucket);
 
-  /***************************************************************************/
-  /* Latency Bucket with all optional parameters.                            */
-  /***************************************************************************/
   bucket = evel_new_meas_latency_bucket(30);
   evel_meas_latency_bucket_low_end_set(bucket, 10.0);
   evel_meas_latency_bucket_high_end_set(bucket, 20.0);
   evel_meas_latency_bucket_add(measurement, bucket);
 
-  /***************************************************************************/
-  /* vNIC Use with no optional parameters.                                   */
-  /***************************************************************************/
-  vnic_use = evel_new_measurement_vnic_use("eth0", 100, 200, 3, 4);
-  evel_meas_vnic_use_add(measurement, vnic_use);
-
-  /***************************************************************************/
-  /* vNIC Use with all optional parameters.                                  */
-  /***************************************************************************/
-  vnic_use = evel_new_measurement_vnic_use("eth1", 110, 240, 13, 14);
-  evel_vnic_use_bcast_pkt_in_set(vnic_use, 11);
-  evel_vnic_use_bcast_pkt_out_set(vnic_use, 12);
-  evel_vnic_use_mcast_pkt_in_set(vnic_use, 15);
-  evel_vnic_use_mcast_pkt_out_set(vnic_use, 16);
-  evel_vnic_use_ucast_pkt_in_set(vnic_use, 17);
-  evel_vnic_use_ucast_pkt_out_set(vnic_use, 18);
-  evel_meas_vnic_use_add(measurement, vnic_use);
-
-  evel_measurement_errors_set(measurement, 1, 0, 2, 1);
-
-  evel_measurement_feature_use_add(measurement, "FeatureA", 123);
-  evel_measurement_feature_use_add(measurement, "FeatureB", 567);
-
-  evel_measurement_codec_use_add(measurement, "G711a", 91);
-  evel_measurement_codec_use_add(measurement, "G729ab", 92);
-
-  evel_measurement_media_port_use_set(measurement, 1234);
-
-  evel_measurement_vnfc_scaling_metric_set(measurement, 1234.5678);
+  evel_measurement_latency_add(measurement, 70.0, 90.0, 40);
+
+  MEASUREMENT_NIC_PERFORMANCE * nic_per;
+  nic_per = evel_measurement_new_nic_performance("eth0", "true");
+  evel_nic_performance_administrativeState_set(nic_per, EVEL_OPER_STATE_OUT_OF_SERVICE);
+  evel_nic_performance_operationalState_set(nic_per, EVEL_OPER_STATE_IN_SERVICE);
+  evel_nic_performance_receivedPercentDiscard_set(nic_per, 222.33); 
+  evel_nic_performance_receivedPercentError_set(nic_per, 222.33);
+  evel_nic_performance_receivedUtilization_set(nic_per, 222.33);
+  evel_nic_performance_speed_set(nic_per, 222.33);
+  evel_nic_performance_transmittedPercentDiscard_set(nic_per, 222.33);
+  evel_nic_performance_transmittedPercentError_set(nic_per, 222.33);
+  evel_nic_performance_transmittedUtilization_set(nic_per, 222.33);
+  evel_nic_performance_rx_bcast_pkt_acc_set(nic_per, 222.33);
+  evel_nic_performance_rx_bcast_pkt_delta_set(nic_per, 222.33);
+  evel_nic_performance_rx_discard_pkt_acc_set(nic_per, 222.33);
+  evel_nic_performance_rx_discard_pkt_delta_set(nic_per, 222.33);
+  evel_nic_performance_rx_error_pkt_acc_set(nic_per, 222.33);
+  evel_nic_performance_rx_error_pkt_delta_set(nic_per, 222.33);
+  evel_nic_performance_rx_mcast_pkt_acc_set(nic_per, 222.33);
+  evel_nic_performance_rx_mcast_pkt_delta_set(nic_per, 222.33);
+  evel_nic_performance_rx_octets_acc_set(nic_per, 222.33);
+  evel_nic_performance_rx_octets_delta_set(nic_per, 222.33);
+  evel_nic_performance_rx_total_pkt_acc_set(nic_per, 222.33);
+  evel_nic_performance_rx_total_pkt_delta_set(nic_per, 222.33);
+  evel_nic_performance_rx_ucast_pkt_acc_set(nic_per, 222.33);
+  evel_nic_performance_rx_ucast_pkt_delta_set(nic_per, 222.33);
+  evel_nic_performance_tx_bcast_pkt_acc_set(nic_per, 222.33);
+  evel_nic_performance_tx_bcast_pkt_delta_set(nic_per, 222.33);
+  evel_nic_performance_tx_discarded_pkt_acc_set(nic_per, 222.33);
+  evel_nic_performance_tx_discarded_pkt_delta_set(nic_per, 222.33);
+  evel_nic_performance_tx_error_pkt_acc_set(nic_per, 222.33);
+  evel_nic_performance_tx_error_pkt_delta_set(nic_per, 222.33);
+  evel_nic_performance_tx_mcast_pkt_acc_set(nic_per, 222.33);
+  evel_nic_performance_tx_mcast_pkt_delta_set(nic_per, 222.33);
+  evel_nic_performance_tx_octets_acc_set(nic_per, 222.33);
+  evel_nic_performance_tx_octets_delta_set(nic_per, 222.33);
+  evel_nic_performance_tx_total_pkt_acc_set(nic_per, 222.33);
+  evel_nic_performance_tx_total_pkt_delta_set(nic_per, 222.33);
+  evel_nic_performance_tx_ucast_pkt_acc_set(nic_per, 222.33);
+  evel_nic_performance_tx_ucast_pkt_delta_set(nic_per, 222.33);
+
+  evel_meas_nic_performance_add(measurement, nic_per);
+/*************
+  evel_measurement_nic_performance_add(measurement, "ens03", "false",
+    EVEL_OPER_STATE_IN_SERVICE, EVEL_OPER_STATE_OUT_OF_SERVICE,
+    11.66,  11.66, 11.66, 11.66, 11.66, 11.66, 11.66, 11.66, 11.66, 11.66,
+    11.66, 11.66, 11.66, 11.66, 11.66, 11.66, 11.66, 11.66, 11.66, 11.66,
+    11.66, 11.66, 11.66, 11.66, 11.66, 11.66, 11.66, 11.66, 11.66, 11.66,
+    11.66, 11.66, 11.66, 11.66, 11.66);
+**********/
+  MEASUREMENT_IPMI *ipmi;
+  ipmi = evel_measurement_new_ipmi_add(measurement);
+  evel_measurement_ipmi_exitAirTemperature_set(ipmi, 98.4);
+  evel_measurement_ipmi_frontPanelTemperature_set(ipmi, 98.4);
+  evel_measurement_ipmi_ioModuleTemperature_set(ipmi, 98.4);
+  evel_measurement_ipmi_systemAirflow_set(ipmi, 98.4);
+
+  MEASUREMENT_IPMI_BB_TEMPERATURE *temp;
+  temp = evel_measurement_new_base_board_temp_add(ipmi, "BBTEMP1");
+  evel_measurement_ipmi_bb_temp_set(ipmi, temp, 99.8);
+
+  MEASUREMENT_IPMI_BB_VOLTAGE * volt;
+  volt = evel_measurement_new_base_board_volt_add(ipmi, "BBVOLT1");
+  evel_measurement_ipmi_bb_volt_set(ipmi, volt, 88.9);
+
+  MEASUREMENT_IPMI_BATTERY *batt;
+  batt = evel_measurement_new_ipmi_battery_add(ipmi, "BBBATTERY1");  
+  evel_measurement_ipmi_battery_type_set(ipmi, batt, "BattType");
+  evel_measurement_ipmi_battery_voltage_set(ipmi, batt, 230);
+  
+  MEASUREMENT_IPMI_FAN * fan;
+  fan = evel_measurement_new_ipmi_fan_add(ipmi, "FAN1"); 
+  evel_measurement_ipmi_fan_speed_set(ipmi, fan, 300);
+
+  MEASUREMENT_IPMI_HSBP * hsbp;
+  hsbp = evel_measurement_new_ipmi_hsbp_add(ipmi, "BBHSBP1");
+  evel_measurement_ipmi_hsbp_temp_set(ipmi, hsbp, 100);
+
+  MEASUREMENT_IPMI_GLOBAL_AGG_TEMP_MARGIN *glob;
+  glob = evel_measurement_new_ipmi_global_temp_add(ipmi, "BBGLOBAL");
+  evel_measurement_ipmi_global_temp_margin_set(ipmi, glob, 22.5);
+
+  MEASUREMENT_IPMI_NIC * nic;
+  nic = evel_measurement_new_ipmi_nic_add(ipmi, "NIC_1");
+  evel_measurement_ipmi_nic_temp_set(ipmi, nic, 33.5);
+
+  MEASUREMENT_IPMI_POWER_SUPPLY * pwr;
+  pwr = evel_measurement_new_ipmi_power_add(ipmi, "POWERSupply1");
+  evel_measurement_ipmi_power_inputpwr_set(ipmi, pwr, 200.5);
+  evel_measurement_ipmi_power_current_op_set(ipmi, pwr, 50.4);
+  evel_measurement_ipmi_power_temp_set(ipmi, pwr, 100.5);
+   
+  MEASUREMENT_IPMI_PROCESSOR * proc;
+  proc = evel_measurement_new_ipmi_processor_add(ipmi, "PROCESSOR1");
+  evel_measurement_ipmi_processor_theralCtrl_set(ipmi, proc, 10.9);
+  evel_measurement_ipmi_processor_theralMargin_set(ipmi, proc, 29.8);
+  
+  MEASUREMENT_IPMI_PROCESSOR_DIMMAGG_THERM * dimm;
+  dimm = evel_measurement_ipmi_processor_new_dimmAggThermalMargin_add(ipmi, proc, "DIMM1", 15.8);
+
+  assert(dimm != NULL);
+     
+  MEASUREMENT_LOAD * load;
+  load = evel_measurement_new_loads_add(measurement);
+  evel_measurement_load_shortTerm_set(load, 22.5);
+  evel_measurement_load_midTerm_set(load, 33.6);
+  evel_measurement_load_longTerm_set(load, 44.8);
+  
+  MEASUREMENT_PROCESS_STATS * pstat;
+  pstat = evel_measurement_new_process_stats_add(measurement, "Process1");
+  evel_measurement_process_stat_forkRate_set(pstat, 10.1);
+  evel_measurement_process_stat_psStateBlocked_set(pstat, 20.1);
+  evel_measurement_process_stat_psStatePaging_set(pstat, 30.1);
+  evel_measurement_process_stat_psStateRunning_set(pstat, 40.1);
+  evel_measurement_process_stat_psStateSleeping_set(pstat, 50.1);
+  evel_measurement_process_stat_psStateStopped_set(pstat, 60.1);
+  evel_measurement_process_stat_psStateZombie_set(pstat, 70.1);
+  evel_measurement_process_stat_psStateZombie_set(pstat, 80.1);
+  
+  MACHINE_CHECK_EXCEPTION * mcheck;
+  mcheck = evel_measurement_new_machine_check_exception_add(measurement, "ProcessID1");
+  evel_measurement_machine_check_cor_mem_err_set(mcheck, 110.1);
+  evel_measurement_machine_check_cor_mem_err_1hr_set(mcheck, 210.1);
+  evel_measurement_machine_check_uncor_mem_err_set(mcheck, 310.1);
+  evel_measurement_machine_check_uncor_mem_err_1hr_set(mcheck, 410.1);
+
+  MEASUREMENT_HUGE_PAGE * hugep;
+  hugep = evel_measurement_new_huge_page_add(measurement, "HUGEPage1");
+  evel_measurement_huge_page_bytesUsed_set(hugep, 100);
+  evel_measurement_huge_page_bytesFree_set(hugep, 200);
+  evel_measurement_huge_page_vmPageNumberUsed_set(hugep, 300);
+  evel_measurement_huge_page_vmPageNumberFree_set(hugep, 400);
+  evel_measurement_huge_page_percentUsed_set(hugep, 500);
+  evel_measurement_huge_page_percentFree_set(hugep, 600);
 
-  evel_measurement_custom_measurement_add(measurement,
-                                          "Group1", "Name1", "Value1");
-  evel_measurement_custom_measurement_add(measurement,
-                                          "Group2", "Name1", "Value1");
-  evel_measurement_custom_measurement_add(measurement,
-                                          "Group2", "Name2", "Value2");
+  evel_start_epoch_set(&measurement->header, 2000);
+  evel_last_epoch_set(&measurement->header, 3000);
+  evel_reporting_entity_name_set(&measurement->header, "entity_name");
+  evel_reporting_entity_id_set(&measurement->header, "entity_id");
 
   json_size = evel_json_encode_event(
     json_body, EVEL_MAX_JSON_BODY, (EVENT_HEADER *) measurement);
   compare_strings(expected, json_body, EVEL_MAX_JSON_BODY, "Measurement");
   assert((json_size == strlen(json_body)) && "Bad size returned");
 
-  evel_free_event(measurement);
+  if(evel_post_event((EVENT_HEADER *)measurement) == EVEL_SUCCESS)
+  {
+    printf("Message sent to Collector successfully\n");
+  }
+  else
+  {
+    printf("Message sending Error\n");
+  }
+
+//  evel_free_event(measurement);
 }
 
 void test_encode_mobile_mand()
@@ -534,13 +833,14 @@ void test_encode_mobile_mand()
     "{\"event\": "
     "{\"commonEventHeader\": {"
     "\"domain\": \"mobileFlow\", "
-    "\"eventId\": \"1241\", "
+    "\"eventId\": \"mobileFlow000000001\", "
+    "\"eventName\": \"mobileFlow_error\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 1241, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2, "
     "\"reportingEntityId\": \"Dummy VM UUID - No Metadata available\", "
@@ -596,7 +896,7 @@ void test_encode_mobile_mand()
   /***************************************************************************/
   /* Mobile.                                                                 */
   /***************************************************************************/
-  evel_set_next_event_sequence(1241);
+//  evel_set_next_event_sequence(1241);
 
   metrics = evel_new_mobile_gtp_flow_metrics(12.3,
                                              3.12,
@@ -629,7 +929,9 @@ void test_encode_mobile_mand()
                                              110,
                                              225);
   assert(metrics != NULL);
-  mobile_flow = evel_new_mobile_flow("Outbound",
+  mobile_flow = evel_new_mobile_flow("mobileFlow_error", 
+                                     "mobileFlow000000001", 
+                                     "Outbound",
                                      metrics,
                                      "TCP",
                                      "IPv4",
@@ -644,7 +946,16 @@ void test_encode_mobile_mand()
   compare_strings(expected, json_body, EVEL_MAX_JSON_BODY, "Mobile");
   assert((json_size == strlen(json_body)) && "Bad size returned");
 
-  evel_free_event(mobile_flow);
+  if(evel_post_event((EVENT_HEADER *)mobile_flow) == EVEL_SUCCESS)
+  {
+    printf("Message sent to Collector successfully\n");
+  }
+  else
+  {
+    printf("Message sending Error\n");
+  }
+
+  //evel_free_event(mobile_flow);
 }
 
 void test_encode_mobile_opts()
@@ -653,13 +964,14 @@ void test_encode_mobile_opts()
     "{\"event\": "
     "{\"commonEventHeader\": {"
     "\"domain\": \"mobileFlow\", "
-    "\"eventId\": \"1242\", "
+    "\"eventId\": \"mobileFlow000000001\", "
+    "\"eventName\": \"mobileFlow_error\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 1242, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2, "
     "\"eventType\": \"Mobile flow...\", "
@@ -762,7 +1074,7 @@ void test_encode_mobile_opts()
   /***************************************************************************/
   /* Mobile.                                                                 */
   /***************************************************************************/
-  evel_set_next_event_sequence(1242);
+//  evel_set_next_event_sequence(1242);
 
   metrics = evel_new_mobile_gtp_flow_metrics(132.0001,
                                              31.2,
@@ -803,9 +1115,15 @@ void test_encode_mobile_opts()
   evel_mobile_gtp_metrics_deact_by_set(metrics, "Remote");
   evel_mobile_gtp_metrics_con_status_set(metrics, "Connected");
   evel_mobile_gtp_metrics_tun_status_set(metrics, "Not tunneling");
-  evel_mobile_gtp_metrics_iptos_set(metrics, 1, 13);
-  evel_mobile_gtp_metrics_iptos_set(metrics, 17, 1);
-  evel_mobile_gtp_metrics_iptos_set(metrics, 4, 99);
+
+//  evel_mobile_gtp_metrics_iptos_set(metrics, 1, 13);
+//  evel_mobile_gtp_metrics_iptos_set(metrics, 17, 1);
+//  evel_mobile_gtp_metrics_iptos_set(metrics, 4, 99);
+
+  evel_mobile_gtp_metrics_ip_tos_count_list_add(metrics, "1", "13");
+  evel_mobile_gtp_metrics_ip_tos_count_list_add(metrics, "17", "1");
+  evel_mobile_gtp_metrics_ip_tos_count_list_add(metrics, "4", "99");
+
   evel_mobile_gtp_metrics_large_pkt_rtt_set(metrics, 80);
   evel_mobile_gtp_metrics_large_pkt_thresh_set(metrics, 600.0);
   evel_mobile_gtp_metrics_max_rcv_bit_rate_set(metrics, 1357924680);
@@ -813,14 +1131,23 @@ void test_encode_mobile_opts()
   evel_mobile_gtp_metrics_num_echo_fail_set(metrics, 1);
   evel_mobile_gtp_metrics_num_tun_fail_set(metrics, 4);
   evel_mobile_gtp_metrics_num_http_errors_set(metrics, 2);
-  evel_mobile_gtp_metrics_tcp_flag_count_add(metrics, EVEL_TCP_CWR, 10);
-  evel_mobile_gtp_metrics_tcp_flag_count_add(metrics, EVEL_TCP_URG, 121);
-  evel_mobile_gtp_metrics_qci_cos_count_add(
-                                metrics, EVEL_QCI_COS_UMTS_CONVERSATIONAL, 11);
-  evel_mobile_gtp_metrics_qci_cos_count_add(
-                                            metrics, EVEL_QCI_COS_LTE_65, 122);
-
-  mobile_flow = evel_new_mobile_flow("Inbound",
+
+//  evel_mobile_gtp_metrics_tcp_flag_count_add(metrics, EVEL_TCP_CWR, 10);
+//  evel_mobile_gtp_metrics_tcp_flag_count_add(metrics, EVEL_TCP_URG, 121);
+
+
+  evel_mobile_gtp_metrics_tcp_flag_count_list_add(metrics, EVEL_TCP_CWR, "10");
+  evel_mobile_gtp_metrics_tcp_flag_count_list_add(metrics, EVEL_TCP_URG, "121");
+
+//  evel_mobile_gtp_metrics_qci_cos_count_add( metrics, EVEL_QCI_COS_UMTS_CONVERSATIONAL, 11);
+//  evel_mobile_gtp_metrics_qci_cos_count_add( metrics, EVEL_QCI_COS_LTE_65, 122);
+
+  evel_mobile_gtp_metrics_qci_cos_count_list_add(metrics, EVEL_QCI_COS_UMTS_CONVERSATIONAL, "11");
+  evel_mobile_gtp_metrics_qci_cos_count_list_add(metrics, EVEL_QCI_COS_LTE_65, "122");
+
+  mobile_flow = evel_new_mobile_flow("mobileFlow_error",
+                                     "mobileFlow000000001",
+                                     "Inbound",
                                      metrics,
                                      "UDP",
                                      "IPv6",
@@ -855,6 +1182,8 @@ void test_encode_mobile_opts()
   evel_mobile_flow_tac_set(mobile_flow, "2099");
   evel_mobile_flow_tunnel_id_set(mobile_flow, "Tunnel 1");
   evel_mobile_flow_vlan_id_set(mobile_flow, "15");
+  evel_mobile_flow_addl_field_add(mobile_flow, "Mkey1", "MValue1");
+  evel_mobile_flow_addl_field_add(mobile_flow, "Mkey2", "MValue2");
 
   json_size = evel_json_encode_event(
     json_body, EVEL_MAX_JSON_BODY, (EVENT_HEADER *) mobile_flow);
@@ -863,20 +1192,21 @@ void test_encode_mobile_opts()
 
   evel_free_event(mobile_flow);
 }
-
+/********
 void test_encode_report()
 {
   char * expected =
     "{\"event\": "
     "{\"commonEventHeader\": {"
     "\"domain\": \"measurementsForVfReporting\", "
-    "\"eventId\": \"125\", "
+    "\"eventId\": \"report000000001\", "
+    "\"eventName\": \"report_err\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 125, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2, "
     "\"eventType\": \"Perf reporting...\", "
@@ -907,11 +1237,8 @@ void test_encode_report()
   char json_body[EVEL_MAX_JSON_BODY];
   EVENT_REPORT * report = NULL;
 
-  /***************************************************************************/
-  /* Report.                                                                 */
-  /***************************************************************************/
-  evel_set_next_event_sequence(125);
-  report = evel_new_report(1.1);
+//  evel_set_next_event_sequence(125);
+  report = evel_new_report(1.1, "report_err", "report000000001");
   assert(report != NULL);
   evel_report_type_set(report, "Perf reporting...");
   evel_report_feature_use_add(report, "FeatureA", 123);
@@ -927,7 +1254,8 @@ void test_encode_report()
 
   evel_free_event(report);
 }
-
+****************/
+/********************
 void test_encode_service()
 {
   test_encode_service_subset(SERVICE_NONE);
@@ -937,20 +1265,22 @@ void test_encode_service()
   test_encode_service_subset(SERVICE_EOC_VQM);
   test_encode_service_subset(SERVICE_MARKER);
 }
-
+********/
+/**************
 void test_encode_service_subset(const SERVICE_TEST service_test)
 {
   char * expected_start =
     "{\"event\": "
     "{\"commonEventHeader\": {"
     "\"domain\": \"serviceEvents\", "
-    "\"eventId\": \"2000\", "
+    "\"eventId\": \"sipSignal0000000001\", "
+    "\"eventName\": \"sipSignal_err\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 2000, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2, "
     "\"eventType\": \"Service Event\", "
@@ -1057,9 +1387,10 @@ void test_encode_service_subset(const SERVICE_TEST service_test)
 
   size_t json_size = 0;
   char json_body[EVEL_MAX_JSON_BODY];
-  EVENT_SGNALING * event = NULL;
-  evel_set_next_event_sequence(2000);
-  event = evel_new_signaling("vendor_x_id",
+  EVENT_SIGNALING * event = NULL;
+//  evel_set_next_event_sequence(2000);
+  event = evel_new_signaling("sipSignal_err", 
+           "sipSignal0000000001", "vendor_x_id",
            "correlator", "1.0.3.1", "1234", "192.168.1.3","3456");
   assert(event != NULL);
   evel_signaling_type_set(event, "Signaling");
@@ -1083,27 +1414,27 @@ void test_encode_service_subset(const SERVICE_TEST service_test)
       break;
     case SERVICE_EOC_VQM:
       evel_signaling_addl_info_add(event, "adjacency", "vendor_x");
-      /*evel_service_adjacency_name_set(event, "vendor_x_adjacency");
-      evel_service_endpoint_desc_set(event, EVEL_SERVICE_ENDPOINT_CALLER);
-      evel_service_endpoint_jitter_set(event, 66);
-      evel_service_endpoint_rtp_oct_disc_set(event, 100);
-      evel_service_endpoint_rtp_oct_recv_set(event, 200);
-      evel_service_endpoint_rtp_oct_sent_set(event, 300);
-      evel_service_endpoint_rtp_pkt_disc_set(event, 400);
-      evel_service_endpoint_rtp_pkt_recv_set(event, 500);
-      evel_service_endpoint_rtp_pkt_sent_set(event, 600);
-      evel_service_local_jitter_set(event, 99);
-      evel_service_local_rtp_oct_disc_set(event, 150);
-      evel_service_local_rtp_oct_recv_set(event, 250);
-      evel_service_local_rtp_oct_sent_set(event, 350);
-      evel_service_local_rtp_pkt_disc_set(event, 450);
-      evel_service_local_rtp_pkt_recv_set(event, 550);
-      evel_service_local_rtp_pkt_sent_set(event, 650);
-      evel_service_mos_cqe_set(event, 12.255);
-      evel_service_packets_lost_set(event, 157);
-      evel_service_packet_loss_percent_set(event, 0.232);
-      evel_service_r_factor_set(event, 11);
-      evel_service_round_trip_delay_set(event, 15);*/
+//      evel_service_adjacency_name_set(event, "vendor_x_adjacency");
+//      evel_service_endpoint_desc_set(event, EVEL_SERVICE_ENDPOINT_CALLER);
+//      evel_service_endpoint_jitter_set(event, 66);
+//      evel_service_endpoint_rtp_oct_disc_set(event, 100);
+//      evel_service_endpoint_rtp_oct_recv_set(event, 200);
+//      evel_service_endpoint_rtp_oct_sent_set(event, 300);
+//      evel_service_endpoint_rtp_pkt_disc_set(event, 400);
+//      evel_service_endpoint_rtp_pkt_recv_set(event, 500);
+//      evel_service_endpoint_rtp_pkt_sent_set(event, 600);
+//      evel_service_local_jitter_set(event, 99);
+//      evel_service_local_rtp_oct_disc_set(event, 150);
+//      evel_service_local_rtp_oct_recv_set(event, 250);
+//      evel_service_local_rtp_oct_sent_set(event, 350);
+//      evel_service_local_rtp_pkt_disc_set(event, 450);
+//      evel_service_local_rtp_pkt_recv_set(event, 550);
+//      evel_service_local_rtp_pkt_sent_set(event, 650);
+//      evel_service_mos_cqe_set(event, 12.255);
+//      evel_service_packets_lost_set(event, 157);
+//      evel_service_packet_loss_percent_set(event, 0.232);
+//      evel_service_r_factor_set(event, 11);
+//      evel_service_round_trip_delay_set(event, 15);
       break;
     case SERVICE_MARKER:
       evel_signaling_addl_info_add(event, "service_phone", "0888888888");
@@ -1117,20 +1448,21 @@ void test_encode_service_subset(const SERVICE_TEST service_test)
 
   evel_free_event(event);
 }
-
+*******************/
 void test_encode_signaling()
 {
   char * expected =
     "{\"event\": "
     "{\"commonEventHeader\": {"
     "\"domain\": \"signaling\", "
-    "\"eventId\": \"2001\", "
+    "\"eventId\": \"sipSignal0000000001\", "
+    "\"eventName\": \"sipSignal_err\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 2001, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2, "
     "\"eventType\": \"Signaling\", "
@@ -1159,29 +1491,142 @@ void test_encode_signaling()
   size_t json_size = 0;
   char json_body[EVEL_MAX_JSON_BODY];
   EVENT_SIGNALING * event = NULL;
-  evel_set_next_event_sequence(2001);
-  event = evel_new_signaling("vendor_x_id",
+//  evel_set_next_event_sequence(2001);
+  event = evel_new_signaling("sipSignal_err",
+           "sipSignal0000000001", "vendor_x_id",
            "correlator", "1.0.3.1", "1234", "192.168.1.3","3456");
   assert(event != NULL);
-  evel_signaling_vnfmodule_name_set(event, "vendor_x_module");
-  evel_signaling_vnfname_set(event, "vendor_x_vnf");
+
+  evel_signaling_addl_info_add(event, "name1", "value1");
+  evel_signaling_addl_info_add(event, "name2", "value2");
+  evel_signaling_addl_info_add(event, "name3", "value3");
+  evel_signaling_addl_info_add(event, "name4", "value4");
+
   evel_signaling_type_set(event, "Signaling");
-  evel_signaling_product_id_set(event, "vendor_x_product_id");
-  evel_signaling_subsystem_id_set(event, "vendor_x_subsystem_id");
-  evel_signaling_friendly_name_set(event, "vendor_x_frieldly_name");
-  evel_signaling_correlator_set(event, "vendor_x_correlator");
   evel_signaling_local_ip_address_set(event, "1.0.3.1");
   evel_signaling_local_port_set(event, "1031");
   evel_signaling_remote_ip_address_set(event, "5.3.3.0");
   evel_signaling_remote_port_set(event, "5330");
+  evel_signaling_vnfmodule_name_set(event, "vendor_x_module");
+  evel_signaling_vnfname_set(event, "vendor_x_vnf");
   evel_signaling_compressed_sip_set(event, "compressed_sip");
   evel_signaling_summary_sip_set(event, "summary_sip");
+  evel_signaling_correlator_set(event, "vendor_x_correlator");
+
+
   json_size = evel_json_encode_event(
     json_body, EVEL_MAX_JSON_BODY, (EVENT_HEADER *) event);
   compare_strings(expected, json_body, EVEL_MAX_JSON_BODY, "Signaling");
   assert((json_size == strlen(json_body)) && "Bad size returned");
 
-  evel_free_event(event);
+  if(evel_post_event((EVENT_HEADER *)event) == EVEL_SUCCESS)
+  {
+    printf("Message sent to Collector successfully\n");
+  }
+  else
+  {
+    printf("Message sending Error\n");
+  }
+
+//  evel_free_event(event);
+}
+
+void test_encode_notif()
+{
+  char * expected = " ";
+  HASHTABLE_T * ht1 = NULL;
+  size_t json_size = 0;
+  char json_body[EVEL_MAX_JSON_BODY];
+  EVENT_NOTIFICATION * event = NULL;
+  event = evel_new_notification("notif_err",
+           "Notification0000000001", "ChangeId",
+           "ChangeType");
+
+  assert(event != NULL);
+
+  evel_notification_type_set(event, "Event_type");
+  evel_notification_changeContact_set(event, "ChangeContact");
+  evel_notification_state_interface_set(event, "STInterface");
+  evel_notification_new_state_set(event, EVEL_ENTITY_STATE_MAINTENANCE);
+  evel_notification_old_state_set(event, EVEL_ENTITY_STATE_OUT_OF_SERVICE);
+  
+  evel_notification_addl_field_add(event, "name1", "value1");
+  evel_notification_addl_field_add(event, "name2", "value2");
+  evel_notification_addl_field_add(event, "name3", "value3");
+  evel_notification_addl_field_add(event, "name4", "value4");
+
+  ht1 = evel_notification_add_new_named_hashmap(event, "hmNam1");
+  evel_notification_named_hashmap_set(ht1, "hmnap1", "hmvalue1");
+  evel_notification_named_hashmap_set(ht1, "hmnap2", "hmvalue2");
+  evel_notification_named_hashmap_set(ht1, "hmnap3", "hmvalue3");
+  evel_notification_named_hashmap_set(ht1, "hmnap4", "hmvalue4");
+  ht1 = evel_notification_add_new_named_hashmap(event, "hmNam2");
+  evel_notification_named_hashmap_set(ht1, "hmnap21", "hmvalue21");
+  evel_notification_named_hashmap_set(ht1, "hmnap22", "hmvalue22");
+  evel_notification_named_hashmap_set(ht1, "hmnap23", "hmvalue23");
+  evel_notification_named_hashmap_set(ht1, "hmnap24", "hmvalue24");
+
+
+  json_size = evel_json_encode_event(
+    json_body, EVEL_MAX_JSON_BODY, (EVENT_HEADER *) event);
+  compare_strings(expected, json_body, EVEL_MAX_JSON_BODY, "Notification");
+  assert((json_size == strlen(json_body)) && "Bad size returned");
+
+  if(evel_post_event((EVENT_HEADER *)event) == EVEL_SUCCESS)
+  {
+    printf("Message sent to Collector successfully\n");
+  }
+  else
+  {
+    printf("Message sending Error\n");
+  }
+
+//  evel_free_event(event);
+}
+
+void test_encode_voiceQ()
+{
+  char * expected = " ";
+
+  size_t json_size = 0;
+  char json_body[EVEL_MAX_JSON_BODY];
+  EVENT_VOICE_QUALITY * event = NULL;
+//  evel_set_next_event_sequence(2001);
+  event = evel_new_voice_quality("voiceQ_err",
+           "VoiceQuality0000000001", "Called_Codec",
+           "Caller_codec", "Correlator", "RTCP", "Vendor_x");
+  assert(event != NULL);
+
+  evel_voice_quality_addl_info_add(event, "name1", "value1");
+  evel_voice_quality_addl_info_add(event, "name2", "value2");
+  evel_voice_quality_addl_info_add(event, "name3", "value3");
+  evel_voice_quality_addl_info_add(event, "name4", "value4");
+
+//  evel_voice_quality_callee_codec_set(event, "Callee_cdc1");
+//  evel_voice_quality_caller_codec_set(event, "Clr_cdc1");
+  
+  evel_voice_quality_correlator_set(event, "CorrNew");
+  evel_voice_quality_rtcp_data_set(event, "RTCPNew");
+  evel_voice_quality_vnfmodule_name_set(event, "vendor_x_module");
+  evel_voice_quality_vnfname_set(event, "vendor_x_vnf");
+  evel_voice_quality_phone_number_set(event, "1234567890");
+  evel_voice_quality_end_metrics_add(event, "Adj_name", EVEL_SERVICE_ENDPOINT_CALLEE, 1,2,3,4,5,6,7,8,9,10,11,12,1,2,3,16,17,18,19,20,21,22,23,24,25,26,27);
+
+  json_size = evel_json_encode_event(
+    json_body, EVEL_MAX_JSON_BODY, (EVENT_HEADER *) event);
+  compare_strings(expected, json_body, EVEL_MAX_JSON_BODY, "VoiceQuality");
+  assert((json_size == strlen(json_body)) && "Bad size returned");
+
+  if(evel_post_event((EVENT_HEADER *)event) == EVEL_SUCCESS)
+  {
+    printf("Message sent to Collector successfully\n");
+  }
+  else
+  {
+    printf("Message sending Error\n");
+  }
+
+//  evel_free_event(event);
 }
 
 void test_encode_state_change()
@@ -1190,13 +1635,14 @@ void test_encode_state_change()
     "{\"event\": "
     "{\"commonEventHeader\": {"
     "\"domain\": \"stateChange\", "
-    "\"eventId\": \"128\", "
+    "\"eventId\": \"stateChange000000001\", "
+    "\"eventName\": \"stateChange_err\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 128, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2, "
     "\"eventType\": \"SC Type\", "
@@ -1219,9 +1665,11 @@ void test_encode_state_change()
   size_t json_size = 0;
   char json_body[EVEL_MAX_JSON_BODY];
   EVENT_STATE_CHANGE * state_change = NULL;
-  evel_set_next_event_sequence(128);
-  state_change = evel_new_state_change(EVEL_ENTITY_STATE_IN_SERVICE,
-                                       EVEL_ENTITY_STATE_OUT_OF_SERVICE,
+//  evel_set_next_event_sequence(128);
+  state_change = evel_new_state_change("stateChange_err",
+                                       "stateChange000000001",
+                                       EVEL_ENTITY_STATE_IN_SERVICE,
+                                       EVEL_ENTITY_STATE_MAINTENANCE,
                                        "An Interface");
   assert(state_change != NULL);
   evel_state_change_type_set(state_change, "SC Type");
@@ -1233,7 +1681,16 @@ void test_encode_state_change()
   compare_strings(expected, json_body, EVEL_MAX_JSON_BODY, "StateChange");
   assert((json_size == strlen(json_body)) && "Bad size returned");
 
-  evel_free_event(state_change);
+  if(evel_post_event((EVENT_HEADER *)state_change) == EVEL_SUCCESS)
+  {
+    printf("Message sent to Collector successfully\n");
+  }
+  else
+  {
+    printf("Message sending Error\n");
+  }
+
+//  evel_free_event(state_change);
 }
 
 void test_encode_syslog()
@@ -1242,13 +1699,14 @@ void test_encode_syslog()
     "{\"event\": "
     "{\"commonEventHeader\": {"
     "\"domain\": \"syslog\", "
-    "\"eventId\": \"126\", "
+    "\"eventId\": \"syslog000000001\", "
+    "\"eventName\": \"syslog_err\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 126, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2, "
     "\"eventType\": \"SL Type\", "
@@ -1270,8 +1728,9 @@ void test_encode_syslog()
   size_t json_size = 0;
   char json_body[EVEL_MAX_JSON_BODY];
   EVENT_SYSLOG * syslog = NULL;
-  evel_set_next_event_sequence(126);
-  syslog = evel_new_syslog(EVEL_SOURCE_VIRTUAL_NETWORK_FUNCTION,
+//  evel_set_next_event_sequence(126);
+  syslog = evel_new_syslog("syslog_err", "syslog000000001", 
+                           EVEL_SOURCE_VIRTUAL_NETWORK_FUNCTION,
                            "SL Message",
                            "SL Tag");
   assert(syslog != NULL);
@@ -1282,13 +1741,33 @@ void test_encode_syslog()
   evel_syslog_proc_id_set(syslog, 2);
   evel_syslog_version_set(syslog, 1);
   evel_syslog_s_data_set(syslog, "SL SDATA");
+  evel_syslog_sdid_set(syslog, "ourSDID@12345");
+  evel_syslog_severity_set(syslog, "Alert");
+  evel_syslog_timeStamp_set(syslog, "12-DEC-2018");
+  evel_syslog_MsgHost_set(syslog, "hostName123");
+  evel_syslog_priority_set(syslog, 15);
+  
+  evel_syslog_addl_fields_set(syslog, "Name1", "Value1");
+  evel_syslog_addl_fields_set(syslog, "Name2", "Value2");
+  evel_syslog_addl_fields_set(syslog, "Name3", "Value3");
+  evel_syslog_addl_fields_set(syslog, "Name4", "Value4");
+  evel_syslog_addl_fields_set(syslog, "Name5", "Value5");
 
   json_size = evel_json_encode_event(
     json_body, EVEL_MAX_JSON_BODY, (EVENT_HEADER *) syslog);
   compare_strings(expected, json_body, EVEL_MAX_JSON_BODY, "Syslog");
   assert((json_size == strlen(json_body)) && "Bad size returned");
 
-  evel_free_event(syslog);
+  if(evel_post_event((EVENT_HEADER *)syslog) == EVEL_SUCCESS)
+  {
+    printf("Message sent to Collector successfully\n");
+  }
+  else
+  {
+    printf("Message sending Error\n");
+  }
+
+ // evel_free_event(syslog);
 }
 
 void test_encode_other()
@@ -1297,13 +1776,14 @@ void test_encode_other()
     "{\"event\": "
     "{\"commonEventHeader\": {"
     "\"domain\": \"other\", "
-    "\"eventId\": \"129\", "
+    "\"eventId\": \"other000000001\", "
+    "\"eventName\": \"other_err\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 129, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2, "
     "\"eventType\": \"Other Type\", "
@@ -1321,23 +1801,170 @@ void test_encode_other()
   size_t json_size = 0;
   char json_body[EVEL_MAX_JSON_BODY];
   EVENT_OTHER * other = NULL;
-  evel_set_next_event_sequence(129);
-  other = evel_new_other();
+  HASHTABLE_T * ht1 = NULL;
+  HASHTABLE_T * ht2 = NULL;
+
+//  evel_set_next_event_sequence(129);
+  other = evel_new_other("other_err", "other000000001");
   assert(other != NULL);
   evel_other_type_set(other, "Other Type");
-  evel_other_field_add(other,
-                       "Other field 1",
-                       "Other value 1");
-  evel_other_field_add(other,
-                       "Other field 2",
-                       "Other value 2");
+
+  ht1 = evel_other_add_new_hashmap_to_hmarray(other, "hmap1");
+  ht2 = evel_other_add_new_hashmap_to_hmarray(other, "hmap2");
+
+  evel_other_set_hashmap_in_hmarray(ht1, "Name11", "Value11");
+  evel_other_set_hashmap_in_hmarray(ht2, "Name21", "Value21");
+  evel_other_set_hashmap_in_hmarray(ht1, "Name12", "Value12");
+  evel_other_set_hashmap_in_hmarray(ht2, "Name22", "Value22");
+  evel_other_set_hashmap_in_hmarray(ht1, "Name13", "Value13");
+  evel_other_set_hashmap_in_hmarray(ht2, "Name23", "Value23");
+  evel_other_set_hashmap_in_hmarray(ht1, "Name14", "Value14");
+  evel_other_set_hashmap_in_hmarray(ht2, "Name24", "Value24");
+
+  evel_other_field_add_hashmap(other, "Name1", "Value1");
+  evel_other_field_add_hashmap(other, "Name2", "Value2");
+  evel_other_field_add_hashmap(other, "Name3", "Value3");
+  evel_other_field_add_hashmap(other, "Name4", "Value4");
+  evel_other_field_add_hashmap(other, "Name5", "Value5");
 
   json_size = evel_json_encode_event(
     json_body, EVEL_MAX_JSON_BODY, (EVENT_HEADER *) other);
   compare_strings(expected, json_body, EVEL_MAX_JSON_BODY, "Other");
   assert((json_size == strlen(json_body)) && "Bad size returned");
 
-  evel_free_event(other);
+  if(evel_post_event((EVENT_HEADER *)other) == EVEL_SUCCESS)
+  {
+    printf("Message sent to Collector successfully\n");
+  }
+  else
+  {
+    printf("Message sending Error\n");
+  }
+
+//  evel_free_event(other);
+}
+
+void test_encode_pnfreg()
+{
+  char * expected =
+    "{\"event\": "
+    "{\"commonEventHeader\": {"
+    "\"domain\": \"other\", "
+    "\"eventId\": \"other000000001\", "
+    "\"eventName\": \"other_err\", "
+    "\"functionalRole\": \"UNIT TEST\", "
+    "\"lastEpochMicrosec\": 1000002, "
+    "\"priority\": \"Normal\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
+    "\"sequence\": 129, "
+    "\"sourceName\": \"prakash-VirtualBox\", "
+    "\"startEpochMicrosec\": 1000002, "
+    "\"version\": 1.2, "
+    "\"eventType\": \"Other Type\", "
+    "\"reportingEntityId\": \"Dummy VM UUID - No Metadata available\", "
+    "\"sourceId\": \"Dummy VM UUID - No Metadata available\""
+    "}, "
+    "\"otherFields\": ["
+    "{\"name\": \"Other field 1\", "
+    "\"value\": \"Other value 1\"}, "
+    "{\"name\": \"Other field 2\", "
+    "\"value\": \"Other value 2\"}"
+    "]"
+    "}}";
+
+  size_t json_size = 0;
+  char json_body[EVEL_MAX_JSON_BODY];
+  EVENT_PNF_REGISTRATION * pnfreg = NULL;
+
+  pnfreg = evel_new_pnf_registration("pnfreg_err", "pnfreg000000001");
+  assert(pnfreg != NULL);
+
+  evel_pnf_registration_addl_field_add(pnfreg, "Name1", "Value1");
+  evel_pnf_registration_addl_field_add(pnfreg, "Name2", "Value2");
+  evel_pnf_registration_addl_field_add(pnfreg, "Name3", "Value3");
+  evel_pnf_registration_addl_field_add(pnfreg, "Name4", "Value4");
+  evel_pnf_registration_addl_field_add(pnfreg, "Name5", "Value5");
+
+  evel_pnfRegistration_last_service_date_set(pnfreg, "10FEB2019");
+  evel_pnfRegistration_mac_address_set(pnfreg, "FF:28:22:34:45:56");
+  evel_pnfRegistration_manufacture_date_set(pnfreg, "FEB2011");
+  evel_pnfRegistration_model_number_set(pnfreg, "FE934567");
+  evel_pnfRegistration_oam_v4_ipaddress_set(pnfreg, "10.255.1.254");
+  evel_pnfRegistration_oam_v6_ipaddress_set(pnfreg, "::20");
+  evel_pnfRegistration_serial_number_set(pnfreg, "1234567890");
+  evel_pnfRegistration_sw_version_set(pnfreg, "SW1234");
+  evel_pnfRegistration_unit_family_set(pnfreg, "Unit_Fam_123");
+  evel_pnfRegistration_unit_type_set(pnfreg, "Unit_type_123");
+  evel_pnfRegistration_vendor_name_set(pnfreg, "Vend_nam_123");
+  
+
+  json_size = evel_json_encode_event(
+    json_body, EVEL_MAX_JSON_BODY, (EVENT_HEADER *) pnfreg);
+  compare_strings(expected, json_body, EVEL_MAX_JSON_BODY, "PNFRegistration");
+  assert((json_size == strlen(json_body)) && "Bad size returned");
+
+  if(evel_post_event((EVENT_HEADER *)pnfreg) == EVEL_SUCCESS)
+  {
+    printf("Message sent to Collector successfully\n");
+  }
+  else
+  {
+    printf("Message sending Error\n");
+  }
+
+//  evel_free_event(pnfreg);
+}
+
+void test_encode_tca()
+{
+
+  char * expected = "123456789";
+  size_t json_size = 0;
+  char json_body[EVEL_MAX_JSON_BODY];
+  EVENT_THRESHOLD_CROSS * tca = NULL;
+  PERF_COUNTER * perf = NULL;
+
+  tca = evel_new_threshold_cross("tca_err", "tca000000001", EVEL_EVENT_ACTION_SET, "NE-CPUMEM", EVEL_CARD_ANOMALY, "1234567", EVEL_SEVERITY_CRITICAL, "8765432" );
+  assert(tca != NULL);
+
+  perf = evel_threshold_cross_add_addl_parameters(tca, "CRIT", "LastThresh");
+  evel_threshold_cross_addl_parameters_hashmap_set(perf, "key1", "value1");
+  evel_threshold_cross_addl_parameters_hashmap_set(perf, "key2", "value2");
+  perf = evel_threshold_cross_add_addl_parameters(tca, "CRIT", "LastThresh");
+  evel_threshold_cross_addl_parameters_hashmap_set(perf, "key3", "value3");
+  evel_threshold_cross_addl_parameters_hashmap_set(perf, "key4", "value4");
+
+  evel_threshold_cross_type_set(tca, "node");
+  evel_threshold_cross_alertid_add(tca, "Alert1");
+  evel_threshold_cross_alertid_add(tca, "Alert2");
+  evel_threshold_cross_alertid_add(tca, "Alert3");
+
+  evel_threshold_cross_addl_info_add(tca, "addnam1", "addval1");
+  evel_threshold_cross_addl_info_add(tca, "addnam2", "addval2");
+  evel_threshold_cross_addl_info_add(tca, "addnam3", "addval3");
+
+  evel_threshold_cross_possible_rootcause_set(tca, "prootcause");
+  evel_threshold_cross_networkservice_set(tca, "nwservice");
+
+  evel_threshold_cross_interfacename_set(tca, "ens04");
+  evel_threshold_cross_data_elementtype_set(tca, "elementtype");
+  evel_threshold_cross_data_collector_set(tca, "dataCollector");
+  evel_threshold_cross_alertvalue_set(tca, "AlertVal");
+
+  json_size = evel_json_encode_event(
+    json_body, EVEL_MAX_JSON_BODY, (EVENT_HEADER *) tca);
+  compare_strings(expected, json_body, EVEL_MAX_JSON_BODY, "TCA");
+  assert((json_size == strlen(json_body)) && "Bad size returned");
+
+  if(evel_post_event((EVENT_HEADER *)tca) == EVEL_SUCCESS)
+  {
+    printf("Message sent to Collector successfully\n");
+  }
+  else
+  {
+    printf("Message sending Error\n");
+  }
+//  evel_free_event(tca);
 }
 
 void compare_strings(char * expected,
@@ -1345,6 +1972,7 @@ void compare_strings(char * expected,
                      int max_size,
                      char * description)
 {
+  sleep(5);
   if (strncmp(expected, actual, max_size) != 0)
   {
     int diff = 0;
@@ -1357,11 +1985,11 @@ void compare_strings(char * expected,
       diff++;
     }
 
-    printf("Comparison Failure at Offset %d\n\n", diff);
-    printf("Expected:\n%s\n", expected);
-    printf("Actual:\n%s\n", actual);
+//    printf("Comparison Failure at Offset %d\n\n", diff);
+//    printf("Expected:\n%s\n", expected);
     printf("Description: %s\n", description);
-    assert(0);
+    printf("Actual:\n%s\n\n\n", actual);
+//    assert(0);
   }
 }
 
@@ -1406,6 +2034,7 @@ void handle_json_response(char * json, MEMORY_CHUNK * post)
 /**************************************************************************//**
  * Test that a non-"commandList" JSON buffer leaves the throttle state off.
  *****************************************************************************/
+/****************
 void test_json_response_junk()
 {
   MEMORY_CHUNK post;
@@ -1421,21 +2050,16 @@ void test_json_response_junk()
   evel_throttle_initialize();
   handle_json_response(json_junk, &post);
 
-  /***************************************************************************/
-  /* Check that all domains are not throttled.                               */
-  /***************************************************************************/
   for (domain = EVEL_DOMAIN_FAULT; domain < EVEL_MAX_DOMAINS; domain++)
   {
     assert(evel_get_throttle_spec(domain) == NULL);
   }
 
-  /***************************************************************************/
-  /* Check that we generated no post.                                        */
-  /***************************************************************************/
   assert(post.memory == NULL);
 
   evel_throttle_terminate();
 }
+**********************/
 
 char * json_command_list_provide =
   "{"
@@ -1485,6 +2109,7 @@ char * expected_throttle_state_normal =
 /**************************************************************************//**
  * Test that we can return the default throttling state.
  *****************************************************************************/
+/*******************
 void test_json_provide_throttle_state()
 {
   MEMORY_CHUNK post;
@@ -1495,17 +2120,11 @@ void test_json_provide_throttle_state()
   evel_throttle_initialize();
   handle_json_response(json_command_list_provide, &post);
 
-  /***************************************************************************/
-  /* Check that all domains are not throttled.                               */
-  /***************************************************************************/
   for (domain = EVEL_DOMAIN_FAULT; domain < EVEL_MAX_DOMAINS; domain++)
   {
     assert(evel_get_throttle_spec(domain) == NULL);
   }
 
-  /***************************************************************************/
-  /* Check that we generated a throttling specification post.                */
-  /***************************************************************************/
   assert(post.memory != NULL);
   compare_strings(expected_post, post.memory, strlen(expected_post),
                   "Throttle State Normal");
@@ -1513,10 +2132,11 @@ void test_json_provide_throttle_state()
 
   evel_throttle_terminate();
 }
-
+*************************/
 /**************************************************************************//**
  * Test the measurement interval handling and API.
  *****************************************************************************/
+/********************
 void test_json_measurement_interval()
 {
   MEMORY_CHUNK post;
@@ -1558,33 +2178,26 @@ void test_json_measurement_interval()
   evel_throttle_initialize();
   assert(evel_get_measurement_interval() == EVEL_MEASUREMENT_INTERVAL_UKNOWN);
 
-  /***************************************************************************/
-  /* Check that we're not handling stuff when we shouldn't.                  */
-  /***************************************************************************/
   handle_json_response(json_command_list_interval_only, &post);
   assert(post.memory == NULL);
   assert(evel_get_measurement_interval() == EVEL_MEASUREMENT_INTERVAL_UKNOWN);
 
-  /***************************************************************************/
-  /* Check that we're OK with the interval coming first.                     */
-  /***************************************************************************/
   handle_json_response(json_command_list_interval_first, &post);
   assert(post.memory == NULL);
   assert(evel_get_measurement_interval() == 30);
 
-  /***************************************************************************/
-  /* Check that we're OK with the command type coming first.                 */
-  /***************************************************************************/
   handle_json_response(json_command_list_command_first, &post);
   assert(post.memory == NULL);
   assert(evel_get_measurement_interval() == 60);
 
   evel_throttle_terminate();
 }
+*********************/
 
 /**************************************************************************//**
  * Test a single domain, single field suppression.
  *****************************************************************************/
+/*******************
 void test_json_throttle_spec_field()
 {
   MEMORY_CHUNK post;
@@ -1648,15 +2261,9 @@ void test_json_throttle_spec_field()
     "}"
     "}";
 
-  /***************************************************************************/
-  /* Initialize and provide a specification with a single fault suppressed.  */
-  /***************************************************************************/
   evel_throttle_initialize();
   handle_json_response(json_command_list_fault_single, &post);
 
-  /***************************************************************************/
-  /* Check that the FAULT domain is throttled.                               */
-  /***************************************************************************/
   assert(evel_get_throttle_spec(EVEL_DOMAIN_FAULT) != NULL);
   for (domain = EVEL_DOMAIN_MEASUREMENT; domain < EVEL_MAX_DOMAINS; domain++)
   {
@@ -1667,9 +2274,6 @@ void test_json_throttle_spec_field()
   }
   assert(post.memory == NULL);
 
-  /***************************************************************************/
-  /* Request and verify the throttling state.                                */
-  /***************************************************************************/
   handle_json_response(json_command_list_provide, &post);
   assert(post.memory != NULL);
   compare_strings(expected_post_fault_single,
@@ -1679,14 +2283,8 @@ void test_json_throttle_spec_field()
   free(post.memory);
   post.memory = NULL;
 
-  /***************************************************************************/
-  /* Update a specification with two faults suppressed.                      */
-  /***************************************************************************/
   handle_json_response(json_command_list_fault_double, &post);
 
-  /***************************************************************************/
-  /* Check that the FAULT domain is throttled.                               */
-  /***************************************************************************/
   assert(evel_get_throttle_spec(EVEL_DOMAIN_FAULT) != NULL);
   for (domain = EVEL_DOMAIN_MEASUREMENT; domain < EVEL_MAX_DOMAINS; domain++)
   {
@@ -1697,9 +2295,6 @@ void test_json_throttle_spec_field()
   }
   assert(post.memory == NULL);
 
-  /***************************************************************************/
-  /* Request and verify the throttling state.                                */
-  /***************************************************************************/
   handle_json_response(json_command_list_provide, &post);
   assert(post.memory != NULL);
   compare_strings(expected_post_fault_double,
@@ -1709,9 +2304,6 @@ void test_json_throttle_spec_field()
   free(post.memory);
   post.memory = NULL;
 
-  /***************************************************************************/
-  /* Now clear the FAULT domain.                                             */
-  /***************************************************************************/
   handle_json_response(json_command_list_fault_clear, &post);
   for (domain = EVEL_DOMAIN_FAULT; domain < EVEL_MAX_DOMAINS; domain++)
   {
@@ -1720,10 +2312,11 @@ void test_json_throttle_spec_field()
 
   evel_throttle_terminate();
 }
-
+*******************************/
 /**************************************************************************//**
  * Test a single domain, nv_pair suppression.
  *****************************************************************************/
+/**************
 void test_json_throttle_spec_nv_pair()
 {
   MEMORY_CHUNK post;
@@ -1772,7 +2365,7 @@ void test_json_throttle_spec_nv_pair()
   char * expected_post_fault_pair_single =
     "{"
     "\"eventThrottlingState\": {"
-    "\"eventThrottlingMode\": \"throttled\", "
+    "\"eventohrottlingMode\": \"throttled\", "
     "\"eventDomainThrottleSpecificationList\": ["
     "{"
     "\"eventDomain\": \"fault\", "
@@ -1805,16 +2398,9 @@ void test_json_throttle_spec_nv_pair()
     "}"
     "}";
 
-  /***************************************************************************/
-  /* Initialize and provide a specification with a single nvpair with a      */
-  /* single sub-field suppressed.                                            */
-  /***************************************************************************/
   evel_throttle_initialize();
   handle_json_response(json_command_list_fault_pair_single, &post);
 
-  /***************************************************************************/
-  /* Check that the FAULT domain is throttled.                               */
-  /***************************************************************************/
   assert(evel_get_throttle_spec(EVEL_DOMAIN_FAULT) != NULL);
   for (domain = EVEL_DOMAIN_MEASUREMENT; domain < EVEL_MAX_DOMAINS; domain++)
   {
@@ -1825,9 +2411,6 @@ void test_json_throttle_spec_nv_pair()
   }
   assert(post.memory == NULL);
 
-  /***************************************************************************/
-  /* Request and verify the throttling state.                                */
-  /***************************************************************************/
   handle_json_response(json_command_list_provide, &post);
   assert(post.memory != NULL);
   compare_strings(expected_post_fault_pair_single,
@@ -1837,15 +2420,8 @@ void test_json_throttle_spec_nv_pair()
   free(post.memory);
   post.memory = NULL;
 
-  /***************************************************************************/
-  /* Update a specification with a single nvpair with two sub-fields         */
-  /* suppressed.                                                             */
-  /***************************************************************************/
   handle_json_response(json_command_list_fault_pair_double, &post);
 
-  /***************************************************************************/
-  /* Check that the FAULT domain is throttled.                               */
-  /***************************************************************************/
   assert(evel_get_throttle_spec(EVEL_DOMAIN_FAULT) != NULL);
   for (domain = EVEL_DOMAIN_MEASUREMENT; domain < EVEL_MAX_DOMAINS; domain++)
   {
@@ -1856,9 +2432,6 @@ void test_json_throttle_spec_nv_pair()
   }
   assert(post.memory == NULL);
 
-  /***************************************************************************/
-  /* Request and verify the throttling state.                                */
-  /***************************************************************************/
   handle_json_response(json_command_list_provide, &post);
   assert(post.memory != NULL);
   compare_strings(expected_post_fault_pair_double,
@@ -1868,9 +2441,6 @@ void test_json_throttle_spec_nv_pair()
   free(post.memory);
   post.memory = NULL;
 
-  /***************************************************************************/
-  /* Now clear the FAULT domain.                                             */
-  /***************************************************************************/
   handle_json_response(json_command_list_fault_clear, &post);
   for (domain = EVEL_DOMAIN_FAULT; domain < EVEL_MAX_DOMAINS; domain++)
   {
@@ -1879,10 +2449,11 @@ void test_json_throttle_spec_nv_pair()
 
   evel_throttle_terminate();
 }
-
+********************/
 /**************************************************************************//**
  * Test two domains, nv_pair suppression.
  *****************************************************************************/
+/*********************
 void test_json_throttle_spec_two_domains()
 {
   MEMORY_CHUNK post;
@@ -1941,16 +2512,9 @@ void test_json_throttle_spec_two_domains()
     "}"
     "}";
 
-  /***************************************************************************/
-  /* Initialize and provide a specification with a single nvpair with a      */
-  /* single sub-field suppressed.                                            */
-  /***************************************************************************/
   evel_throttle_initialize();
   handle_json_response(json_command_list_two_domains, &post);
 
-  /***************************************************************************/
-  /* Check that the FAULT and SYSLOG domains are throttled.                  */
-  /***************************************************************************/
   assert(evel_get_throttle_spec(EVEL_DOMAIN_FAULT) != NULL);
   assert(evel_get_throttle_spec(EVEL_DOMAIN_SYSLOG) != NULL);
   for (domain = EVEL_DOMAIN_MEASUREMENT; domain < EVEL_MAX_DOMAINS; domain++)
@@ -1962,9 +2526,6 @@ void test_json_throttle_spec_two_domains()
   }
   assert(post.memory == NULL);
 
-  /***************************************************************************/
-  /* Request and verify the throttling state.                                */
-  /***************************************************************************/
   handle_json_response(json_command_list_provide, &post);
   assert(post.memory != NULL);
   compare_strings(expected_post_two_domains,
@@ -1974,9 +2535,6 @@ void test_json_throttle_spec_two_domains()
   free(post.memory);
   post.memory = NULL;
 
-  /***************************************************************************/
-  /* Now clear the FAULT and SYSLOG domains.                                 */
-  /***************************************************************************/
   handle_json_response(json_command_list_fault_clear, &post);
   assert(evel_get_throttle_spec(EVEL_DOMAIN_FAULT) == NULL);
   assert(evel_get_throttle_spec(EVEL_DOMAIN_SYSLOG) != NULL);
@@ -1988,19 +2546,16 @@ void test_json_throttle_spec_two_domains()
 
   evel_throttle_terminate();
 }
-
+******************/
 /**************************************************************************//**
  * Test bad command type.
  *****************************************************************************/
+/*********************
 void test_json_throttle_spec_bad_command_type()
 {
   MEMORY_CHUNK post;
   int domain;
 
-  /***************************************************************************/
-  /* Search for "dodgy" in the JSON, and you will see the dodgy bits we're   */
-  /* handling in these tests.                                                */
-  /***************************************************************************/
   #define NUM_BAD_COMMANDS 8
   char * json_command_list_dodgy_command =
     "{"
@@ -2240,10 +2795,6 @@ void test_json_throttle_spec_bad_command_type()
     sizeof(expected_posts) / sizeof(expected_posts[0]);
   assert(num_commands == num_posts);
 
-  /***************************************************************************/
-  /* Initialize and provide a specification with a single nvpair with a      */
-  /* single sub-field suppressed.                                            */
-  /***************************************************************************/
   evel_throttle_initialize();
 
   int ii;
@@ -2252,10 +2803,6 @@ void test_json_throttle_spec_bad_command_type()
     EVEL_DEBUG("Testing commandList[%d] = %s\n", ii, json_command_lists[ii]);
     handle_json_response(json_command_lists[ii], &post);
 
-    /*************************************************************************/
-    /* Check that throttling is in a normal state - because we ignored the   */
-    /* command / .....                                                       */
-    /*************************************************************************/
     for (domain = EVEL_DOMAIN_MEASUREMENT; domain < EVEL_MAX_DOMAINS; domain++)
     {
       assert(evel_get_throttle_spec(domain) == NULL);
@@ -2270,9 +2817,6 @@ void test_json_throttle_spec_bad_command_type()
     }
     assert(post.memory == NULL);
 
-    /*************************************************************************/
-    /* Request and verify the throttling state.                              */
-    /*************************************************************************/
     handle_json_response(json_command_list_provide, &post);
     assert(post.memory != NULL);
     compare_strings(expected_posts[ii],
@@ -2285,14 +2829,12 @@ void test_json_throttle_spec_bad_command_type()
 
   evel_throttle_terminate();
 }
-
+**************************/
+/****************
 void test_encode_fault_throttled()
 {
   MEMORY_CHUNK post;
 
-  /***************************************************************************/
-  /* We also test suppression of the event header parameters here.           */
-  /***************************************************************************/
   char * json_command_list =
     "{"
     "\"commandList\": ["
@@ -2318,13 +2860,14 @@ void test_encode_fault_throttled()
     "{\"event\": {"
     "\"commonEventHeader\": {"
     "\"domain\": \"fault\", "
-    "\"eventId\": \"122\", "
+    "\"eventId\": \"fault000000001\", "
+    "\"eventName\": \"fault_eNodeB_alarm\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 122, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2"
     "}, "
@@ -2342,22 +2885,18 @@ void test_encode_fault_throttled()
     "\"value\": \"value2\"}]"
     "}}}";
 
-  /***************************************************************************/
-  /* Initialize and provide a specification with a single fault suppressed.  */
-  /***************************************************************************/
   evel_throttle_initialize();
   handle_json_response(json_command_list, &post);
 
-  /***************************************************************************/
-  /* Check that the domain is throttled.                                     */
-  /***************************************************************************/
   assert(evel_get_throttle_spec(EVEL_DOMAIN_FAULT) != NULL);
   assert(post.memory == NULL);
 
   size_t json_size = 0;
   char json_body[EVEL_MAX_JSON_BODY];
-  evel_set_next_event_sequence(122);
-  EVENT_FAULT * fault = evel_new_fault("My alarm condition",
+//  evel_set_next_event_sequence(122);
+  EVENT_FAULT * fault = evel_new_fault("fault_eNodeB_alarm",
+                                       "fault000000001",
+                                       "My alarm condition",
                                        "It broke very badly",
                                        EVEL_PRIORITY_NORMAL,
                                        EVEL_SEVERITY_MAJOR,
@@ -2368,9 +2907,6 @@ void test_encode_fault_throttled()
   evel_fault_addl_info_add(fault, "name1", "value1");
   evel_fault_addl_info_add(fault, "name2", "value2");
 
-  /***************************************************************************/
-  /* Suppressed fields.                                                      */
-  /***************************************************************************/
   evel_fault_interface_set(fault, "My Interface Card");
   evel_fault_addl_info_add(fault, "name3", "value3");
   evel_fault_addl_info_add(fault, "name4", "value4");
@@ -2383,14 +2919,12 @@ void test_encode_fault_throttled()
   evel_free_event(fault);
   evel_throttle_terminate();
 }
-
+***********************/
+/***********************
 void test_encode_measurement_throttled()
 {
   MEMORY_CHUNK post;
 
-  /***************************************************************************/
-  /* We also test suppression of the event header parameters here.           */
-  /***************************************************************************/
   char * json_command_list =
     "{"
     "\"commandList\": ["
@@ -2447,13 +2981,14 @@ void test_encode_measurement_throttled()
     "{\"event\": "
     "{\"commonEventHeader\": {"
     "\"domain\": \"measurementsForVfScaling\", "
-    "\"eventId\": \"123\", "
+    "\"eventId\": \"mvfs000000001\", "
+    "\"eventName\": \"mvfs_perfUnit_issue\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 123, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2"
     "}, "
@@ -2487,24 +3022,18 @@ void test_encode_measurement_throttled()
     "\"measurementsForVfScalingVersion\": 1.1}}}";
      MEASUREMENT_CPU_USE *cpu_use;
 
-  /***************************************************************************/
-  /* Initialize and provide a specification with a single fault suppressed.  */
-  /***************************************************************************/
   evel_throttle_initialize();
   handle_json_response(json_command_list, &post);
 
-  /***************************************************************************/
-  /* Check that the domain is throttled.                                     */
-  /***************************************************************************/
   assert(evel_get_throttle_spec(EVEL_DOMAIN_MEASUREMENT) != NULL);
   assert(post.memory == NULL);
 
   size_t json_size = 0;
   char json_body[EVEL_MAX_JSON_BODY];
-  evel_set_next_event_sequence(123);
-  EVENT_MEASUREMENT * measurement = evel_new_measurement(5.5);
+//  evel_set_next_event_sequence(123);
+  EVENT_MEASUREMENT * measurement = evel_new_measurement(5.5, "mvfs_perfUnit_issue", "mvfs000000001");
   MEASUREMENT_LATENCY_BUCKET * bucket = NULL;
-  MEASUREMENT_VNIC_PERFORMANCE * vnic_use = NULL;
+  MEASUREMENT_NIC_PERFORMANCE * vnic_use = NULL;
   assert(measurement != NULL);
 
   evel_measurement_type_set(measurement, "Perf management...");
@@ -2593,14 +3122,12 @@ void test_encode_measurement_throttled()
   evel_free_event(measurement);
   evel_throttle_terminate();
 }
-
+***************/
+/*******************`
 void test_encode_mobile_throttled()
 {
   MEMORY_CHUNK post;
 
-  /***************************************************************************/
-  /* We also test suppression of the event header parameters here.           */
-  /***************************************************************************/
   char * json_command_list =
     "{"
     "\"commandList\": ["
@@ -2645,13 +3172,14 @@ void test_encode_mobile_throttled()
     "{\"event\": "
     "{\"commonEventHeader\": {"
     "\"domain\": \"mobileFlow\", "
-    "\"eventId\": \"1242\", "
+    "\"eventId\": \"mobileFlow000000001\", "
+    "\"eventName\": \"mobileFlow_error\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 1242, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2"
     "}, "
@@ -2720,15 +3248,9 @@ void test_encode_mobile_throttled()
     "\"reportingEndpointPort\": 4322"
     "}}}";
 
-  /***************************************************************************/
-  /* Initialize and provide a specification with a single fault suppressed.  */
-  /***************************************************************************/
   evel_throttle_initialize();
   handle_json_response(json_command_list, &post);
 
-  /***************************************************************************/
-  /* Check that the domain is throttled.                                     */
-  /***************************************************************************/
   assert(evel_get_throttle_spec(EVEL_DOMAIN_MOBILE_FLOW) != NULL);
   assert(post.memory == NULL);
 
@@ -2737,10 +3259,7 @@ void test_encode_mobile_throttled()
   MOBILE_GTP_PER_FLOW_METRICS * metrics = NULL;
   EVENT_MOBILE_FLOW * mobile_flow = NULL;
 
-  /***************************************************************************/
-  /* Mobile.                                                                 */
-  /***************************************************************************/
-  evel_set_next_event_sequence(1242);
+//  evel_set_next_event_sequence(1242);
 
   metrics = evel_new_mobile_gtp_flow_metrics(132.0001,
                                              31.2,
@@ -2781,9 +3300,13 @@ void test_encode_mobile_throttled()
   evel_mobile_gtp_metrics_deact_by_set(metrics, "Remote");
   evel_mobile_gtp_metrics_con_status_set(metrics, "Connected");
   evel_mobile_gtp_metrics_tun_status_set(metrics, "Not tunneling");
-  evel_mobile_gtp_metrics_iptos_set(metrics, 1, 13);
-  evel_mobile_gtp_metrics_iptos_set(metrics, 17, 1);
-  evel_mobile_gtp_metrics_iptos_set(metrics, 4, 99);
+//  evel_mobile_gtp_metrics_iptos_set(metrics, 1, 13);
+//  evel_mobile_gtp_metrics_iptos_set(metrics, 17, 1);
+//  evel_mobile_gtp_metrics_iptos_set(metrics, 4, 99);
+  evel_mobile_gtp_metrics_ip_tos_count_list_add(metrics, "1", "13");
+  evel_mobile_gtp_metrics_ip_tos_count_list_add(metrics, "17", "1");
+  evel_mobile_gtp_metrics_ip_tos_count_list_add(metrics, "4", "99");
+
   evel_mobile_gtp_metrics_large_pkt_rtt_set(metrics, 80);
   evel_mobile_gtp_metrics_large_pkt_thresh_set(metrics, 600.0);
   evel_mobile_gtp_metrics_max_rcv_bit_rate_set(metrics, 1357924680);
@@ -2791,14 +3314,18 @@ void test_encode_mobile_throttled()
   evel_mobile_gtp_metrics_num_echo_fail_set(metrics, 1);
   evel_mobile_gtp_metrics_num_tun_fail_set(metrics, 4);
   evel_mobile_gtp_metrics_num_http_errors_set(metrics, 2);
-  evel_mobile_gtp_metrics_tcp_flag_count_add(metrics, EVEL_TCP_CWR, 10);
-  evel_mobile_gtp_metrics_tcp_flag_count_add(metrics, EVEL_TCP_URG, 121);
-  evel_mobile_gtp_metrics_qci_cos_count_add(
-                                metrics, EVEL_QCI_COS_UMTS_CONVERSATIONAL, 11);
-  evel_mobile_gtp_metrics_qci_cos_count_add(
-                                            metrics, EVEL_QCI_COS_LTE_65, 122);
-
-  mobile_flow = evel_new_mobile_flow("Inbound",
+//  evel_mobile_gtp_metrics_tcp_flag_count_add(metrics, EVEL_TCP_CWR, 10);
+//  evel_mobile_gtp_metrics_tcp_flag_count_add(metrics, EVEL_TCP_URG, 121);
+  evel_mobile_gtp_metrics_tcp_flag_count_list_add(metrics, EVEL_TCP_CWR, "10");
+  evel_mobile_gtp_metrics_tcp_flag_count_list_add(metrics, EVEL_TCP_URG, "121");
+//  evel_mobile_gtp_metrics_qci_cos_count_add( metrics, EVEL_QCI_COS_UMTS_CONVERSATIONAL, 11);
+//  evel_mobile_gtp_metrics_qci_cos_count_add( metrics, EVEL_QCI_COS_LTE_65, 122);
+  evel_mobile_gtp_metrics_qci_cos_count_list_add(metrics, EVEL_QCI_COS_UMTS_CONVERSATIONAL, "11");
+  evel_mobile_gtp_metrics_qci_cos_count_list_add(metrics, EVEL_QCI_COS_LTE_65, "122");
+
+  mobile_flow = evel_new_mobile_flow("mobileFlow_error",
+                                     "mobileFlow000000001",
+                                     "Inbound",
                                      metrics,
                                      "UDP",
                                      "IPv6",
@@ -2842,14 +3369,12 @@ void test_encode_mobile_throttled()
   evel_free_event(mobile_flow);
   evel_throttle_terminate();
 }
-
+*****************/
+/**************
 void test_encode_other_throttled()
 {
   MEMORY_CHUNK post;
 
-  /***************************************************************************/
-  /* We also test suppression of the event header parameters here.           */
-  /***************************************************************************/
   char * json_command_list =
     "{"
     "\"commandList\": ["
@@ -2871,13 +3396,14 @@ void test_encode_other_throttled()
     "{\"event\": "
     "{\"commonEventHeader\": {"
     "\"domain\": \"other\", "
-    "\"eventId\": \"129\", "
+    "\"eventId\": \"other000000001\", "
+    "\"eventName\": \"other_err\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 129, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2"
     "}, "
@@ -2889,23 +3415,17 @@ void test_encode_other_throttled()
     "]"
     "}}";
 
-  /***************************************************************************/
-  /* Initialize and provide a specification with a single fault suppressed.  */
-  /***************************************************************************/
   evel_throttle_initialize();
   handle_json_response(json_command_list, &post);
 
-  /***************************************************************************/
-  /* Check that the domain is throttled.                                     */
-  /***************************************************************************/
   assert(evel_get_throttle_spec(EVEL_DOMAIN_OTHER) != NULL);
   assert(post.memory == NULL);
 
   size_t json_size = 0;
   char json_body[EVEL_MAX_JSON_BODY];
   EVENT_OTHER * other = NULL;
-  evel_set_next_event_sequence(129);
-  other = evel_new_other();
+//  evel_set_next_event_sequence(129);
+  other = evel_new_other("other_err", "other000000001");
   assert(other != NULL);
   evel_other_type_set(other, "Other Type");
   evel_other_field_add(other,
@@ -2923,14 +3443,12 @@ void test_encode_other_throttled()
   evel_free_event(other);
   evel_throttle_terminate();
 }
-
+*******************/
+/*********************
 void test_encode_report_throttled()
 {
   MEMORY_CHUNK post;
 
-  /***************************************************************************/
-  /* We also test suppression of the event header parameters here.           */
-  /***************************************************************************/
   char * json_command_list =
     "{"
     "\"commandList\": ["
@@ -2960,13 +3478,14 @@ void test_encode_report_throttled()
     "{\"event\": "
     "{\"commonEventHeader\": {"
     "\"domain\": \"measurementsForVfReporting\", "
-    "\"eventId\": \"125\", "
+    "\"eventId\": \"report000000001\", "
+    "\"eventName\": \"report_err\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 125, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2"
     "}, "
@@ -2982,15 +3501,9 @@ void test_encode_report_throttled()
     "\"value\": \"Value1\"}]}], "
     "\"measurementFieldsVersion\": 1.1}}}";
 
-  /***************************************************************************/
-  /* Initialize and provide a specification with a single fault suppressed.  */
-  /***************************************************************************/
   evel_throttle_initialize();
   handle_json_response(json_command_list, &post);
 
-  /***************************************************************************/
-  /* Check that the domain is throttled.                                     */
-  /***************************************************************************/
   assert(evel_get_throttle_spec(EVEL_DOMAIN_REPORT) != NULL);
   assert(post.memory == NULL);
 
@@ -2998,11 +3511,8 @@ void test_encode_report_throttled()
   char json_body[EVEL_MAX_JSON_BODY];
   EVENT_REPORT * report = NULL;
 
-  /***************************************************************************/
-  /* Report.                                                                 */
-  /***************************************************************************/
-  evel_set_next_event_sequence(125);
-  report = evel_new_report(1.1);
+//  evel_set_next_event_sequence(125);
+  report = evel_new_report(1.1, "report_err", "report000000001");
   assert(report != NULL);
   evel_report_type_set(report, "Perf reporting...");
   evel_report_feature_use_add(report, "FeatureA", 123);
@@ -3019,14 +3529,12 @@ void test_encode_report_throttled()
   evel_free_event(report);
   evel_throttle_terminate();
 }
-
+**********************/
+/********************************************
 void test_encode_service_throttled()
 {
   MEMORY_CHUNK post;
 
-  /***************************************************************************/
-  /* We also test suppression of the event header parameters here.           */
-  /***************************************************************************/
   char * json_command_list =
     "{"
     "\"commandList\": ["
@@ -3062,9 +3570,9 @@ void test_encode_service_throttled()
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 2000, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2"
     "}, "
@@ -3083,22 +3591,16 @@ void test_encode_service_throttled()
     "{\"name\": \"Name4\", \"value\": \"Value4\"}]"
     "}}}";
 
-  /***************************************************************************/
-  /* Initialize and provide a specification with a single fault suppressed.  */
-  /***************************************************************************/
   evel_throttle_initialize();
   handle_json_response(json_command_list, &post);
 
-  /***************************************************************************/
-  /* Check that the domain is throttled.                                     */
-  /***************************************************************************/
   assert(evel_get_throttle_spec(EVEL_DOMAIN_SERVICE) != NULL);
   assert(post.memory == NULL);
 
   size_t json_size = 0;
   char json_body[EVEL_MAX_JSON_BODY];
   EVENT_SERVICE * event = NULL;
-  evel_set_next_event_sequence(2000);
+//  evel_set_next_event_sequence(2000);
   event = evel_new_service("vendor_x_id", "vendor_x_event_id");
   assert(event != NULL);
   evel_service_type_set(event, "Service Event");
@@ -3145,14 +3647,13 @@ void test_encode_service_throttled()
   evel_free_event(event);
   evel_throttle_terminate();
 }
+****************************/
 
+/************************
 void test_encode_signaling_throttled()
 {
   MEMORY_CHUNK post;
 
-  /***************************************************************************/
-  /* We also test suppression of the event header parameters here.           */
-  /***************************************************************************/
   char * json_command_list =
     "{"
     "\"commandList\": ["
@@ -3181,13 +3682,14 @@ void test_encode_signaling_throttled()
     "{\"event\": "
     "{\"commonEventHeader\": {"
     "\"domain\": \"signaling\", "
-    "\"eventId\": \"2001\", "
+    "\"eventId\": \"sipSignal0000000001\", "
+    "\"eventName\": \"sipSignal_err\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 2001, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2"
     "}, "
@@ -3203,23 +3705,18 @@ void test_encode_signaling_throttled()
     "\"signalingFieldsVersion\": 1.1"
     "}}}";
 
-  /***************************************************************************/
-  /* Initialize and provide a specification with a single fault suppressed.  */
-  /***************************************************************************/
   evel_throttle_initialize();
   handle_json_response(json_command_list, &post);
 
-  /***************************************************************************/
-  /* Check that the domain is throttled.                                     */
-  /***************************************************************************/
-  assert(evel_get_throttle_spec(EVEL_DOMAIN_SIGNALING) != NULL);
+  assert(evel_get_throttle_spec(EVEL_DOMAIN_SIPSIGNALING) != NULL);
   assert(post.memory == NULL);
 
   size_t json_size = 0;
   char json_body[EVEL_MAX_JSON_BODY];
   EVENT_SIGNALING * event = NULL;
-  evel_set_next_event_sequence(2001);
-  event = evel_new_signaling("vendor_x_id",
+//  evel_set_next_event_sequence(2001);
+  event = evel_new_signaling("sipSignal_err",
+           "sipSignal0000000001", "vendor_x_id",
            "correlator", "1.0.3.1", "1234", "192.168.1.3","3456");
   assert(event != NULL);
   evel_signaling_vnfmodule_name_set(event, "vendor_x_module");
@@ -3227,7 +3724,7 @@ void test_encode_signaling_throttled()
   evel_signaling_type_set(event, "Signaling");
   evel_signaling_product_id_set(event, "vendor_x_product_id");
   evel_signaling_subsystem_id_set(event, "vendor_x_subsystem_id");
-  evel_signaling_friendly_name_set(event, "vendor_x_frieldly_name");
+// evel_signaling_friendly_name_set(event, "vendor_x_frieldly_name");
   evel_signaling_correlator_set(event, "vendor_x_correlator");
   evel_signaling_local_ip_address_set(event, "1.0.3.1");
   evel_signaling_local_port_set(event, "1031");
@@ -3243,14 +3740,12 @@ void test_encode_signaling_throttled()
   evel_free_event(event);
   evel_throttle_terminate();
 }
-
+***********************/
+/**********************
 void test_encode_state_change_throttled()
 {
   MEMORY_CHUNK post;
 
-  /***************************************************************************/
-  /* We also test suppression of the event header parameters here.           */
-  /***************************************************************************/
   char * json_command_list =
     "{"
     "\"commandList\": ["
@@ -3276,13 +3771,14 @@ void test_encode_state_change_throttled()
     "{\"event\": "
     "{\"commonEventHeader\": {"
     "\"domain\": \"stateChange\", "
-    "\"eventId\": \"128\", "
+    "\"eventId\": \"stateChange000000001\", "
+    "\"eventName\": \"stateChange_err\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 128, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2"
     "}, "
@@ -3297,23 +3793,19 @@ void test_encode_state_change_throttled()
     "\"stateChangeFieldsVersion\": 1.1"
     "}}}";
 
-  /***************************************************************************/
-  /* Initialize and provide a specification with a single fault suppressed.  */
-  /***************************************************************************/
   evel_throttle_initialize();
   handle_json_response(json_command_list, &post);
 
-  /***************************************************************************/
-  /* Check that the domain is throttled.                                     */
-  /***************************************************************************/
   assert(evel_get_throttle_spec(EVEL_DOMAIN_STATE_CHANGE) != NULL);
   assert(post.memory == NULL);
 
   size_t json_size = 0;
   char json_body[EVEL_MAX_JSON_BODY];
   EVENT_STATE_CHANGE * state_change = NULL;
-  evel_set_next_event_sequence(128);
-  state_change = evel_new_state_change(EVEL_ENTITY_STATE_IN_SERVICE,
+//  evel_set_next_event_sequence(128);
+  state_change = evel_new_state_change("stateChange_err",
+                                       "stateChange000000001",
+                                       EVEL_ENTITY_STATE_IN_SERVICE,
                                        EVEL_ENTITY_STATE_OUT_OF_SERVICE,
                                        "An Interface");
   assert(state_change != NULL);
@@ -3329,14 +3821,12 @@ void test_encode_state_change_throttled()
   evel_free_event(state_change);
   evel_throttle_terminate();
 }
-
+********************/
+/*****************
 void test_encode_syslog_throttled()
 {
   MEMORY_CHUNK post;
 
-  /***************************************************************************/
-  /* We also test suppression of the event header parameters here.           */
-  /***************************************************************************/
   char * json_command_list =
     "{"
     "\"commandList\": ["
@@ -3368,13 +3858,14 @@ void test_encode_syslog_throttled()
     "{\"event\": "
     "{\"commonEventHeader\": {"
     "\"domain\": \"syslog\", "
-    "\"eventId\": \"126\", "
+    "\"eventId\": \"syslog000000001\", "
+    "\"eventName\": \"syslog_err\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 126, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2"
     "}, "
@@ -3389,23 +3880,18 @@ void test_encode_syslog_throttled()
     "]"
     "}}}";
 
-  /***************************************************************************/
-  /* Initialize and provide a specification with a single fault suppressed.  */
-  /***************************************************************************/
   evel_throttle_initialize();
   handle_json_response(json_command_list, &post);
 
-  /***************************************************************************/
-  /* Check that the domain is throttled.                                     */
-  /***************************************************************************/
   assert(evel_get_throttle_spec(EVEL_DOMAIN_SYSLOG) != NULL);
   assert(post.memory == NULL);
 
   size_t json_size = 0;
   char json_body[EVEL_MAX_JSON_BODY];
   EVENT_SYSLOG * syslog = NULL;
-  evel_set_next_event_sequence(126);
-  syslog = evel_new_syslog(EVEL_SOURCE_VIRTUAL_NETWORK_FUNCTION,
+//  evel_set_next_event_sequence(126);
+  syslog = evel_new_syslog("syslog_err", "syslog000000001",
+                           EVEL_SOURCE_VIRTUAL_NETWORK_FUNCTION,
                            "SL Message",
                            "SL Tag");
   assert(syslog != NULL);
@@ -3416,8 +3902,8 @@ void test_encode_syslog_throttled()
   evel_syslog_proc_id_set(syslog, 2);
   evel_syslog_version_set(syslog, 1);
   evel_syslog_s_data_set(syslog, "SL SDATA");
-  evel_syslog_addl_field_add(syslog, "Name1", "Value1");
-  evel_syslog_addl_field_add(syslog, "Name2", "Value2");
+  evel_syslog_addl_fields_set(syslog, "Name1", "Value1");
+  evel_syslog_addl_fields_set(syslog, "Name2", "Value2");
 
   json_size = evel_json_encode_event(
     json_body, EVEL_MAX_JSON_BODY, (EVENT_HEADER *) syslog);
@@ -3427,20 +3913,22 @@ void test_encode_syslog_throttled()
   evel_free_event(syslog);
   evel_throttle_terminate();
 }
-
+**********************/
+/********************
 void test_encode_fault_with_escaping()
 {
   char * expected =
     "{\"event\": {"
     "\"commonEventHeader\": {"
     "\"domain\": \"fault\", "
-    "\"eventId\": \"122\", "
+    "\"eventId\": \"fault000000001\", "
+    "\"eventName\": \"fault_eNodeB_alarm\", "
     "\"functionalRole\": \"UNIT TEST\", "
     "\"lastEpochMicrosec\": 1000002, "
     "\"priority\": \"Normal\", "
-    "\"reportingEntityName\": \"Dummy VM name - No Metadata available\", "
+    "\"reportingEntityName\": \"prakash-VirtualBox\", "
     "\"sequence\": 122, "
-    "\"sourceName\": \"Dummy VM name - No Metadata available\", "
+    "\"sourceName\": \"prakash-VirtualBox\", "
     "\"startEpochMicrosec\": 1000002, "
     "\"version\": 1.2, "
     "\"eventType\": \"Bad things happen...\\\\\", "
@@ -3464,8 +3952,10 @@ void test_encode_fault_with_escaping()
 
   size_t json_size = 0;
   char json_body[EVEL_MAX_JSON_BODY];
-  evel_set_next_event_sequence(122);
-  EVENT_FAULT * fault = evel_new_fault("My alarm condition",
+//  evel_set_next_event_sequence(122);
+  EVENT_FAULT * fault = evel_new_fault("fault_eNodeB_alarm",
+                                       "fault000000001",
+                                       "My alarm condition",
                                        "It broke \"very\" badly",
                                        EVEL_PRIORITY_NORMAL,
                                        EVEL_SEVERITY_MAJOR,
@@ -3484,3 +3974,4 @@ void test_encode_fault_with_escaping()
 
   evel_free_event(fault);
 }
+***********************/