Added support for new features in common driver framework in ODC driver.

 * Flow Filter
 * vTerminal

Change-Id: I7fdc072119baeed78313f58cd93f629e03215ebf
Signed-off-by: senthil <senthil-b@hcl.com>

diff --git a/coordinator/modules/vtncacheutil/confignode.cc b/coordinator/modules/vtncacheutil/confignode.cc
index 839acf241f722cfa076ff62e2498d9c68bf3a6be..0af0232cdfb21a429850ec48f9728ce1ff3b25e8 100644 (file)
--- a/coordinator/modules/vtncacheutil/confignode.cc
+++ b/coordinator/modules/vtncacheutil/confignode.cc
@@ -8,6 +8,7 @@
  */
 #include "confignode.hh"
 #include "keytree.hh"
+#include "vtn_cache_mod.hh"
 
 namespace unc {
 namespace vtndrvcache {
@@ -20,44 +21,12 @@ namespace vtndrvcache {
  */
 std::string TypeToStrFun(unc_key_type_t search_type) {
   std::string TypeStr;
-  switch (search_type) {
-    case UNC_KT_ROOT:
-      TypeStr = std::string("UNC_KT_ROOT");
-      break;
-
-    case UNC_KT_VTN:
-      TypeStr = std::string("UNC_KT_VTN");
-      break;
-
-    case UNC_KT_VBRIDGE:
-      TypeStr = std::string("UNC_KT_VBRIDGE");
-      break;
-
-    case UNC_KT_VBR_IF:
-      TypeStr = std::string("UNC_KT_VBR_IF");
-      break;
-
-    case UNC_KT_VBR_VLANMAP:
-      TypeStr = std::string("UNC_KT_VBR_VLANMAP");
-      break;
-
-    case UNC_KT_SWITCH:
-      TypeStr = std::string("UNC_KT_SWITCH");
-      break;
-
-    case UNC_KT_PORT:
-      TypeStr = std::string("UNC_KT_PORT");
-      break;
-
-    case UNC_KT_LINK:
-      TypeStr = std::string("UNC_KT_LINK");
-      break;
-
-    default:
-      TypeStr = std::string("Unknown");
-      pfc_log_info("%s: key_type = %d", PFC_FUNCNAME,
-                   search_type);
-      break;
+  std::map<unc_key_type_t, std::string>::const_iterator search =
+      VtnDrvCacheMod::keyTypeStrMap.find(search_type);
+  if (search != VtnDrvCacheMod::keyTypeStrMap.end()) {
+    TypeStr = search->second;
+  } else {
+     TypeStr = std::string("Unknown");
   }
   return TypeStr;
 }

diff --git a/coordinator/modules/vtncacheutil/include/vtn_cache_mod.hh b/coordinator/modules/vtncacheutil/include/vtn_cache_mod.hh
new file mode 100644 (file)
index 0000000..05d74ad
--- /dev/null
+++ b/coordinator/modules/vtncacheutil/include/vtn_cache_mod.hh
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2013 NEC Corporation
+ * All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this
+ * distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+#ifndef __VTNCACHEMOD_HH__
+#define __VTNCACHEMOD_HH__
+
+#include <pfcxx/module.hh>
+#include <map>
+#include <string>
+#include "unc/keytype.h"
+
+namespace unc {
+namespace vtndrvcache {
+
+class VtnDrvCacheMod: public pfc::core::Module {
+ public:
+  /**
+   ** @brief : VtnDrvCacheMod Constructor
+   **/
+  explicit VtnDrvCacheMod(const pfc_modattr_t *mattr);
+
+  /**
+   ** @brief : Call init function to initialize module
+   **/
+  pfc_bool_t  init();
+
+  /**
+   ** @brief : Call fini function to release module
+   **/
+  pfc_bool_t  fini();
+
+  /**
+   * @brief : keyTypeStrMap is a map to contain the keytype names
+   **/
+  typedef std::map<unc_key_type_t, std::string> KeyStrMap;
+  static KeyStrMap keyTypeStrMap;
+  typedef struct {
+    unc_key_type_t keytype;
+    char name[50];
+  }key_name_pair;
+};
+}  // namespace vtndrvcache
+}  // namespace unc
+#endif

diff --git a/coordinator/modules/vtncacheutil/include/vtn_conf_utility.hh b/coordinator/modules/vtncacheutil/include/vtn_conf_utility.hh
index 69b6d7f3f6cf948d07cdcb908ab71012ff5ae9d9..36379672542aa337a8d44b0c8fd574c25c5a53a8 100644 (file)
--- a/coordinator/modules/vtncacheutil/include/vtn_conf_utility.hh
+++ b/coordinator/modules/vtncacheutil/include/vtn_conf_utility.hh
@@ -35,8 +35,7 @@ class  ConfUtil {
   static std::string get_search_key(const key_vtn_t &key,
                                     const val_vtn_t &val) {
     ODC_FUNC_TRACE;
-    std::string key_str(reinterpret_cast<const char*>(&key.vtn_name));
-    return key_str;
+    return get_key(key);
   }
 
   /**
@@ -46,8 +45,7 @@ class  ConfUtil {
    */
   static std::string get_key(const key_vtn_t &key) {
     ODC_FUNC_TRACE;
-    std::string key_str(reinterpret_cast<const char*>(&key.vtn_name));
-    return key_str;
+    return (reinterpret_cast<const char*>(&key.vtn_name));
   }
   /**
    * @brief       : This method returns the parent Key for UNC_KT_VTN
@@ -77,11 +75,7 @@ class  ConfUtil {
   static std::string get_search_key(const key_vbr_t &key,
                                     const val_vbr_t &val) {
     ODC_FUNC_TRACE;
-    std::string key_str(reinterpret_cast<const char*>
-                        (key.vtn_key.vtn_name));
-    key_str += std::string(reinterpret_cast<const char*>
-                           (key.vbridge_name));
-    return key_str;
+    return (get_key(key.vtn_key) + (get_key(key)));
   }
 
   /**
@@ -91,9 +85,7 @@ class  ConfUtil {
    **/
   static std::string get_key(const key_vbr_t &key) {
     ODC_FUNC_TRACE;
-    std::string key_str(reinterpret_cast<const char*>
-                        (key.vbridge_name));
-    return key_str;
+    return (reinterpret_cast<const char*>(key.vbridge_name));
   }
 
   /**
@@ -103,11 +95,7 @@ class  ConfUtil {
    */
   static std::string get_parent_key(const key_vbr_t &key) {
     ODC_FUNC_TRACE;
-    std::string key_str = reinterpret_cast<const char*>
-        (key.vtn_key.vtn_name);
-    pfc_log_debug("Exiting Function %s.. vbr parentkey: %s", PFC_FUNCNAME,
-                  key_str.c_str());
-    return key_str;
+    return (reinterpret_cast<const char*>(key.vtn_key.vtn_name));
   }
 
   /**
@@ -128,12 +116,7 @@ class  ConfUtil {
   static std::string get_search_key(const key_vbr_if_t &key,
                                     const pfcdrv_val_vbr_if_t &val) {
     ODC_FUNC_TRACE;
-    std::string key_str(reinterpret_cast<const char*>
-                        (key.vbr_key.vtn_key.vtn_name));
-    key_str += std::string(reinterpret_cast<const char*>
-                           (key.vbr_key.vbridge_name));
-    key_str += std::string(reinterpret_cast<const char*>(key.if_name));
-    return key_str;
+    return (get_parent_key(key) + get_key(key));
   }
 
   /**
@@ -143,9 +126,7 @@ class  ConfUtil {
    */
   static std::string get_key(const key_vbr_if_t &key) {
     ODC_FUNC_TRACE;
-    std::string key_str(reinterpret_cast<const char*>
-                        (key.if_name));
-    return key_str;
+    return (reinterpret_cast<const char*>(key.if_name));
   }
   /**
    * @brief       : This method returns the parent Key for UNC_KT_VBR_IF
@@ -154,11 +135,7 @@ class  ConfUtil {
    */
   static std::string get_parent_key(const key_vbr_if_t &key) {
     ODC_FUNC_TRACE;
-    std::string key_str(reinterpret_cast<const char*>
-                        (key.vbr_key.vtn_key.vtn_name));
-    key_str += std::string(reinterpret_cast<const char*>
-                           (key.vbr_key.vbridge_name));
-    return key_str;
+    return (get_key(key.vbr_key.vtn_key) + get_key(key.vbr_key));
   }
 
   /**
@@ -179,10 +156,7 @@ class  ConfUtil {
   static std::string get_search_key(const key_vlan_map_t &key,
                                     const pfcdrv_val_vlan_map_t &val) {
     ODC_FUNC_TRACE;
-    std::string key_str(reinterpret_cast<const char*>
-                        (key.vbr_key.vtn_key.vtn_name));
-    key_str += std::string(reinterpret_cast<const char*>
-                           (key.vbr_key.vbridge_name));
+    std::string key_str = get_parent_key(key);
     if (1 == key.logical_port_id_valid) {
      key_str += std::string(reinterpret_cast<const char*>
                             (key.logical_port_id));
@@ -202,11 +176,7 @@ class  ConfUtil {
    */
   static std::string get_parent_key(const key_vlan_map_t &key) {
     ODC_FUNC_TRACE;
-    std::string key_str(reinterpret_cast<const char*>
-                        (key.vbr_key.vtn_key.vtn_name));
-    key_str += std::string(reinterpret_cast<const char*>
-                           (key.vbr_key.vbridge_name));
-    return key_str;
+    return (get_key(key.vbr_key.vtn_key) + get_key(key.vbr_key));
   }
 
   /**
@@ -236,16 +206,6 @@ class  ConfUtil {
     return UNC_KT_SWITCH;
   }
 
-  /**
-   * @brief       : This method returns the Keytype for UNC_KT_PORT
-   * @param [in]  : key
-   * @retval      : unc_key_type_t
-   */
-  static unc_key_type_t  get_key_type(const key_port_t &key) {
-    ODC_FUNC_TRACE;
-    return UNC_KT_PORT;
-  }
-
   /**
    * @brief       : This method returns the parent Key for UNC_KT_SWITCH
    * @param [in]  : key
@@ -257,17 +217,14 @@ class  ConfUtil {
   }
 
   /**
-   * @brief       : This method returns the parent Key for UNC_KT_PORT
+   * @brief       : This method returns the search Key for UNC_KT_SWITCH
    * @param [in]  : key
-   * @retval      : parent key - string
+   * @retval      : string
    */
-  static std::string get_parent_key(const key_port_t &key) {
+  static std::string get_search_key(const key_switch_t &key,
+                                    const val_switch_st &val) {
     ODC_FUNC_TRACE;
-    std::string key_str(reinterpret_cast<const char*>
-                        (key.sw_key.ctr_key.controller_name));
-    key_str += std::string(reinterpret_cast<const char*>
-                           (key.sw_key.switch_id));
-    return key_str;
+    return get_key(key);
   }
 
   /**
@@ -275,61 +232,56 @@ class  ConfUtil {
    * @param [in]  : key
    * @retval      : string
    */
-  static std::string get_search_key(const key_switch_t &key,
-                                    const val_switch_st &val) {
+  static std::string get_key(const key_switch_t &key) {
     ODC_FUNC_TRACE;
     std::string key_str(reinterpret_cast<const char*>
                         (key.ctr_key.controller_name));
-    key_str += std::string(reinterpret_cast<const char*>
-                           (key.switch_id));
-    return key_str;
+    return (key_str + (reinterpret_cast<const char*>(key.switch_id)));
   }
 
   /**
-   * @brief       : This method returns the search Key for UNC_KT_PORT
+   * @brief       : This method returns the Keytype for UNC_KT_PORT
    * @param [in]  : key
-   * @retval      : string
-   **/
-  static std::string get_search_key(const key_port_t &key,
-                                    const val_port_st_t &val) {
+   * @retval      : unc_key_type_t
+   */
+  static unc_key_type_t  get_key_type(const key_port_t &key) {
     ODC_FUNC_TRACE;
-    std::string key_str(reinterpret_cast<const char*>
-                        (key.sw_key.ctr_key.controller_name));
-    key_str += std::string(reinterpret_cast<const char*>
-                           (key.sw_key.switch_id));
-    key_str += std::string(reinterpret_cast<const char*>
-                           (key.port_id));
-    return key_str;
+    return UNC_KT_PORT;
   }
 
   /**
-   * @brief       : This method returns the name for UNC_KT_PORT
+   * @brief       : This method returns the parent Key for UNC_KT_PORT
    * @param [in]  : key
-   * @retval      : string
+   * @retval      : parent key - string
    */
-  static std::string get_key(const key_port_t &key) {
+  static std::string get_parent_key(const key_port_t &key) {
     ODC_FUNC_TRACE;
     std::string key_str(reinterpret_cast<const char*>
                         (key.sw_key.ctr_key.controller_name));
-    key_str += std::string(reinterpret_cast<const char*>
-                           (key.sw_key.switch_id));
-    key_str += std::string(reinterpret_cast<const char*>
-                           (key.port_id));
-    return key_str;
+    return (key_str + (reinterpret_cast<const char*>(key.sw_key.switch_id)));
   }
 
+
   /**
-   * @brief       : This method returns the search Key for UNC_KT_SWITCH
+   * @brief       : This method returns the search Key for UNC_KT_PORT
+   * @param [in]  : key
+   * @retval      : string
+   **/
+  static std::string get_search_key(const key_port_t &key,
+                                    const val_port_st_t &val) {
+    ODC_FUNC_TRACE;
+    return get_key(key);
+  }
+
+  /**
+   * @brief       : This method returns the name for UNC_KT_PORT
    * @param [in]  : key
    * @retval      : string
    */
-  static std::string get_key(const key_switch_t &key) {
+  static std::string get_key(const key_port_t &key) {
     ODC_FUNC_TRACE;
-    std::string key_str(reinterpret_cast<const char*>
-                        (key.ctr_key.controller_name));
-    key_str += std::string(reinterpret_cast<const char*>
-                           (key.switch_id));
-    return key_str;
+    return (get_parent_key(key) +
+           (reinterpret_cast<const char*>(key.port_id)));
   }
 
   /**
@@ -350,6 +302,16 @@ class  ConfUtil {
   static std::string get_search_key(const key_link_t &key,
                                     const val_link_st_t &val) {
     ODC_FUNC_TRACE;
+    return get_key(key);
+  }
+
+  /**
+   * @brief       : This method returns the name for UNC_KT_LINK
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_key(const key_link_t &key) {
+    ODC_FUNC_TRACE;
     std::string key_str(reinterpret_cast<const char*>
                         (key.ctr_key.controller_name));
     key_str += std::string(reinterpret_cast<const char*>
@@ -358,39 +320,574 @@ class  ConfUtil {
                            (key.port_id1));
     key_str += std::string(reinterpret_cast<const char*>
                            (key.switch_id2));
+    return (key_str + (reinterpret_cast<const char*>(key.port_id2)));
+  }
+
+  /**
+   * @brief       : This method returns the parent Key for UNC_KT_LINK
+   * @param [in]  : key
+   * @retval      : parent key - string
+   */
+  static std::string get_parent_key(const key_link_t &key) {
+    ODC_FUNC_TRACE;
+    return "ROOT";
+  }
+
+  /**
+   * @brief       : This method returns the Keytype for UNC_KT_FLOWLIST
+   * @param [in]  : key
+   * @retval      : unc_key_type_t
+   */
+  static unc_key_type_t  get_key_type(const key_flowlist_t  &key) {
+    ODC_FUNC_TRACE;
+    return UNC_KT_FLOWLIST;
+  }
+
+  /**
+   * @brief       : This method returns the search Key for UNC_KT_FLOWLIST
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_search_key(const key_flowlist_t &key,
+                                    const val_flowlist_t &val) {
+    ODC_FUNC_TRACE;
+    return (reinterpret_cast<const char*>(key.flowlist_name));
+  }
+
+  /**
+   * @brief       : This method returns the name for UNC_KT_FLOWLIST
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_key(const key_flowlist_t &key) {
+    ODC_FUNC_TRACE;
+    return (reinterpret_cast<const char*>(key.flowlist_name));
+  }
+
+  /**
+   * @brief       : This method returns the parent Key for UNC_KT_FLOWLIST
+   * @param [in]  : key
+   * @retval      : parent key - string
+   */
+  static std::string get_parent_key(const key_flowlist_t &key) {
+    ODC_FUNC_TRACE;
+    return "ROOT";
+  }
+
+  /**
+   * @brief       : This method returns the Keytype for UNC_KT_FLOWLIST_ENTRY
+   * @param [in]  : key
+   * @retval      : unc_key_type_t
+   */
+  static unc_key_type_t  get_key_type(const key_flowlist_entry_t  &key) {
+    ODC_FUNC_TRACE;
+    return UNC_KT_FLOWLIST_ENTRY;
+  }
+
+  /**
+   * @brief       : This method returns the search Key for UNC_KT_FLOWLIST_ENTRY
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_search_key(const key_flowlist_entry_t &key,
+                                    const val_flowlist_entry_t &val) {
+    ODC_FUNC_TRACE;
+    return get_key(key);
+  }
+
+  /**
+   * @brief       : This method returns the name for UNC_KT_FLOWLIST_ENTRY
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_key(const key_flowlist_entry_t &key) {
+    ODC_FUNC_TRACE;
+    char buff[10];
+    snprintf(buff, sizeof(buff), "%u", key.sequence_num);
+    return (reinterpret_cast<const char*>(key.flowlist_key.flowlist_name)
+            + std::string(buff));
+  }
+
+  /**
+   * @brief       : This method returns the parent Key for UNC_KT_FLOWLIST_ENTRY
+   * @param [in]  : key
+   * @retval      : parent key - string
+   */
+  static std::string get_parent_key(const key_flowlist_entry_t &key) {
+    ODC_FUNC_TRACE;
+    return reinterpret_cast<const char*>(key.flowlist_key.flowlist_name);
+  }
+
+  /**
+   * @brief       : This method returns the Keytype for UNC_KT_VTN_FLOWFILTER
+   * @param [in]  : key
+   * @retval      : unc_key_type_t
+   */
+  static unc_key_type_t  get_key_type(const key_vtn_flowfilter_t &key) {
+    ODC_FUNC_TRACE;
+    return UNC_KT_VTN_FLOWFILTER;
+  }
+
+  /**
+   * @brief       : This method returns the search Key for UNC_KT_VTN_FLOWFILTER
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_search_key(const key_vtn_flowfilter_t &key,
+                                    const val_flowfilter_t &val) {
+    ODC_FUNC_TRACE;
+    return get_key(key);
+  }
+
+  /**
+   * @brief       : This method returns the name for UNC_KT_VTN_FLOWFILTER
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_key(const key_vtn_flowfilter_t &key) {
+    ODC_FUNC_TRACE;
+    char buff[10];
+    snprintf(buff, sizeof(buff), "%u", key.input_direction);
+    return (get_key(key.vtn_key) + std::string(buff));
+  }
+
+  /**
+   * @brief       : This method returns the parent Key for UNC_KT_VTN_FLOWFILTER
+   * @param [in]  : key
+   * @retval      : parent key - string
+   */
+  static std::string get_parent_key(const key_vtn_flowfilter_t &key) {
+    ODC_FUNC_TRACE;
+    return (reinterpret_cast<const char*>(key.vtn_key.vtn_name));
+  }
+
+  /**
+   * @brief       : This method returns the Keytype for UNC_KT_VTN_FLOWFILTER_ENTRY
+   * @param [in]  : key
+   * @retval      : unc_key_type_t
+   */
+  static unc_key_type_t  get_key_type(const key_vtn_flowfilter_entry_t &key) {
+    ODC_FUNC_TRACE;
+    return UNC_KT_VTN_FLOWFILTER_ENTRY;
+  }
+
+  /**
+   * @brief       : This method returns the search Key for UNC_KT_VTN_FLOWFILTER_ENTRY
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_search_key(const key_vtn_flowfilter_entry_t &key,
+                                    const val_vtn_flowfilter_entry_t &val) {
+    ODC_FUNC_TRACE;
+    return get_key(key);
+  }
+
+  /**
+   * @brief       : This method returns the name for UNC_KT_VTN_FLOWFILTER_ENTRY
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_key(const key_vtn_flowfilter_entry_t &key) {
+    ODC_FUNC_TRACE;
+    char buffer[10];
+    snprintf(buffer, sizeof(buffer), "%u", key.sequence_num);
+    pfc_log_trace("sequence number for vtnflowfilter entry : %s", buffer);
+    return (get_parent_key(key) + std::string(buffer));
+  }
+
+  /**
+   * @brief       : This method returns the parent Key for UNC_KT_VTN_FLOWFILTER_ENTRY
+   * @param [in]  : key
+   * @retval      : parent key - string
+   */
+  static std::string get_parent_key(const key_vtn_flowfilter_entry_t &key) {
+    ODC_FUNC_TRACE;
+    char buff[10];
+    snprintf(buff, sizeof(buff), "%u", key.flowfilter_key.input_direction);
+    return (reinterpret_cast<const char*>(key.flowfilter_key.vtn_key.vtn_name)
+            + std::string(buff));
+  }
+
+  /**
+   * @brief       : This method returns the Keytype for UNC_KT_VBR_FLOWFILTER
+   * @param [in]  : key
+   * @retval      : unc_key_type_t
+   */
+  static unc_key_type_t  get_key_type(const key_vbr_flowfilter_t &key) {
+    ODC_FUNC_TRACE;
+    return UNC_KT_VBR_FLOWFILTER;
+  }
+
+  /**
+   * @brief       : This method returns the search Key for UNC_KT_VBR_FLOWFILTER
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_search_key(const key_vbr_flowfilter_t &key,
+                                    const val_flowfilter_t  &val) {
+    ODC_FUNC_TRACE;
+    return get_key(key);
+  }
+
+  /**
+   * @brief       : This method returns the name for UNC_KT_VBR_FLOWFILTER
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_key(const key_vbr_flowfilter_t &key) {
+    ODC_FUNC_TRACE;
+    char buff[10];
+    snprintf(buff, sizeof(buff), "%u", key.direction);
+    pfc_log_trace("direction for vtnflowfilter entry : %s", buff);
+    return (get_parent_key(key) + std::string(buff));
+  }
+
+  /**
+   * @brief       : This method returns the parent Key for UNC_KT_VBR_FLOWFILTER
+   * @param [in]  : key
+   * @retval      : parent key - string
+   */
+  static std::string get_parent_key(const key_vbr_flowfilter_t &key) {
+    ODC_FUNC_TRACE;
+    std::string key_str = reinterpret_cast<const char*>
+                        (key.vbr_key.vtn_key.vtn_name);
+    return (key_str + reinterpret_cast<const char*>(key.vbr_key.vbridge_name));
+  }
+
+  /**
+   * @brief       : This method returns the Keytype for UNC_KT_VBR_FLOWFILTER_ENTRY
+   * @param [in]  : key
+   * @retval      : unc_key_type_t
+   */
+  static unc_key_type_t  get_key_type(const key_vbr_flowfilter_entry_t &key) {
+    ODC_FUNC_TRACE;
+    return UNC_KT_VBR_FLOWFILTER_ENTRY;
+  }
+
+  /**
+   * @brief       : This method returns the search Key for UNC_KT_VBR_FLOWFILTER_ENTRY
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_search_key(const key_vbr_flowfilter_entry_t &key,
+                                    const val_flowfilter_entry_t  &val) {
+    ODC_FUNC_TRACE;
+    return get_key(key);
+  }
+
+  /**
+   * @brief       : This method returns the name for UNC_KT_VBR_FLOWFILTER_ENTRY
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_key(const key_vbr_flowfilter_entry_t &key) {
+    ODC_FUNC_TRACE;
+    char buff[10];
+    snprintf(buff, sizeof(buff), "%u", key.sequence_num);
+    pfc_log_trace("sequence for vtnflowfilter entry : %s", buff);
+    return (get_parent_key(key) + std::string(buff));
+  }
+
+  /**
+   * @brief       : This method returns the parent Key for UNC_KT_VBR_FLOWFILTER_ENTRY
+   * @param [in]  : key
+   * @retval      : parent key - string
+   */
+  static std::string get_parent_key(const key_vbr_flowfilter_entry_t &key) {
+    ODC_FUNC_TRACE;
+    std::string key_str(reinterpret_cast<const char*>
+                        (key.flowfilter_key.vbr_key.vtn_key.vtn_name));
     key_str += std::string(reinterpret_cast<const char*>
-                           (key.port_id2));
-    return key_str;
+                           (key.flowfilter_key.vbr_key.vbridge_name));
+    char buffer[10];
+    snprintf(buffer, sizeof(buffer), "%u", key.flowfilter_key.direction);
+    return (key_str + std::string(buffer));
   }
 
   /**
-   * @brief       : This method returns the name for UNC_KT_LINK
+   * @brief       : This method returns the Keytype for UNC_KT_VBRIF_FLOWFILTER
+   * @param [in]  : key
+   * @retval      : unc_key_type_t
+   */
+  static unc_key_type_t  get_key_type(const key_vbr_if_flowfilter_t &key) {
+    ODC_FUNC_TRACE;
+    return UNC_KT_VBRIF_FLOWFILTER;
+  }
+
+  /**
+   * @brief       : This method returns the search Key for UNC_KT_VBRIF_FLOWFILTER
    * @param [in]  : key
    * @retval      : string
    */
-  static std::string get_key(const key_link_t &key) {
+  static std::string get_search_key(const key_vbr_if_flowfilter_t &key,
+                                    const pfcdrv_val_vbrif_vextif_t  &val) {
+    ODC_FUNC_TRACE;
+    return get_key(key);
+  }
+
+  /**
+   * @brief       : This method returns the name for UNC_KT_VBRIF_FLOWFILTER
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_key(const key_vbr_if_flowfilter_t  &key) {
+    ODC_FUNC_TRACE;
+    char buffer[10];
+    snprintf(buffer, sizeof(buffer), "%u", key.direction);
+    return (get_parent_key(key) + std::string(buffer));
+  }
+
+  /**
+   * @brief       : This method returns the parent Key for UNC_KT_VBRIF_FLOWFILTER
+   * @param [in]  : key
+   * @retval      : parent key - string
+   */
+  static std::string get_parent_key(const key_vbr_if_flowfilter_t &key) {
     ODC_FUNC_TRACE;
     std::string key_str(reinterpret_cast<const char*>
-                        (key.ctr_key.controller_name));
+                        (key.if_key.vbr_key.vtn_key.vtn_name));
     key_str += std::string(reinterpret_cast<const char*>
-                           (key.switch_id1));
+                           (key.if_key.vbr_key.vbridge_name));
+    return (key_str + reinterpret_cast<const char*>(key.if_key.if_name));
+  }
+
+  /**
+   * @brief       : This method returns the Keytype for UNC_KT_VBRIF_FLOWFILTER_ENTRY
+   * @param [in]  : key
+   * @retval      : unc_key_type_t
+   */
+  static unc_key_type_t get_key_type(const key_vbr_if_flowfilter_entry_t &key) {
+    ODC_FUNC_TRACE;
+    return UNC_KT_VBRIF_FLOWFILTER_ENTRY;
+  }
+
+  /**
+   * @brief       : This method returns the search Key for UNC_KT_VBRIF_FLOWFILTER_ENTRY
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_search_key(const key_vbr_if_flowfilter_entry_t &key,
+                                    const pfcdrv_val_flowfilter_entry_t  &val) {
+    ODC_FUNC_TRACE;
+    return get_key(key);
+  }
+
+  /**
+   * @brief       : This method returns the name for UNC_KT_VBRIF_FLOWFILTER_ENTRY
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_key(const key_vbr_if_flowfilter_entry_t  &key) {
+    ODC_FUNC_TRACE;
+    char buff[10];
+    snprintf(buff, sizeof(buff), "%u", key.sequence_num);
+    pfc_log_trace("sequence number for vbriflow-filter entry : %s", buff);
+    return (get_parent_key(key) + std::string(buff));
+  }
+
+  /**
+   * @brief       : This method returns the parent Key for UNC_KT_VBRIF_FLOWFILTER_ENTRY
+   * @param [in]  : key
+   * @retval      : parent key - string
+   */
+  static std::string get_parent_key(const key_vbr_if_flowfilter_entry_t &key) {
+    ODC_FUNC_TRACE;
+    std::string key_str(reinterpret_cast<const char*>
+                        (key.flowfilter_key.if_key.vbr_key.vtn_key.vtn_name));
     key_str += std::string(reinterpret_cast<const char*>
-                           (key.port_id1));
+                           (key.flowfilter_key.if_key.vbr_key.vbridge_name));
     key_str += std::string(reinterpret_cast<const char*>
-                           (key.switch_id2));
+                           (key.flowfilter_key.if_key.if_name));
+    char buffer[10];
+    snprintf(buffer, sizeof(buffer), "%u", key.flowfilter_key.direction);
+    return (key_str + std::string(buffer));
+  }
+
+  /**
+   * @brief       : This method returns the Keytype for UNC_KT_VTERMINAL
+   * @param [in]  : key
+   * @retval      : unc_key_type_t
+   */
+  static unc_key_type_t  get_key_type(const key_vterm_t &key) {
+    ODC_FUNC_TRACE;
+    return UNC_KT_VTERMINAL;
+  }
+
+  /**
+   * @brief       : This method returns the search Key for UNC_KT_VTERMINAL
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_search_key(const key_vterm_t &key,
+                                    const val_vterm_t  &val) {
+    ODC_FUNC_TRACE;
+    return get_key(key);
+  }
+
+  /**
+   * @brief       : This method returns the name for UNC_KT_VTERMINAL
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_key(const key_vterm_t &key) {
+    ODC_FUNC_TRACE;
+    std::string key_str(reinterpret_cast<const char*>
+                        (key.vtn_key.vtn_name));
+    return (key_str + reinterpret_cast<const char*>(key.vterminal_name));
+  }
+
+  /**
+   * @brief       : This method returns the parent Key for UNC_KT_VTERMINAL
+   * @param [in]  : key
+   * @retval      : parent key - string
+   */
+  static std::string get_parent_key(const key_vterm_t &key) {
+    ODC_FUNC_TRACE;
+    return (reinterpret_cast<const char*>(key.vtn_key.vtn_name));
+  }
+
+  /**
+   * @brief       : This method returns the Keytype for UNC_KT_VTERM_IF
+   * @param [in]  : key
+   * @retval      : unc_key_type_t
+   */
+  static unc_key_type_t  get_key_type(const key_vterm_if_t &key) {
+    ODC_FUNC_TRACE;
+    return UNC_KT_VTERM_IF;
+  }
+
+  /**
+   * @brief       : This method returns the search Key for UNC_KT_VTERM_IF
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_search_key(const key_vterm_if_t &key,
+                                    const val_vterm_if_t  &val) {
+    ODC_FUNC_TRACE;
+    return get_key(key);
+  }
+
+  /**
+   * @brief       : This method returns the name for UNC_KT_VTERM_IF
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_key(const key_vterm_if_t &key) {
+    ODC_FUNC_TRACE;
+    return (get_parent_key(key) + (reinterpret_cast<const char*>(key.if_name)));
+  }
+
+  /**
+   * @brief       : This method returns the parent Key for UNC_KT_VTERM_IF
+   * @param [in]  : key
+   * @retval      : parent key - string
+   */
+  static std::string get_parent_key(const key_vterm_if_t &key) {
+    ODC_FUNC_TRACE;
+    std::string key_str(reinterpret_cast<const char*>
+                        (key.vterm_key.vtn_key.vtn_name));
+    return (key_str + reinterpret_cast<const char*>
+                       (key.vterm_key.vterminal_name));
+  }
+
+  /**
+   * @brief       : This method returns the Keytype for UNC_KT_VTERMIF_FLOWFILTER
+   * @param [in]  : key
+   * @retval      : unc_key_type_t
+   */
+  static unc_key_type_t  get_key_type(const key_vterm_if_flowfilter_t &key) {
+    ODC_FUNC_TRACE;
+    return UNC_KT_VTERMIF_FLOWFILTER;
+  }
+
+  /**
+   * @brief       : This method returns the search Key for UNC_KT_VTERMIF_FLOWFILTER
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_search_key(const key_vterm_if_flowfilter_t &key,
+                                    const val_flowfilter_t &val) {
+    ODC_FUNC_TRACE;
+    return get_key(key);
+  }
+
+  /**
+   * @brief       : This method returns the name for UNC_KT_VTERMIF_FLOWFILTER
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_key(const key_vterm_if_flowfilter_t &key) {
+    ODC_FUNC_TRACE;
+    char buffer[10];
+    snprintf(buffer, sizeof(buffer), "%u", key.direction);
+    return (get_parent_key(key) + std::string(buffer));
+  }
+
+  /**
+   * @brief       : This method returns the parent Key for UNC_KT_VTERMIF_FLOWFILTER
+   * @param [in]  : key
+   * @retval      : parent key - string
+   */
+  static std::string get_parent_key(const key_vterm_if_flowfilter_t &key) {
+    ODC_FUNC_TRACE;
+    std::string key_str(reinterpret_cast<const char*>
+                        (key.if_key.vterm_key.vtn_key.vtn_name));
     key_str += std::string(reinterpret_cast<const char*>
-                           (key.port_id2));
-    return key_str;
+                        (key.if_key.vterm_key.vterminal_name));
+    return (key_str + reinterpret_cast<const char*>(key.if_key.if_name));
   }
 
   /**
-   * @brief       : This method returns the parent Key for UNC_KT_LINK
+   * @brief       : This method returns the Keytype for UNC_KT_VTERMIF_FLOWFILTER_ENTRY
+   * @param [in]  : key
+   * @retval      : unc_key_type_t
+   */
+  static unc_key_type_t get_key_type(
+      const key_vterm_if_flowfilter_entry_t &key) {
+    ODC_FUNC_TRACE;
+    return UNC_KT_VTERMIF_FLOWFILTER_ENTRY;
+  }
+
+  /**
+   * @brief       : This method returns the search Key for UNC_KT_VTERMIF_FLOWFILTER_ENTRY
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_search_key(const key_vterm_if_flowfilter_entry_t &key,
+                                    const val_flowfilter_entry_t &val) {
+    ODC_FUNC_TRACE;
+    return get_key(key);
+  }
+
+  /**
+   * @brief       : This method returns the name for UNC_KT_VTERMIF_FLOWFILTER_ENTRY
+   * @param [in]  : key
+   * @retval      : string
+   */
+  static std::string get_key(const key_vterm_if_flowfilter_entry_t &key) {
+    ODC_FUNC_TRACE;
+    char buff[10];
+    snprintf(buff, sizeof(buff), "%u", key.sequence_num);
+    return ((get_parent_key(key)) + (std::string(buff)));
+  }
+
+  /**
+   * @brief       : This method returns the parent Key for UNC_KT_VTERMIF_FLOWFILTER_ENTRY
    * @param [in]  : key
    * @retval      : parent key - string
    */
-  static std::string get_parent_key(const key_link_t &key) {
+  static std::string get_parent_key(
+      const key_vterm_if_flowfilter_entry_t &key) {
     ODC_FUNC_TRACE;
-    return "ROOT";
+    std::string key_str(reinterpret_cast<const char*>
+                        (key.flowfilter_key.if_key.vterm_key.vtn_key.vtn_name));
+    key_str += std::string(reinterpret_cast<const char*>
+                        (key.flowfilter_key.if_key.vterm_key.vterminal_name));
+    key_str += std::string(reinterpret_cast<const char*>
+                        (key.flowfilter_key.if_key.if_name));
+    char buffer[10];
+    snprintf(buffer, sizeof(buffer), "%u", key.flowfilter_key.direction);
+    return (key_str + std::string(buffer));
   }
 };
 }  // namespace vtndrvcache

diff --git a/coordinator/modules/vtncacheutil/keytree.cc b/coordinator/modules/vtncacheutil/keytree.cc
index bca1086a9d19b6f2e95d76cb9ebc2d29a0ca83d1..cc58f7927c56f99e43362b66dd4f5ded4761e853 100644 (file)
--- a/coordinator/modules/vtncacheutil/keytree.cc
+++ b/coordinator/modules/vtncacheutil/keytree.cc
@@ -60,7 +60,18 @@ key_tree key_tree_table[] = {
   { UNC_KT_VBR_VLANMAP, UNC_KT_VBRIDGE, 1 },
   { UNC_KT_SWITCH, UNC_KT_ROOT, 0 },
   { UNC_KT_PORT, UNC_KT_SWITCH, 1 },
-  { UNC_KT_LINK, UNC_KT_ROOT, 0 }
+  { UNC_KT_LINK, UNC_KT_ROOT, 0 },
+  { UNC_KT_FLOWLIST_ENTRY, UNC_KT_FLOWLIST, 0 },
+  { UNC_KT_VTN_FLOWFILTER, UNC_KT_VTN, 0 },
+  { UNC_KT_VTN_FLOWFILTER_ENTRY, UNC_KT_VTN_FLOWFILTER, 0 },
+  { UNC_KT_VBR_FLOWFILTER, UNC_KT_VBRIDGE, 0},
+  { UNC_KT_VBR_FLOWFILTER_ENTRY, UNC_KT_VBR_FLOWFILTER, 0 },
+  { UNC_KT_VBRIF_FLOWFILTER, UNC_KT_VBR_IF, 0 },
+  { UNC_KT_VBRIF_FLOWFILTER_ENTRY, UNC_KT_VBRIF_FLOWFILTER, 0 },
+  { UNC_KT_VTERMINAL, UNC_KT_VTN, 6 },
+  { UNC_KT_VTERM_IF, UNC_KT_VTERMINAL, 0},
+  { UNC_KT_VTERMIF_FLOWFILTER, UNC_KT_VTERM_IF, 0},
+  { UNC_KT_VTERMIF_FLOWFILTER_ENTRY, UNC_KT_VTERMIF_FLOWFILTER, 0}
 };
 
 /**

diff --git a/coordinator/modules/vtncacheutil/vtn_cache_mod.cc b/coordinator/modules/vtncacheutil/vtn_cache_mod.cc
index a4b05b4463ce3aa9d9fc3a4078696dd868c3d2d8..95aa96f179db797a4348c521be00d61b640881ad 100644 (file)
--- a/coordinator/modules/vtncacheutil/vtn_cache_mod.cc
+++ b/coordinator/modules/vtncacheutil/vtn_cache_mod.cc
@@ -6,33 +6,61 @@
  * terms of the Eclipse Public License v1.0 which accompanies this
  * distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
  */
-#include <pfcxx/module.hh>
+#include <vtn_cache_mod.hh>
 
 namespace unc {
 namespace vtndrvcache {
 
-class VtnDrvCacheMod: public pfc::core::Module {
- public:
-  /**
-   ** @brief : VtnDrvCacheMod Constructor
-   **/
-  explicit VtnDrvCacheMod(const pfc_modattr_t *mattr):
-  pfc::core::Module(mattr) { }
+/**
+ ** @brief : VtnDrvCacheMod Constructor
+ **/
+VtnDrvCacheMod::VtnDrvCacheMod(const pfc_modattr_t *mattr)
+: pfc::core::Module(mattr) {
+  keyTypeStrMap.clear();
+}
 
-  /**
-   ** @brief : Call init function to initialize module
-   **/
-  pfc_bool_t  init() {
-    return PFC_TRUE;
-  }
+/**
+ ** @brief : Call init function to initialize module
+ **/
+pfc_bool_t  VtnDrvCacheMod::init() {
+  // Intialize keyTypeStrMap Map
+  keyTypeStrMap.clear();
+  key_name_pair obj[] = {{UNC_KT_ROOT, "UNC_KT_ROOT"},
+  {UNC_KT_VTN, "UNC_KT_VTN"},
+  {UNC_KT_VBRIDGE, "UNC_KT_VBRIDGE"}, {UNC_KT_VBR_IF, "UNC_KT_VBR_IF"},
+  {UNC_KT_VBR_VLANMAP, "UNC_KT_VBR_VLANMAP"}, {UNC_KT_SWITCH, "UNC_KT_SWITCH"},
+  {UNC_KT_PORT, "UNC_KT_PORT"}, {UNC_KT_LINK, "UNC_KT_LINK"},
+  {UNC_KT_FLOWLIST, "UNC_KT_FLOWLIST"},
+  {UNC_KT_FLOWLIST_ENTRY, "UNC_KT_FLOWLIST_ENTRY"},
+  {UNC_KT_VTN_FLOWFILTER, "UNC_KT_VTN_FLOWFILTER"},
+  {UNC_KT_VTN_FLOWFILTER_ENTRY, "UNC_KT_VTN_FLOWFILTER_ENTRY"},
+  {UNC_KT_VBR_FLOWFILTER,  "UNC_KT_VBR_FLOWFILTER"},
+  {UNC_KT_VBR_FLOWFILTER_ENTRY, "UNC_KT_VBR_FLOWFILTER_ENTRY"},
+  {UNC_KT_VBRIF_FLOWFILTER, "UNC_KT_VBRIF_FLOWFILTER"},
+  {UNC_KT_VBRIF_FLOWFILTER_ENTRY, "UNC_KT_VBRIF_FLOWFILTER_ENTRY"},
+  {UNC_KT_VTERMINAL, "UNC_KT_VTERMINAL"},
+  {UNC_KT_VTERM_IF, "UNC_KT_VTERM_IF"},
+  {UNC_KT_VTERMIF_FLOWFILTER, "UNC_KT_VTERMIF_FLOWFILTER"},
+  {UNC_KT_VTERMIF_FLOWFILTER_ENTRY, "UNC_KT_VTERMIF_FLOWFILTER_ENTRY"}};
 
-  /**
-   ** @brief : Call fini function to release module
-   **/
-  pfc_bool_t  fini() {
-    return PFC_TRUE;
+  for (uint32_t i = 0; i < sizeof((obj))/sizeof((obj[0])); i++) {
+    keyTypeStrMap.insert(std::pair<unc_key_type_t,
+                         std::string>(obj[i].keytype, obj[i].name));
   }
-};
+
+  return PFC_TRUE;
+}
+
+// Static variable keyTypeStrMap
+std::map<unc_key_type_t, std::string> VtnDrvCacheMod::keyTypeStrMap;
+
+/**
+ ** @brief : Call fini function to release module
+ **/
+pfc_bool_t  VtnDrvCacheMod::fini() {
+  keyTypeStrMap.clear();
+  return PFC_TRUE;
+}
 }  // namespace vtndrvcache
 }  // namespace unc
 PFC_MODULE_IPC_DECL(unc::vtndrvcache::VtnDrvCacheMod, 0);

diff --git a/coordinator/modules/vtndrvintf/include/request_template.hh b/coordinator/modules/vtndrvintf/include/request_template.hh
index 13b500592d2e36252e1cc62140214065dc8a60ca..512f760a15a31f0e7392755894ef0deebeca491a 100644 (file)
--- a/coordinator/modules/vtndrvintf/include/request_template.hh
+++ b/coordinator/modules/vtndrvintf/include/request_template.hh
@@ -140,15 +140,8 @@ class KtRequestHandler : public KtHandler {
   populate_response_header(pfc::core::ipc::ServerSession &sess,
                          unc::driver::odl_drv_response_header_t &resp_hdr);
 
-  /**
-   * @brief  - This method initializes map for STDEF
-   * @retval -  void
-   **/
-  void initialize_map();
 
   KtHandler* get_handler(unc_key_type_t keytype);
-  std::map<unc_key_type_t, pfc_ipcstdef_t*> key_map_;
-  std::map<unc_key_type_t, pfc_ipcstdef_t*> val_map_;
   kt_handler_map* kt_map_;
 };
 
@@ -158,20 +151,7 @@ class KtRequestHandler : public KtHandler {
  **/
 
 template<typename key, typename val>
-KtRequestHandler<key, val>::~KtRequestHandler() {
-     std::map<unc_key_type_t, pfc_ipcstdef_t*> :: iterator map_it;
-     for (map_it = key_map_.begin(); map_it != key_map_.end(); map_it++) {
-                delete map_it->second;
-                map_it->second = NULL;
-     }
-     for (map_it = val_map_.begin(); map_it != val_map_.end(); map_it++) {
-                delete map_it->second;
-                map_it->second = NULL;
-     }
-
-     key_map_.clear();
-     val_map_.clear();
-}
+KtRequestHandler<key, val>::~KtRequestHandler() {}
 
   /**
    * @brief    - This method retrieves the Key struct from ConfigNode pointer
@@ -946,9 +926,8 @@ KtRequestHandler<key_root_t, val_root_t>::handle_response(
 
         void* key = get_key_struct(cfgnode);
         void* val = get_val_struct(cfgnode);
-        initialize_map();
-        pfc_ipcstdef_t* key_sdf =key_map_.find(keytype)->second;
-        pfc_ipcstdef_t* val_sdf =val_map_.find(keytype)->second;
+        pfc_ipcstdef_t* key_sdf =VtnDrvIntf::key_map.find(keytype)->second;
+        pfc_ipcstdef_t* val_sdf =VtnDrvIntf::val_map.find(keytype)->second;
         ret_code = sess.addOutput(*key_sdf, key);
         if (ret_code) {
           pfc_log_error("%s: addOutput failed for key_sdf with ret_code , %u",
@@ -1138,73 +1117,6 @@ KtRequestHandler<key, val>::populate_response_header(
 
   return UNC_RC_SUCCESS;
 }
-
-  /**
-   * @brief  - This method initializes map for STDEF
-   * @retval - void
-   **/
-template<typename key, typename val>
-void
-KtRequestHandler<key, val>::initialize_map() {
-  uint32_t loop = 0;
-  unc_key_type_t KT[] = {UNC_KT_VTN, UNC_KT_VBRIDGE, UNC_KT_VBR_IF,
-                                    UNC_KT_VBR_VLANMAP};
-  uint32_t kt_size = sizeof KT/sizeof(unc_key_type_t);
-  for (; loop < kt_size; loop++) {
-    switch (KT[loop]) {
-      case UNC_KT_VTN:
-        {
-          pfc_ipcstdef_t *stdef_k = new pfc_ipcstdef_t;
-          PFC_IPC_STDEF_INIT(stdef_k, key_vtn);
-          pfc_ipcstdef_t *stdef_v = new pfc_ipcstdef_t;
-          PFC_IPC_STDEF_INIT(stdef_v, val_vtn);
-          key_map_.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
-                                                                     stdef_k));
-          val_map_.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
-                                                                     stdef_v));
-          break;
-        }
-      case UNC_KT_VBRIDGE:
-        {
-          pfc_ipcstdef_t *stdef_kvbr = new pfc_ipcstdef_t;
-          PFC_IPC_STDEF_INIT(stdef_kvbr, key_vbr);
-          pfc_ipcstdef_t *stdef_vbr = new pfc_ipcstdef_t;
-          PFC_IPC_STDEF_INIT(stdef_vbr, val_vbr);
-          key_map_.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
-                                                             stdef_kvbr));
-          val_map_.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
-                                                              stdef_vbr));
-          break;
-        }
-      case UNC_KT_VBR_IF:
-        {
-          pfc_ipcstdef_t *stdef_kvbrif = new pfc_ipcstdef_t;
-          PFC_IPC_STDEF_INIT(stdef_kvbrif, key_vbr_if);
-          pfc_ipcstdef_t *stdef_vbrif = new pfc_ipcstdef_t;
-          PFC_IPC_STDEF_INIT(stdef_vbrif, pfcdrv_val_vbr_if);
-          key_map_.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
-                                                              stdef_kvbrif));
-          val_map_.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
-                                                               stdef_vbrif));
-          break;
-        }
-      case UNC_KT_VBR_VLANMAP:
-        {
-          pfc_ipcstdef_t *stdef_kvbrvlanmap = new pfc_ipcstdef_t;
-          PFC_IPC_STDEF_INIT(stdef_kvbrvlanmap, key_vlan_map);
-          pfc_ipcstdef_t *stdef_vbrvlanmap = new pfc_ipcstdef_t;
-          PFC_IPC_STDEF_INIT(stdef_vbrvlanmap, val_vlan_map);
-          key_map_.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
-                                                          stdef_kvbrvlanmap));
-          val_map_.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
-                                                           stdef_vbrvlanmap));
-         break;
-        }
-      default:
-        break;
-    }
-  }
-}
-}  // namespace driver
-}  // namespace unc
+}  //  namespace driver
+}  //  namespace unc
 #endif

diff --git a/coordinator/modules/vtndrvintf/include/vtn_drv_module.hh b/coordinator/modules/vtndrvintf/include/vtn_drv_module.hh
index 45246fd89f13b9f0002f78121428fd68131e8e92..cd2bdc4f6c77914c869227372c4861d14002c63d 100644 (file)
--- a/coordinator/modules/vtndrvintf/include/vtn_drv_module.hh
+++ b/coordinator/modules/vtndrvintf/include/vtn_drv_module.hh
@@ -19,7 +19,6 @@
 #include <driver/driver_command.hh>
 #include <vtn_drv_transaction_handle.hh>
 #include <driver/driver_interface.hh>
-#include <pfcxx/ipc_server.hh>
 #include <unc/unc_events.h>
 #include <string>
 #include <map>
@@ -45,6 +44,15 @@ enum ValDomainEventIndex {
 
 class VtnDrvIntf :public pfc::core::Module {
  public:
+  typedef std::map<unc_key_type_t, pfc_ipcstdef_t*> kt_map;
+  static kt_map key_map;
+  static kt_map val_map;
+
+  /**
+   * @brief  - Method to initialize pfc_ipcstdef_t pointer with keytype
+   * @retval - None
+   */
+  void  initialize_map(void);
   /**
    * @brief     : Constructor
    * @param[in] : pfc_modattr_t*
@@ -200,6 +208,16 @@ class VtnDrvIntf :public pfc::core::Module {
   template <typename key, typename value>
   void create_handler(unc_key_type_t keytype);
 
+#define POPULATE_STDEF(key, value, keytype, stdef_k, stdef_v)  \
+  pfc_ipcstdef_t *stdef_k = new pfc_ipcstdef_t; \
+  PFC_IPC_STDEF_INIT(stdef_k, key); \
+  pfc_ipcstdef_t *stdef_v = new pfc_ipcstdef_t;\
+  PFC_IPC_STDEF_INIT(stdef_v, value); \
+  key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(keytype,\
+                                                            stdef_k));\
+  val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(keytype, \
+                                                            stdef_v));
+
   // used for Controller ping
   pfc::core::TaskQueue* taskq_;
 

diff --git a/coordinator/modules/vtndrvintf/include/vtn_drv_transaction_handle.hh b/coordinator/modules/vtndrvintf/include/vtn_drv_transaction_handle.hh
index d1db4afea3ed0070a56e7cff0be9dad5934caea3..6b0c34f1431632a2add51290a6e977ff4c085374 100644 (file)
--- a/coordinator/modules/vtndrvintf/include/vtn_drv_transaction_handle.hh
+++ b/coordinator/modules/vtndrvintf/include/vtn_drv_transaction_handle.hh
@@ -24,7 +24,6 @@ namespace driver {
 class DriverTxnInterface : public unc::tclib::TcLibInterface {
  public:
   typedef std::list<std::string> ::iterator ctr_iter;
-  typedef std::map<unc_key_type_t, pfc_ipcstdef_t*> kt_map;
   typedef std::map <unc_key_type_t, KtHandler*> kt_handler_map;
   /**
    * @brief  - DriverTxnInterface constructor
@@ -393,12 +392,6 @@ class DriverTxnInterface : public unc::tclib::TcLibInterface {
                                                    uint32_t config_id,
                                                    unc::tclib::TcControllerList
                                                    controllers);
-  /**
-   * @brief  - Method to initialize pfc_ipcstdef_t pointer with keytype
-   * @retval - None
-   */
-  void  initialize_map(void);
-
   /**
    * @brief       - Method to Abort the controller which failed in VOTE
    * @param[in]   - Tc controller list
@@ -419,8 +412,6 @@ class DriverTxnInterface : public unc::tclib::TcLibInterface {
 
  private:
   ControllerFramework* crtl_inst_;
-  kt_map key_map_;
-  kt_map val_map_;
   kt_handler_map kt_handler_map_;
 };
 }  // namespace driver

diff --git a/coordinator/modules/vtndrvintf/vtn_drv_module.cc b/coordinator/modules/vtndrvintf/vtn_drv_module.cc
index c3ab74ca6d6ae93cb3c76394224b89c914371787..be6d0aed5104cef018947020d2008d31b21a46f2 100644 (file)
--- a/coordinator/modules/vtndrvintf/vtn_drv_module.cc
+++ b/coordinator/modules/vtndrvintf/vtn_drv_module.cc
@@ -13,6 +13,8 @@
 namespace unc {
 namespace driver {
 
+std::map<unc_key_type_t, pfc_ipcstdef_t*>VtnDrvIntf::key_map;
+std::map<unc_key_type_t, pfc_ipcstdef_t*>VtnDrvIntf::val_map;
 /**
  * @brief     : constructor
  */
@@ -29,10 +31,22 @@ VtnDrvIntf::VtnDrvIntf(const pfc_modattr_t* attr)
 VtnDrvIntf::~VtnDrvIntf() {
   ODC_FUNC_TRACE;
   std::map <unc_key_type_t, unc::driver::KtHandler*> ::iterator map_it;
+  std::map<unc_key_type_t, pfc_ipcstdef_t*> :: iterator map_key;
   for (map_it = map_kt_.begin(); map_it != map_kt_.end(); map_it++) {
        delete (map_it)->second;
   }
   map_kt_.clear();
+  for (map_key = key_map.begin(); map_key != key_map.end(); map_key++) {
+    delete map_key->second;
+    map_key->second = NULL;
+  }
+  for (map_key = val_map.begin(); map_key != val_map.end(); map_key++) {
+    delete map_key->second;
+    map_key->second = NULL;
+  }
+
+  key_map.clear();
+  val_map.clear();
 }
 
 /**
@@ -49,6 +63,7 @@ pfc_bool_t VtnDrvIntf::init(void) {
                                         conf_parser_.time_interval);
   PFC_ASSERT(ctrl_inst_ != NULL);
   set_controller_instance(ctrl_inst_);
+  initialize_map();
 
   create_handler<key_root_t, val_root_t>(UNC_KT_ROOT);
   create_handler<key_ctr_t, val_ctr_t>(UNC_KT_CONTROLLER);
@@ -58,6 +73,29 @@ pfc_bool_t VtnDrvIntf::init(void) {
       (UNC_KT_VBR_IF);
   create_handler<key_vlan_map_t, pfcdrv_val_vlan_map_t>
       (UNC_KT_VBR_VLANMAP);
+  create_handler<key_flowlist, val_flowlist>
+      (UNC_KT_FLOWLIST);
+  create_handler<key_flowlist_entry, val_flowlist_entry>
+      (UNC_KT_FLOWLIST_ENTRY);
+  create_handler<key_vtn_flowfilter, val_flowfilter>
+      (UNC_KT_VTN_FLOWFILTER);
+  create_handler<key_vtn_flowfilter_entry, val_vtn_flowfilter_entry>
+      (UNC_KT_VTN_FLOWFILTER_ENTRY);
+  create_handler<key_vbr_flowfilter, val_flowfilter>
+      (UNC_KT_VBR_FLOWFILTER);
+  create_handler<key_vbr_flowfilter_entry, val_flowfilter_entry>
+      (UNC_KT_VBR_FLOWFILTER_ENTRY);
+  create_handler<key_vbr_if_flowfilter, pfcdrv_val_vbrif_vextif>
+      (UNC_KT_VBRIF_FLOWFILTER);
+  create_handler<key_vbr_if_flowfilter_entry, pfcdrv_val_flowfilter_entry>
+      (UNC_KT_VBRIF_FLOWFILTER_ENTRY);
+  create_handler<key_vterm, val_vterm>(UNC_KT_VTERMINAL);
+  create_handler<key_vterm_if, val_vterm_if>(UNC_KT_VTERM_IF);
+  create_handler<key_vterm_if_flowfilter, val_flowfilter>
+      (UNC_KT_VTERMIF_FLOWFILTER);
+  create_handler<key_vterm_if_flowfilter_entry, val_flowfilter_entry>
+      (UNC_KT_VTERMIF_FLOWFILTER_ENTRY);
+
 
   unc::tclib::TcLibModule* tclib_obj =
       static_cast<unc::tclib::TcLibModule*>(pfc::core::Module::getInstance(
@@ -709,6 +747,47 @@ void VtnDrvIntf::create_handler(unc_key_type_t keytype)  {
           handler_));
 }
 }
+/**
+* @Description :Method to fill the map pfc_ipcstdef_t pointer against keytype
+* @param[in]   :NONE
+* @return      :NONE
+**/
+void  VtnDrvIntf::initialize_map() {
+  ODC_FUNC_TRACE;
+  POPULATE_STDEF(key_vtn, val_vtn, UNC_KT_VTN, stdefk_vtn, stdefv_vtn);
+  POPULATE_STDEF(key_vbr, val_vbr, UNC_KT_VBRIDGE, stdefk_vbr, stdefv_vbr);
+  POPULATE_STDEF(key_vbr_if, val_vbr_if, UNC_KT_VBR_IF, stdefk_vbrif,
+                 stdefv_vbrif);
+  POPULATE_STDEF(key_vlan_map, val_vlan_map, UNC_KT_VBR_VLANMAP, stdefk_vlan,
+                 stdefv_vlan);
+  POPULATE_STDEF(key_flowlist, val_flowlist, UNC_KT_FLOWLIST, stdefk_fl,
+                 stdefv_fl);
+  POPULATE_STDEF(key_flowlist_entry, val_flowlist_entry, UNC_KT_FLOWLIST_ENTRY,
+                 stdefk_fle, stdefv_fle);
+  POPULATE_STDEF(key_vtn_flowfilter, val_flowfilter, UNC_KT_VTN_FLOWFILTER,
+                 stdefk_ff, stdefv_ff);
+  POPULATE_STDEF(key_vtn_flowfilter_entry, val_vtn_flowfilter_entry,
+                 UNC_KT_VTN_FLOWFILTER_ENTRY, stdefk_vtn_fle, stdefv_vtn_fle);
+  POPULATE_STDEF(key_vbr_flowfilter, val_flowfilter, UNC_KT_VBR_FLOWFILTER,
+                 stdefk_vbr_fl, stdefv_vbr_fl);
+  POPULATE_STDEF(key_vbr_flowfilter_entry, val_flowfilter_entry,
+                 UNC_KT_VBR_FLOWFILTER_ENTRY, stdefk_vbr_fle, stdefv_vbr_fle);
+  POPULATE_STDEF(key_vbr_if_flowfilter, pfcdrv_val_vbrif_vextif,
+                 UNC_KT_VBRIF_FLOWFILTER, stdefk_vbrif_fl, stdefv_vbrif_fl);
+  POPULATE_STDEF(key_vbr_if_flowfilter_entry, pfcdrv_val_flowfilter_entry,
+                 UNC_KT_VBRIF_FLOWFILTER_ENTRY, stdefk_vbrif_fle,
+                 stdefv_vbrif_fle);
+  POPULATE_STDEF(key_vterm, val_vterm, UNC_KT_VTERMINAL, stdefk_vtrem,
+                 stdefv_vterm);
+  POPULATE_STDEF(key_vterm_if, val_vterm_if, UNC_KT_VTERM_IF, stdefk_vtrem_if,
+                 stdefv_vterm_if);
+  POPULATE_STDEF(key_vterm_if_flowfilter, val_flowfilter,
+                 UNC_KT_VTERMIF_FLOWFILTER, stdefk_vtrem_if_ff,
+                 stdefv_vterm_if_ff);
+  POPULATE_STDEF(key_vterm_if_flowfilter_entry, val_flowfilter_entry,
+                 UNC_KT_VTERMIF_FLOWFILTER_ENTRY, stdefk_vtrem_if_fle,
+                 stdefv_vterm_if_fle);
+}
 
 }  // namespace driver
 }  // namespace unc

diff --git a/coordinator/modules/vtndrvintf/vtn_drv_transaction_handle.cc b/coordinator/modules/vtndrvintf/vtn_drv_transaction_handle.cc
index 7161562516549188d3c0ac39c2793c71d15c2de8..d00df36972ac489bfaf25cea4dbf5ffc03d19b3b 100644 (file)
--- a/coordinator/modules/vtndrvintf/vtn_drv_transaction_handle.cc
+++ b/coordinator/modules/vtndrvintf/vtn_drv_transaction_handle.cc
@@ -8,6 +8,7 @@
  */
 
 #include <vtn_drv_transaction_handle.hh>
+#include <vtn_drv_module.hh>
 #include <list>
 #include <vector>
 #include <memory>
@@ -20,28 +21,13 @@ namespace driver {
 */
 DriverTxnInterface::DriverTxnInterface(ControllerFramework* ctrl_frame,
                             kt_handler_map &map_kt)
-    : crtl_inst_(ctrl_frame), kt_handler_map_(map_kt) {
-      initialize_map();
-    }
+    : crtl_inst_(ctrl_frame), kt_handler_map_(map_kt) {}
 
 
 /**
  * @brief : Destructor
  */
-DriverTxnInterface::~DriverTxnInterface() {
-  std::map<unc_key_type_t, pfc_ipcstdef_t*> :: iterator map_it;
-  for (map_it = key_map_.begin(); map_it != key_map_.end(); map_it++) {
-    delete map_it->second;
-    map_it->second = NULL;
-  }
-  for (map_it = val_map_.begin(); map_it != val_map_.end(); map_it++) {
-    delete map_it->second;
-    map_it->second = NULL;
-  }
-
-  key_map_.clear();
-  val_map_.clear();
-}
+DriverTxnInterface::~DriverTxnInterface() {}
 
 /**
 * @Description :This functions invokes when TC sends COMMIT request to driver
@@ -345,8 +331,8 @@ unc::tclib::TcCommonRet DriverTxnInterface::HandleCommitCache
         tclib_ptr->TcLibWriteControllerInfo(ctr_name, retc, 1);
         void* key = hnd_ptr->get_key_struct(cfgnode);
         void* val = hnd_ptr->get_val_struct(cfgnode);
-        pfc_ipcstdef_t* key_sdf =key_map_.find(keytype)->second;
-        pfc_ipcstdef_t* val_sdf =val_map_.find(keytype)->second;
+        pfc_ipcstdef_t* key_sdf = VtnDrvIntf::key_map.find(keytype)->second;
+        pfc_ipcstdef_t* val_sdf = VtnDrvIntf::val_map.find(keytype)->second;
         tclib_ptr->TcLibWriteKeyValueDataInfo(ctr_name, (uint32_t)keytype,
                                               *key_sdf, *val_sdf,
                                               key, val);
@@ -399,71 +385,5 @@ unc::tclib::TcCommonRet DriverTxnInterface::HandleAuditEnd(uint32_t session_id,
   return unc::tclib::TC_SUCCESS;
 }
 
-/**
-* @Description :Method to fill the map pfc_ipcstdef_t pointer against keytype
-* @param[in]   :NONE
-* @return      :NONE
-**/
-void  DriverTxnInterface::initialize_map() {
-  ODC_FUNC_TRACE;
-  uint32_t loop = 0;
-  unc_key_type_t KT[] = {UNC_KT_VTN, UNC_KT_VBRIDGE, UNC_KT_VBR_IF,
-                         UNC_KT_VBR_VLANMAP};
-  uint32_t kt_size = sizeof KT/sizeof(unc_key_type_t);
-  for (loop = 0; loop < kt_size; loop++) {
-    switch (KT[loop]) {
-      case UNC_KT_VTN:
-        {
-        pfc_ipcstdef_t *stdef_k = new pfc_ipcstdef_t;
-        PFC_IPC_STDEF_INIT(stdef_k, key_vtn);
-        pfc_ipcstdef_t *stdef_v = new pfc_ipcstdef_t;
-        PFC_IPC_STDEF_INIT(stdef_v, val_vtn);
-        key_map_.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
-                                                                  stdef_k));
-        val_map_.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
-                                                                  stdef_v));
-        break;
-        }
-      case UNC_KT_VBRIDGE:
-        {
-        pfc_ipcstdef_t *stdef_kvbr = new pfc_ipcstdef_t;
-        PFC_IPC_STDEF_INIT(stdef_kvbr, key_vbr);
-        pfc_ipcstdef_t *stdef_vbr = new pfc_ipcstdef_t;
-        PFC_IPC_STDEF_INIT(stdef_vbr, val_vbr);
-        key_map_.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
-                                                                  stdef_kvbr));
-        val_map_.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
-                                                                  stdef_vbr));
-        break;
-        }
-      case UNC_KT_VBR_IF:
-        {
-        pfc_ipcstdef_t *stdef_kvbrif = new pfc_ipcstdef_t;
-        PFC_IPC_STDEF_INIT(stdef_kvbrif, key_vbr_if);
-        pfc_ipcstdef_t *stdef_vbrif = new pfc_ipcstdef_t;
-        PFC_IPC_STDEF_INIT(stdef_vbrif, val_vbr_if);
-        key_map_.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
-                                                                stdef_kvbrif));
-        val_map_.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
-                                                                stdef_vbrif));
-        break;
-        }
-      case UNC_KT_VBR_VLANMAP:
-        {
-          pfc_ipcstdef_t *stdef_kvbrvlanmap = new pfc_ipcstdef_t;
-          PFC_IPC_STDEF_INIT(stdef_kvbrvlanmap, key_vlan_map);
-          pfc_ipcstdef_t *stdef_vbrvlanmap = new pfc_ipcstdef_t;
-          PFC_IPC_STDEF_INIT(stdef_vbrvlanmap, val_vlan_map);
-          key_map_.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
-                                                          stdef_kvbrvlanmap));
-          val_map_.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
-                                                           stdef_vbrvlanmap));
-          break;
-        }
-      default:
-        break;
-    }
-  }
-}
 }  // namespace driver
 }  // namespace unc

diff --git a/coordinator/test/modules/odcdriver/ut/Makefile b/coordinator/test/modules/odcdriver/ut/Makefile
index 8b33a89cee9d5e00e52dfdac974c983ee2a4f813..8b1220b269d3b2633ddec1d5c413e6ba7558f4c9 100644 (file)
--- a/coordinator/test/modules/odcdriver/ut/Makefile
+++ b/coordinator/test/modules/odcdriver/ut/Makefile
@@ -60,6 +60,7 @@ ODCDRIVER_SOURCES += odc_link.cc
 
 VTNCACHEUTIL_SOURCES = keytree.cc
 VTNCACHEUTIL_SOURCES += confignode.cc
+VTNCACHEUTIL_SOURCES += vtn_cache_mod.cc
 VTNDRVINTF_STUB_SOURCES += controller_fw.cc
 VTNDRVINTF_STUB_SOURCES += vtn_drv_module.cc
 

diff --git a/coordinator/test/modules/odcdriver/ut/odc_link_ut.cc b/coordinator/test/modules/odcdriver/ut/odc_link_ut.cc
index 44676217ef20040f382293f5f7aad2b2d2cb7bee..7ae430bdb71f2cfacd0068720ea01c4f7fef985d 100644 (file)
--- a/coordinator/test/modules/odcdriver/ut/odc_link_ut.cc
+++ b/coordinator/test/modules/odcdriver/ut/odc_link_ut.cc
@@ -10,6 +10,7 @@
 #include <odc_link.hh>
 #include <odc_controller.hh>
 #include <odc_driver_common_defs.hh>
+#include <vtn_cache_mod.hh>
 #include <vtn_drv_module.hh>
 #include <gtest/gtest.h>
 #include <string>
@@ -258,6 +259,9 @@ TEST(odcdriver_link, test_link_data_add_resp_dynamically) {
   ctr->physical_port_cache = unc::vtndrvcache::KeyTree::create_cache();
 
   pfc_bool_t cache_empty = PFC_TRUE;
+  const pfc_modattr_t *temp = NULL;
+  unc::vtndrvcache::VtnDrvCacheMod init_obj(temp);
+  init_obj.init();
   unc::odcdriver::OdcLink obj_link(conf_file);
   EXPECT_EQ(UNC_RC_SUCCESS, obj_link.fetch_config(ctr, cache_empty));
 

diff --git a/coordinator/test/modules/stub/ContrllerFrameworkStub/vtn_drv_module.cc b/coordinator/test/modules/stub/ContrllerFrameworkStub/vtn_drv_module.cc
index 0171b6daef4007b81c73754bc60eb20bd398fe1c..656debc87b4fbcb8d15c5c0edeaadf41cbb6b3f1 100644 (file)
--- a/coordinator/test/modules/stub/ContrllerFrameworkStub/vtn_drv_module.cc
+++ b/coordinator/test/modules/stub/ContrllerFrameworkStub/vtn_drv_module.cc
@@ -11,6 +11,8 @@
 
 namespace unc {
 namespace driver {
+std::map<unc_key_type_t, pfc_ipcstdef_t*>VtnDrvIntf::key_map;
+std::map<unc_key_type_t, pfc_ipcstdef_t*>VtnDrvIntf::val_map;
 
 VtnDrvIntf VtnDrvIntf::theInstance(NULL);
 

diff --git a/coordinator/test/modules/stub/ContrllerFrameworkStub/vtn_drv_module.hh b/coordinator/test/modules/stub/ContrllerFrameworkStub/vtn_drv_module.hh
index 7de58d6e2b73bf5cc66a276b7fc64dc092680222..b4232325f8c1cc1e22e3b2ced1caa5f85e8e8959 100644 (file)
--- a/coordinator/test/modules/stub/ContrllerFrameworkStub/vtn_drv_module.hh
+++ b/coordinator/test/modules/stub/ContrllerFrameworkStub/vtn_drv_module.hh
@@ -26,15 +26,241 @@ namespace driver {
 
 class VtnDrvIntf :public pfc::core::Module {
  public:
+  typedef std::map<unc_key_type_t, pfc_ipcstdef_t*> kt_map;
+  static kt_map key_map;
+  static kt_map val_map;
   explicit VtnDrvIntf(const pfc_modattr_t* attr);
 
   ~VtnDrvIntf() {
   }
 
   pfc_bool_t init(void) {
+    initialize_map();
     return PFC_TRUE;
   }
 
+void  initialize_map() {
+  ODC_FUNC_TRACE;
+  uint32_t loop = 0;
+  unc_key_type_t KT[] = {UNC_KT_VTN, UNC_KT_VBRIDGE, UNC_KT_VBR_IF,
+                         UNC_KT_VBR_VLANMAP, UNC_KT_FLOWLIST,
+                         UNC_KT_FLOWLIST_ENTRY, UNC_KT_VTN_FLOWFILTER,
+                         UNC_KT_VTN_FLOWFILTER_ENTRY, UNC_KT_VBR_FLOWFILTER,
+                         UNC_KT_VBR_FLOWFILTER_ENTRY, UNC_KT_VBRIF_FLOWFILTER,
+                         UNC_KT_VRTIF_FLOWFILTER_ENTRY, UNC_KT_VTERMINAL,
+                         UNC_KT_VTERM_IF, UNC_KT_VTERMIF_FLOWFILTER,
+                         UNC_KT_VTERMIF_FLOWFILTER_ENTRY};
+  uint32_t kt_size = sizeof KT/sizeof(unc_key_type_t);
+  for (loop = 0; loop < kt_size; loop++) {
+    switch (KT[loop]) {
+      case UNC_KT_VTN:
+        {
+        pfc_ipcstdef_t *stdef_k = new pfc_ipcstdef_t;
+        PFC_IPC_STDEF_INIT(stdef_k, key_vtn);
+        pfc_ipcstdef_t *stdef_v = new pfc_ipcstdef_t;
+        PFC_IPC_STDEF_INIT(stdef_v, val_vtn);
+        key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                                  stdef_k));
+        val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                                  stdef_v));
+        break;
+        }
+      case UNC_KT_VBRIDGE:
+        {
+        pfc_ipcstdef_t *stdef_kvbr = new pfc_ipcstdef_t;
+        PFC_IPC_STDEF_INIT(stdef_kvbr, key_vbr);
+        pfc_ipcstdef_t *stdef_vbr = new pfc_ipcstdef_t;
+        PFC_IPC_STDEF_INIT(stdef_vbr, val_vbr);
+        key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                                  stdef_kvbr));
+        val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                                  stdef_vbr));
+        break;
+        }
+      case UNC_KT_VBR_IF:
+        {
+        pfc_ipcstdef_t *stdef_kvbrif = new pfc_ipcstdef_t;
+        PFC_IPC_STDEF_INIT(stdef_kvbrif, key_vbr_if);
+        pfc_ipcstdef_t *stdef_vbrif = new pfc_ipcstdef_t;
+        PFC_IPC_STDEF_INIT(stdef_vbrif, val_vbr_if);
+        key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                                stdef_kvbrif));
+        val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                                stdef_vbrif));
+        break;
+        }
+      case UNC_KT_VBR_VLANMAP:
+        {
+          pfc_ipcstdef_t *stdef_kvbrvlanmap = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_kvbrvlanmap, key_vlan_map);
+          pfc_ipcstdef_t *stdef_vbrvlanmap = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_vbrvlanmap, val_vlan_map);
+          key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                          stdef_kvbrvlanmap));
+          val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                           stdef_vbrvlanmap));
+          break;
+        }
+      case UNC_KT_FLOWLIST:
+        {
+          pfc_ipcstdef_t *stdef_kflowlist = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_kflowlist, key_flowlist);
+          pfc_ipcstdef_t *stdef_val_flowlist = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_val_flowlist, val_flowlist);
+          key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                          stdef_kflowlist));
+          val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                           stdef_val_flowlist));
+          break;
+        }
+      case UNC_KT_FLOWLIST_ENTRY:
+        {
+          pfc_ipcstdef_t *stdef_kflowlist_entry = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_kflowlist_entry, key_flowlist_entry);
+          pfc_ipcstdef_t *stdef_val_flowlist_entry = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_val_flowlist_entry, val_flowlist_entry);
+          key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                      stdef_kflowlist_entry));
+          val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                  stdef_val_flowlist_entry));
+          break;
+        }
+      case UNC_KT_VTN_FLOWFILTER:
+        {
+          pfc_ipcstdef_t *stdef_kvtn_flowfilter = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_kvtn_flowfilter, key_vtn_flowfilter);
+          pfc_ipcstdef_t *stdef_val_vtn_flowfilter = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_val_vtn_flowfilter, val_flowfilter);
+          key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                      stdef_kvtn_flowfilter));
+          val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                  stdef_val_vtn_flowfilter));
+          break;
+        }
+      case UNC_KT_VTN_FLOWFILTER_ENTRY:
+        {
+          pfc_ipcstdef_t *stdef_kvtn_flowfilter_entry = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_kvtn_flowfilter_entry,
+                             key_vtn_flowfilter_entry);
+          pfc_ipcstdef_t *stdef_val_vtn_flowfilter_entry = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_val_vtn_flowfilter_entry,
+                             val_vtn_flowfilter_entry);
+          key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                            stdef_kvtn_flowfilter_entry));
+          val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                            stdef_val_vtn_flowfilter_entry));
+          break;
+        }
+      case UNC_KT_VBR_FLOWFILTER:
+        {
+          pfc_ipcstdef_t *stdef_kvbr_flowfilter = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_kvbr_flowfilter, key_vbr_flowfilter);
+          pfc_ipcstdef_t *stdef_val_vbr_flowfilter = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_val_vbr_flowfilter, val_flowfilter);
+          key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                  stdef_kvbr_flowfilter));
+          val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                  stdef_val_vbr_flowfilter));
+          break;
+        }
+      case UNC_KT_VBR_FLOWFILTER_ENTRY:
+        {
+          pfc_ipcstdef_t *stdef_kvbr_flowfilter_entry = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_kvbr_flowfilter_entry,
+                             key_vbr_flowfilter_entry);
+          pfc_ipcstdef_t *stdef_val_vbr_flowfilter_entry = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_val_vbr_flowfilter_entry,
+                             val_flowfilter_entry);
+          key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                stdef_kvbr_flowfilter_entry));
+          val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                              stdef_val_vbr_flowfilter_entry));
+          break;
+        }
+      case UNC_KT_VBRIF_FLOWFILTER:
+        {
+          pfc_ipcstdef_t *stdef_kvbrif_flowfilter = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_kvbrif_flowfilter, key_vbr_if_flowfilter);
+          pfc_ipcstdef_t *stdef_val_vbrif_flowfilter = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_val_vbrif_flowfilter,
+                             pfcdrv_val_vbrif_vextif);
+          key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                  stdef_kvbrif_flowfilter));
+          val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                  stdef_val_vbrif_flowfilter));
+          break;
+        }
+      case UNC_KT_VRTIF_FLOWFILTER_ENTRY:
+        {
+          pfc_ipcstdef_t *stdef_kvbrif_flowfilter_entry = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_kvbrif_flowfilter_entry,
+                             key_vbr_if_flowfilter_entry);
+          pfc_ipcstdef_t *stdef_val_vbrif_flowfilter_entry = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_val_vbrif_flowfilter_entry,
+                             pfcdrv_val_flowfilter_entry);
+          key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                              stdef_kvbrif_flowfilter_entry));
+          val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                          stdef_val_vbrif_flowfilter_entry));
+          break;
+        }
+      case UNC_KT_VTERMINAL:
+        {
+          pfc_ipcstdef_t *stdef_key_vterm = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_key_vterm, key_vterm);
+          pfc_ipcstdef_t *stdef_val_vterm = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_val_vterm, val_vterm);
+          key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                  stdef_key_vterm));
+          val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                  stdef_val_vterm));
+          break;
+        }
+      case UNC_KT_VTERM_IF:
+        {
+          pfc_ipcstdef_t *stdef_key_vterm_if = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_key_vterm_if, key_vterm_if);
+          pfc_ipcstdef_t *stdef_val_vterm_if = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_val_vterm_if, val_vterm_if);
+          key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                  stdef_key_vterm_if));
+          val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                  stdef_val_vterm_if));
+          break;
+        }
+      case UNC_KT_VTERMIF_FLOWFILTER:
+        {
+          pfc_ipcstdef_t *stdef_kvtermif_flowfilter = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_kvtermif_flowfilter,
+                             key_vterm_if_flowfilter);
+          pfc_ipcstdef_t *stdef_val_vtermif_flowfilter = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_val_vtermif_flowfilter, val_flowfilter);
+          key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                  stdef_kvtermif_flowfilter));
+          val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                                stdef_val_vtermif_flowfilter));
+          break;
+        }
+      case UNC_KT_VTERMIF_FLOWFILTER_ENTRY:
+        {
+          pfc_ipcstdef_t *stdef_kvtermif_flowfilter_entry = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_kvtermif_flowfilter_entry,
+                                     key_vterm_if_flowfilter_entry);
+          pfc_ipcstdef_t *stdef_val_vtermif_flowfilter_entry = new pfc_ipcstdef_t;
+          PFC_IPC_STDEF_INIT(stdef_val_vtermif_flowfilter_entry,
+                                          val_flowfilter_entry);
+          key_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                            stdef_kvtermif_flowfilter_entry));
+          val_map.insert(std::pair<unc_key_type_t, pfc_ipcstdef_t*>(KT[loop],
+                                          stdef_val_vtermif_flowfilter_entry));
+          break;
+        }
+      default:
+        break;
+    }
+  }
+}
+
   pfc_bool_t fini() {
     return PFC_TRUE;
   }

diff --git a/coordinator/test/modules/vtncacheutil/ut/Makefile b/coordinator/test/modules/vtncacheutil/ut/Makefile
index 9bb1403c0036b2ac74211c7aa3ed9df989fa678a..f2c98a5e31ab3f38cb11ab9493dcef659fe036ae 100644 (file)
--- a/coordinator/test/modules/vtncacheutil/ut/Makefile
+++ b/coordinator/test/modules/vtncacheutil/ut/Makefile
@@ -14,26 +14,38 @@
 GTEST_SRCROOT := ../../../..
 include ../../defs.mk
 
+COMMON_STUB_PATH = ../..
 EXEC_NAME :=  vtncacheutil_ut
 
 MODULE_SRCROOT = $(GTEST_SRCROOT)/modules
 
+MISC_STUBDIR = $(COMMON_STUB_PATH)/stub/misc
+
 VTNCACHEUTIL_SRCDIR = $(MODULE_SRCROOT)/vtncacheutil
 
 # Define a list of directories that contain source files.
-ALT_SRCDIRS += $(VTNCACHEUTIL_SRCDIR)
+ALT_SRCDIRS += $(VTNCACHEUTIL_SRCDIR) $(MISC_STUBDIR)
+
+
+UT_INCDIRS_PREP = ${COMMON_STUB_PATH} $(COMMON_STUB_PATH)/stub/include $(COMMON_STUB_PATH)/stub/include/cxx
 
 EXTRA_CXX_INCDIRS = $(MODULE_SRCROOT)
 EXTRA_CXX_INCDIRS += $(VTNCACHEUTIL_SRCDIR)/include
 
+CPPFLAGS += -include ut_stub.h
+
 VTNCACHEUTIL_SOURCES = keytree.cc
 VTNCACHEUTIL_SOURCES += confignode.cc
+VTNCACHEUTIL_SOURCES += vtn_cache_mod.cc
 
 UT_SOURCES = test_keytree.cc
 UT_SOURCES += test_confignode.cc
 
+MISC_SOURCES  = module.cc
+
 CXX_SOURCES += $(UT_SOURCES)
 CXX_SOURCES += $(VTNCACHEUTIL_SOURCES)
+CXX_SOURCES += $(MISC_SOURCES)
 
 EXTRA_CXXFLAGS += -fprofile-arcs -ftest-coverage
 EXTRA_CXXFLAGS += -Dprivate=public -Dprotected=public

diff --git a/coordinator/test/modules/vtncacheutil/ut/test_confignode.cc b/coordinator/test/modules/vtncacheutil/ut/test_confignode.cc
index 4b82aea65cddb332348d2c2ede1c6cbb7dc0fb60..236531f953c487e740dbd9b7ca03f4cef441ade9 100644 (file)
--- a/coordinator/test/modules/vtncacheutil/ut/test_confignode.cc
+++ b/coordinator/test/modules/vtncacheutil/ut/test_confignode.cc
@@ -8,12 +8,16 @@
  */
 
 #include <gtest/gtest.h>
+#include <vtn_cache_mod.hh>
 #include <keytree.hh>
 #include <vtn_conf_data_element_op.hh>
 
 namespace unc {
 namespace vtndrvcache {
 TEST(TypeToStrFun, keytype) {
+  const pfc_modattr_t *temp = NULL;
+  VtnDrvCacheMod init_obj(temp);
+  init_obj.init();
   std::string ret = TypeToStrFun(UNC_KT_VTN);
   EXPECT_EQ(ret, "UNC_KT_VTN");
 
@@ -246,5 +250,67 @@ TEST(TypeToStrFun, keytype_kt_link) {
   std::string ret = TypeToStrFun(UNC_KT_LINK);
   EXPECT_EQ(ret, "UNC_KT_LINK");
 }
+TEST(TypeToStrFun, key_flowlist) {
+  std::string ret = TypeToStrFun(UNC_KT_FLOWLIST);
+  EXPECT_EQ(ret, "UNC_KT_FLOWLIST");
+}
+
+TEST(TypeToStrFun, key_flowlist_entry) {
+  std::string ret = TypeToStrFun(UNC_KT_FLOWLIST_ENTRY);
+  EXPECT_EQ(ret, "UNC_KT_FLOWLIST_ENTRY");
+}
+
+TEST(TypeToStrFun, key_vtn_flowfilter) {
+  std::string ret = TypeToStrFun(UNC_KT_VTN_FLOWFILTER);
+  EXPECT_EQ(ret, "UNC_KT_VTN_FLOWFILTER");
+}
+
+TEST(TypeToStrFun, key_vtn_flowfilter_entry) {
+  std::string ret = TypeToStrFun(UNC_KT_VTN_FLOWFILTER_ENTRY);
+  EXPECT_EQ(ret, "UNC_KT_VTN_FLOWFILTER_ENTRY");
+}
+
+TEST(TypeToStrFun, key_vbr_flowfilter) {
+  std::string ret = TypeToStrFun(UNC_KT_VBR_FLOWFILTER);
+  EXPECT_EQ(ret, "UNC_KT_VBR_FLOWFILTER");
+}
+
+TEST(TypeToStrFun, key_vbr_flowfilter_entry) {
+  std::string ret = TypeToStrFun(UNC_KT_VBR_FLOWFILTER_ENTRY);
+  EXPECT_EQ(ret, "UNC_KT_VBR_FLOWFILTER_ENTRY");
+}
+
+TEST(TypeToStrFun, key_vbr_if_flowfilter) {
+  std::string ret = TypeToStrFun(UNC_KT_VBRIF_FLOWFILTER);
+  EXPECT_EQ(ret, "UNC_KT_VBRIF_FLOWFILTER");
+}
+
+TEST(TypeToStrFun, key_vbr_if_flowfilter_entry) {
+  std::string ret = TypeToStrFun(UNC_KT_VBRIF_FLOWFILTER_ENTRY);
+  EXPECT_EQ(ret, "UNC_KT_VBRIF_FLOWFILTER_ENTRY");
+}
+
+TEST(TypeToStrFun, key_vterm) {
+  std::string ret = TypeToStrFun(UNC_KT_VTERMINAL);
+  EXPECT_EQ(ret, "UNC_KT_VTERMINAL");
+}
+
+TEST(TypeToStrFun, key_vterm_if) {
+  std::string ret = TypeToStrFun(UNC_KT_VTERM_IF);
+  EXPECT_EQ(ret, "UNC_KT_VTERM_IF");
+}
+
+TEST(TypeToStrFun, key_vterm_if_flowfilter) {
+  std::string ret = TypeToStrFun(UNC_KT_VTERMIF_FLOWFILTER);
+  EXPECT_EQ(ret, "UNC_KT_VTERMIF_FLOWFILTER");
+}
+
+TEST(TypeToStrFun, key_vterm_if_flowfilter_entry) {
+  std::string ret = TypeToStrFun(UNC_KT_VTERMIF_FLOWFILTER_ENTRY);
+  EXPECT_EQ(ret, "UNC_KT_VTERMIF_FLOWFILTER_ENTRY");
+
+  ret = TypeToStrFun(UNC_KT_VLINK);
+  EXPECT_EQ(ret, "Unknown");
+}
 }  // namespace vtndrvcache
 }  // namespace unc

diff --git a/coordinator/test/modules/vtncacheutil/ut/test_keytree.cc b/coordinator/test/modules/vtncacheutil/ut/test_keytree.cc
index 53ba25ce4bd8e4f49611ba919a1fc71637b2a4e7..e075a4801e758c32b42e9673c3b253510a20b426 100644 (file)
--- a/coordinator/test/modules/vtncacheutil/ut/test_keytree.cc
+++ b/coordinator/test/modules/vtncacheutil/ut/test_keytree.cc
@@ -105,7 +105,8 @@ TEST(append_commit_node, Reterive_key_val) {
       (&key1_obj, &val1_obj, operation);
   ret = KeyTree_obj->append_commit_node(cfgptr1);
   EXPECT_EQ(ret, UNC_RC_SUCCESS);
-  ConfigNode *cfgptr2 = new CacheElementUtil<key_vlan_map_t, pfcdrv_val_vlan_map_t,
+  ConfigNode *cfgptr2 = new CacheElementUtil<key_vlan_map_t,
+             pfcdrv_val_vlan_map_t,
              uint32_t>(&key2_obj, &val2_obj, operation);
   ret = KeyTree_obj->append_commit_node(cfgptr2);
   EXPECT_EQ(ret, UNC_RC_SUCCESS);
@@ -2580,5 +2581,2058 @@ TEST(update_physical_attribute_node, single_link_update_sucess) {
   cfgptr_link_update_sw01sw02 = NULL;
   EXPECT_EQ(ret, UNC_RC_SUCCESS);
 }
+
+TEST(append_commit_node, FlowList) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_flowlist_t key_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  val_flowlist_t val_obj;
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.flowlist_name, "flowlistone", sizeof(key_obj.flowlist_name));
+  ConfigNode *cfgptr = new CacheElementUtil<key_flowlist_t, val_flowlist_t,
+             uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_commit_node, Retrive_Flow_List) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_flowlist_t key_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  val_flowlist_t val_obj;
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.flowlist_name, "flowlistone", sizeof(key_obj.flowlist_name));
+  ConfigNode *cfgptr = new CacheElementUtil<key_flowlist_t, val_flowlist_t,
+             uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+
+  CommonIterator* itr_ptr = KeyTree_obj->create_iterator();
+  cfgptr = itr_ptr->FirstItem();
+  CacheElementUtil<key_flowlist_t, val_flowlist_t, uint32_t> *tmp_ptr =
+      static_cast<CacheElementUtil<key_flowlist_t, val_flowlist_t,
+      uint32_t>*> (cfgptr);
+
+  EXPECT_STREQ(reinterpret_cast<char*>(key_obj.flowlist_name),
+         reinterpret_cast<char*>(tmp_ptr->get_key_structure()->flowlist_name));
+  pfc_log_info("Flow-list name= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->flowlist_name));
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr->get_key_name().c_str(), tmp_ptr->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr->get_parent_key_name().c_str(),
+               tmp_ptr->get_key_generate().c_str());
+  delete itr_ptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+}
+
+TEST(get_parenttype, KT_FLOW_LIST) {
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+
+  unc_key_type_t keytype = KeyTree_obj->get_parenttype(UNC_KT_FLOWLIST);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  EXPECT_EQ(keytype, UNC_KT_ROOT);
+}
+
+TEST(append_commit_node, same_root_level) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vtn key_obj;
+  memcpy(key_obj.vtn_name, "vtn1", sizeof(key_obj.vtn_name));
+
+  val_vtn val_obj;
+  memcpy(val_obj.description, "vtn1_des", sizeof(val_obj.description));
+
+  ConfigNode *cfgptr = new CacheElementUtil<key_vtn, val_vtn, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+
+  key_flowlist_t key_obj1;
+  memset(&key_obj1, 0, sizeof(key_obj1));
+  val_flowlist_t val_obj1;
+  memset(&val_obj1, 0, sizeof(val_obj1));
+  memcpy(key_obj1.flowlist_name, "flowlistone", sizeof(key_obj1.flowlist_name));
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_flowlist_t,
+             val_flowlist_t, uint32_t>
+      (&key_obj1, &val_obj1, operation);
+  ret = KeyTree_obj->append_commit_node(cfgptr1);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  CommonIterator* itr_ptr = KeyTree_obj->create_iterator();
+  cfgptr = itr_ptr->FirstItem();
+  CacheElementUtil<key_vtn, val_vtn, uint32_t> *tmp_ptr =
+      static_cast<CacheElementUtil<key_vtn, val_vtn, uint32_t>*> (cfgptr);
+  EXPECT_STREQ(reinterpret_cast<char*>(key_obj.vtn_name),
+         reinterpret_cast<char*>(tmp_ptr->get_key_structure()->vtn_name));
+  EXPECT_STREQ(reinterpret_cast<char*>(val_obj.description),
+          reinterpret_cast<char*>(tmp_ptr->get_val_structure()->description));
+  pfc_log_info("vtn name= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->vtn_name));
+  pfc_log_info("Description= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_val_structure()->description));
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr->get_key_name().c_str(), tmp_ptr->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr->get_parent_key_name().c_str(),
+               tmp_ptr->get_key_generate().c_str());
+  cfgptr1 = itr_ptr->NextItem();
+  CacheElementUtil<key_flowlist_t, val_flowlist_t, uint32_t> *tmp_ptr1 =
+      static_cast<CacheElementUtil<key_flowlist_t, val_flowlist_t,
+      uint32_t>*> (cfgptr1);
+
+  EXPECT_STREQ(reinterpret_cast<char*>(key_obj1.flowlist_name),
+         reinterpret_cast<char*>(tmp_ptr1->get_key_structure()->flowlist_name));
+  pfc_log_info("Flow-list name= %s", reinterpret_cast<char*>(
+          tmp_ptr1->get_key_structure()->flowlist_name));
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr1->get_key_name().c_str(), tmp_ptr1->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr1->get_parent_key_name().c_str(),
+               tmp_ptr1->get_key_generate().c_str());
+
+  delete itr_ptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(get_parenttype, KT_FLOW_LIST_ENTRY) {
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+
+  unc_key_type_t keytype = KeyTree_obj->get_parenttype(UNC_KT_FLOWLIST_ENTRY);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  EXPECT_EQ(keytype, UNC_KT_FLOWLIST);
+}
+
+TEST(append_commit_node, FlowList_Entry) {
+  int operation = 1;
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+  key_flowlist_t key_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  val_flowlist_t val_obj;
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.flowlist_name, "flowlistone", sizeof(key_obj.flowlist_name));
+
+  ConfigNode *cfgptr = new CacheElementUtil<key_flowlist_t,
+             val_flowlist_t, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_flowlist_entry  key_flolistentry;
+  val_flowlist_entry  val_flowlistentry;
+  memset(&key_flolistentry, 0, sizeof(key_flolistentry));
+  memset(&val_flowlistentry, 0, sizeof(val_flowlistentry));
+  memcpy(key_flolistentry.flowlist_key.flowlist_name, "flowlistone",
+         sizeof(key_obj.flowlist_name));
+  key_flolistentry.sequence_num = 20;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_flowlist_entry,
+             val_flowlist_entry, uint32_t>
+      (&key_flolistentry, &val_flowlistentry, operation);
+  ret = KeyTree_obj->append_commit_node(cfgptr1);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_commit_node, FlowList_Entry_Retrive) {
+  int operation = 1;
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+  key_flowlist_t key_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  val_flowlist_t val_obj;
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.flowlist_name, "flowlistone", sizeof(key_obj.flowlist_name));
+
+  ConfigNode *cfgptr = new CacheElementUtil<key_flowlist_t, val_flowlist_t,
+             uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_flowlist_entry  key_flolistentry;
+  val_flowlist_entry  val_flowlistentry;
+  memset(&key_flolistentry, 0, sizeof(key_flolistentry));
+  memset(&val_flowlistentry, 0, sizeof(val_flowlistentry));
+  memcpy(key_flolistentry.flowlist_key.flowlist_name, "flowlistone",
+         sizeof(key_obj.flowlist_name));
+  key_flolistentry.sequence_num = 20;
+  memcpy(val_flowlistentry.mac_dst, "10", sizeof(val_flowlistentry.mac_dst));
+  memcpy(val_flowlistentry.mac_src, "11", sizeof(val_flowlistentry.mac_src));
+  val_flowlistentry.mac_eth_type = 12;
+  val_flowlistentry.vlan_priority = 13;
+  val_flowlistentry.ip_dscp = 14;
+  val_flowlistentry.ip_proto = 15;
+  val_flowlistentry.l4_dst_port = 16;
+  val_flowlistentry.l4_src_port = 17;
+  val_flowlistentry.l4_src_port_endpt = 18;
+  val_flowlistentry.l4_dst_port_endpt = 19;
+  val_flowlistentry.icmp_type = 21;
+  val_flowlistentry.icmp_code = 22;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_flowlist_entry,
+             val_flowlist_entry, uint32_t>
+      (&key_flolistentry, &val_flowlistentry, operation);
+  ret = KeyTree_obj->append_commit_node(cfgptr1);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  CommonIterator* itr_ptr = KeyTree_obj->create_iterator();
+  cfgptr = itr_ptr->FirstItem();
+  CacheElementUtil<key_flowlist_t, val_flowlist_t, uint32_t> *tmp_ptr =
+      static_cast<CacheElementUtil<key_flowlist_t, val_flowlist_t,
+      uint32_t>*> (cfgptr);
+  EXPECT_STREQ(reinterpret_cast<char*>(key_obj.flowlist_name),
+         reinterpret_cast<char*>(tmp_ptr->get_key_structure()->flowlist_name));
+  pfc_log_info("kt_flowlist:flowlistname= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->flowlist_name));
+  pfc_log_info(":Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr->get_key_name().c_str(), tmp_ptr->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr->get_parent_key_name().c_str(),
+               tmp_ptr->get_key_generate().c_str());
+  cfgptr1 = itr_ptr->NextItem();
+  CacheElementUtil<key_flowlist_entry, val_flowlist_entry, uint32_t> *tmp_ptr1 =
+      static_cast<CacheElementUtil<key_flowlist_entry, val_flowlist_entry,
+      uint32_t>*> (cfgptr1);
+  EXPECT_STREQ(reinterpret_cast<char*>(key_flolistentry.flowlist_key.
+                                       flowlist_name),
+         reinterpret_cast<char*>(tmp_ptr1->get_key_structure()->
+                                 flowlist_key.flowlist_name));
+  pfc_log_info("kt_flowlist_entry:flowlistname= %s", reinterpret_cast<char*>(
+          tmp_ptr1->get_key_structure()->flowlist_key.flowlist_name));
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr1->get_key_name().c_str(), tmp_ptr1->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr1->get_parent_key_name().c_str(),
+               tmp_ptr1->get_key_generate().c_str());
+  pfc_log_info("kt_flowlist_entry:sequence number= %d", tmp_ptr1->
+               get_key_structure()->sequence_num);
+  pfc_log_info("kt_flowlistentry:mac_dst= %s", reinterpret_cast<char*>(
+          tmp_ptr1->get_val_structure()->mac_dst));
+  pfc_log_info("kt_flowlistentry:mac_src= %s", reinterpret_cast<char*>(
+          tmp_ptr1->get_val_structure()->mac_src));
+  pfc_log_info("kt_flowlistentry:mac_eth_type= %d", tmp_ptr1->
+               get_val_structure()->mac_eth_type);
+  pfc_log_info("kt_flowlistentry:vlan_priority= %d", tmp_ptr1->
+               get_val_structure()->vlan_priority);
+  pfc_log_info("kt_flowlistentry:ip_dscp= %d", tmp_ptr1->
+               get_val_structure()->ip_dscp);
+  pfc_log_info("kt_flowlistentry:ip_proto= %d", tmp_ptr1->
+               get_val_structure()->ip_proto);
+  pfc_log_info("kt_flowlistentry:l4_dst_port= %d", tmp_ptr1->
+               get_val_structure()->l4_dst_port);
+  pfc_log_info("kt_flowlistentry:l4_src_port= %d", tmp_ptr1->
+               get_val_structure()->l4_src_port);
+  pfc_log_info("kt_flowlistentry:l4_src_port_endpt= %d", tmp_ptr1->
+               get_val_structure()->l4_src_port_endpt);
+  pfc_log_info("kt_flowlistentry:l4_dst_port_endpt= %d", tmp_ptr1->
+               get_val_structure()->l4_dst_port_endpt);
+  pfc_log_info("kt_flowlistentry:icmp_type= %d", tmp_ptr1->
+               get_val_structure()->icmp_type);
+  pfc_log_info("kt_flowlistentry:icmp_code= %d", tmp_ptr1->
+               get_val_structure()->icmp_code);
+  delete itr_ptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+}
+
+TEST(append_audit_node, parent_not_exist_flowlist_entry) {
+  int operation = 1;
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+  key_flowlist_entry  key_flolistentry;
+  val_flowlist_entry  val_flowlistentry;
+  memset(&key_flolistentry, 0, sizeof(key_flolistentry));
+  memset(&val_flowlistentry, 0, sizeof(val_flowlistentry));
+  memcpy(key_flolistentry.flowlist_key.flowlist_name, "flowlistone",
+         sizeof(key_flolistentry.flowlist_key.flowlist_name));
+  key_flolistentry.sequence_num = 20;
+  memcpy(val_flowlistentry.mac_dst, "10", sizeof(val_flowlistentry.mac_dst));
+  memcpy(val_flowlistentry.mac_src, "11", sizeof(val_flowlistentry.mac_src));
+
+  ConfigNode *cfgptr = new CacheElementUtil<key_flowlist_entry,
+             val_flowlist_entry, uint32_t>
+      (&key_flolistentry, &val_flowlistentry, operation);
+  int ret = KeyTree_obj->append_audit_node(cfgptr);
+
+  delete cfgptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_DRV_RC_ERR_GENERIC);
+}
+
+TEST(add_child_to_hash, FlowList_Success) {
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+  int operation = 1;
+  key_flowlist_t key_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  val_flowlist_t val_obj;
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.flowlist_name, "flowlistone", sizeof(key_obj.flowlist_name));
+
+  ConfigNode *cfgptr = new CacheElementUtil<key_flowlist_t,
+             val_flowlist_t, uint32_t>
+      (&key_obj, &val_obj, operation);
+  int ret = KeyTree_obj->add_child_to_hash(cfgptr);
+  delete KeyTree_obj;
+  delete cfgptr;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(add_child_to_hash, FlowListEntry_Success) {
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+  int operation = 1;
+  key_flowlist_t key_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  val_flowlist_t val_obj;
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.flowlist_name, "flowlistone", sizeof(key_obj.flowlist_name));
+
+  ConfigNode *cfgptr = new CacheElementUtil<key_flowlist_t,
+             val_flowlist_t, uint32_t>
+      (&key_obj, &val_obj, operation);
+  int ret = KeyTree_obj->add_child_to_hash(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_flowlist_entry  key_flolistentry;
+  val_flowlist_entry  val_flowlistentry;
+  memset(&key_flolistentry, 0, sizeof(key_flolistentry));
+  memset(&val_flowlistentry, 0, sizeof(val_flowlistentry));
+  memcpy(key_flolistentry.flowlist_key.flowlist_name, "flowlistone",
+         sizeof(key_flolistentry.flowlist_key.flowlist_name));
+  key_flolistentry.sequence_num = 20;
+  memcpy(val_flowlistentry.mac_dst, "10", sizeof(val_flowlistentry.mac_dst));
+  memcpy(val_flowlistentry.mac_src, "11", sizeof(val_flowlistentry.mac_src));
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_flowlist_entry,
+             val_flowlist_entry, uint32_t>
+      (&key_flolistentry, &val_flowlistentry, operation);
+  ret = KeyTree_obj->add_child_to_hash(cfgptr1);
+  delete KeyTree_obj;
+  delete cfgptr;
+  delete cfgptr1;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(get_parenttype, VtnFlowFilter) {
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+  unc_key_type_t keytype = KeyTree_obj->get_parenttype(UNC_KT_VTN_FLOWFILTER);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  EXPECT_EQ(keytype, UNC_KT_VTN);
+}
+
+TEST(get_parenttype, VtnFlowFilter_Entry) {
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+  unc_key_type_t keytype = KeyTree_obj->
+      get_parenttype(UNC_KT_VTN_FLOWFILTER_ENTRY);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  EXPECT_EQ(keytype, UNC_KT_VTN_FLOWFILTER);
+}
+
+TEST(append_commit_node, VtnFlowFilter) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vtn_flowfilter key_obj;
+  val_flowfilter val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vtn_key.vtn_name, "vtn1", sizeof(key_obj.vtn_key.vtn_name));
+  key_obj.input_direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vtn_flowfilter,
+             val_flowfilter, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_commit_node, VtnFlowFilter_Entry) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vtn_flowfilter key_obj;
+  val_flowfilter val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vtn_key.vtn_name, "vtn1", sizeof(key_obj.vtn_key.vtn_name));
+  key_obj.input_direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vtn_flowfilter,
+             val_flowfilter, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_vtn_flowfilter_entry key_VFlowFilterEntry;
+  val_vtn_flowfilter_entry val_VFlowFilterEntry;
+  memset(&key_VFlowFilterEntry, 0, sizeof(key_VFlowFilterEntry));
+  memset(&val_VFlowFilterEntry, 0, sizeof(val_VFlowFilterEntry));
+  memcpy(key_VFlowFilterEntry.flowfilter_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_VFlowFilterEntry.flowfilter_key.vtn_key.vtn_name));
+  key_VFlowFilterEntry.flowfilter_key.input_direction = 1;
+  key_VFlowFilterEntry.sequence_num = 20;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vtn_flowfilter_entry,
+             val_vtn_flowfilter_entry, uint32_t>
+      (&key_VFlowFilterEntry, &val_VFlowFilterEntry, operation);
+
+  ret = KeyTree_obj->append_commit_node(cfgptr1);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_commit_node, VtnFlowFilter_Retrive) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vtn_flowfilter key_obj;
+  val_flowfilter val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vtn_key.vtn_name, "vtn1", sizeof(key_obj.vtn_key.vtn_name));
+  key_obj.input_direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vtn_flowfilter,
+             val_flowfilter, uint32_t>(&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  CommonIterator* itr_ptr = KeyTree_obj->create_iterator();
+  cfgptr = itr_ptr->FirstItem();
+  CacheElementUtil<key_vtn_flowfilter, val_flowfilter, uint32_t> *tmp_ptr =
+      static_cast<CacheElementUtil<key_vtn_flowfilter, val_flowfilter,
+      uint32_t>*> (cfgptr);
+
+  EXPECT_STREQ(reinterpret_cast<char*>(key_obj.vtn_key.vtn_name),
+         reinterpret_cast<char*>(tmp_ptr->get_key_structure()->
+                                 vtn_key.vtn_name));
+  pfc_log_info("VtnFlowFilter Vtn Name= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->vtn_key.vtn_name));
+  pfc_log_info("VtnFlowFilter Input_direction= %d",
+          tmp_ptr->get_key_structure()->input_direction);
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr->get_key_name().c_str(), tmp_ptr->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr->get_parent_key_name().c_str(),
+               tmp_ptr->get_key_generate().c_str());
+  delete itr_ptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_commit_node, VtnFlowFilter_Entry_Retrive) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vtn_flowfilter key_obj;
+  val_flowfilter val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vtn_key.vtn_name, "vtn1", sizeof(key_obj.vtn_key.vtn_name));
+  key_obj.input_direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vtn_flowfilter,
+             val_flowfilter, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_vtn_flowfilter_entry key_VFlowFilterEntry;
+  val_vtn_flowfilter_entry val_VFlowFilterEntry;
+  memset(&key_VFlowFilterEntry, 0, sizeof(key_VFlowFilterEntry));
+  memset(&val_VFlowFilterEntry, 0, sizeof(val_VFlowFilterEntry));
+  memcpy(key_VFlowFilterEntry.flowfilter_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_VFlowFilterEntry.flowfilter_key.vtn_key.vtn_name));
+  key_VFlowFilterEntry.flowfilter_key.input_direction = 1;
+  key_VFlowFilterEntry.sequence_num = 20;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vtn_flowfilter_entry,
+             val_vtn_flowfilter_entry, uint32_t>
+      (&key_VFlowFilterEntry, &val_VFlowFilterEntry, operation);
+
+  ret = KeyTree_obj->append_commit_node(cfgptr1);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  CommonIterator* itr_ptr = KeyTree_obj->create_iterator();
+  cfgptr = itr_ptr->FirstItem();
+  CacheElementUtil<key_vtn_flowfilter, val_flowfilter, uint32_t> *tmp_ptr =
+      static_cast<CacheElementUtil<key_vtn_flowfilter, val_flowfilter,
+      uint32_t>*> (cfgptr);
+
+  EXPECT_STREQ(reinterpret_cast<char*>(key_obj.vtn_key.vtn_name),
+         reinterpret_cast<char*>(tmp_ptr->get_key_structure()->
+                                 vtn_key.vtn_name));
+  pfc_log_info("VtnFlowFilter Vtn Name= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->vtn_key.vtn_name));
+  pfc_log_info("VtnFlowFilter Input_direction= %d",
+          tmp_ptr->get_key_structure()->input_direction);
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr->get_key_name().c_str(), tmp_ptr->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr->get_parent_key_name().c_str(),
+               tmp_ptr->get_key_generate().c_str());
+  cfgptr1 = itr_ptr->NextItem();
+  CacheElementUtil<key_vtn_flowfilter_entry, val_vtn_flowfilter_entry,
+      uint32_t> *tmp_ptr1 =
+      static_cast<CacheElementUtil<key_vtn_flowfilter_entry,
+      val_vtn_flowfilter_entry, uint32_t>*> (cfgptr1);
+  EXPECT_STREQ(reinterpret_cast<char*>(key_VFlowFilterEntry.flowfilter_key.
+                                       vtn_key.vtn_name),
+         reinterpret_cast<char*>(tmp_ptr1->get_key_structure()->
+                                 flowfilter_key.vtn_key.vtn_name));
+  pfc_log_info("VtnFlowFilter Vtn Name= %s", reinterpret_cast<char*>(
+          tmp_ptr1->get_key_structure()->flowfilter_key.vtn_key.vtn_name));
+  pfc_log_info("VtnFlowFilter Input_direction= %d",
+          tmp_ptr1->get_key_structure()->flowfilter_key.input_direction);
+  pfc_log_info("vtnflowfilterentry:sequence number= %d", tmp_ptr1->
+               get_key_structure()->sequence_num);
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr1->get_key_name().c_str(), tmp_ptr1->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr1->get_parent_key_name().c_str(),
+               tmp_ptr1->get_key_generate().c_str());
+  delete itr_ptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(add_child_to_hash, VtnFlowFilter_success) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vtn_flowfilter key_obj;
+  val_flowfilter val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vtn_key.vtn_name, "vtn1", sizeof(key_obj.vtn_key.vtn_name));
+  key_obj.input_direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vtn_flowfilter,
+             val_flowfilter, uint32_t>
+      (&key_obj, &val_obj, operation);
+  int ret = KeyTree_obj->add_child_to_hash(cfgptr);
+  delete KeyTree_obj;
+  delete cfgptr;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(add_child_to_hash, VtnFlowFilterEntry_Success) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vtn_flowfilter key_obj;
+  val_flowfilter val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vtn_key.vtn_name, "vtn1", sizeof(key_obj.vtn_key.vtn_name));
+  key_obj.input_direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vtn_flowfilter,
+             val_flowfilter, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->add_child_to_hash(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_vtn_flowfilter_entry key_VFlowFilterEntry;
+  val_vtn_flowfilter_entry val_VFlowFilterEntry;
+  memset(&key_VFlowFilterEntry, 0, sizeof(key_VFlowFilterEntry));
+  memset(&val_VFlowFilterEntry, 0, sizeof(val_VFlowFilterEntry));
+  memcpy(key_VFlowFilterEntry.flowfilter_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_VFlowFilterEntry.flowfilter_key.vtn_key.vtn_name));
+  key_VFlowFilterEntry.flowfilter_key.input_direction = 1;
+  key_VFlowFilterEntry.sequence_num = 20;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vtn_flowfilter_entry,
+             val_vtn_flowfilter_entry, uint32_t>
+      (&key_VFlowFilterEntry, &val_VFlowFilterEntry, operation);
+
+  ret = KeyTree_obj->add_child_to_hash(cfgptr1);
+  delete KeyTree_obj;
+  delete cfgptr;
+  delete cfgptr1;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_audit_node, parent_not_exist_vtnflofilter_entry) {
+  int operation = 1;
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+  key_vtn_flowfilter_entry key_VFlowFilterEntry;
+  val_vtn_flowfilter_entry val_VFlowFilterEntry;
+  memset(&key_VFlowFilterEntry, 0, sizeof(key_VFlowFilterEntry));
+  memset(&val_VFlowFilterEntry, 0, sizeof(val_VFlowFilterEntry));
+  memcpy(key_VFlowFilterEntry.flowfilter_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_VFlowFilterEntry.flowfilter_key.vtn_key.vtn_name));
+  key_VFlowFilterEntry.flowfilter_key.input_direction = 1;
+  key_VFlowFilterEntry.sequence_num = 20;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vtn_flowfilter_entry,
+             val_vtn_flowfilter_entry, uint32_t>
+      (&key_VFlowFilterEntry, &val_VFlowFilterEntry, operation);
+  int ret = KeyTree_obj->append_audit_node(cfgptr);
+
+  delete cfgptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_DRV_RC_ERR_GENERIC);
+}
+
+TEST(get_parenttype, VbrFlowFilter) {
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vtn key_obj;
+  val_vtn val_obj;
+  memcpy(key_obj.vtn_name, "vtn1", sizeof(key_obj.vtn_name));
+  memcpy(val_obj.description, "vtn1_des", sizeof(val_obj.description));
+
+  unc_key_type_t keytype = KeyTree_obj->get_parenttype(UNC_KT_VBR_FLOWFILTER);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  EXPECT_EQ(keytype, UNC_KT_VBRIDGE);
+}
+
+TEST(append_commit_node, VbrFlowFilter) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vbr_flowfilter_t key_obj;
+  val_flowfilter_t val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vbr_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_obj.vbr_key.vtn_key.vtn_name));
+  memcpy(key_obj.vbr_key.vbridge_name, "vbridge1",
+         sizeof(key_obj.vbr_key.vbridge_name));
+  key_obj.direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vbr_flowfilter_t,
+             val_flowfilter_t, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_commit_node, VbrFlowFilter_Retrive) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vbr_flowfilter_t key_obj;
+  val_flowfilter_t val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vbr_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_obj.vbr_key.vtn_key.vtn_name));
+  memcpy(key_obj.vbr_key.vbridge_name, "vbridge1",
+         sizeof(key_obj.vbr_key.vbridge_name));
+  key_obj.direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vbr_flowfilter_t,
+             val_flowfilter_t, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  CommonIterator* itr_ptr = KeyTree_obj->create_iterator();
+  cfgptr = itr_ptr->FirstItem();
+  CacheElementUtil<key_vbr_flowfilter_t, val_flowfilter_t, uint32_t> *tmp_ptr =
+      static_cast<CacheElementUtil<key_vbr_flowfilter_t, val_flowfilter_t,
+      uint32_t>*> (cfgptr);
+
+  EXPECT_STREQ(reinterpret_cast<char*>(key_obj.vbr_key.vtn_key.vtn_name),
+         reinterpret_cast<char*>(tmp_ptr->get_key_structure()->
+                                 vbr_key.vtn_key.vtn_name));
+  pfc_log_info("Vtn Name= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->vbr_key.vtn_key.vtn_name));
+  pfc_log_info("Vbridge Name= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->vbr_key.vbridge_name));
+  pfc_log_info("Direction= %d", tmp_ptr->get_key_structure()->direction);
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr->get_key_name().c_str(), tmp_ptr->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr->get_parent_key_name().c_str(),
+               tmp_ptr->get_key_generate().c_str());
+  delete itr_ptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(add_child_to_hash, VbrFlowFilter_Success) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vbr_flowfilter_t key_obj;
+  val_flowfilter_t val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vbr_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_obj.vbr_key.vtn_key.vtn_name));
+  memcpy(key_obj.vbr_key.vbridge_name, "vbridge1",
+         sizeof(key_obj.vbr_key.vbridge_name));
+  key_obj.direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vbr_flowfilter_t,
+             val_flowfilter_t, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  int ret = KeyTree_obj->add_child_to_hash(cfgptr);
+  delete KeyTree_obj;
+  delete cfgptr;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(get_parenttype, VbrFlowFilterEntry) {
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+
+  unc_key_type_t keytype = KeyTree_obj->
+      get_parenttype(UNC_KT_VBR_FLOWFILTER_ENTRY);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  EXPECT_EQ(keytype, UNC_KT_VBR_FLOWFILTER);
+}
+
+TEST(append_commit_node, VbrFlowFilterEntry) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vbr_flowfilter_t key_obj;
+  val_flowfilter_t val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vbr_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_obj.vbr_key.vtn_key.vtn_name));
+  memcpy(key_obj.vbr_key.vbridge_name, "vbridge1", sizeof(key_obj.vbr_key.
+                                                          vbridge_name));
+  key_obj.direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vbr_flowfilter_t,
+             val_flowfilter_t, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_vbr_flowfilter_entry key_vbrflowfilterentry;
+  val_flowfilter_entry val_vbrflowfilterentry;
+  memset(&key_vbrflowfilterentry, 0, sizeof(key_vbrflowfilterentry));
+  memset(&val_vbrflowfilterentry, 0, sizeof(val_vbrflowfilterentry));
+  memcpy(key_vbrflowfilterentry.flowfilter_key.vbr_key.vtn_key.vtn_name,
+         "vtn1", sizeof(key_vbrflowfilterentry.flowfilter_key.vbr_key.vtn_key.
+                        vtn_name));
+  memcpy(key_vbrflowfilterentry.flowfilter_key.vbr_key.vbridge_name,
+         "vbridge1", sizeof(key_vbrflowfilterentry.flowfilter_key.vbr_key.
+                            vbridge_name));
+  key_vbrflowfilterentry.flowfilter_key.direction = 1;
+  key_vbrflowfilterentry.sequence_num = 20;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vbr_flowfilter_entry,
+             val_flowfilter_entry, uint32_t>
+      (&key_vbrflowfilterentry, &val_vbrflowfilterentry, operation);
+
+  ret = KeyTree_obj->append_commit_node(cfgptr1);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_commit_node, VbrFlowFilterEntry_Retrive) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vbr_flowfilter_t key_obj;
+  val_flowfilter_t val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vbr_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_obj.vbr_key.vtn_key.vtn_name));
+  memcpy(key_obj.vbr_key.vbridge_name, "vbridge1",
+         sizeof(key_obj.vbr_key.vbridge_name));
+  key_obj.direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vbr_flowfilter_t,
+             val_flowfilter_t, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_vbr_flowfilter_entry key_vbrflowfilterentry;
+  val_flowfilter_entry val_vbrflowfilterentry;
+  memset(&key_vbrflowfilterentry, 0, sizeof(key_vbrflowfilterentry));
+  memset(&val_vbrflowfilterentry, 0, sizeof(val_vbrflowfilterentry));
+  memcpy(key_vbrflowfilterentry.flowfilter_key.vbr_key.vtn_key.vtn_name,
+         "vtn1", sizeof(key_vbrflowfilterentry.flowfilter_key.vbr_key.
+                        vtn_key.vtn_name));
+  memcpy(key_vbrflowfilterentry.flowfilter_key.vbr_key.vbridge_name,
+         "vbridge1", sizeof(key_vbrflowfilterentry.flowfilter_key.vbr_key.
+                            vbridge_name));
+  key_vbrflowfilterentry.flowfilter_key.direction = 1;
+  key_vbrflowfilterentry.sequence_num = 20;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vbr_flowfilter_entry,
+             val_flowfilter_entry, uint32_t>
+      (&key_vbrflowfilterentry, &val_vbrflowfilterentry, operation);
+
+  ret = KeyTree_obj->append_commit_node(cfgptr1);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  CommonIterator* itr_ptr = KeyTree_obj->create_iterator();
+  cfgptr = itr_ptr->FirstItem();
+  CacheElementUtil<key_vbr_flowfilter_t, val_flowfilter_t, uint32_t> *tmp_ptr =
+      static_cast<CacheElementUtil<key_vbr_flowfilter_t, val_flowfilter_t,
+      uint32_t>*> (cfgptr);
+
+  EXPECT_STREQ(reinterpret_cast<char*>(key_obj.vbr_key.vtn_key.vtn_name),
+         reinterpret_cast<char*>(tmp_ptr->get_key_structure()->
+                                 vbr_key.vtn_key.vtn_name));
+  pfc_log_info("Vtn Name= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->vbr_key.vtn_key.vtn_name));
+  pfc_log_info("Vbridge Name= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->vbr_key.vbridge_name));
+  pfc_log_info("Direction= %d", tmp_ptr->get_key_structure()->direction);
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr->get_key_name().c_str(), tmp_ptr->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr->get_parent_key_name().c_str(),
+               tmp_ptr->get_key_generate().c_str());
+  cfgptr1 = itr_ptr->NextItem();
+  CacheElementUtil<key_vbr_flowfilter_entry, val_flowfilter_entry,
+      uint32_t> *tmp_ptr1 =
+      static_cast<CacheElementUtil<key_vbr_flowfilter_entry,
+      val_flowfilter_entry, uint32_t>*> (cfgptr1);
+  EXPECT_STREQ(reinterpret_cast<char*>(key_vbrflowfilterentry.flowfilter_key.
+                                       vbr_key.vtn_key.vtn_name),
+         reinterpret_cast<char*>(tmp_ptr1->get_key_structure()->
+                                 flowfilter_key.vbr_key.vtn_key.vtn_name));
+  pfc_log_info("Entry:Vtn Name= %s", reinterpret_cast<char*>(
+        tmp_ptr1->get_key_structure()->
+        flowfilter_key.vbr_key.vtn_key.vtn_name));
+  pfc_log_info("Entry:Vbridge Name= %s", reinterpret_cast<char*>(
+        tmp_ptr1->get_key_structure()->flowfilter_key.vbr_key.vbridge_name));
+  pfc_log_info("Entry:Direction= %d", tmp_ptr1->get_key_structure()->
+               flowfilter_key.direction);
+  pfc_log_info("Entry:SequenceNumber= %d", tmp_ptr1->get_key_structure()->
+               sequence_num);
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr1->get_key_name().c_str(), tmp_ptr1->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr1->get_parent_key_name().c_str(),
+               tmp_ptr1->get_key_generate().c_str());
+  delete itr_ptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(add_child_to_hash, VbrFlowFilterEntry_Success) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vbr_flowfilter_t key_obj;
+  val_flowfilter_t val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vbr_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_obj.vbr_key.vtn_key.vtn_name));
+  memcpy(key_obj.vbr_key.vbridge_name, "vbridge1",
+         sizeof(key_obj.vbr_key.vbridge_name));
+  key_obj.direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vbr_flowfilter_t,
+      val_flowfilter_t, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->add_child_to_hash(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_vbr_flowfilter_entry key_vbrflowfilterentry;
+  val_flowfilter_entry val_vbrflowfilterentry;
+  memset(&key_vbrflowfilterentry, 0, sizeof(key_vbrflowfilterentry));
+  memset(&val_vbrflowfilterentry, 0, sizeof(val_vbrflowfilterentry));
+  memcpy(key_vbrflowfilterentry.flowfilter_key.vbr_key.vtn_key.vtn_name,
+         "vtn1", sizeof(key_vbrflowfilterentry.flowfilter_key.vbr_key.vtn_key.
+                        vtn_name));
+  memcpy(key_vbrflowfilterentry.flowfilter_key.vbr_key.vbridge_name,
+         "vbridge1", sizeof(key_vbrflowfilterentry.flowfilter_key.vbr_key.
+                            vbridge_name));
+  key_vbrflowfilterentry.flowfilter_key.direction = 1;
+  key_vbrflowfilterentry.sequence_num = 20;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vbr_flowfilter_entry,
+             val_flowfilter_entry, uint32_t>
+      (&key_vbrflowfilterentry, &val_vbrflowfilterentry, operation);
+
+  ret = KeyTree_obj->add_child_to_hash(cfgptr1);
+  delete KeyTree_obj;
+  delete cfgptr;
+  delete cfgptr1;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_audit_node, parent_not_exist_vbrflowfilter_entry) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+  key_vbr_flowfilter_entry key_vbrflowfilterentry;
+  val_flowfilter_entry val_vbrflowfilterentry;
+  memset(&key_vbrflowfilterentry, 0, sizeof(key_vbrflowfilterentry));
+  memset(&val_vbrflowfilterentry, 0, sizeof(val_vbrflowfilterentry));
+  memcpy(key_vbrflowfilterentry.flowfilter_key.vbr_key.vtn_key.vtn_name,
+         "vtn1", sizeof(key_vbrflowfilterentry.flowfilter_key.vbr_key.
+                        vtn_key.vtn_name));
+  memcpy(key_vbrflowfilterentry.flowfilter_key.vbr_key.vbridge_name,
+         "vbridge1", sizeof(key_vbrflowfilterentry.flowfilter_key.
+                            vbr_key.vbridge_name));
+  key_vbrflowfilterentry.flowfilter_key.direction = 1;
+  key_vbrflowfilterentry.sequence_num = 20;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vbr_flowfilter_entry,
+             val_flowfilter_entry, uint32_t>
+      (&key_vbrflowfilterentry, &val_vbrflowfilterentry, operation);
+  uint32_t ret = KeyTree_obj->append_audit_node(cfgptr);
+  delete cfgptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_DRV_RC_ERR_GENERIC);
+}
+
+TEST(get_parenttype, VbrIfFlowFilter) {
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+
+  unc_key_type_t keytype = KeyTree_obj->get_parenttype(UNC_KT_VBRIF_FLOWFILTER);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  EXPECT_EQ(keytype, UNC_KT_VBR_IF);
+}
+
+TEST(append_commit_node, VbrIfFlowFilter) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vbr_if_flowfilter key_obj;
+  pfcdrv_val_vbrif_vextif val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.if_key.vbr_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_obj.if_key.vbr_key.vtn_key.vtn_name));
+  memcpy(key_obj.if_key.vbr_key.vbridge_name, "vbridge1",
+         sizeof(key_obj.if_key.vbr_key.vbridge_name));
+  memcpy(key_obj.if_key.if_name, "Interface1", sizeof(key_obj.if_key.if_name));
+  key_obj.direction = 2;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vbr_if_flowfilter,
+             pfcdrv_val_vbrif_vextif, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_commit_node, VbrIfFlowFilter_Retrive) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vbr_if_flowfilter key_obj;
+  pfcdrv_val_vbrif_vextif val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.if_key.vbr_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_obj.if_key.vbr_key.vtn_key.vtn_name));
+  memcpy(key_obj.if_key.vbr_key.vbridge_name, "vbridge1",
+         sizeof(key_obj.if_key.vbr_key.vbridge_name));
+  memcpy(key_obj.if_key.if_name, "Interface1", sizeof(key_obj.if_key.if_name));
+  key_obj.direction = 2;
+  val_obj.interface_type = 3;
+  memcpy(val_obj.vexternal_name, "Vexterna1", sizeof(val_obj.vexternal_name));
+  memcpy(val_obj.vext_if_name, "vextifname1", sizeof(val_obj.vext_if_name));
+  ConfigNode *cfgptr = new CacheElementUtil<key_vbr_if_flowfilter,
+             pfcdrv_val_vbrif_vextif, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  CommonIterator* itr_ptr = KeyTree_obj->create_iterator();
+  cfgptr = itr_ptr->FirstItem();
+  CacheElementUtil<key_vbr_if_flowfilter, pfcdrv_val_vbrif_vextif,
+      uint32_t> *tmp_ptr = static_cast<CacheElementUtil<key_vbr_if_flowfilter,
+      pfcdrv_val_vbrif_vextif, uint32_t>*> (cfgptr);
+
+  EXPECT_STREQ(reinterpret_cast<char*>(key_obj.if_key.vbr_key.vtn_key.
+                                       vtn_name),
+         reinterpret_cast<char*>(tmp_ptr->get_key_structure()->
+                                 if_key.vbr_key.vtn_key.vtn_name));
+  pfc_log_info("vtnname= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->if_key.vbr_key.vtn_key.vtn_name));
+  pfc_log_info("vbridgename= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->if_key.vbr_key.vbridge_name));
+  pfc_log_info("InterfaceName= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->if_key.if_name));
+  pfc_log_info("Direction= %d", tmp_ptr->get_key_structure()->direction);
+  pfc_log_info("Interface_type= %d", tmp_ptr->get_val_structure()->
+               interface_type);
+  pfc_log_info("VexternalName= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_val_structure()->vexternal_name));
+  pfc_log_info("VexternalIfName= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_val_structure()->vext_if_name));
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr->get_key_name().c_str(), tmp_ptr->get_type_name());;
+  pfc_log_info(":ParentKey %s SearchKey %s",
+               tmp_ptr->get_parent_key_name().c_str(),
+               tmp_ptr->get_key_generate().c_str());
+  delete itr_ptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(add_child_to_hash, VbrIfFlowFilter_Success) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vbr_if_flowfilter key_obj;
+  pfcdrv_val_vbrif_vextif val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.if_key.vbr_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_obj.if_key.vbr_key.vtn_key.vtn_name));
+  memcpy(key_obj.if_key.vbr_key.vbridge_name, "vbridge1",
+         sizeof(key_obj.if_key.vbr_key.vbridge_name));
+  memcpy(key_obj.if_key.if_name, "Interface1", sizeof(key_obj.if_key.if_name));
+  key_obj.direction = 2;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vbr_if_flowfilter,
+      pfcdrv_val_vbrif_vextif, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->add_child_to_hash(cfgptr);
+  delete KeyTree_obj;
+  delete cfgptr;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(get_parenttype, VbrIfFlowFilterEntry) {
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+
+  unc_key_type_t keytype = KeyTree_obj->
+      get_parenttype(UNC_KT_VBRIF_FLOWFILTER_ENTRY);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  EXPECT_EQ(keytype, UNC_KT_VBRIF_FLOWFILTER);
+}
+
+TEST(append_commit_node, VbrIfFlowFilterEntry) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vbr_if_flowfilter key_obj;
+  pfcdrv_val_vbrif_vextif val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.if_key.vbr_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_obj.if_key.vbr_key.vtn_key.vtn_name));
+  memcpy(key_obj.if_key.vbr_key.vbridge_name, "vbridge1",
+         sizeof(key_obj.if_key.vbr_key.vbridge_name));
+  memcpy(key_obj.if_key.if_name, "Interface1", sizeof(key_obj.if_key.if_name));
+  key_obj.direction = 2;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vbr_if_flowfilter,
+             pfcdrv_val_vbrif_vextif, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_vbr_if_flowfilter_entry key_vbrifflowfilterentry;
+  pfcdrv_val_flowfilter_entry val_vbrifflowfilterentry;
+  memset(&key_vbrifflowfilterentry, 0, sizeof(key_vbrifflowfilterentry));
+  memset(&val_vbrifflowfilterentry, 0, sizeof(val_vbrifflowfilterentry));
+  memcpy(key_vbrifflowfilterentry.flowfilter_key.if_key.vbr_key.vtn_key.
+         vtn_name, "vtn1", sizeof(key_vbrifflowfilterentry.flowfilter_key.
+                                  if_key.vbr_key.vtn_key.vtn_name));
+  memcpy(key_vbrifflowfilterentry.flowfilter_key.if_key.vbr_key.vbridge_name,
+         "vbridge1", sizeof(key_vbrifflowfilterentry.flowfilter_key.if_key.
+                            vbr_key.vbridge_name));
+  memcpy(key_vbrifflowfilterentry.flowfilter_key.if_key.if_name,
+         "Interface1", sizeof(key_vbrifflowfilterentry.flowfilter_key.
+                              if_key.if_name));
+  key_vbrifflowfilterentry.flowfilter_key.direction = 2;
+  key_vbrifflowfilterentry.sequence_num = 3;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vbr_if_flowfilter_entry,
+             pfcdrv_val_flowfilter_entry, uint32_t>
+      (&key_vbrifflowfilterentry, &val_vbrifflowfilterentry, operation);
+
+  ret = KeyTree_obj->append_commit_node(cfgptr1);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_commit_node, VbrIfFlowFilterEntry_Retrive) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vbr_if_flowfilter key_obj;
+  pfcdrv_val_vbrif_vextif val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.if_key.vbr_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_obj.if_key.vbr_key.vtn_key.vtn_name));
+  memcpy(key_obj.if_key.vbr_key.vbridge_name, "vbridge1",
+         sizeof(key_obj.if_key.vbr_key.vbridge_name));
+  memcpy(key_obj.if_key.if_name, "Interface1", sizeof(key_obj.if_key.if_name));
+  key_obj.direction = 2;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vbr_if_flowfilter,
+             pfcdrv_val_vbrif_vextif, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_vbr_if_flowfilter_entry key_vbrifflowfilterentry;
+  pfcdrv_val_flowfilter_entry val_vbrifflowfilterentry;
+  memset(&key_vbrifflowfilterentry, 0, sizeof(key_vbrifflowfilterentry));
+  memset(&val_vbrifflowfilterentry, 0, sizeof(val_vbrifflowfilterentry));
+  memcpy(key_vbrifflowfilterentry.flowfilter_key.if_key.vbr_key.vtn_key.
+         vtn_name, "vtn1", sizeof(key_vbrifflowfilterentry.flowfilter_key.
+                                  if_key.vbr_key.vtn_key.vtn_name));
+  memcpy(key_vbrifflowfilterentry.flowfilter_key.if_key.vbr_key.vbridge_name,
+         "vbridge1", sizeof(key_vbrifflowfilterentry.flowfilter_key.
+                            if_key.vbr_key.vbridge_name));
+  memcpy(key_vbrifflowfilterentry.flowfilter_key.if_key.if_name,
+         "Interface1", sizeof(key_vbrifflowfilterentry.flowfilter_key.
+                              if_key.if_name));
+  key_vbrifflowfilterentry.flowfilter_key.direction = 2;
+  key_vbrifflowfilterentry.sequence_num = 3;
+  val_vbrifflowfilterentry.val_vbrif_vextif.interface_type = 4;
+  val_vbrifflowfilterentry.val_ff_entry.priority = 5;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vbr_if_flowfilter_entry,
+             pfcdrv_val_flowfilter_entry, uint32_t>
+      (&key_vbrifflowfilterentry, &val_vbrifflowfilterentry, operation);
+
+  ret = KeyTree_obj->append_commit_node(cfgptr1);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  CommonIterator* itr_ptr = KeyTree_obj->create_iterator();
+  cfgptr = itr_ptr->FirstItem();
+  CacheElementUtil<key_vbr_if_flowfilter,
+      pfcdrv_val_vbrif_vextif, uint32_t> *tmp_ptr =
+      static_cast<CacheElementUtil<key_vbr_if_flowfilter,
+      pfcdrv_val_vbrif_vextif, uint32_t>*> (cfgptr);
+
+  EXPECT_STREQ(reinterpret_cast<char*>(key_obj.if_key.vbr_key.vtn_key.vtn_name),
+         reinterpret_cast<char*>(tmp_ptr->get_key_structure()->
+                                 if_key.vbr_key.vtn_key.vtn_name));
+  pfc_log_info("vtnname= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->if_key.vbr_key.vtn_key.vtn_name));
+  pfc_log_info("vbridgename= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->if_key.vbr_key.vbridge_name));
+  pfc_log_info("InterfaceName= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->if_key.if_name));
+  pfc_log_info("Direction= %d", tmp_ptr->get_key_structure()->direction);
+  pfc_log_info("Interface_type= %d", tmp_ptr->get_val_structure()->
+               interface_type);
+  pfc_log_info("VexternalName= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_val_structure()->vexternal_name));
+  pfc_log_info("VexternalIfName= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_val_structure()->vext_if_name));
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr->get_key_name().c_str(), tmp_ptr->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr->get_parent_key_name().c_str(),
+               tmp_ptr->get_key_generate().c_str());
+  cfgptr1 = itr_ptr->NextItem();
+  CacheElementUtil<key_vbr_if_flowfilter_entry,
+      pfcdrv_val_flowfilter_entry, uint32_t> *tmp_ptr1 =
+      static_cast<CacheElementUtil<key_vbr_if_flowfilter_entry,
+      pfcdrv_val_flowfilter_entry, uint32_t>*> (cfgptr1);
+
+  EXPECT_STREQ(reinterpret_cast<char*>(key_vbrifflowfilterentry.flowfilter_key.
+                                       if_key.vbr_key.vtn_key.vtn_name),
+       reinterpret_cast<char*>(tmp_ptr1->get_key_structure()->
+                               flowfilter_key.if_key.vbr_key.vtn_key.vtn_name));
+  pfc_log_info("Entry:vtnname= %s", reinterpret_cast<char*>(
+          tmp_ptr1->get_key_structure()->flowfilter_key.if_key.vbr_key.vtn_key.
+          vtn_name));
+  pfc_log_info("Entry:VbridgeName= %s", reinterpret_cast<char*>(
+          tmp_ptr1->get_key_structure()->flowfilter_key.if_key.vbr_key.
+          vbridge_name));
+  pfc_log_info("Entry:Interfacename= %s", reinterpret_cast<char*>(
+          tmp_ptr1->get_key_structure()->flowfilter_key.if_key.if_name));
+  pfc_log_info("Entry:Direction= %d", tmp_ptr1->get_key_structure()->
+               flowfilter_key.direction);
+  pfc_log_info("Entry:sequence_num= %d", tmp_ptr1->get_key_structure()->
+               sequence_num);
+  pfc_log_info("Entry:interface_type= %d", tmp_ptr1->get_val_structure()->
+               val_vbrif_vextif.interface_type);
+  pfc_log_info("Entry:Priority= %d", tmp_ptr1->get_val_structure()->
+               val_ff_entry.priority);
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr1->get_key_name().c_str(), tmp_ptr1->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr1->get_parent_key_name().c_str(),
+               tmp_ptr1->get_key_generate().c_str());
+  delete itr_ptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(add_child_to_hash, VbrIfFlowFilterEntry_Success) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vbr_if_flowfilter key_obj;
+  pfcdrv_val_vbrif_vextif val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.if_key.vbr_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_obj.if_key.vbr_key.vtn_key.vtn_name));
+  memcpy(key_obj.if_key.vbr_key.vbridge_name, "vbridge1",
+         sizeof(key_obj.if_key.vbr_key.vbridge_name));
+  memcpy(key_obj.if_key.if_name, "Interface1", sizeof(key_obj.if_key.if_name));
+  key_obj.direction = 2;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vbr_if_flowfilter,
+             pfcdrv_val_vbrif_vextif, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->add_child_to_hash(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_vbr_if_flowfilter_entry key_vbrifflowfilterentry;
+  pfcdrv_val_flowfilter_entry val_vbrifflowfilterentry;
+  memset(&key_vbrifflowfilterentry, 0, sizeof(key_vbrifflowfilterentry));
+  memset(&val_vbrifflowfilterentry, 0, sizeof(val_vbrifflowfilterentry));
+  memcpy(key_vbrifflowfilterentry.flowfilter_key.if_key.vbr_key.vtn_key.
+         vtn_name, "vtn1", sizeof(key_vbrifflowfilterentry.flowfilter_key.
+                                  if_key.vbr_key.vtn_key.vtn_name));
+  memcpy(key_vbrifflowfilterentry.flowfilter_key.if_key.vbr_key.vbridge_name,
+         "vbridge1", sizeof(key_vbrifflowfilterentry.flowfilter_key.
+                            if_key.vbr_key.vbridge_name));
+  memcpy(key_vbrifflowfilterentry.flowfilter_key.if_key.if_name,
+         "Interface1", sizeof(key_vbrifflowfilterentry.flowfilter_key.
+                              if_key.if_name));
+  key_vbrifflowfilterentry.flowfilter_key.direction = 2;
+  key_vbrifflowfilterentry.sequence_num = 3;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vbr_if_flowfilter_entry,
+             pfcdrv_val_flowfilter_entry, uint32_t>
+      (&key_vbrifflowfilterentry, &val_vbrifflowfilterentry, operation);
+
+  ret = KeyTree_obj->add_child_to_hash(cfgptr1);
+  delete KeyTree_obj;
+  delete cfgptr;
+  delete cfgptr1;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_commit_node, parent_not_exist_vbrifflowfilterentry) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vbr_if_flowfilter_entry key_vbrifflowfilterentry;
+  pfcdrv_val_flowfilter_entry val_vbrifflowfilterentry;
+  memset(&key_vbrifflowfilterentry, 0, sizeof(key_vbrifflowfilterentry));
+  memset(&val_vbrifflowfilterentry, 0, sizeof(val_vbrifflowfilterentry));
+  memcpy(key_vbrifflowfilterentry.flowfilter_key.if_key.vbr_key.vtn_key.
+         vtn_name, "vtnr2", sizeof(key_vbrifflowfilterentry.flowfilter_key.
+                                   if_key.vbr_key.vtn_key.vtn_name));
+  memcpy(key_vbrifflowfilterentry.flowfilter_key.if_key.
+         vbr_key.vbridge_name,
+         "vbridge2", sizeof(key_vbrifflowfilterentry.flowfilter_key.if_key.
+                            vbr_key.vbridge_name));
+  memcpy(key_vbrifflowfilterentry.flowfilter_key.if_key.if_name,
+         "Interface3", sizeof(key_vbrifflowfilterentry.
+                              flowfilter_key.if_key.if_name));
+  key_vbrifflowfilterentry.flowfilter_key.direction = 4;
+  key_vbrifflowfilterentry.sequence_num = 5;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vbr_if_flowfilter_entry,
+             pfcdrv_val_flowfilter_entry, uint32_t>
+      (&key_vbrifflowfilterentry, &val_vbrifflowfilterentry, operation);
+
+  uint32_t ret = KeyTree_obj->append_audit_node(cfgptr1);
+  delete KeyTree_obj;
+  delete cfgptr1;
+  KeyTree_obj = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_DRV_RC_ERR_GENERIC);
+}
+
+TEST(get_parenttype, Vterminal) {
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+
+  unc_key_type_t keytype = KeyTree_obj->get_parenttype(UNC_KT_VTERMINAL);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  EXPECT_EQ(keytype, UNC_KT_VTN);
+}
+
+TEST(append_commit_node, Vterminal) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vterm key_obj;
+  val_vterm val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vtn_key.vtn_name, "vtn1", sizeof(key_obj.vtn_key.vtn_name));
+  memcpy(key_obj.vterminal_name, "vtermina1", sizeof(key_obj.vterminal_name));
+  memcpy(val_obj.controller_id, "odc1", sizeof(val_obj.controller_id));
+  memcpy(val_obj.domain_id, "domain1", sizeof(val_obj.domain_id));
+  memcpy(val_obj.vterm_description, "VterminalDescription",
+         sizeof(val_obj.vterm_description));
+  ConfigNode *cfgptr = new CacheElementUtil<key_vterm, val_vterm, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_commit_node, Vterminal_Retrive) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vterm key_obj;
+  val_vterm val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vtn_key.vtn_name, "vtn1", sizeof(key_obj.vtn_key.vtn_name));
+  memcpy(key_obj.vterminal_name, "vtermina1", sizeof(key_obj.vterminal_name));
+  memcpy(val_obj.controller_id, "odc1", sizeof(val_obj.controller_id));
+  memcpy(val_obj.domain_id, "domain1", sizeof(val_obj.domain_id));
+  memcpy(val_obj.vterm_description, "VterminalDescription",
+         sizeof(val_obj.vterm_description));
+  ConfigNode *cfgptr = new CacheElementUtil<key_vterm, val_vterm, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  CommonIterator* itr_ptr = KeyTree_obj->create_iterator();
+  cfgptr = itr_ptr->FirstItem();
+  CacheElementUtil<key_vterm, val_vterm, uint32_t> *tmp_ptr =
+      static_cast<CacheElementUtil<key_vterm, val_vterm, uint32_t>*> (cfgptr);
+  EXPECT_STREQ(reinterpret_cast<char*>(key_obj.vtn_key.vtn_name),
+         reinterpret_cast<char*>(tmp_ptr->get_key_structure()->
+                                 vtn_key.vtn_name));
+  pfc_log_info("vtnname= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->vtn_key.vtn_name));
+  pfc_log_info("vterminalname= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->vterminal_name));
+  pfc_log_info("controllerid= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_val_structure()->controller_id));
+  pfc_log_info("domainid= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_val_structure()->domain_id));
+  pfc_log_info("vterm_description= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_val_structure()->vterm_description));
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr->get_key_name().c_str(), tmp_ptr->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr->get_parent_key_name().c_str(),
+               tmp_ptr->get_key_generate().c_str());
+  delete itr_ptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(add_child_to_hash, Vterminal) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vterm key_obj;
+  val_vterm val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vtn_key.vtn_name, "vtn1", sizeof(key_obj.vtn_key.vtn_name));
+  memcpy(key_obj.vterminal_name, "vtermina1", sizeof(key_obj.vterminal_name));
+  memcpy(val_obj.controller_id, "odc1", sizeof(val_obj.controller_id));
+  memcpy(val_obj.domain_id, "domain1", sizeof(val_obj.domain_id));
+  memcpy(val_obj.vterm_description, "VterminalDescription",
+         sizeof(val_obj.vterm_description));
+  ConfigNode *cfgptr = new CacheElementUtil<key_vterm, val_vterm, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->add_child_to_hash(cfgptr);
+  delete KeyTree_obj;
+  delete cfgptr;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(get_parenttype, VterminalIf) {
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+
+  unc_key_type_t keytype = KeyTree_obj->get_parenttype(UNC_KT_VTERM_IF);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  EXPECT_EQ(keytype, UNC_KT_VTERMINAL);
+}
+
+TEST(append_commit_node, VterminalIf) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vterm key_obj;
+  val_vterm val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vtn_key.vtn_name, "vtn1", sizeof(key_obj.vtn_key.vtn_name));
+  memcpy(key_obj.vterminal_name, "vtermina1", sizeof(key_obj.vterminal_name));
+  memcpy(val_obj.controller_id, "odc1", sizeof(val_obj.controller_id));
+  memcpy(val_obj.domain_id, "domain1", sizeof(val_obj.domain_id));
+  memcpy(val_obj.vterm_description, "VterminalDescription",
+         sizeof(val_obj.vterm_description));
+  ConfigNode *cfgptr = new CacheElementUtil<key_vterm, val_vterm, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_vterm_if key_vtermif;
+  val_vterm_if val_vtermif;
+  memset(&key_vtermif, 0, sizeof(key_vtermif));
+  memset(&val_vtermif, 0, sizeof(val_vtermif));
+  memcpy(key_vtermif.vterm_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_vtermif.vterm_key.vtn_key.vtn_name));
+  memcpy(key_vtermif.vterm_key.vterminal_name, "vtermina1",
+         sizeof(key_vtermif.vterm_key.vterminal_name));
+  memcpy(key_vtermif.if_name, "vterminalIf", sizeof(key_vtermif.if_name));
+  val_vtermif.admin_status = 1;
+  val_vtermif.portmap.vlan_id = 567;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vterm_if,
+             val_vterm_if, uint32_t>
+      (&key_vtermif, &val_vtermif, operation);
+
+  ret = KeyTree_obj->append_commit_node(cfgptr1);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_commit_node, VterminalIf_Retrive) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vterm key_obj;
+  val_vterm val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vtn_key.vtn_name, "vtn1", sizeof(key_obj.vtn_key.vtn_name));
+  memcpy(key_obj.vterminal_name, "vtermina1", sizeof(key_obj.vterminal_name));
+  memcpy(val_obj.controller_id, "odc1", sizeof(val_obj.controller_id));
+  memcpy(val_obj.domain_id, "domain1", sizeof(val_obj.domain_id));
+  memcpy(val_obj.vterm_description, "VterminalDescription",
+         sizeof(val_obj.vterm_description));
+  ConfigNode *cfgptr = new CacheElementUtil<key_vterm, val_vterm, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  CommonIterator* itr_ptr = KeyTree_obj->create_iterator();
+  cfgptr = itr_ptr->FirstItem();
+  CacheElementUtil<key_vterm, val_vterm, uint32_t> *tmp_ptr =
+      static_cast<CacheElementUtil<key_vterm, val_vterm, uint32_t>*> (cfgptr);
+  EXPECT_STREQ(reinterpret_cast<char*>(key_obj.vtn_key.vtn_name),
+         reinterpret_cast<char*>(tmp_ptr->get_key_structure()->
+                                 vtn_key.vtn_name));
+  pfc_log_info("vtnname= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->vtn_key.vtn_name));
+  pfc_log_info("vterminalname= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->vterminal_name));
+  pfc_log_info("controllerid= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_val_structure()->controller_id));
+  pfc_log_info("domainid= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_val_structure()->domain_id));
+  pfc_log_info("vterm_description= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_val_structure()->vterm_description));
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr->get_key_name().c_str(), tmp_ptr->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr->get_parent_key_name().c_str(),
+               tmp_ptr->get_key_generate().c_str());
+  key_vterm_if key_vtermif;
+  val_vterm_if val_vtermif;
+  memset(&key_vtermif, 0, sizeof(key_vtermif));
+  memset(&val_vtermif, 0, sizeof(val_vtermif));
+  memcpy(key_vtermif.vterm_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_vtermif.vterm_key.vtn_key.vtn_name));
+  memcpy(key_vtermif.vterm_key.vterminal_name, "vtermina1",
+         sizeof(key_vtermif.vterm_key.vterminal_name));
+  memcpy(key_vtermif.if_name, "vterminalIf", sizeof(key_vtermif.if_name));
+  val_vtermif.admin_status = 1;
+  val_vtermif.portmap.vlan_id = 567;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vterm_if,
+             val_vterm_if, uint32_t>
+      (&key_vtermif, &val_vtermif, operation);
+
+  ret = KeyTree_obj->append_commit_node(cfgptr1);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  cfgptr1 = itr_ptr->NextItem();
+  CacheElementUtil<key_vterm_if, val_vterm_if, uint32_t> *tmp_ptr1 =
+      static_cast<CacheElementUtil<key_vterm_if,
+      val_vterm_if, uint32_t>*> (cfgptr1);
+  EXPECT_STREQ(reinterpret_cast<char*>(key_vtermif.vterm_key.vtn_key.vtn_name),
+         reinterpret_cast<char*>(tmp_ptr1->get_key_structure()->
+                                 vterm_key.vtn_key.vtn_name));
+  pfc_log_info("VtermIF:vtnname= %s", reinterpret_cast<char*>(
+          tmp_ptr1->get_key_structure()->vterm_key.vtn_key.vtn_name));
+  pfc_log_info("VtermIF:vterminalname= %s", reinterpret_cast<char*>(
+          tmp_ptr1->get_key_structure()->vterm_key.vterminal_name));
+  pfc_log_info("VtermIF:VterminalIfName= %s", reinterpret_cast<char*>(
+          tmp_ptr1->get_key_structure()->if_name));
+  pfc_log_info("VtermIF:AdminStatus= %d", tmp_ptr1->get_val_structure()->
+               admin_status);
+  pfc_log_info("VtermIF:VlanId= %d", tmp_ptr1->get_val_structure()->
+               portmap.vlan_id);
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr1->get_key_name().c_str(), tmp_ptr1->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr1->get_parent_key_name().c_str(),
+               tmp_ptr1->get_key_generate().c_str());
+  delete itr_ptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(add_child_to_hash, VterminalIf) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vterm key_obj;
+  val_vterm val_obj;
+  memset(&key_obj, 0, sizeof(key_obj));
+  memset(&val_obj, 0, sizeof(val_obj));
+  memcpy(key_obj.vtn_key.vtn_name, "vtn1", sizeof(key_obj.vtn_key.vtn_name));
+  memcpy(key_obj.vterminal_name, "vtermina1", sizeof(key_obj.vterminal_name));
+  memcpy(val_obj.controller_id, "odc1", sizeof(val_obj.controller_id));
+  memcpy(val_obj.domain_id, "domain1", sizeof(val_obj.domain_id));
+  memcpy(val_obj.vterm_description, "VterminalDescription",
+         sizeof(val_obj.vterm_description));
+  ConfigNode *cfgptr = new CacheElementUtil<key_vterm, val_vterm, uint32_t>
+      (&key_obj, &val_obj, operation);
+
+  uint32_t ret = KeyTree_obj->add_child_to_hash(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_vterm_if key_vtermif;
+  val_vterm_if val_vtermif;
+  memset(&key_vtermif, 0, sizeof(key_vtermif));
+  memset(&val_vtermif, 0, sizeof(val_vtermif));
+  memcpy(key_vtermif.vterm_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_vtermif.vterm_key.vtn_key.vtn_name));
+  memcpy(key_vtermif.vterm_key.vterminal_name, "vtermina1",
+         sizeof(key_vtermif.vterm_key.vterminal_name));
+  memcpy(key_vtermif.if_name, "vterminalIf", sizeof(key_vtermif.if_name));
+  val_vtermif.admin_status = 1;
+  val_vtermif.portmap.vlan_id = 567;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vterm_if,
+             val_vterm_if, uint32_t>
+      (&key_vtermif, &val_vtermif, operation);
+
+  ret = KeyTree_obj->add_child_to_hash(cfgptr1);
+  delete KeyTree_obj;
+  delete cfgptr;
+  delete cfgptr1;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_commit_node, Parent_not_exist_VterminalIf) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+  key_vterm_if key_vtermif;
+  val_vterm_if val_vtermif;
+  memset(&key_vtermif, 0, sizeof(key_vtermif));
+  memset(&val_vtermif, 0, sizeof(val_vtermif));
+  memcpy(key_vtermif.vterm_key.vtn_key.vtn_name, "vtn1",
+         sizeof(key_vtermif.vterm_key.vtn_key.vtn_name));
+  memcpy(key_vtermif.vterm_key.vterminal_name, "vtermina1",
+         sizeof(key_vtermif.vterm_key.vterminal_name));
+  memcpy(key_vtermif.if_name, "vterminalIf", sizeof(key_vtermif.if_name));
+  val_vtermif.admin_status = 1;
+  val_vtermif.portmap.vlan_id = 567;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vterm_if,
+             val_vterm_if, uint32_t>
+      (&key_vtermif, &val_vtermif, operation);
+
+  uint32_t ret = KeyTree_obj->append_audit_node(cfgptr1);
+  delete KeyTree_obj;
+  delete cfgptr1;
+  KeyTree_obj = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_DRV_RC_ERR_GENERIC);
+}
+
+TEST(get_parenttype, VterminalIf_flowfilter) {
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+
+  unc_key_type_t keytype = KeyTree_obj->
+      get_parenttype(UNC_KT_VTERMIF_FLOWFILTER);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  EXPECT_EQ(keytype, UNC_KT_VTERM_IF);
+}
+
+TEST(get_parenttype, VterminalIf_flowfilter_entry) {
+  KeyTree* KeyTree_obj;
+  KeyTree_obj = KeyTree::create_cache();
+
+  unc_key_type_t keytype = KeyTree_obj->
+      get_parenttype(UNC_KT_VTERMIF_FLOWFILTER_ENTRY);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  EXPECT_EQ(keytype, UNC_KT_VTERMIF_FLOWFILTER);
+}
+
+TEST(append_commit_node, vterminalif_flowfilter) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vterm_if_flowfilter key_vtermifflowfilter;;
+  val_flowfilter val_vtermifflowfilter;
+  memset(&key_vtermifflowfilter, 0, sizeof(key_vtermifflowfilter));
+  memset(&val_vtermifflowfilter, 0, sizeof(val_vtermifflowfilter));
+  memcpy(key_vtermifflowfilter.if_key.vterm_key.vtn_key.vtn_name,
+         "vtn1", sizeof(key_vtermifflowfilter.if_key.vterm_key.vtn_key.
+                        vtn_name));
+  memcpy(key_vtermifflowfilter.if_key.vterm_key.vterminal_name,
+         "vtermina1", sizeof(key_vtermifflowfilter.if_key.vterm_key.
+                             vterminal_name));
+  memcpy(key_vtermifflowfilter.if_key.if_name, "VtermIfFFinterface",
+         sizeof(key_vtermifflowfilter.if_key.if_name));
+  key_vtermifflowfilter.direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vterm_if_flowfilter,
+             val_flowfilter, uint32_t>
+      (&key_vtermifflowfilter, &val_vtermifflowfilter, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(add_child_to_hash, vterminalif_flowfilter) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vterm_if_flowfilter key_vtermifflowfilter;;
+  val_flowfilter val_vtermifflowfilter;
+  memset(&key_vtermifflowfilter, 0, sizeof(key_vtermifflowfilter));
+  memset(&val_vtermifflowfilter, 0, sizeof(val_vtermifflowfilter));
+  memcpy(key_vtermifflowfilter.if_key.vterm_key.vtn_key.vtn_name,
+         "vtn1", sizeof(key_vtermifflowfilter.if_key.vterm_key.vtn_key.
+                        vtn_name));
+  memcpy(key_vtermifflowfilter.if_key.vterm_key.vterminal_name,
+         "vtermina1", sizeof(key_vtermifflowfilter.if_key.vterm_key.
+                             vterminal_name));
+  memcpy(key_vtermifflowfilter.if_key.if_name, "VtermIfFFinterface",
+         sizeof(key_vtermifflowfilter.if_key.if_name));
+  key_vtermifflowfilter.direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vterm_if_flowfilter,
+             val_flowfilter, uint32_t>
+      (&key_vtermifflowfilter, &val_vtermifflowfilter, operation);
+
+  uint32_t ret = KeyTree_obj->add_child_to_hash(cfgptr);
+  delete cfgptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_commit_node, Vterminalif_Flowfilter_Retrive) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vterm_if_flowfilter key_vtermifflowfilter;;
+  val_flowfilter val_vtermifflowfilter;
+  memset(&key_vtermifflowfilter, 0, sizeof(key_vtermifflowfilter));
+  memset(&val_vtermifflowfilter, 0, sizeof(val_vtermifflowfilter));
+  memcpy(key_vtermifflowfilter.if_key.vterm_key.vtn_key.vtn_name,
+         "vtn1", sizeof(key_vtermifflowfilter.if_key.vterm_key.vtn_key.
+                        vtn_name));
+  memcpy(key_vtermifflowfilter.if_key.vterm_key.vterminal_name,
+         "vtermina1", sizeof(key_vtermifflowfilter.if_key.vterm_key.
+                             vterminal_name));
+  memcpy(key_vtermifflowfilter.if_key.if_name, "VtermIfFFinterface",
+         sizeof(key_vtermifflowfilter.if_key.if_name));
+  key_vtermifflowfilter.direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vterm_if_flowfilter,
+             val_flowfilter, uint32_t>
+      (&key_vtermifflowfilter, &val_vtermifflowfilter, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  CommonIterator* itr_ptr = KeyTree_obj->create_iterator();
+  cfgptr = itr_ptr->FirstItem();
+  CacheElementUtil<key_vterm_if_flowfilter, val_flowfilter, uint32_t> *tmp_ptr =
+      static_cast<CacheElementUtil<key_vterm_if_flowfilter,
+      val_flowfilter, uint32_t>*> (cfgptr);
+
+  EXPECT_STREQ(reinterpret_cast<char*>(key_vtermifflowfilter.if_key.vterm_key.
+                                       vtn_key.vtn_name),
+         reinterpret_cast<char*>(tmp_ptr->get_key_structure()->
+                                 if_key.vterm_key.vtn_key.vtn_name));
+  pfc_log_info("Vtn Name= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->if_key.vterm_key.vtn_key.vtn_name));
+  pfc_log_info("Vterminal Name= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->if_key.vterm_key.vterminal_name));
+  pfc_log_info("VterminalFFInterface Name= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->if_key.if_name));
+  pfc_log_info("VterminalFF Direction= %d",
+          tmp_ptr->get_key_structure()->direction);
+  pfc_log_info("Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr->get_key_name().c_str(), tmp_ptr->get_type_name());;
+  pfc_log_info("ParentKey %s SearchKey %s",
+               tmp_ptr->get_parent_key_name().c_str(),
+               tmp_ptr->get_key_generate().c_str());
+  delete itr_ptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_commit_node, vterminalif_flowfilter_entry) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vterm_if_flowfilter key_vtermifflowfilter;;
+  val_flowfilter val_vtermifflowfilter;
+  memset(&key_vtermifflowfilter, 0, sizeof(key_vtermifflowfilter));
+  memset(&val_vtermifflowfilter, 0, sizeof(val_vtermifflowfilter));
+  memcpy(key_vtermifflowfilter.if_key.vterm_key.vtn_key.vtn_name,
+         "vtn1", sizeof(key_vtermifflowfilter.if_key.vterm_key.vtn_key.
+                        vtn_name));
+  memcpy(key_vtermifflowfilter.if_key.vterm_key.vterminal_name,
+         "vtermina1", sizeof(key_vtermifflowfilter.if_key.vterm_key.
+                             vterminal_name));
+  memcpy(key_vtermifflowfilter.if_key.if_name, "VtermIfFFinterface",
+         sizeof(key_vtermifflowfilter.if_key.if_name));
+  key_vtermifflowfilter.direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vterm_if_flowfilter,
+             val_flowfilter, uint32_t>
+      (&key_vtermifflowfilter, &val_vtermifflowfilter, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_vterm_if_flowfilter_entry key_vtermiflowfilterentry;
+  val_flowfilter_entry val_vtermiflowfilterentry;
+  memset(&key_vtermiflowfilterentry, 0, sizeof(key_vtermiflowfilterentry));
+  memset(&val_vtermiflowfilterentry, 0, sizeof(val_vtermiflowfilterentry));
+  memcpy(key_vtermiflowfilterentry.flowfilter_key.if_key.vterm_key.vtn_key.
+         vtn_name, "vtn1", sizeof(key_vtermiflowfilterentry.flowfilter_key.
+                                  if_key.vterm_key.vtn_key.vtn_name));
+  memcpy(key_vtermiflowfilterentry.flowfilter_key.if_key.vterm_key.
+         vterminal_name, "vtermina1", sizeof(key_vtermiflowfilterentry.
+                                             flowfilter_key.if_key.vterm_key.
+                                             vterminal_name));
+  memcpy(key_vtermiflowfilterentry.flowfilter_key.if_key.if_name,
+         "VtermIfFFinterface", sizeof(key_vtermiflowfilterentry.flowfilter_key.
+                                      if_key.if_name));
+  key_vtermiflowfilterentry.flowfilter_key.direction = 1;
+  key_vtermiflowfilterentry.sequence_num = 33;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vterm_if_flowfilter_entry,
+             val_flowfilter_entry, uint32_t>
+      (&key_vtermiflowfilterentry, &val_vtermiflowfilterentry, operation);
+
+  ret = KeyTree_obj->append_commit_node(cfgptr1);
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(add_child_to_hash, vterminalif_flowfilter_entry) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vterm_if_flowfilter key_vtermifflowfilter;;
+  val_flowfilter val_vtermifflowfilter;
+  memset(&key_vtermifflowfilter, 0, sizeof(key_vtermifflowfilter));
+  memset(&val_vtermifflowfilter, 0, sizeof(val_vtermifflowfilter));
+  memcpy(key_vtermifflowfilter.if_key.vterm_key.vtn_key.vtn_name,
+         "vtn1", sizeof(key_vtermifflowfilter.if_key.vterm_key.vtn_key.
+                        vtn_name));
+  memcpy(key_vtermifflowfilter.if_key.vterm_key.vterminal_name,
+         "vtermina1", sizeof(key_vtermifflowfilter.if_key.vterm_key.
+                             vterminal_name));
+  memcpy(key_vtermifflowfilter.if_key.if_name, "VtermIfFFinterface",
+         sizeof(key_vtermifflowfilter.if_key.if_name));
+  key_vtermifflowfilter.direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vterm_if_flowfilter,
+             val_flowfilter, uint32_t>
+      (&key_vtermifflowfilter, &val_vtermifflowfilter, operation);
+
+  uint32_t ret = KeyTree_obj->add_child_to_hash(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_vterm_if_flowfilter_entry key_vtermiflowfilterentry;
+  val_flowfilter_entry val_vtermiflowfilterentry;
+  memset(&key_vtermiflowfilterentry, 0, sizeof(key_vtermiflowfilterentry));
+  memset(&val_vtermiflowfilterentry, 0, sizeof(val_vtermiflowfilterentry));
+  memcpy(key_vtermiflowfilterentry.flowfilter_key.if_key.vterm_key.vtn_key.
+         vtn_name, "vtn1", sizeof(key_vtermiflowfilterentry.flowfilter_key.
+                                  if_key.vterm_key.vtn_key.vtn_name));
+  memcpy(key_vtermiflowfilterentry.flowfilter_key.if_key.vterm_key.
+         vterminal_name, "vtermina1", sizeof(key_vtermiflowfilterentry.
+                                             flowfilter_key.if_key.vterm_key.
+                                             vterminal_name));
+  memcpy(key_vtermiflowfilterentry.flowfilter_key.if_key.if_name,
+         "VtermIfFFinterface", sizeof(key_vtermiflowfilterentry.
+                                      flowfilter_key.if_key.if_name));
+  key_vtermiflowfilterentry.flowfilter_key.direction = 1;
+  key_vtermiflowfilterentry.sequence_num = 33;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vterm_if_flowfilter_entry,
+             val_flowfilter_entry, uint32_t>
+      (&key_vtermiflowfilterentry, &val_vtermiflowfilterentry, operation);
+
+  ret = KeyTree_obj->add_child_to_hash(cfgptr1);
+  delete cfgptr;
+  delete cfgptr1;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
+
+TEST(append_audit_node, parent_not_exist_vterminalif_flowfilter_entry) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+  key_vterm_if_flowfilter_entry key_vtermiflowfilterentry;
+  val_flowfilter_entry val_vtermiflowfilterentry;
+  memset(&key_vtermiflowfilterentry, 0, sizeof(key_vtermiflowfilterentry));
+  memset(&val_vtermiflowfilterentry, 0, sizeof(val_vtermiflowfilterentry));
+  memcpy(key_vtermiflowfilterentry.flowfilter_key.if_key.vterm_key.vtn_key.
+         vtn_name, "vtn1", sizeof(key_vtermiflowfilterentry.flowfilter_key.
+                                  if_key.vterm_key.vtn_key.vtn_name));
+  memcpy(key_vtermiflowfilterentry.flowfilter_key.if_key.vterm_key.
+         vterminal_name, "vtermina1", sizeof(key_vtermiflowfilterentry.
+                                             flowfilter_key.if_key.
+                                             vterm_key.vterminal_name));
+  memcpy(key_vtermiflowfilterentry.flowfilter_key.if_key.if_name,
+         "VtermIfFFinterface",
+         sizeof(key_vtermiflowfilterentry.flowfilter_key.if_key.if_name));
+  key_vtermiflowfilterentry.flowfilter_key.direction = 1;
+  key_vtermiflowfilterentry.sequence_num = 33;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vterm_if_flowfilter_entry,
+             val_flowfilter_entry, uint32_t>
+      (&key_vtermiflowfilterentry, &val_vtermiflowfilterentry, operation);
+
+  uint32_t ret = KeyTree_obj->append_audit_node(cfgptr1);
+  delete cfgptr1;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_DRV_RC_ERR_GENERIC);
+}
+
+TEST(append_commit_node, Vterminalif_Flowfilter_Entry_Retrive) {
+  int operation = 1;
+  KeyTree* KeyTree_obj = NULL;
+  KeyTree_obj = KeyTree::create_cache();
+
+  key_vterm_if_flowfilter key_vtermifflowfilter;;
+  val_flowfilter val_vtermifflowfilter;
+  memset(&key_vtermifflowfilter, 0, sizeof(key_vtermifflowfilter));
+  memset(&val_vtermifflowfilter, 0, sizeof(val_vtermifflowfilter));
+  memcpy(key_vtermifflowfilter.if_key.vterm_key.vtn_key.vtn_name,
+         "vtn1", sizeof(key_vtermifflowfilter.if_key.vterm_key.vtn_key.
+                        vtn_name));
+  memcpy(key_vtermifflowfilter.if_key.vterm_key.vterminal_name,
+         "vtermina1", sizeof(key_vtermifflowfilter.if_key.
+                             vterm_key.vterminal_name));
+  memcpy(key_vtermifflowfilter.if_key.if_name, "VtermIfFFinterface",
+         sizeof(key_vtermifflowfilter.if_key.if_name));
+  key_vtermifflowfilter.direction = 1;
+  ConfigNode *cfgptr = new CacheElementUtil<key_vterm_if_flowfilter,
+      val_flowfilter, uint32_t>
+      (&key_vtermifflowfilter, &val_vtermifflowfilter, operation);
+
+  uint32_t ret = KeyTree_obj->append_commit_node(cfgptr);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  key_vterm_if_flowfilter_entry key_vtermiflowfilterentry;
+  val_flowfilter_entry val_vtermiflowfilterentry;
+  memset(&key_vtermiflowfilterentry, 0, sizeof(key_vtermiflowfilterentry));
+  memset(&val_vtermiflowfilterentry, 0, sizeof(val_vtermiflowfilterentry));
+  memcpy(key_vtermiflowfilterentry.flowfilter_key.if_key.vterm_key.
+         vtn_key.vtn_name, "vtn1",
+         sizeof(key_vtermiflowfilterentry.flowfilter_key.if_key.
+                vterm_key.vtn_key.vtn_name));
+  memcpy(key_vtermiflowfilterentry.flowfilter_key.if_key.vterm_key.
+         vterminal_name, "vtermina1",
+         sizeof(key_vtermiflowfilterentry.flowfilter_key.if_key.vterm_key.
+                vterminal_name));
+  memcpy(key_vtermiflowfilterentry.flowfilter_key.if_key.if_name,
+         "VtermIfFFinterface",
+         sizeof(key_vtermiflowfilterentry.flowfilter_key.if_key.if_name));
+  key_vtermiflowfilterentry.flowfilter_key.direction = 1;
+  key_vtermiflowfilterentry.sequence_num = 33;
+  ConfigNode *cfgptr1 = new CacheElementUtil<key_vterm_if_flowfilter_entry,
+             val_flowfilter_entry, uint32_t>
+      (&key_vtermiflowfilterentry, &val_vtermiflowfilterentry, operation);
+
+  ret = KeyTree_obj->append_commit_node(cfgptr1);
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+  CommonIterator* itr_ptr = KeyTree_obj->create_iterator();
+  cfgptr = itr_ptr->FirstItem();
+  CacheElementUtil<key_vterm_if_flowfilter, val_flowfilter, uint32_t> *tmp_ptr =
+      static_cast<CacheElementUtil<key_vterm_if_flowfilter, val_flowfilter,
+      uint32_t>*> (cfgptr);
+
+  EXPECT_STREQ(reinterpret_cast<char*>(key_vtermifflowfilter.if_key.vterm_key.
+                                       vtn_key.vtn_name),
+         reinterpret_cast<char*>(tmp_ptr->get_key_structure()->
+                                 if_key.vterm_key.vtn_key.vtn_name));
+  pfc_log_info("FF:Vtn Name= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->if_key.vterm_key.vtn_key.vtn_name));
+  pfc_log_info("FF:Vterminal Name= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->if_key.vterm_key.vterminal_name));
+  pfc_log_info("FF:VterminalFFInterface Name= %s", reinterpret_cast<char*>(
+          tmp_ptr->get_key_structure()->if_key.if_name));
+  pfc_log_info("FF:VterminalFF Direction= %d",
+          tmp_ptr->get_key_structure()->direction);
+  pfc_log_info("FF:Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr->get_key_name().c_str(), tmp_ptr->get_type_name());;
+  pfc_log_info("FF:ParentKey %s SearchKey %s",
+               tmp_ptr->get_parent_key_name().c_str(),
+               tmp_ptr->get_key_generate().c_str());
+  cfgptr1 = itr_ptr->NextItem();
+  CacheElementUtil<key_vterm_if_flowfilter_entry, val_flowfilter_entry,
+                   uint32_t> *tmp_ptr1 =
+      static_cast<CacheElementUtil<key_vterm_if_flowfilter_entry,
+      val_flowfilter_entry, uint32_t>*> (cfgptr1);
+  EXPECT_STREQ(reinterpret_cast<char*>(key_vtermiflowfilterentry.
+                                       flowfilter_key.if_key.vterm_key.
+                                       vtn_key.vtn_name),
+         reinterpret_cast<char*>(tmp_ptr1->get_key_structure()->
+                                 flowfilter_key.if_key.vterm_key.
+                                 vtn_key.vtn_name));
+  pfc_log_info("FFEntry:Vtn Name= %s", reinterpret_cast<char*>(
+          tmp_ptr1->get_key_structure()->
+          flowfilter_key.if_key.vterm_key.vtn_key.vtn_name));
+  pfc_log_info("FFEntry:Vterminal Name= %s", reinterpret_cast<char*>(
+          tmp_ptr1->get_key_structure()->
+          flowfilter_key.if_key.vterm_key.vterminal_name));
+  pfc_log_info("FFEntry:VterminalFFInterface Name= %s", reinterpret_cast<char*>(
+          tmp_ptr1->get_key_structure()->flowfilter_key.if_key.if_name));
+  pfc_log_info("FFEntry:VterminalFF Direction= %d",
+          tmp_ptr1->get_key_structure()->flowfilter_key.direction);
+  pfc_log_info("FFEntry:VterminalFF Sequence Number= %d",
+          tmp_ptr1->get_key_structure()->sequence_num);
+  pfc_log_info("FFEntry:Node Present in Tree ..for:%s keytype %d",
+                 tmp_ptr1->get_key_name().c_str(), tmp_ptr1->get_type_name());;
+  pfc_log_info("FFEntry:ParentKey %s SearchKey %s",
+               tmp_ptr1->get_parent_key_name().c_str(),
+               tmp_ptr1->get_key_generate().c_str());
+  delete itr_ptr;
+  delete KeyTree_obj;
+  KeyTree_obj = NULL;
+  cfgptr = NULL;
+  cfgptr1 = NULL;
+  EXPECT_EQ(ret, UNC_RC_SUCCESS);
+}
 }  // namespace vtndrvcache
 }  // namespace unc

diff --git a/coordinator/test/modules/vtncacheutil/ut/ut_stub.h b/coordinator/test/modules/vtncacheutil/ut/ut_stub.h
new file mode 100644 (file)
index 0000000..671bffa
--- /dev/null
+++ b/coordinator/test/modules/vtncacheutil/ut/ut_stub.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2014 NEC Corporation
+ * All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this
+ * distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+#ifndef _UT_STUB_H_
+#define _UT_STUB_H_
+
+/*
+ * Include stub header files.
+ */
+
+#ifdef  __cplusplus
+#include "stub/include/cxx/pfcxx/module.hh"
+#endif  /*cplusplus */
+
+#endif  // _UT_STUB_H_

diff --git a/coordinator/test/modules/vtndrvintf/request_template/ut/Makefile b/coordinator/test/modules/vtndrvintf/request_template/ut/Makefile
index aa5830baa8aaff58e509246fe5b76d05d9610618..ca2cb65d47227b06c4bc52f4e80c64770c4e34ae 100644 (file)
--- a/coordinator/test/modules/vtndrvintf/request_template/ut/Makefile
+++ b/coordinator/test/modules/vtndrvintf/request_template/ut/Makefile
@@ -47,8 +47,9 @@ CPPFLAGS += -include ut_stub.h
 
 VTNCACHEUTIL_SOURCES = keytree.cc
 VTNCACHEUTIL_SOURCES += confignode.cc
+VTNCACHEUTIL_SOURCES += vtn_cache_mod.cc
 
-CONTROLLER_STUB_SOURCES = controller_fw.cc
+CONTROLLER_STUB_SOURCES = vtn_drv_module.cc controller_fw.cc
 MISC_STUB_SOURCES = ipc_client.cc ipc_server.cc module.cc
 TCLIBMODULE_STUBSOURCES = tclib_module.cc
 

diff --git a/coordinator/test/modules/vtndrvintf/transaction_handle/ut/Makefile b/coordinator/test/modules/vtndrvintf/transaction_handle/ut/Makefile
index efea4236e5c787f895f6d6f813ef9ffe71f710d8..dcfa22600820bada7d83c2f47aaa0967ac42e8b4 100644 (file)
--- a/coordinator/test/modules/vtndrvintf/transaction_handle/ut/Makefile
+++ b/coordinator/test/modules/vtndrvintf/transaction_handle/ut/Makefile
@@ -50,10 +50,11 @@ CPPFLAGS += -include ut_stub.h
 
 VTNCACHEUTIL_SOURCES = keytree.cc
 VTNCACHEUTIL_SOURCES += confignode.cc
+VTNCACHEUTIL_SOURCES += vtn_cache_mod.cc
 VTNDRVINTF_SOURCES = vtn_drv_transaction_handle.cc
 RESTJSONUTIL_SOURCES = http_client.cc json_build_parse.cc rest_client.cc
 MISC_SOURCES = ipc_client.cc ipc_server.cc module.cc
-CONTROLLER_STUB_SOURCES = controller_fw.cc
+CONTROLLER_STUB_SOURCES = vtn_drv_module.cc controller_fw.cc
 TCLIBMODULE_STUBSOURCES = tclib_module.cc
 
 UT_SOURCES = vtn_drv_transaction_handle_ut.cc

diff --git a/coordinator/test/modules/vtndrvintf/transaction_handle/ut/vtn_drv_transaction_handle_ut.cc b/coordinator/test/modules/vtndrvintf/transaction_handle/ut/vtn_drv_transaction_handle_ut.cc
index 0eac53a9dc5be3f6a3bbdae0782336a807bb2f00..a6fcf459595aa57732d0b619e5115168c08bb635 100644 (file)
--- a/coordinator/test/modules/vtndrvintf/transaction_handle/ut/vtn_drv_transaction_handle_ut.cc
+++ b/coordinator/test/modules/vtndrvintf/transaction_handle/ut/vtn_drv_transaction_handle_ut.cc
@@ -12,11 +12,13 @@
 #include <arpa/inet.h>
 #include <vtn_drv_transaction_handle.hh>
 #include <controller_utils.hh>
+#include <vtn_cache_mod.hh>
 #include <stdio.h>
 #include <map>
 #include "../../../stub/tclib_module/tclib_interface.hh"
 #include "../../../stub/tclib_module/tclib_module.hh"
 #include "../../../stub/ContrllerFrameworkStub/driver/driver_interface.hh"
+#include "../../../stub/ContrllerFrameworkStub/vtn_drv_module.hh"
 #include "../../../../../modules/vtndrvintf/include/request_template.hh"
 
 
@@ -27,6 +29,9 @@ class DriverTxnInterfaceTest: public testing::Test {
 
 
 TEST_F(DriverTxnInterfaceTest, HandleCommitGlobalCommitSuccess) {
+  const pfc_modattr_t* attr = NULL;
+  VtnDrvIntf obj(attr);
+  obj.init();
   uint32_t session_id = 1;
   uint32_t config_id = 1;
   std::string ctr_name = "ctr_demo";