diff --git a/plugins/module_utils/network/vyos/config/lag_interfaces/lag_interfaces.py b/plugins/module_utils/network/vyos/config/lag_interfaces/lag_interfaces.py
index af49f42..290f3b3 100644
--- a/plugins/module_utils/network/vyos/config/lag_interfaces/lag_interfaces.py
+++ b/plugins/module_utils/network/vyos/config/lag_interfaces/lag_interfaces.py
@@ -1,434 +1,436 @@
 # Copyright 2019 Red Hat
 # GNU General Public License v3.0+
 # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 """
 The vyos_lag_interfaces class
 It is in this file where the current configuration (as dict)
 is compared to the provided configuration (as dict) and the command set
 necessary to bring the current configuration to it's desired end-state is
 created
 """
 from __future__ import absolute_import, division, print_function
 
 __metaclass__ = type
 from ansible.module_utils.network.common.cfg.base import ConfigBase
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.facts.facts import (
     Facts,
 )
 from ansible.module_utils.network.common.utils import to_list, dict_diff
 from ansible.module_utils.six import iteritems
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.utils.utils import (
     search_obj_in_list,
     get_lst_diff_for_dicts,
     list_diff_want_only,
     list_diff_have_only,
 )
 
 
 class Lag_interfaces(ConfigBase):
     """
     The vyos_lag_interfaces class
     """
 
     gather_subset = ["!all", "!min"]
 
     gather_network_resources = ["lag_interfaces"]
 
     params = [
         "arp_monitor",
         "hash_policy",
         "members",
         "mode",
         "name",
         "primary",
     ]
 
     def __init__(self, module):
         super(Lag_interfaces, self).__init__(module)
 
     def get_lag_interfaces_facts(self):
         """ Get the 'facts' (the current configuration)
 
         :rtype: A dictionary
         :returns: The current configuration as a dictionary
         """
         facts, _warnings = Facts(self._module).get_facts(
             self.gather_subset, self.gather_network_resources
         )
         lag_interfaces_facts = facts["ansible_network_resources"].get(
             "lag_interfaces"
         )
         if not lag_interfaces_facts:
             return []
         return lag_interfaces_facts
 
     def execute_module(self):
         """ Execute the module
 
         :rtype: A dictionary
         :returns: The result from module execution
         """
         result = {"changed": False}
         commands = list()
         warnings = list()
         existing_lag_interfaces_facts = self.get_lag_interfaces_facts()
         commands.extend(self.set_config(existing_lag_interfaces_facts))
         if commands:
             if self._module.check_mode:
                 resp = self._connection.edit_config(commands, commit=False)
             else:
                 resp = self._connection.edit_config(commands)
             result["changed"] = True
 
         result["commands"] = commands
 
         if self._module._diff:
             result["diff"] = resp["diff"] if result["changed"] else None
 
         changed_lag_interfaces_facts = self.get_lag_interfaces_facts()
 
         result["before"] = existing_lag_interfaces_facts
         if result["changed"]:
             result["after"] = changed_lag_interfaces_facts
 
         result["warnings"] = warnings
         return result
 
     def set_config(self, existing_lag_interfaces_facts):
         """ Collect the configuration from the args passed to the module,
             collect the current configuration (as a dict from facts)
 
         :rtype: A list
         :returns: the commands necessary to migrate the current configuration
                   to the desired configuration
         """
         want = self._module.params["config"]
         have = existing_lag_interfaces_facts
         resp = self.set_state(want, have)
         return to_list(resp)
 
     def set_state(self, want, have):
         """ Select the appropriate function based on the state provided
 
         :param want: the desired configuration as a dictionary
         :param have: the current configuration as a dictionary
         :rtype: A list
         :returns: the commands necessary to migrate the current configuration
                   to the desired configuration
         """
         commands = []
         state = self._module.params["state"]
         if state in ("merged", "replaced", "overridden") and not want:
             self._module.fail_json(
-                msg="config is required for state {0}".format(state)
+                msg="value of config parameter must not be empty for state {0}".format(
+                    state
+                )
             )
         if state == "overridden":
             commands.extend(self._state_overridden(want, have))
         elif state == "deleted":
             if want:
                 for want_item in want:
                     name = want_item["name"]
                     obj_in_have = search_obj_in_list(name, have)
                     commands.extend(self._state_deleted(obj_in_have))
             else:
                 for have_item in have:
                     commands.extend(self._state_deleted(have_item))
         else:
             for want_item in want:
                 name = want_item["name"]
                 obj_in_have = search_obj_in_list(name, have)
                 if state == "merged":
                     commands.extend(self._state_merged(want_item, obj_in_have))
                 elif state == "replaced":
                     commands.extend(
                         self._state_replaced(want_item, obj_in_have)
                     )
         return commands
 
     def _state_replaced(self, want, have):
         """ The command generator when state is replaced
 
         :rtype: A list
         :returns: the commands necessary to migrate the current configuration
                   to the desired configuration
         """
         commands = []
         if have:
             commands.extend(self._render_del_commands(want, have))
         commands.extend(self._state_merged(want, have))
         return commands
 
     def _state_overridden(self, want, have):
         """ The command generator when state is overridden
 
         :rtype: A list
         :returns: the commands necessary to migrate the current configuration
                   to the desired configuration
         """
         commands = []
         for have_item in have:
             lag_name = have_item["name"]
             obj_in_want = search_obj_in_list(lag_name, want)
             if not obj_in_want:
                 commands.extend(self._purge_attribs(have_item))
 
         for want_item in want:
             name = want_item["name"]
             obj_in_have = search_obj_in_list(name, have)
             commands.extend(self._state_replaced(want_item, obj_in_have))
         return commands
 
     def _state_merged(self, want, have):
         """ The command generator when state is merged
 
         :rtype: A list
         :returns: the commands necessary to merge the provided into
                   the current configuration
         """
         commands = []
         if have:
             commands.extend(self._render_updates(want, have))
         else:
             commands.extend(self._render_set_commands(want))
         return commands
 
     def _state_deleted(self, have):
         """ The command generator when state is deleted
 
         :rtype: A list
         :returns: the commands necessary to remove the current configuration
                   of the provided objects
         """
         commands = []
         if have:
             commands.extend(self._purge_attribs(have))
         return commands
 
     def _render_updates(self, want, have):
         commands = []
 
         temp_have_members = have.pop("members", None)
         temp_want_members = want.pop("members", None)
 
         updates = dict_diff(have, want)
 
         if temp_have_members:
             have["members"] = temp_have_members
         if temp_want_members:
             want["members"] = temp_want_members
 
         commands.extend(self._add_bond_members(want, have))
 
         if updates:
             for key, value in iteritems(updates):
                 if value:
                     if key == "arp_monitor":
                         commands.extend(
                             self._add_arp_monitor(updates, key, want, have)
                         )
                     else:
                         commands.append(
                             self._compute_command(
                                 have["name"], key, str(value)
                             )
                         )
         return commands
 
     def _render_set_commands(self, want):
         commands = []
         have = []
 
         params = Lag_interfaces.params
 
         for attrib in params:
             value = want[attrib]
             if value:
                 if attrib == "arp_monitor":
                     commands.extend(
                         self._add_arp_monitor(want, attrib, want, have)
                     )
                 elif attrib == "members":
                     commands.extend(self._add_bond_members(want, have))
                 elif attrib != "name":
                     commands.append(
                         self._compute_command(
                             want["name"], attrib, value=str(value)
                         )
                     )
         return commands
 
     def _purge_attribs(self, have):
         commands = []
         for item in Lag_interfaces.params:
             if have.get(item):
                 if item == "members":
                     commands.extend(self._delete_bond_members(have))
                 elif item != "name":
                     commands.append(
                         self._compute_command(
                             have["name"], attrib=item, remove=True
                         )
                     )
         return commands
 
     def _render_del_commands(self, want, have):
         commands = []
 
         params = Lag_interfaces.params
         for attrib in params:
             if attrib == "members":
                 commands.extend(self._update_bond_members(attrib, want, have))
             elif attrib == "arp_monitor":
                 commands.extend(self._update_arp_monitor(attrib, want, have))
             elif have.get(attrib) and not want.get(attrib):
                 commands.append(
                     self._compute_command(have["name"], attrib, remove=True)
                 )
         return commands
 
     def _add_bond_members(self, want, have):
         commands = []
         diff_members = get_lst_diff_for_dicts(want, have, "members")
         if diff_members:
             for key in diff_members:
                 commands.append(
                     self._compute_command(
                         key["member"],
                         "bond-group",
                         want["name"],
                         type="ethernet",
                     )
                 )
         return commands
 
     def _add_arp_monitor(self, updates, key, want, have):
         commands = []
         arp_monitor = updates.get(key) or {}
         diff_targets = self._get_arp_monitor_target_diff(
             want, have, key, "target"
         )
 
         if "interval" in arp_monitor:
             commands.append(
                 self._compute_command(
                     key=want["name"] + " arp-monitor",
                     attrib="interval",
                     value=str(arp_monitor["interval"]),
                 )
             )
         if diff_targets:
             for target in diff_targets:
                 commands.append(
                     self._compute_command(
                         key=want["name"] + " arp-monitor",
                         attrib="target",
                         value=target,
                     )
                 )
         return commands
 
     def _delete_bond_members(self, have):
         commands = []
         for member in have["members"]:
             commands.append(
                 self._compute_command(
                     member["member"],
                     "bond-group",
                     have["name"],
                     remove=True,
                     type="ethernet",
                 )
             )
         return commands
 
     def _update_arp_monitor(self, key, want, have):
         commands = []
         want_arp_target = []
         have_arp_target = []
         want_arp_monitor = want.get(key) or {}
         have_arp_monitor = have.get(key) or {}
 
         if want_arp_monitor and "target" in want_arp_monitor:
             want_arp_target = want_arp_monitor["target"]
 
         if have_arp_monitor and "target" in have_arp_monitor:
             have_arp_target = have_arp_monitor["target"]
 
         if "interval" in have_arp_monitor and not want_arp_monitor:
             commands.append(
                 self._compute_command(
                     key=have["name"] + " arp-monitor",
                     attrib="interval",
                     remove=True,
                 )
             )
         if "target" in have_arp_monitor:
             target_diff = list_diff_have_only(want_arp_target, have_arp_target)
             if target_diff:
                 for target in target_diff:
                     commands.append(
                         self._compute_command(
                             key=have["name"] + " arp-monitor",
                             attrib="target",
                             value=target,
                             remove=True,
                         )
                     )
 
         return commands
 
     def _update_bond_members(self, key, want, have):
         commands = []
         want_members = want.get(key) or []
         have_members = have.get(key) or []
 
         members_diff = list_diff_have_only(want_members, have_members)
         if members_diff:
             for member in members_diff:
                 commands.append(
                     self._compute_command(
                         member["member"],
                         "bond-group",
                         have["name"],
                         True,
                         "ethernet",
                     )
                 )
         return commands
 
     def _get_arp_monitor_target_diff(
         self, want_list, have_list, dict_name, lst
     ):
         want_arp_target = []
         have_arp_target = []
 
         want_arp_monitor = want_list.get(dict_name) or {}
         if want_arp_monitor and lst in want_arp_monitor:
             want_arp_target = want_arp_monitor[lst]
 
         if not have_list:
             diff = want_arp_target
         else:
             have_arp_monitor = have_list.get(dict_name) or {}
             if have_arp_monitor and lst in have_arp_monitor:
                 have_arp_target = have_arp_monitor[lst]
 
             diff = list_diff_want_only(want_arp_target, have_arp_target)
         return diff
 
     def _compute_command(
         self, key, attrib, value=None, remove=False, type="bonding"
     ):
         if remove:
             cmd = "delete interfaces " + type
         else:
             cmd = "set interfaces " + type
         cmd += " " + key
         if attrib == "arp_monitor":
             attrib = "arp-monitor"
         elif attrib == "hash_policy":
             attrib = "hash-policy"
         cmd += " " + attrib
         if value:
             cmd += " '" + value + "'"
         return cmd
diff --git a/plugins/module_utils/network/vyos/config/lldp_global/lldp_global.py b/plugins/module_utils/network/vyos/config/lldp_global/lldp_global.py
index 8570874..303d46a 100644
--- a/plugins/module_utils/network/vyos/config/lldp_global/lldp_global.py
+++ b/plugins/module_utils/network/vyos/config/lldp_global/lldp_global.py
@@ -1,252 +1,254 @@
 # Copyright 2019 Red Hat
 # GNU General Public License v3.0+
 # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 """
 The vyos_lldp_global class
 It is in this file where the current configuration (as dict)
 is compared to the provided configuration (as dict) and the command set
 necessary to bring the current configuration to it's desired end-state is
 created
 """
 from __future__ import absolute_import, division, print_function
 
 __metaclass__ = type
 from ansible.module_utils.network.common.cfg.base import ConfigBase
 from ansible.module_utils.network.common.utils import to_list, dict_diff
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.facts.facts import (
     Facts,
 )
 from ansible.module_utils.six import iteritems
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.utils.utils import (
     get_lst_diff_for_dicts,
     list_diff_have_only,
 )
 
 
 class Lldp_global(ConfigBase):
     """
     The vyos_lldp_global class
     """
 
     gather_subset = ["!all", "!min"]
 
     gather_network_resources = ["lldp_global"]
 
     params = ["enable", "address", "snmp", "legacy_protocols"]
 
     def __init__(self, module):
         super(Lldp_global, self).__init__(module)
 
     def get_lldp_global_facts(self):
         """ Get the 'facts' (the current configuration)
 
         :rtype: A dictionary
         :returns: The current configuration as a dictionary
         """
         facts, _warnings = Facts(self._module).get_facts(
             self.gather_subset, self.gather_network_resources
         )
         lldp_global_facts = facts["ansible_network_resources"].get(
             "lldp_global"
         )
         if not lldp_global_facts:
             return {}
         return lldp_global_facts
 
     def execute_module(self):
         """ Execute the module
 
         :rtype: A dictionary
         :returns: The result from module execution
         """
         result = {"changed": False}
         commands = list()
         warnings = list()
 
         existing_lldp_global_facts = self.get_lldp_global_facts()
         commands.extend(self.set_config(existing_lldp_global_facts))
         if commands:
             if not self._module.check_mode:
                 self._connection.edit_config(commands)
             result["changed"] = True
         result["commands"] = commands
 
         changed_lldp_global_facts = self.get_lldp_global_facts()
 
         result["before"] = existing_lldp_global_facts
         if result["changed"]:
             result["after"] = changed_lldp_global_facts
 
         result["warnings"] = warnings
         return result
 
     def set_config(self, existing_lldp_global_facts):
         """ Collect the configuration from the args passed to the module,
             collect the current configuration (as a dict from facts)
 
         :rtype: A list
         :returns: the commands necessary to migrate the current configuration
                   to the desired configuration
         """
         want = self._module.params["config"]
         have = existing_lldp_global_facts
         resp = self.set_state(want, have)
         return to_list(resp)
 
     def set_state(self, want, have):
         """ Select the appropriate function based on the state provided
 
         :param want: the desired configuration as a dictionary
         :param have: the current configuration as a dictionary
         :rtype: A list
         :returns: the commands necessary to migrate the current configuration
                   to the desired configuration
         """
         commands = []
         state = self._module.params["state"]
         if state in ("merged", "replaced") and not want:
             self._module.fail_json(
-                msg="config is required for state {0}".format(state)
+                msg="value of config parameter must not be empty for state {0}".format(
+                    state
+                )
             )
         if state == "deleted":
             commands.extend(self._state_deleted(want=None, have=have))
         elif state == "merged":
             commands.extend(self._state_merged(want=want, have=have))
         elif state == "replaced":
             commands.extend(self._state_replaced(want=want, have=have))
         return commands
 
     def _state_replaced(self, want, have):
         """ The command generator when state is replaced
 
         :rtype: A list
         :returns: the commands necessary to migrate the current configuration
                   to the desired configuration
         """
         commands = []
         if have:
             commands.extend(self._state_deleted(want, have))
         commands.extend(self._state_merged(want, have))
         return commands
 
     def _state_merged(self, want, have):
         """ The command generator when state is merged
 
         :rtype: A list
         :returns: the commands necessary to merge the provided into
                   the current configuration
         """
         commands = []
         commands.extend(self._render_updates(want, have))
         return commands
 
     def _state_deleted(self, want, have):
         """ The command generator when state is deleted
 
         :rtype: A list
         :returns: the commands necessary to remove the current configuration
                   of the provided objects
         """
         commands = []
         if want:
             for item in Lldp_global.params:
                 if item == "legacy_protocols":
                     commands.extend(self._update_lldp_protocols(want, have))
                 elif (
                     have.get(item) and not want.get(item) and item != "enable"
                 ):
                     commands.append(Lldp_global.del_cmd + item)
         elif have:
             for item in Lldp_global.params:
                 if have.get(item):
                     if item == "legacy_protocols":
                         commands.append(
                             self._compute_command(
                                 "legacy-protocols", remove=True
                             )
                         )
                     elif item == "address":
                         commands.append(
                             self._compute_command(
                                 "management-address", remove=True
                             )
                         )
                     elif item == "snmp":
                         commands.append(
                             self._compute_command(item, remove=True)
                         )
 
         return commands
 
     def _render_updates(self, want, have):
         commands = []
         if have:
             temp_have_legacy_protos = have.pop("legacy_protocols", None)
         else:
             have = {}
             temp_want_legacy_protos = want.pop("legacy_protocols", None)
 
         updates = dict_diff(have, want)
 
         if have and temp_have_legacy_protos:
             have["legacy_protocols"] = temp_have_legacy_protos
         if not have and temp_want_legacy_protos:
             want["legacy_protocols"] = temp_want_legacy_protos
 
         commands.extend(self._add_lldp_protocols(want, have))
 
         if updates:
             for key, value in iteritems(updates):
                 if value:
                     if key == "enable":
                         commands.append(self._compute_command())
                     elif key == "address":
                         commands.append(
                             self._compute_command(
                                 "management-address", str(value)
                             )
                         )
                     elif key == "snmp":
                         if value == "disable":
                             commands.append(
                                 self._compute_command(key, remove=True)
                             )
                         else:
                             commands.append(
                                 self._compute_command(key, str(value))
                             )
         return commands
 
     def _add_lldp_protocols(self, want, have):
         commands = []
         diff_members = get_lst_diff_for_dicts(want, have, "legacy_protocols")
         for key in diff_members:
             commands.append(self._compute_command("legacy-protocols", key))
         return commands
 
     def _update_lldp_protocols(self, want_item, have_item):
         commands = []
         want_protocols = want_item.get("legacy_protocols") or []
         have_protocols = have_item.get("legacy_protocols") or []
 
         members_diff = list_diff_have_only(want_protocols, have_protocols)
         if members_diff:
             for member in members_diff:
                 commands.append(
                     self._compute_command(
                         "legacy-protocols", member, remove=True
                     )
                 )
         return commands
 
     def _compute_command(self, key=None, value=None, remove=False):
         if remove:
             cmd = "delete service lldp"
         else:
             cmd = "set service lldp"
         if key:
             cmd += " " + key
 
         if value:
             cmd += " '" + value + "'"
         return cmd
diff --git a/plugins/module_utils/network/vyos/config/lldp_interfaces/lldp_interfaces.py b/plugins/module_utils/network/vyos/config/lldp_interfaces/lldp_interfaces.py
index 6b76296..aa0bd36 100644
--- a/plugins/module_utils/network/vyos/config/lldp_interfaces/lldp_interfaces.py
+++ b/plugins/module_utils/network/vyos/config/lldp_interfaces/lldp_interfaces.py
@@ -1,426 +1,428 @@
 #
 # -*- coding: utf-8 -*-
 # Copyright 2019 Red Hat
 # GNU General Public License v3.0+
 # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 """
 The vyos_lldp_interfaces class
 It is in this file where the current configuration (as dict)
 is compared to the provided configuration (as dict) and the command set
 necessary to bring the current configuration to it's desired end-state is
 created
 """
 
 from __future__ import absolute_import, division, print_function
 
 __metaclass__ = type
 
 
 from ansible.module_utils.network.common.cfg.base import ConfigBase
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.facts.facts import (
     Facts,
 )
 from ansible.module_utils.network.common.utils import to_list, dict_diff
 from ansible.module_utils.six import iteritems
 from ansible.module_utils.network.vyos.utils.utils import (
     search_obj_in_list,
     search_dict_tv_in_list,
     key_value_in_dict,
     is_dict_element_present,
 )
 
 
 class Lldp_interfaces(ConfigBase):
     """
     The vyos_lldp_interfaces class
     """
 
     gather_subset = ["!all", "!min"]
 
     gather_network_resources = ["lldp_interfaces"]
 
     params = ["enable", "location", "name"]
 
     def __init__(self, module):
         super(Lldp_interfaces, self).__init__(module)
 
     def get_lldp_interfaces_facts(self):
         """ Get the 'facts' (the current configuration)
 
         :rtype: A dictionary
         :returns: The current configuration as a dictionary
         """
         facts, _warnings = Facts(self._module).get_facts(
             self.gather_subset, self.gather_network_resources
         )
         lldp_interfaces_facts = facts["ansible_network_resources"].get(
             "lldp_interfaces"
         )
         if not lldp_interfaces_facts:
             return []
         return lldp_interfaces_facts
 
     def execute_module(self):
         """ Execute the module
 
         :rtype: A dictionary
         :returns: The result from module execution
         """
         result = {"changed": False}
         commands = list()
         warnings = list()
         existing_lldp_interfaces_facts = self.get_lldp_interfaces_facts()
         commands.extend(self.set_config(existing_lldp_interfaces_facts))
         if commands:
             if self._module.check_mode:
                 resp = self._connection.edit_config(commands, commit=False)
             else:
                 resp = self._connection.edit_config(commands)
             result["changed"] = True
 
         result["commands"] = commands
 
         if self._module._diff:
             result["diff"] = resp["diff"] if result["changed"] else None
 
         changed_lldp_interfaces_facts = self.get_lldp_interfaces_facts()
         result["before"] = existing_lldp_interfaces_facts
         if result["changed"]:
             result["after"] = changed_lldp_interfaces_facts
 
         result["warnings"] = warnings
         return result
 
     def set_config(self, existing_lldp_interfaces_facts):
         """ Collect the configuration from the args passed to the module,
             collect the current configuration (as a dict from facts)
 
         :rtype: A list
         :returns: the commands necessary to migrate the current configuration
                   to the desired configuration
         """
         want = self._module.params["config"]
         have = existing_lldp_interfaces_facts
         resp = self.set_state(want, have)
         return to_list(resp)
 
     def set_state(self, want, have):
         """ Select the appropriate function based on the state provided
 
         :param want: the desired configuration as a dictionary
         :param have: the current configuration as a dictionary
         :rtype: A list
         :returns: the commands necessary to migrate the current configuration
                   to the desired configuration
         """
         commands = []
         state = self._module.params["state"]
         if state in ("merged", "replaced", "overridden") and not want:
             self._module.fail_json(
-                msg="config is required for state {0}".format(state)
+                msg="value of config parameter must not be empty for state {0}".format(
+                    state
+                )
             )
         if state == "overridden":
             commands.extend(self._state_overridden(want=want, have=have))
         elif state == "deleted":
             if want:
                 for item in want:
                     name = item["name"]
                     have_item = search_obj_in_list(name, have)
                     commands.extend(
                         self._state_deleted(want=None, have=have_item)
                     )
             else:
                 for have_item in have:
                     commands.extend(
                         self._state_deleted(want=None, have=have_item)
                     )
         else:
             for want_item in want:
                 name = want_item["name"]
                 have_item = search_obj_in_list(name, have)
                 if state == "merged":
                     commands.extend(
                         self._state_merged(want=want_item, have=have_item)
                     )
                 else:
                     commands.extend(
                         self._state_replaced(want=want_item, have=have_item)
                     )
         return commands
 
     def _state_replaced(self, want, have):
         """ The command generator when state is replaced
 
         :rtype: A list
         :returns: the commands necessary to migrate the current configuration
                   to the desired configuration
         """
         commands = []
         if have:
             commands.extend(self._state_deleted(want, have))
         commands.extend(self._state_merged(want, have))
         return commands
 
     def _state_overridden(self, want, have):
         """ The command generator when state is overridden
 
         :rtype: A list
         :returns: the commands necessary to migrate the current configuration
                   to the desired configuration
         """
         commands = []
         for have_item in have:
             lldp_name = have_item["name"]
             lldp_in_want = search_obj_in_list(lldp_name, want)
             if not lldp_in_want:
                 commands.append(
                     self._compute_command(have_item["name"], remove=True)
                 )
 
         for want_item in want:
             name = want_item["name"]
             lldp_in_have = search_obj_in_list(name, have)
             commands.extend(self._state_replaced(want_item, lldp_in_have))
         return commands
 
     def _state_merged(self, want, have):
         """ The command generator when state is merged
 
         :rtype: A list
         :returns: the commands necessary to merge the provided into
                   the current configuration
         """
         commands = []
         if have:
             commands.extend(self._render_updates(want, have))
         else:
             commands.extend(self._render_set_commands(want))
         return commands
 
     def _state_deleted(self, want, have):
         """ The command generator when state is deleted
 
         :rtype: A list
         :returns: the commands necessary to remove the current configuration
                   of the provided objects
         """
         commands = []
         if want:
             params = Lldp_interfaces.params
             for attrib in params:
                 if attrib == "location":
                     commands.extend(
                         self._update_location(have["name"], want, have)
                     )
 
         elif have:
             commands.append(self._compute_command(have["name"], remove=True))
         return commands
 
     def _render_updates(self, want, have):
         commands = []
         lldp_name = have["name"]
         commands.extend(self._configure_status(lldp_name, want, have))
         commands.extend(self._add_location(lldp_name, want, have))
 
         return commands
 
     def _render_set_commands(self, want):
         commands = []
         have = {}
         lldp_name = want["name"]
         params = Lldp_interfaces.params
 
         commands.extend(self._add_location(lldp_name, want, have))
         for attrib in params:
             value = want[attrib]
             if value:
                 if attrib == "location":
                     commands.extend(self._add_location(lldp_name, want, have))
                 elif attrib == "enable":
                     if not value:
                         commands.append(
                             self._compute_command(lldp_name, value="disable")
                         )
                 else:
                     commands.append(self._compute_command(lldp_name))
 
         return commands
 
     def _configure_status(self, name, want_item, have_item):
         commands = []
         if is_dict_element_present(have_item, "enable"):
             temp_have_item = False
         else:
             temp_have_item = True
         if want_item["enable"] != temp_have_item:
             if want_item["enable"]:
                 commands.append(
                     self._compute_command(name, value="disable", remove=True)
                 )
             else:
                 commands.append(self._compute_command(name, value="disable"))
         return commands
 
     def _add_location(self, name, want_item, have_item):
         commands = []
         have_dict = {}
         have_ca = {}
         set_cmd = name + " location "
         want_location_type = want_item.get("location") or {}
         have_location_type = have_item.get("location") or {}
 
         if want_location_type["coordinate_based"]:
             want_dict = want_location_type.get("coordinate_based") or {}
             if is_dict_element_present(have_location_type, "coordinate_based"):
                 have_dict = have_location_type.get("coordinate_based") or {}
             location_type = "coordinate-based"
             updates = dict_diff(have_dict, want_dict)
             for key, value in iteritems(updates):
                 if value:
                     commands.append(
                         self._compute_command(
                             set_cmd + location_type, key, str(value)
                         )
                     )
 
         elif want_location_type["civic_based"]:
             location_type = "civic-based"
             want_dict = want_location_type.get("civic_based") or {}
             want_ca = want_dict.get("ca_info") or []
             if is_dict_element_present(have_location_type, "civic_based"):
                 have_dict = have_location_type.get("civic_based") or {}
                 have_ca = have_dict.get("ca_info") or []
                 if want_dict["country_code"] != have_dict["country_code"]:
                     commands.append(
                         self._compute_command(
                             set_cmd + location_type,
                             "country-code",
                             str(want_dict["country_code"]),
                         )
                     )
             else:
                 commands.append(
                     self._compute_command(
                         set_cmd + location_type,
                         "country-code",
                         str(want_dict["country_code"]),
                     )
                 )
             commands.extend(self._add_civic_address(name, want_ca, have_ca))
 
         elif want_location_type["elin"]:
             location_type = "elin"
             if is_dict_element_present(have_location_type, "elin"):
                 if want_location_type.get("elin") != have_location_type.get(
                     "elin"
                 ):
                     commands.append(
                         self._compute_command(
                             set_cmd + location_type,
                             value=str(want_location_type["elin"]),
                         )
                     )
             else:
                 commands.append(
                     self._compute_command(
                         set_cmd + location_type,
                         value=str(want_location_type["elin"]),
                     )
                 )
         return commands
 
     def _update_location(self, name, want_item, have_item):
         commands = []
         del_cmd = name + " location"
         want_location_type = want_item.get("location") or {}
         have_location_type = have_item.get("location") or {}
 
         if want_location_type["coordinate_based"]:
             want_dict = want_location_type.get("coordinate_based") or {}
             if is_dict_element_present(have_location_type, "coordinate_based"):
                 have_dict = have_location_type.get("coordinate_based") or {}
                 location_type = "coordinate-based"
                 for key, value in iteritems(have_dict):
                     only_in_have = key_value_in_dict(key, value, want_dict)
                     if not only_in_have:
                         commands.append(
                             self._compute_command(
                                 del_cmd + location_type, key, str(value), True
                             )
                         )
             else:
                 commands.append(self._compute_command(del_cmd, remove=True))
 
         elif want_location_type["civic_based"]:
             want_dict = want_location_type.get("civic_based") or {}
             want_ca = want_dict.get("ca_info") or []
             if is_dict_element_present(have_location_type, "civic_based"):
                 have_dict = have_location_type.get("civic_based") or {}
                 have_ca = have_dict.get("ca_info")
                 commands.extend(
                     self._update_civic_address(name, want_ca, have_ca)
                 )
             else:
                 commands.append(self._compute_command(del_cmd, remove=True))
 
         else:
             if is_dict_element_present(have_location_type, "elin"):
                 if want_location_type.get("elin") != have_location_type.get(
                     "elin"
                 ):
                     commands.append(
                         self._compute_command(del_cmd, remove=True)
                     )
             else:
                 commands.append(self._compute_command(del_cmd, remove=True))
         return commands
 
     def _add_civic_address(self, name, want, have):
         commands = []
         for item in want:
             ca_type = item["ca_type"]
             ca_value = item["ca_value"]
             obj_in_have = search_dict_tv_in_list(
                 ca_type, ca_value, have, "ca_type", "ca_value"
             )
             if not obj_in_have:
                 commands.append(
                     self._compute_command(
                         key=name + " location civic-based ca-type",
                         attrib=str(ca_type) + " ca-value",
                         value=ca_value,
                     )
                 )
         return commands
 
     def _update_civic_address(self, name, want, have):
         commands = []
         for item in have:
             ca_type = item["ca_type"]
             ca_value = item["ca_value"]
             in_want = search_dict_tv_in_list(
                 ca_type, ca_value, want, "ca_type", "ca_value"
             )
             if not in_want:
                 commands.append(
                     self._compute_command(
                         name,
                         "location civic-based ca-type",
                         str(ca_type),
                         remove=True,
                     )
                 )
         return commands
 
     def _compute_command(self, key, attrib=None, value=None, remove=False):
         if remove:
             cmd = "delete service lldp interface "
         else:
             cmd = "set service lldp interface "
         cmd += key
         if attrib:
             cmd += " " + attrib
         if value:
             cmd += " '" + value + "'"
         return cmd
diff --git a/tests/integration/targets/vyos_lag_interfaces/tests/cli/empty_config.yaml b/tests/integration/targets/vyos_lag_interfaces/tests/cli/empty_config.yaml
index 50f6d97..c222354 100644
--- a/tests/integration/targets/vyos_lag_interfaces/tests/cli/empty_config.yaml
+++ b/tests/integration/targets/vyos_lag_interfaces/tests/cli/empty_config.yaml
@@ -1,36 +1,36 @@
 ---
 - debug:
       msg: "START vyos_lag_interfaces empty_config integration tests on connection={{ ansible_connection }}"
 
 - name: Merged with empty config should give appropriate error message
   vyos.vyos.vyos_lag_interfaces:
     config:
     state: merged
   register: result
   ignore_errors: True
 
 - assert:
     that:
-      - result.msg == 'config is required for state merged'
+      - result.msg == 'value of config parameter must not be empty for state merged'
 
 - name: Replaced with empty config should give appropriate error message
   vyos.vyos.vyos_lag_interfaces:
     config:
     state: replaced
   register: result
   ignore_errors: True
 
 - assert:
     that:
-      - result.msg == 'config is required for state replaced'
+      - result.msg == 'value of config parameter must not be empty for state replaced'
 
 - name: Overridden with empty config should give appropriate error message
   vyos.vyos.vyos_lag_interfaces:
     config:
     state: overridden
   register: result
   ignore_errors: True
 
 - assert:
     that:
-      - result.msg == 'config is required for state overridden'
+      - result.msg == 'value of config parameter must not be empty for state overridden'
diff --git a/tests/integration/targets/vyos_lldp_global/tests/cli/empty_config.yaml b/tests/integration/targets/vyos_lldp_global/tests/cli/empty_config.yaml
index 2497015..5bac638 100644
--- a/tests/integration/targets/vyos_lldp_global/tests/cli/empty_config.yaml
+++ b/tests/integration/targets/vyos_lldp_global/tests/cli/empty_config.yaml
@@ -1,25 +1,25 @@
 ---
 - debug:
       msg: "START vyos_lldp_global empty_config integration tests on connection={{ ansible_connection }}"
 
 - name: Merged with empty config should give appropriate error message
   vyos.vyos.vyos_lldp_global:
     config:
     state: merged
   register: result
   ignore_errors: True
 
 - assert:
     that:
-      - result.msg == 'config is required for state merged'
+      - result.msg == 'value of config parameter must not be empty for state merged'
 
 - name: Replaced with empty config should give appropriate error message
   vyos.vyos.vyos_lldp_global:
     config:
     state: replaced
   register: result
   ignore_errors: True
 
 - assert:
     that:
-      - result.msg == 'config is required for state replaced'
+      - result.msg == 'value of config parameter must not be empty for state replaced'
diff --git a/tests/integration/targets/vyos_lldp_interfaces/tests/cli/empty_config.yaml b/tests/integration/targets/vyos_lldp_interfaces/tests/cli/empty_config.yaml
index 9711791..4afb7fe 100644
--- a/tests/integration/targets/vyos_lldp_interfaces/tests/cli/empty_config.yaml
+++ b/tests/integration/targets/vyos_lldp_interfaces/tests/cli/empty_config.yaml
@@ -1,36 +1,36 @@
 ---
 - debug:
       msg: "START vyos_lldp_interfaces empty_config integration tests on connection={{ ansible_connection }}"
 
 - name: Merged with empty config should give appropriate error message
   vyos.vyos.vyos_lldp_interfaces:
     config:
     state: merged
   register: result
   ignore_errors: True
 
 - assert:
     that:
-      - result.msg == 'config is required for state merged'
+      - result.msg == 'value of config parameter must not be empty for state merged'
 
 - name: Replaced with empty config should give appropriate error message
   vyos.vyos.vyos_lldp_interfaces:
     config:
     state: replaced
   register: result
   ignore_errors: True
 
 - assert:
     that:
-      - result.msg == 'config is required for state replaced'
+      - result.msg == 'value of config parameter must not be empty for state replaced'
 
 - name: Overridden with empty config should give appropriate error message
   vyos.vyos.vyos_lldp_interfaces:
     config:
     state: overridden
   register: result
   ignore_errors: True
 
 - assert:
     that:
-      - result.msg == 'config is required for state overridden'
+      - result.msg == 'value of config parameter must not be empty for state overridden'