import unittest

class TestHpc(unittest.TestCase):
    def test___init__(self):
        # hpc = Hpc(config)
        assert False # TODO: implement your test here

    def test_bind_private_queue(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.bind_private_queue(cluster_id, duration, is_auto_renewal, name, pay_type, queue_name, type_id, type_name, update_time))
        assert False # TODO: implement your test here

    def test_bind_private_queue_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.bind_private_queue_request(cluster_id, duration, is_auto_renewal, name, pay_type, queue_name, type_id, type_name, update_time))
        assert False # TODO: implement your test here

    def test_bind_private_queue_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.bind_private_queue_validate())
        assert False # TODO: implement your test here

    def test_create_cluster(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.create_cluster(account_service, cluster_id, cluster_name, create_time, cur_cpu, deploy_mode, instance_id, instance_image, nas_id, nas_path, paid_period, paid_type, scheduler_type, software_info, status, status_time, tasks_running, tasks_total, user_name))
        assert False # TODO: implement your test here

    def test_create_cluster_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.create_cluster_request(account_service, cluster_id, cluster_name, create_time, cur_cpu, deploy_mode, instance_id, instance_image, nas_id, nas_path, paid_period, paid_type, scheduler_type, software_info, status, status_time, tasks_running, tasks_total, user_name))
        assert False # TODO: implement your test here

    def test_create_cluster_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.create_cluster_validate())
        assert False # TODO: implement your test here

    def test_create_job_file(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.create_job_file(cluster_id, file_type, file_value, target_file))
        assert False # TODO: implement your test here

    def test_create_job_file_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.create_job_file_request(cluster_id, file_type, file_value, target_file))
        assert False # TODO: implement your test here

    def test_create_job_file_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.create_job_file_validate())
        assert False # TODO: implement your test here

    def test_create_ldap_user(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.create_ldap_user(cn, description, gid_number, given_name, home_directory, mail, object_class, ou, parent_dn, password, sn, uid, uid_number))
        assert False # TODO: implement your test here

    def test_create_ldap_user_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.create_ldap_user_request(cn, description, gid_number, given_name, home_directory, mail, object_class, ou, parent_dn, password, sn, uid, uid_number))
        assert False # TODO: implement your test here

    def test_create_ldap_user_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.create_ldap_user_validate())
        assert False # TODO: implement your test here

    def test_delete_cluster(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.delete_cluster(run_user))
        assert False # TODO: implement your test here

    def test_delete_cluster_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.delete_cluster_request(run_user))
        assert False # TODO: implement your test here

    def test_delete_cluster_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.delete_cluster_validate())
        assert False # TODO: implement your test here

    def test_delete_jobs(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.delete_jobs(cluster_id, job_ids))
        assert False # TODO: implement your test here

    def test_delete_jobs_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.delete_jobs_request(cluster_id, job_ids))
        assert False # TODO: implement your test here

    def test_delete_jobs_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.delete_jobs_validate())
        assert False # TODO: implement your test here

    def test_disable_hpc(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.disable_hpc(user_id))
        assert False # TODO: implement your test here

    def test_disable_hpc_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.disable_hpc_request(user_id))
        assert False # TODO: implement your test here

    def test_disable_hpc_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.disable_hpc_validate())
        assert False # TODO: implement your test here

    def test_enable_hpc(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.enable_hpc(user_id))
        assert False # TODO: implement your test here

    def test_enable_hpc_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.enable_hpc_request(user_id))
        assert False # TODO: implement your test here

    def test_enable_hpc_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.enable_hpc_validate())
        assert False # TODO: implement your test here

    def test_get_cost(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_cost(action, expires, package_month, plan_id, prod_id, queue_type, usage_time, zone))
        assert False # TODO: implement your test here

    def test_get_cost_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_cost_request(action, expires, package_month, plan_id, prod_id, queue_type, usage_time, zone))
        assert False # TODO: implement your test here

    def test_get_cost_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_cost_validate())
        assert False # TODO: implement your test here

    def test_get_current_queue(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_current_queue(user_id))
        assert False # TODO: implement your test here

    def test_get_current_queue_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_current_queue_request(user_id))
        assert False # TODO: implement your test here

    def test_get_current_queue_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_current_queue_validate())
        assert False # TODO: implement your test here

    def test_get_hpc_status(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_hpc_status())
        assert False # TODO: implement your test here

    def test_get_hpc_status_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_hpc_status_request())
        assert False # TODO: implement your test here

    def test_get_hpc_status_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_hpc_status_validate())
        assert False # TODO: implement your test here

    def test_get_job_detail(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_job_detail())
        assert False # TODO: implement your test here

    def test_get_job_detail_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_job_detail_request())
        assert False # TODO: implement your test here

    def test_get_job_detail_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_job_detail_validate())
        assert False # TODO: implement your test here

    def test_get_login_node(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_login_node(run_user))
        assert False # TODO: implement your test here

    def test_get_login_node_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_login_node_request(run_user))
        assert False # TODO: implement your test here

    def test_get_login_node_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_login_node_validate())
        assert False # TODO: implement your test here

    def test_get_meter(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_meter(action, aggregation, end_time, expires, instance_ids, metering_period, meters, start_time, time_zone, zone))
        assert False # TODO: implement your test here

    def test_get_meter_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_meter_request(action, aggregation, end_time, expires, instance_ids, metering_period, meters, start_time, time_zone, zone))
        assert False # TODO: implement your test here

    def test_get_meter_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_meter_validate())
        assert False # TODO: implement your test here

    def test_get_product_billing_model(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_product_billing_model(action, expires, prod_id, zone))
        assert False # TODO: implement your test here

    def test_get_product_billing_model_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_product_billing_model_request(action, expires, prod_id, zone))
        assert False # TODO: implement your test here

    def test_get_product_billing_model_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_product_billing_model_validate())
        assert False # TODO: implement your test here

    def test_get_queue_types(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_queue_types())
        assert False # TODO: implement your test here

    def test_get_queue_types_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_queue_types_request())
        assert False # TODO: implement your test here

    def test_get_queue_types_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.get_queue_types_validate())
        assert False # TODO: implement your test here

    def test_is_available_queue(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.is_available_queue(queue_name, user_id))
        assert False # TODO: implement your test here

    def test_is_available_queue_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.is_available_queue_request(queue_name, user_id))
        assert False # TODO: implement your test here

    def test_is_available_queue_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.is_available_queue_validate())
        assert False # TODO: implement your test here

    def test_list_cluster(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.list_cluster(action, expires, run_user, zone))
        assert False # TODO: implement your test here

    def test_list_cluster_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.list_cluster_request(action, expires, run_user, zone))
        assert False # TODO: implement your test here

    def test_list_cluster_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.list_cluster_validate())
        assert False # TODO: implement your test here

    def test_list_jobs(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.list_jobs(action, cluster_id, expires, job_state, run_user, zone))
        assert False # TODO: implement your test here

    def test_list_jobs_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.list_jobs_request(action, cluster_id, expires, job_state, run_user, zone))
        assert False # TODO: implement your test here

    def test_list_jobs_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.list_jobs_validate())
        assert False # TODO: implement your test here

    def test_list_users(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.list_users(org_dn, username))
        assert False # TODO: implement your test here

    def test_list_users_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.list_users_request(org_dn, username))
        assert False # TODO: implement your test here

    def test_list_users_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.list_users_validate())
        assert False # TODO: implement your test here

    def test_modify_ldap_password(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.modify_ldap_password(new_password, old_password, user_dn))
        assert False # TODO: implement your test here

    def test_modify_ldap_password_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.modify_ldap_password_request(new_password, old_password, user_dn))
        assert False # TODO: implement your test here

    def test_modify_ldap_password_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.modify_ldap_password_validate())
        assert False # TODO: implement your test here

    def test_reg_login_node(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.reg_login_node(inst_ib_ip, runas_user))
        assert False # TODO: implement your test here

    def test_reg_login_node_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.reg_login_node_request(inst_ib_ip, runas_user))
        assert False # TODO: implement your test here

    def test_reg_login_node_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.reg_login_node_validate())
        assert False # TODO: implement your test here

    def test_stop_jobs(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.stop_jobs(cluster_id, job_ids))
        assert False # TODO: implement your test here

    def test_stop_jobs_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.stop_jobs_request(cluster_id, job_ids))
        assert False # TODO: implement your test here

    def test_stop_jobs_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.stop_jobs_validate())
        assert False # TODO: implement your test here

    def test_submit_job(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.submit_job(action, cluster_id, cmd_line, name, priority, queue_name, resource_limit, run_user, stderr_redirect_path, stdout_redirect_path, zone))
        assert False # TODO: implement your test here

    def test_submit_job_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.submit_job_request(action, cluster_id, cmd_line, name, priority, queue_name, resource_limit, run_user, stderr_redirect_path, stdout_redirect_path, zone))
        assert False # TODO: implement your test here

    def test_submit_job_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.submit_job_validate())
        assert False # TODO: implement your test here

    def test_unbind_private_queue(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.unbind_private_queue(id))
        assert False # TODO: implement your test here

    def test_unbind_private_queue_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.unbind_private_queue_request(id))
        assert False # TODO: implement your test here

    def test_unbind_private_queue_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.unbind_private_queue_validate())
        assert False # TODO: implement your test here

    def test_unreg_login_node(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.unreg_login_node(run_user))
        assert False # TODO: implement your test here

    def test_unreg_login_node_request(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.unreg_login_node_request(run_user))
        assert False # TODO: implement your test here

    def test_unreg_login_node_validate(self):
        # hpc = Hpc(config)
        # self.assertEqual(expected, hpc.unreg_login_node_validate())
        assert False # TODO: implement your test here

if __name__ == '__main__':
    unittest.main()
