diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/__init__.py
index 8b5e885..12bdd8e 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/__init__.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/__init__.py
@@ -12,6 +12,5 @@ from pgadmin.utils.route import BaseTestGenerator
 
 class TriggerFunctionTestGenerator(BaseTestGenerator):
 
-    def generate_tests(self):
+    def runTest(self):
         return
-
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_delete.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_delete.py
index 301540d..3de5b4e 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_delete.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_delete.py
@@ -51,6 +51,7 @@ class TriggerFuncDeleteTestCase(BaseTestGenerator):
                                     cls.server_ids)
         # Add schemas
         schema_utils.add_schemas(cls.tester)
+
         # Add trigger functions
         trigger_funcs_utils.add_trigger_function(
             cls.tester, cls.server_connect_response, cls.server_ids)
@@ -74,4 +75,3 @@ class TriggerFuncDeleteTestCase(BaseTestGenerator):
         database_utils.delete_database(cls.tester)
         server_utils.delete_server(cls.tester)
         utils.delete_parent_id_file()
-
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_get.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_get.py
index 083f222..0ba2bca 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_get.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_get.py
@@ -68,12 +68,13 @@ class TriggerFuncGetTestCase(BaseTestGenerator):
             db_con = database_utils.verify_database(
                 self.tester, utils.SERVER_GROUP, server_id, db_id)
             if db_con['data']["connected"]:
-                schema_id = schema_ids_dict[int(server_id)]
+                schema_id = schema_ids_dict[int(server_id)][0]
                 schema_response = schema_utils.verify_schemas(
                     self.tester, server_id, db_id, schema_id)
                 if schema_response.status_code == 200:
-                    trigger_func_ids = trigger_ids_dict[int(server_id)]
-                    for trigger_func_id in trigger_func_ids:
+                    trigger_func_list = trigger_ids_dict[int(server_id)]
+                    for trigger_func in trigger_func_list:
+                        trigger_func_id = trigger_func[0]
                         trigger_response = \
                             trigger_funcs_utils.verify_trigger_function(
                                 self.tester, server_id, db_id, schema_id,
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_put.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_put.py
index 9a839ef..5025d40 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_put.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_put.py
@@ -78,8 +78,9 @@ class TriggerFuncPutTestCase(BaseTestGenerator):
                                                               db_id,
                                                               schema_id)
                 if schema_response.status_code == 200:
-                    trigger_func_ids = trigger_ids_dict[int(server_id)]
-                    for trigger_func_id in trigger_func_ids:
+                    trigger_func_list = trigger_ids_dict[int(server_id)]
+                    for trigger_func in trigger_func_list:
+                        trigger_func_id = trigger_func[0]
                         trigger_response = \
                             trigger_funcs_utils.verify_trigger_function(
                                 self.tester, server_id, db_id, schema_id,
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/utils.py
index 421e2aa..e693c5a 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/utils.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/utils.py
@@ -20,6 +20,7 @@ from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
 from regression import test_utils as utils
 
 TRIGGER_FUNCTIONS_URL = '/browser/trigger_function/obj/'
+TRIGGER_FUNCTIONS_DELETE_URL = '/browser/trigger_function/delete/'
 
 
 def get_trigger_func_data(server_connect_data):
@@ -68,6 +69,7 @@ def write_trigger_func_id(trigger_func_ids_list, server_id):
     """
 
     pickle_id_dict = utils.get_pickle_id_dict()
+
     if os.path.isfile(pickle_path):
         existing_server_id = open(pickle_path, 'rb')
         tol_server_id = pickle.load(existing_server_id)
@@ -100,7 +102,7 @@ def add_trigger_function(tester, server_connect_response, server_ids):
         if db_con['data']["connected"]:
             schema_id = schema_ids_dict[int(server_id)][0]
             schema_utils.verify_schemas(tester, server_id, db_id,
-                                                   schema_id)
+                                        schema_id)
             data = get_trigger_func_data(server_connect_response)
             # Get the type from config data. We are adding two types
             # i.e. event_trigger and trigger.
@@ -108,7 +110,7 @@ def add_trigger_function(tester, server_connect_response, server_ids):
             trigger_func_ids_list = []
             for func_type in trigger_func_types:
                 data['prorettypename'] = func_type
-                data["name"] = str(uuid.uuid4())[1:8]
+                data["name"] = "event_{}".format(str(uuid.uuid4())[1:8])
                 if schema_id:
                     data['pronamespace'] = schema_id
                 else:
@@ -122,7 +124,9 @@ def add_trigger_function(tester, server_connect_response, server_ids):
                 assert response.status_code == 200
                 response_data = json.loads(response.data.decode('utf-8'))
                 trigger_func_id = response_data['node']['_id']
-                trigger_func_ids_list.append(trigger_func_id)
+                event_trigger_name = str(response_data['node']['label'])
+                trigger_func_ids_list.append(
+                    (trigger_func_id, event_trigger_name, func_type))
 
             write_trigger_func_id(trigger_func_ids_list, server_id)
 
@@ -157,13 +161,14 @@ def delete_trigger_function(tester):
             schema_response = schema_utils.verify_schemas(
                 tester, server_id, db_id, schema_id)
             if schema_response.status_code == 200:
-                trigger_func_ids = trigger_ids_dict[int(server_id)]
-                for trigger_func_id in trigger_func_ids:
+                trigger_func_list = trigger_ids_dict[int(server_id)]
+                for trigger_func in trigger_func_list:
+                    trigger_func_id = trigger_func[0]
                     trigger_response = verify_trigger_function(
                         tester, server_id, db_id, schema_id, trigger_func_id)
                     if trigger_response.status_code == 200:
                         del_response = tester.delete(
-                            TRIGGER_FUNCTIONS_URL + str(
+                            TRIGGER_FUNCTIONS_DELETE_URL + str(
                                 utils.SERVER_GROUP) + '/' +
                             str(server_id) + '/' + str(db_id) + '/' +
                             str(schema_id) + '/' + str(trigger_func_id),
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/__init__.py
new file mode 100644
index 0000000..ace9a3e
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/__init__.py
@@ -0,0 +1,16 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from pgadmin.utils.route import BaseTestGenerator
+
+
+class SequenceTestGenerator(BaseTestGenerator):
+
+   def runTest(self):
+       return []
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_add.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_add.py
new file mode 100644
index 0000000..0222621
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_add.py
@@ -0,0 +1,72 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from regression import test_utils as utils
+from pgadmin.utils.route import BaseTestGenerator
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from pgadmin.browser.server_groups.servers.databases.tests import utils as \
+    database_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from . import utils as sequence_utils
+
+
+class SequenceAddTestCase(BaseTestGenerator):
+    """ This class will add new sequence(s) under schema node. """
+
+    scenarios = [
+        # Fetching default URL for sequence node.
+        ('Fetch sequence Node URL', dict(url='/browser/sequence/obj/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function perform the three tasks
+         1. Add the test server(s)
+         2. Connect to server(s)
+         3. Add the database(s)
+         4. Add the schema(s)
+
+        :return: None
+        """
+
+        # First, add the server
+        server_utils.add_server(cls.tester)
+
+        # Connect to server
+        cls.server_connect_response, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
+        if len(cls.server_connect_response) == 0:
+            raise Exception("No Server(s) connected to add the database!!!")
+
+        # Add database
+        database_utils.add_database(cls.tester, cls.server_connect_response,
+                                    cls.server_ids)
+        # Add schemas
+        schema_utils.add_schemas(cls.tester)
+
+    def runTest(self):
+        """ This function will add sequence(s) under schema node. """
+
+        sequence_utils.add_sequences(self.tester)
+
+    @classmethod
+    def tearDownClass(cls):
+        """This function deletes the added sequence, schema, database, server
+        and parent id file
+
+        :return: None
+        """
+
+        sequence_utils.delete_sequence(cls.tester)
+        schema_utils.delete_schema(cls.tester)
+        database_utils.delete_database(cls.tester)
+        server_utils.delete_server(cls.tester)
+        utils.delete_parent_id_file()
\ No newline at end of file
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_delete.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_delete.py
new file mode 100644
index 0000000..8e74218
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_delete.py
@@ -0,0 +1,75 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from regression import test_utils as utils
+from pgadmin.utils.route import BaseTestGenerator
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from pgadmin.browser.server_groups.servers.databases.tests import utils as \
+    database_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from . import utils as sequence_utils
+
+
+class SequenceDeleteTestCase(BaseTestGenerator):
+    """ This class will delete added sequence under schema node. """
+
+    scenarios = [
+        # Fetching default URL for sequence node.
+        ('Fetch sequence Node URL', dict(url='/browser/sequence/obj/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function perform the three tasks
+         1. Add the test server(s)
+         2. Connect to server(s)
+         3. Add database(s)
+         4. Add schema(s)
+         5. Add sequence(s)
+
+        :return: None
+        """
+
+        # First, add the server
+        server_utils.add_server(cls.tester)
+
+        # Connect to server
+        cls.server_connect_response, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
+        if len(cls.server_connect_response) == 0:
+            raise Exception("No Server(s) connected to add the database!!!")
+
+        # Add database(s)
+        database_utils.add_database(cls.tester, cls.server_connect_response,
+                                    cls.server_ids)
+        # Add schema(s)
+        schema_utils.add_schemas(cls.tester)
+
+        # Add sequence(s)
+        sequence_utils.add_sequences(cls.tester)
+
+    def runTest(self):
+        """ This function will delete added sequence under schema node. """
+
+        sequence_utils.delete_sequence(self.tester)
+
+    @classmethod
+    def tearDownClass(cls):
+        """This function deletes the added sequence, schema, database, server
+        and parent id file
+
+        :return: None
+        """
+
+        schema_utils.delete_schema(cls.tester)
+        database_utils.delete_database(cls.tester)
+        server_utils.delete_server(cls.tester)
+        utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_get.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_get.py
new file mode 100644
index 0000000..1941b98
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_get.py
@@ -0,0 +1,93 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from regression import test_utils as utils
+from pgadmin.utils.route import BaseTestGenerator
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from pgadmin.browser.server_groups.servers.databases.tests import utils as \
+    database_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from . import utils as sequence_utils
+
+
+class SequenceGetTestCase(BaseTestGenerator):
+    """ This class will fetch added sequence under schema node. """
+
+    scenarios = [
+        # Fetching default URL for sequence node.
+        ('Fetch sequence Node URL', dict(url='/browser/sequence/obj/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function perform the three tasks
+         1. Add the test server(s)
+         2. Connect to server(s)
+         3. Add database(s)
+         4. Add schema(s)
+         5. Add sequence(s)
+
+        :return: None
+        """
+
+        # First, add the server
+        server_utils.add_server(cls.tester)
+
+        # Connect to server
+        cls.server_connect_response, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
+        if len(cls.server_connect_response) == 0:
+            raise Exception("No Server(s) connected to add the database!!!")
+
+        # Add database(s)
+        database_utils.add_database(cls.tester, cls.server_connect_response,
+                                    cls.server_ids)
+        # Add schema(s)
+        schema_utils.add_schemas(cls.tester)
+
+        # Add sequence(s)
+        sequence_utils.add_sequences(cls.tester)
+
+    def runTest(self):
+        """ This function will fetch added sequence under schema node. """
+
+        all_id = utils.get_ids()
+        server_ids = all_id["sid"]
+        db_ids_dict = all_id["did"][0]
+        schema_ids_dict = all_id["scid"][0]
+        sequence_ids_dict = all_id["seid"][0]
+
+        for server_id in server_ids:
+            db_id = db_ids_dict[int(server_id)]
+            schema_info = schema_ids_dict[int(server_id)]
+            schema_id = schema_info[0]
+            sequence_id = sequence_ids_dict[server_id]
+            get_response = sequence_utils.verify_sequence(self.tester,
+                                                          utils.SERVER_GROUP,
+                                                          server_id,
+                                                          db_id,
+                                                          schema_id,
+                                                          sequence_id)
+            self.assertEquals(get_response.status_code, 200)
+
+    @classmethod
+    def tearDownClass(cls):
+        """This function delete the added sequence, schema, database, server
+        and parent id file
+
+        :return: None
+        """
+
+        sequence_utils.delete_sequence(cls.tester)
+        schema_utils.delete_schema(cls.tester)
+        database_utils.delete_database(cls.tester)
+        server_utils.delete_server(cls.tester)
+        utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_put.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_put.py
new file mode 100644
index 0000000..5e449a3
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_put.py
@@ -0,0 +1,112 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from regression import test_utils as utils
+from pgadmin.utils.route import BaseTestGenerator
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from pgadmin.browser.server_groups.servers.databases.tests import utils as \
+    database_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from . import utils as sequence_utils
+import json
+from regression.test_setup import advanced_config_data
+
+
+class SequencePutTestCase(BaseTestGenerator):
+    """ This class will update added sequence under schema node. """
+
+    scenarios = [
+        # Fetching default URL for sequence node.
+        ('Fetch sequence Node URL', dict(url='/browser/sequence/obj/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function perform the three tasks
+         1. Add the test server(s)
+         2. Connect to server(s)
+         3. Add database(s)
+         4. Add schema(s)
+         5. Add sequence(s)
+
+        :return: None
+        """
+
+        # First, add the server
+        server_utils.add_server(cls.tester)
+
+        # Connect to server
+        cls.server_connect_response, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
+        if len(cls.server_connect_response) == 0:
+            raise Exception("No Server(s) connected to add the database!!!")
+
+        # Add database(s)
+        database_utils.add_database(cls.tester, cls.server_connect_response,
+                                    cls.server_ids)
+        # Add schema(s)
+        schema_utils.add_schemas(cls.tester)
+
+        # Add sequence(s)
+        sequence_utils.add_sequences(cls.tester)
+
+    def runTest(self):
+        """ This function will update added sequence under schema node. """
+
+        all_id = utils.get_ids()
+        server_ids = all_id["sid"]
+        db_ids_dict = all_id["did"][0]
+        schema_ids_dict = all_id["scid"][0]
+        sequence_ids_dict = all_id["seid"][0]
+
+        for server_id in server_ids:
+            db_id = db_ids_dict[int(server_id)]
+            schema_info = schema_ids_dict[int(server_id)]
+            schema_id = schema_info[0]
+            sequence_id = sequence_ids_dict[server_id]
+            get_response = sequence_utils.verify_sequence(self.tester,
+                                                          utils.SERVER_GROUP,
+                                                          server_id,
+                                                          db_id,
+                                                          schema_id,
+                                                          sequence_id)
+            if get_response.status_code == 200:
+                data = \
+                    {
+                        "comment":
+                            advanced_config_data['sequnce_update_data']
+                            ['comment'],
+                        "id": sequence_id
+                    }
+
+                put_response = self.tester.put(
+                    self.url + str(utils.SERVER_GROUP) + '/' +
+                    str(server_id) + '/' +
+                    str(db_id) + '/' +
+                    str(schema_id) + '/' +
+                    str(sequence_id),
+                    data=json.dumps(data),
+                    follow_redirects=True)
+                self.assertEquals(put_response.status_code, 200)
+
+    @classmethod
+    def tearDownClass(cls):
+        """This function deletes the added sequence, schema, database, server
+        and parent id file
+
+        :return: None
+        """
+
+        sequence_utils.delete_sequence(cls.tester)
+        schema_utils.delete_schema(cls.tester)
+        database_utils.delete_database(cls.tester)
+        server_utils.delete_server(cls.tester)
+        utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/utils.py
new file mode 100644
index 0000000..374048d
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/utils.py
@@ -0,0 +1,152 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+import json
+import os
+import pickle
+from regression.test_setup import pickle_path, advanced_config_data
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from regression import test_utils as utils
+import uuid
+
+SEQUENCE_URL = '/browser/sequence/obj/'
+
+
+def get_sequence_config_data(schema_name, server_connect_data):
+    adv_config_data = None
+    db_user = server_connect_data['data']['user']['name']
+
+    # Get the config data of appropriate db user
+    for config_test_data in advanced_config_data['sequence_credentials']:
+        if db_user == config_test_data['owner']:
+            adv_config_data = config_test_data
+
+            data = \
+                {
+                    "cache": adv_config_data['cache'],
+                    "cycled": adv_config_data['cycled'],
+                    "increment": adv_config_data['increment'],
+                    "maximum": adv_config_data['max_value'],
+                    "minimum": adv_config_data['min_value'],
+                    "name": "sequence_{0}".format(str(uuid.uuid4())[1:4]),
+                    "relacl": adv_config_data['acl'],
+                    "schema": schema_name,
+                    "securities": adv_config_data['security'],
+                    "seqowner": adv_config_data['owner'],
+                    "start": adv_config_data['start_val']
+                }
+
+            return data
+
+
+def add_sequences(tester):
+    all_id = utils.get_ids()
+    server_ids = all_id["sid"]
+    db_ids_dict = all_id["did"][0]
+    schema_info_dict = all_id["scid"][0]
+
+    for server_id in server_ids:
+        db_id = db_ids_dict[int(server_id)]
+        db_con = database_utils.verify_database(tester, utils.SERVER_GROUP,
+                                                server_id, db_id)
+        if db_con['data']["connected"]:
+            server_connect_response = server_utils.verify_server(
+                tester, utils.SERVER_GROUP, server_id)
+
+            schema_name = schema_info_dict[int(server_id)][1]
+            data = get_sequence_config_data(schema_name,
+                                            server_connect_response)
+            schema_id = schema_info_dict[int(server_id)][0]
+
+            response = tester.post(
+                SEQUENCE_URL + str(utils.SERVER_GROUP) + '/' +
+                str(server_id) + '/' + str(db_id) +
+                '/' + str(schema_id) + '/',
+                data=json.dumps(data),
+                content_type='html/json')
+            assert response.status_code == 200
+            response_data = json.loads(response.data.decode('utf-8'))
+            write_sequence_info(response_data, server_id)
+
+
+def write_sequence_info(response_data, server_id):
+    """
+    This function writes the sequence id into parent_id.pkl
+
+    :param response_data: sequence add response data
+    :type response_data: dict
+    :param server_id: server id
+    :type server_id: str
+    :return: None
+    """
+
+    sequence_id = response_data['node']['_id']
+    pickle_id_dict = utils.get_pickle_id_dict()
+    if os.path.isfile(pickle_path):
+        existing_server_id = open(pickle_path, 'rb')
+        tol_server_id = pickle.load(existing_server_id)
+        pickle_id_dict = tol_server_id
+    if 'fid' in pickle_id_dict:
+        if pickle_id_dict['seid']:
+            # Add the sequence_id as value in dict
+            pickle_id_dict["seid"][0].update({server_id: sequence_id})
+        else:
+            # Create new dict with server_id and sequence_id
+            pickle_id_dict["seid"].append({server_id: sequence_id})
+    sequence_output = open(pickle_path, 'wb')
+    pickle.dump(pickle_id_dict, sequence_output)
+    sequence_output.close()
+
+
+def verify_sequence(tester, server_group, server_id, db_id, schema_id,
+                    sequence_id):
+    """This function verifies the sequence using GET API"""
+
+    get_response = tester.get(SEQUENCE_URL + str(server_group) + '/' +
+                              str(server_id) + '/' +
+                              str(db_id) + '/' +
+                              str(schema_id) + '/' +
+                              str(sequence_id),
+                              content_type='html/json')
+
+    return get_response
+
+
+def delete_sequence(tester):
+    all_id = utils.get_ids()
+    server_ids = all_id["sid"]
+    db_ids_dict = all_id["did"][0]
+    schema_ids_dict = all_id["scid"][0]
+    sequence_ids_dict = all_id["seid"][0]
+
+    for server_id in server_ids:
+        db_id = db_ids_dict[int(server_id)]
+        schema_info = schema_ids_dict[int(server_id)]
+        schema_id = schema_info[0]
+        sequence_id = sequence_ids_dict[server_id]
+        get_response = verify_sequence(tester,
+                                       utils.SERVER_GROUP,
+                                       server_id,
+                                       db_id,
+                                       schema_id,
+                                       sequence_id)
+        if get_response.status_code == 200:
+            delete_response = tester.delete(
+                SEQUENCE_URL + str(utils.SERVER_GROUP) + '/' +
+                str(server_id) + '/' +
+                str(db_id) + '/' +
+                str(schema_id) + '/' +
+                str(sequence_id),
+                follow_redirects=True)
+
+            assert delete_response.status_code == 200
+            del_resp_data = json.loads(delete_response.data.decode('utf-8'))
+            assert del_resp_data['success'] == 1
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/__init__.py
index 8de0478..c9cf28a 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/__init__.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/__init__.py
@@ -12,6 +12,5 @@ from pgadmin.utils.route import BaseTestGenerator
 
 class SchemaTestGenerator(BaseTestGenerator):
 
-    def generate_tests(self):
+    def runTest(self):
         return []
-
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/utils.py
index e90500a..4f91484 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/utils.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/utils.py
@@ -19,6 +19,7 @@ from pgadmin.browser.server_groups.servers.databases.tests import utils as \
 from regression import test_utils as utils
 
 SCHEMA_URL = '/browser/schema/obj/'
+SCHEMA_DELETE_URL = '/browser/schema/delete/'
 
 
 def get_schema_config_data(server_connect_response):
@@ -39,7 +40,7 @@ def get_schema_config_data(server_connect_response):
             "defseqacl": adv_config_data['seq_acl'],
             "deftblacl": adv_config_data['tbl_acl'],
             "deftypeacl": adv_config_data['type_acl'],
-            "name": "test_{0}".format(str(uuid.uuid4())[1:8]),
+            "name": "schema_{0}".format(str(uuid.uuid4())[1:8]),
             "namespaceowner": adv_config_data['owner'],
             "nspacl": adv_config_data['privilege'],
             "seclabels": adv_config_data['sec_label']
@@ -138,7 +139,7 @@ def delete_schema(tester):
                 raise Exception("No schema(s) to delete.")
 
             del_response = tester.delete(
-                SCHEMA_URL + str(utils.SERVER_GROUP) + '/' +
+                SCHEMA_DELETE_URL + str(utils.SERVER_GROUP) + '/' +
                 str(server_id) + '/' +
                 str(db_id) + '/' +
                 str(schema_id),
diff --git a/web/regression/test_advanced_config.json.in b/web/regression/test_advanced_config.json.in
index 538682c..b339c92 100644
--- a/web/regression/test_advanced_config.json.in
+++ b/web/regression/test_advanced_config.json.in
@@ -299,6 +299,198 @@
 
    "collation_update_data": {
     "comment": "This is collation update comment"
+  },
+
+  "casts_credentials":
+  [{
+    "cast_context": "IMPLICIT",
+    "encoding": "UTF8",
+    "name": "money->bigint",
+    "source_type": "money",
+    "target_type": "bigint",
+    "owner": "postgres"
+  }],
+
+  "cast_update_data":
+  {
+    "comment": "This is cast update comment"
+  },
+
+  "extension_credentials":[
+  {
+    "name": "postgres_fdw",
+    "relocate": true,
+    "schema": "",
+    "version": "1.0",
+    "owner": "postgres"
+  }],
+
+   "extension_update_data":
+  {
+    "schema": "schema"
+  },
+
+    "fdw_credentials":[
+  {
+    "acl":
+    [
+      {
+        "grantee":"postgres",
+        "grantor":"postgres",
+        "privileges":
+        [
+          {
+            "privilege_type":"U",
+            "privilege":true,
+            "with_grant":true
+          }
+        ]
+      }
+    ],
+    "handler": "postgres_fdw_handler",
+    "options": [],
+    "owner": "postgres",
+    "validator": "postgres_fdw_validator",
+    "name": "fdw"
+  }],
+
+    "fdw_update_data":
+  {
+    "comment": "This is FDW update comment"
+  },
+
+   "fsrv_credentials":[
+  {
+    "fsrv_acl":
+    [
+      {
+        "grantee":"postgres",
+        "grantor":"postgres",
+        "privileges":
+        [
+          {
+            "privilege_type":"U",
+            "privilege":true,
+            "with_grant":false
+          }
+        ]
+      }
+    ],
+    "fsrv_options":
+    [
+      {
+        "fsrvoption":"host",
+        "fsrvvalue":"localhost"
+      },
+      {
+        "fsrvoption":"port",
+        "fsrvvalue":"5433"
+      },
+      {
+        "fsrvoption":"dbname",
+        "fsrvvalue":"postgres"
+      }
+    ],
+    "owner": "postgres",
+    "name": "foreign_server1"
+  }],
+
+  "FSRV_update_data":
+  {
+    "comment": "This is foreign server update comment"
+  },
+
+  "user_mapping_credentials":[
+  {
+    "name": "postgres",
+    "option": [],
+    "owner": "postgres",
+    "options":
+    [
+      {
+        "umoption":"user",
+        "umvalue":"postgres"
+      },
+      {
+        "umoption":"password",
+        "umvalue":"edb"
+      }
+    ]
+  }],
+
+  "user_mapping_update_data":
+  {
+    "options":
+    {
+      "changed":
+      [
+        {"umoption":"password",
+          "umvalue":"edb1"
+        }
+      ]
+    }
+  },
+
+     "event_trigger_credentials":
+  [{
+    "enable": "O",
+    "event_func": "test_schema.test_abort_any_command",
+    "event_name":  "DDL_COMMAND_END",
+    "owner":  "postgres",
+    "name": "test_event_trg",
+    "provider": []
+  }],
+
+   "event_trigger_update_data":
+  {
+    "comment": "This is event trigger update comment"
+  },
+  
+    "sequence_credentials":
+  [{
+    "cache": "1",
+    "cycled": true,
+    "increment":  "1",
+    "max_value": "100000",
+    "min_value": "1",
+    "name": "test_empno",
+    "acl":
+    [
+      {
+        "grantee":"postgres",
+        "grantor":"postgres",
+        "privileges":
+        [
+          {
+            "privilege_type":"r",
+            "privilege":true,
+            "with_grant":false
+          },
+          {
+            "privilege_type":"w",
+            "privilege":true,
+            "with_grant":false
+          },
+          {
+            "privilege_type":"U",
+            "privilege":true,
+            "with_grant":false
+          }
+        ]
+      }
+    ],
+    "schema_name": "test_schema",
+    "security":  [],
+    "owner":  "postgres",
+    "start_val": "100"
+  }],
+
+    "sequnce_update_data":
+  {
+    "comment": "This is sequence update comment"
   }
 
-}
\ No newline at end of file
+
+ }
+
+
diff --git a/web/regression/test_utils.py b/web/regression/test_utils.py
index ec33680..e078eaa 100644
--- a/web/regression/test_utils.py
+++ b/web/regression/test_utils.py
@@ -9,7 +9,6 @@
 
 import os
 import pickle
-
 from test_setup import config_data, pickle_path
 
 
@@ -26,7 +25,14 @@ def get_pickle_id_dict():
         "tsid": [],  # tablespace
         "scid": [],  # schema
         "tfnid": [],  # trigger functions
-        "coid": []  # collation
+        "coid": [],  # collation
+        "cid": [],  # casts
+        "etid": [], # event_trigger
+        "eid": [],  # extension
+        "fid": [],  # FDW
+        "fsid": [],  # FRS
+        "umid": [],  # user_mapping
+        "seid": []  # sequence
     }
     return pickle_id_dict
 
