def blackbox_test(self):
     # Make sure no pre-existing campaign with campaign urn:
     # 'urn:campaign:ca:ucla:Mobilize:July:2011:Test'
     HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN)
     # Complete testing on 241 testing xml
     for x in range(1,242):
         FILE_PATH = XML_PATH + '/xml' + str(x) + '.xml'
         self.arg_pass_in['xml'] = (pycurl.FORM_FILE, FILE_PATH)
         # Use zip(dict.keys(), dict.values())
         # can convert dict into a list of tuples
         self.http.set_pass_in_with_file(zip(self.arg_pass_in.keys(), self.arg_pass_in.values()))
         # Need to upload a file, set flag to 1
         # to change the type of HTTP request
         self.http.request(1)
         self.total_case = self.total_case + 1
         # Print status
         print 'Processing Case ID {0}.\n{1}% to finish XML Schema Testing.'.format('XML'+str(self.total_case), self.total_case*100/TOTAL_CASE)
         print self.http.contents
         # check response
         if self.exp_result[x] == 'success':
             if (self.http.http_code != 200) or (self.http.cont_dict['result'] != 'success'):
                 HTTP.write_err_report(self.err_report,\
                                       'XML'+str(self.total_case),\
                                       self.arg_pass_in,\
                                       self.http.contents,\
                                       '{"result": "success"}')
                 # increment the invalid case id list and unexpected case counter
                 self.invalid_case_id_list.append('XML'+str(self.total_case))
                 self.unexpect_case = self.unexpect_case + 1
             else:
                 HTTP.write_succ_report(self.succ_report,\
                                        'XML'+str(self.total_case),\
                                        self.arg_pass_in,\
                                        self.http.contents)
                 # need to delete the campaign after writing the success report
                 result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN)
                 if result != 'success':
                     print >> sys.stderr, 'Error: Cannot delete existing campaign'
                     sys.exit(1)
         else:
             # Need to check whether expected string is a substring of result
             print self.http.contents.find(self.exp_result[x])
             if (self.http.http_code != 200) or \
                (self.http.cont_dict['result'] != 'failure') or \
                (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_XML) or \
                (self.http.contents.find(self.exp_result[x]) == -1):
                 HTTP.write_err_report(self.err_report,\
                                       'XML'+str(self.total_case),\
                                       self.arg_pass_in,\
                                       self.http.contents,\
                                       gconst.INVALID_XML+': '+self.exp_result[x])
                 # increment the invalid case id list and unexpected case counter
                 self.invalid_case_id_list.append('XML'+str(self.total_case))
                 self.unexpect_case = self.unexpect_case + 1
                 # Although unexpected success, still need to delete the original campaign
                 if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'):
                     result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN)
                     if result != 'success':
                         print >> sys.stderr, 'Error: Cannot delete existing campaign'
                         sys.exit(1)
             else:
                 HTTP.write_succ_report(self.succ_report,\
                                        'XML'+str(self.total_case),\
                                        self.arg_pass_in,\
                                        self.http.contents)
 def err_response_check(self, exp_result):
     # helper function to check invalid cases response
     if exp_result == gconst.AUTH_FAIL:
         if (self.http.http_code != 200) or \
            (self.http.cont_dict['result'] != 'failure') or \
            (self.http.cont_dict['errors'][0]['code'] != gconst.AUTH_FAIL):
             HTTP.write_err_report(self.err_report,\
                                   'CC'+str(self.total_case),\
                                   self.arg_pass_in,\
                                   self.http.contents,\
                                   gconst.AUTH_FAIL+': '+gconst.ERROR[gconst.AUTH_FAIL])
             # increment the invalid case id list and unexpected case counter
             self.invalid_case_id_list.append('CC'+str(self.total_case))
             self.unexpect_case = self.unexpect_case + 1
             # Unexpected 'success' create campaign, need to delete the wrong campaign
             if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'):
                 result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN)
                 if result != 'success':
                     print >> sys.stderr, 'Error: Cannot delete existing campaign'
                     sys.exit(1)
         else:
             HTTP.write_succ_report(self.succ_report,\
                                    'CC'+str(self.total_case),\
                                    self.arg_pass_in,\
                                    self.http.contents)
     elif exp_result == gconst.CLT_TOO_LONG:
         if (self.http.http_code != 200) or \
            (self.http.cont_dict['result'] != 'failure') or \
            (self.http.cont_dict['errors'][0]['code'] != gconst.CLT_TOO_LONG):
             HTTP.write_err_report(self.err_report,\
                                   'CC'+str(self.total_case),\
                                   self.arg_pass_in,\
                                   self.http.contents,\
                                   gconst.CLT_TOO_LONG+': '+gconst.ERROR[gconst.CLT_TOO_LONG])
             # increment the invalid case id list and unexpected case counter
             self.invalid_case_id_list.append('CC'+str(self.total_case))
             self.unexpect_case = self.unexpect_case + 1
             # Unexpected 'success' create campaign, need to delete the wrong campaign
             if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'):
                 result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN)
                 if result != 'success':
                     print >> sys.stderr, 'Error: Cannot delete existing campaign'
                     sys.exit(1)
         else:
             HTTP.write_succ_report(self.succ_report,\
                                    'CC'+str(self.total_case),\
                                    self.arg_pass_in,\
                                    self.http.contents)
     elif exp_result == gconst.INVALID_RUN_STATE:
         if (self.http.http_code != 200) or \
            (self.http.cont_dict['result'] != 'failure') or \
            (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_RUN_STATE):
             HTTP.write_err_report(self.err_report,\
                                   'CC'+str(self.total_case),\
                                   self.arg_pass_in,\
                                   self.http.contents,\
                                   gconst.INVALID_RUN_STATE+': '+gconst.ERROR[gconst.INVALID_RUN_STATE])
             # increment the invalid case id list and unexpected case counter
             self.invalid_case_id_list.append('CC'+str(self.total_case))
             self.unexpect_case = self.unexpect_case + 1
             # Unexpected 'success' create campaign, need to delete the wrong campaign
             if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'):
                 result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN)
                 if result != 'success':
                     print >> sys.stderr, 'Error: Cannot delete existing campaign'
                     sys.exit(1)
         else:
             HTTP.write_succ_report(self.succ_report,\
                                    'CC'+str(self.total_case),\
                                    self.arg_pass_in,\
                                    self.http.contents)
     elif exp_result == gconst.INVALID_PRI_STATE:
         if (self.http.http_code != 200) or \
            (self.http.cont_dict['result'] != 'failure') or \
            (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_PRI_STATE):
             HTTP.write_err_report(self.err_report,\
                                   'CC'+str(self.total_case),\
                                   self.arg_pass_in,\
                                   self.http.contents,\
                                   gconst.INVALID_PRI_STATE+': '+gconst.ERROR[gconst.INVALID_PRI_STATE])
             # increment the invalid case id list and unexpected case counter
             self.invalid_case_id_list.append('CC'+str(self.total_case))
             self.unexpect_case = self.unexpect_case + 1
             # Unexpected 'success' create campaign, need to delete the wrong campaign
             if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'):
                 result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN)
                 if result != 'success':
                     print >> sys.stderr, 'Error: Cannot delete existing campaign'
                     sys.exit(1)
         else:
             HTTP.write_succ_report(self.succ_report,\
                                    'CC'+str(self.total_case),\
                                    self.arg_pass_in,\
                                    self.http.contents)
     elif exp_result == gconst.INVALID_CLS_URN:
         if (self.http.http_code != 200) or \
            (self.http.cont_dict['result'] != 'failure') or \
            (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_CLS_URN):
             HTTP.write_err_report(self.err_report,\
                                   'CC'+str(self.total_case),\
                                   self.arg_pass_in,\
                                   self.http.contents,\
                                   gconst.INVALID_CLS_URN+': '+gconst.ERROR[gconst.INVALID_CLS_URN])
             # increment the invalid case id list and unexpected case counter
             self.invalid_case_id_list.append('CC'+str(self.total_case))
             self.unexpect_case = self.unexpect_case + 1
             # Unexpected 'success' create campaign, need to delete the wrong campaign
             if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'):
                 result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN)
                 if result != 'success':
                     print >> sys.stderr, 'Error: Cannot delete existing campaign'
                     sys.exit(1)
         else:
             HTTP.write_succ_report(self.succ_report,\
                                    'CC'+str(self.total_case),\
                                    self.arg_pass_in,\
                                    self.http.contents)
     elif exp_result == gconst.INVALID_XML:
         if (self.http.http_code != 200) or \
            (self.http.cont_dict['result'] != 'failure') or \
            (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_XML):
             HTTP.write_err_report(self.err_report,\
                                   'CC'+str(self.total_case),\
                                   self.arg_pass_in,\
                                   self.http.contents,\
                                   gconst.INVALID_XML+': '+gconst.ERROR[gconst.INVALID_XML])
             # increment the invalid case id list and unexpected case counter
             self.invalid_case_id_list.append('CC'+str(self.total_case))
             self.unexpect_case = self.unexpect_case + 1
             # Unexpected 'success' create campaign, need to delete the wrong campaign
             if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'):
                 result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN)
                 if result != 'success':
                     print >> sys.stderr, 'Error: Cannot delete existing campaign'
                     sys.exit(1)
         else:
             HTTP.write_succ_report(self.succ_report,\
                                    'CC'+str(self.total_case),\
                                    self.arg_pass_in,\
                                    self.http.contents)
     # this is necessary, since we don't really have an invalid case for "description"
     # TODO: you may delete this condition when "description" has something invalid
     elif exp_result == 'v':
         if (self.http.http_code != 200) or (self.http.cont_dict['result'] != 'success'):
             HTTP.write_err_report(self.err_report,\
                                   'CC'+str(self.total_case),\
                                   self.arg_pass_in,\
                                   self.http.contents,\
                                   '{"result": "success"}')
             # increment the invalid case id list and unexpected case counter
             self.invalid_case_id_list.append('CC'+str(self.total_case))
             self.unexpect_case = self.unexpect_case + 1
         else:
             HTTP.write_succ_report(self.succ_report,\
                                    'CC'+str(self.total_case),\
                                    self.arg_pass_in,\
                                    self.http.contents)
             # need to delete the campaign after writing the success report
             result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN)
             if result != 'success':
                 print >> sys.stderr, 'Error: Cannot delete existing campaign'
                 sys.exit(1)
     else:
         print >> sys.stderr, 'Error: Unexpected invalid test case'
         sys.exit(1)
    def blackbox_test(self):
        # Should delete the old campaign first
        HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN)

        # Combination of three kinds of test cases defined in README
        # Special cases for 'Missing Argument' of argument 'description'
        # Part I: Valid Case
        for a in self.valid_arg['auth_token']:
            self.arg_pass_in = {}
            self.arg_pass_in_msg = []
            self.arg_pass_in['auth_token'] = a
            self.arg_pass_in_msg.append(self.valid_arg_msg['auth_token'][0])
            for clt in self.valid_arg['client']:
                self.arg_pass_in['client'] = clt
                self.arg_pass_in_msg.append(self.valid_arg_msg['client'][self.valid_arg['client'].index(clt)])
                for run in self.valid_arg['running_state']:
                    self.arg_pass_in['running_state'] = run
                    self.arg_pass_in_msg.append(self.valid_arg_msg['running_state'][self.valid_arg['running_state'].index(run)])
                    for pri in self.valid_arg['privacy_state']:
                        self.arg_pass_in['privacy_state'] = pri
                        self.arg_pass_in_msg.append(self.valid_arg_msg['privacy_state'][self.valid_arg['privacy_state'].index(pri)])
                        for cls in self.valid_arg['class_urn_list']:
                            self.arg_pass_in['class_urn_list'] = cls
                            self.arg_pass_in_msg.append(self.valid_arg_msg['class_urn_list'][self.valid_arg['class_urn_list'].index(cls)])
                            for xml in self.valid_arg['xml']:
                                self.arg_pass_in['xml'] = xml
                                self.arg_pass_in_msg.append(self.valid_arg_msg['xml'][self.valid_arg['xml'].index(xml)])
                                for des in self.valid_arg['description']:
                                    self.update_arg_pass_in('description', des, 0)
                                    self.arg_pass_in_msg.append(self.valid_arg_msg['description'][self.valid_arg['description'].index(des)])
                                    # Determine the expected result
                                    exp_result = self.result_det(self.arg_pass_in_msg)
                                    # Use zip(dict.keys(), dict.values())
                                    # can convert dict into a list of tuples
                                    self.http.set_pass_in_with_file(zip(self.arg_pass_in.keys(), self.arg_pass_in.values()))
                                    # Need to upload a file, set flag to 1
                                    # to change the type of HTTP request
                                    self.http.request(1)
                                    self.total_case = self.total_case + 1
                                    # Print status
                                    print 'Processing Case ID {0}.\n{1}% to finish Campaign Create API.'.format('CC'+str(self.total_case), \
                                          self.total_case*100/TOTAL_CASE)
                                    # Check the response
                                    if exp_result == 'v':
                                        if (self.http.http_code != 200) or (self.http.cont_dict['result'] != 'success'):
                                            HTTP.write_err_report(self.err_report,\
                                                                  'CC'+str(self.total_case),\
                                                                  self.arg_pass_in,\
                                                                  self.http.contents,\
                                                                  '{"result": "success"}')
                                            # increment the invalid case id list and unexpected case counter
                                            self.invalid_case_id_list.append('CC'+str(self.total_case))
                                            self.unexpect_case = self.unexpect_case + 1
                                        else:
                                            HTTP.write_succ_report(self.succ_report,\
                                                                   'CC'+str(self.total_case),\
                                                                   self.arg_pass_in,\
                                                                   self.http.contents)
                                            # need to delete the campaign after expected creation
                                            result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN)
                                            if result != 'success':
                                                print >> sys.stderr, 'Error: Cannot delete existing campaign'
                                                sys.exit(1)
                                    else:
                                        print >> sys.stderr, 'Error: Invalid valid test case'
                                        sys.exit(1)
                                    # update arg_pass_in and arg_pass_in_msg
                                    self.update_arg_pass_in('description', des, 1)
                                    self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
                                # update arg_pass_in and arg_pass_in_msg
                                del self.arg_pass_in['xml']
                                self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
                            # update arg_pass_in and arg_pass_in_msg
                            del self.arg_pass_in['class_urn_list']
                            self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
                        # update arg_pass_in and arg_pass_in_msg
                        del self.arg_pass_in['privacy_state']
                        self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
                    # update arg_pass_in and arg_pass_in_msg
                    del self.arg_pass_in['running_state']
                    self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
                # update arg_pass_in and arg_pass_in_msg
                del self.arg_pass_in['client']
                self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)         
            # update arg_pass_in and arg_pass_in_msg
            del self.arg_pass_in['auth_token']
            self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)

        ########################################################################
        ########################################################################    
        # Part II: Invalid case with one invalid argument
        # Here I reduce the number of test cases by only picking one combination
        # of valid case
        # pick each invalid argument once
        for arg_name in self.para_name_list:
            for arg in self.invalid_arg[arg_name]:
                # first keep all argument valid
                self.form_one_valid_arg()
                self.update_arg_pass_in(arg_name, arg, 0)
                self.arg_pass_in_msg.append(self.invalid_arg_msg[arg_name][self.invalid_arg[arg_name].index(arg)])
                # Determine the expected result
                exp_result = self.result_det(self.arg_pass_in_msg)
                # Use zip(dict.keys(), dict.values())
                # can convert dict into a list of tuples
                self.http.set_pass_in_with_file(zip(self.arg_pass_in.keys(), self.arg_pass_in.values()))
                # Need to upload a file, set flag to 1
                # to change the type of HTTP request
                self.http.request(1)
                self.total_case = self.total_case + 1
                # Print status
                print 'Processing Case ID {0}.\n{1}% to finish Campaign Create API.'.format('CC'+str(self.total_case), \
                      self.total_case*100/TOTAL_CASE)
                # check the response
                self.err_response_check(exp_result)
        
        ########################################################################
        ########################################################################    
        # Part III: Invalid case with two invalid arguments
        # Here I reduce the number of test cases by only picking one combination
        # of valid case
        for arg_name1 in self.para_name_list:
            index1 = self.para_name_list.index(arg_name1)
            for arg_name2 in self.para_name_list[index1+1:]:
                # add those two arguments into arg_pass_in dict
                for arg1 in self.invalid_arg[arg_name1]:
                    self.form_one_valid_arg()
                    self.update_arg_pass_in(arg_name1, arg1, 0)
                    self.arg_pass_in_msg.append(self.invalid_arg_msg[arg_name1][self.invalid_arg[arg_name1].index(arg1)])
                    for arg2 in self.invalid_arg[arg_name2]:
                        self.update_arg_pass_in(arg_name2, arg2, 0)
                        self.arg_pass_in_msg.append(self.invalid_arg_msg[arg_name2][self.invalid_arg[arg_name2].index(arg2)])
                        # Determine the expected result
                        exp_result = self.result_det(self.arg_pass_in_msg)
                        # Use zip(dict.keys(), dict.values())
                        # can convert dict into a list of tuples
                        self.http.set_pass_in_with_file(zip(self.arg_pass_in.keys(), self.arg_pass_in.values()))
                        # Need to upload a file, set flag to 1
                        # to change the type of HTTP request
                        self.http.request(1)
                        self.total_case = self.total_case + 1
                        # Print status
                        print 'Processing Case ID {0}.\n{1}% to finish Campaign Create API.'.format('CC'+str(self.total_case), \
                              self.total_case*100/TOTAL_CASE)
                        # check the response
                        self.err_response_check(exp_result)
                        # update arg_pass_in and arg_pass_in_msg
                        self.update_arg_pass_in(arg_name2, arg2, 1)
                        self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
   def blackbox_test(self):
       # Should refresh the server campaign with URN gconst.CAMP_URN
       HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN)
       HTTP.create_camp(self.host, self.TOKEN, gconst.CLS_URN_LIST)
       # Combination of three kinds of test cases defined in README
       # Special cases for 'Wrong argument name' and 'Missing Argument'
       # Part I: Valid Case
       for a in self.valid_arg['auth_token']:
           self.arg_pass_in = {}
           self.arg_pass_in_msg = []
           self.arg_pass_in['auth_token'] = a
           self.arg_pass_in_msg.append(self.valid_arg_msg['auth_token'][0])
           for clt in self.valid_arg['client']:
               self.arg_pass_in['client'] = clt
               self.arg_pass_in_msg.append(self.valid_arg_msg['client'][self.valid_arg['client'].index(clt)])
               for camp in self.valid_arg['campaign_urn_list']:
                   self.update_arg_pass_in('campaign_urn_list', camp, 0)
                   self.arg_pass_in_msg.append(self.valid_arg_msg['campaign_urn_list'][self.valid_arg['campaign_urn_list'].index(camp)])
                   for cls in self.valid_arg['class_urn_list']:
                       self.update_arg_pass_in('class_urn_list', cls, 0)
                       self.arg_pass_in_msg.append(self.valid_arg_msg['class_urn_list'][self.valid_arg['class_urn_list'].index(cls)])
                       # Determine the expected result
                       exp_result = self.result_det(self.arg_pass_in_msg)
                       # HTTP request part
                       # Increment the total and invalid cases at the same time
                       self.http.set_pass_in(self.arg_pass_in)
                       self.http.request(0)
                       self.total_case = self.total_case + 1
                       # Print status
                       print 'Processing Case ID {0}.\n{1}% to finish User Read API.'.format('UR'+str(self.total_case), self.total_case*100/TOTAL_CASE)
                       # Check the response
                       if exp_result == 'v':
                           if (self.http.http_code != 200) or (self.http.cont_dict['result'] != 'success'):
                               HTTP.write_err_report(self.err_report,\
                                                     'UR'+str(self.total_case),\
                                                     self.arg_pass_in,\
                                                     self.http.contents,\
                                                     '{"result": "success", "data":...}')
                               # increment the invalid case id list and unexpected case counter
                               self.invalid_case_id_list.append('UR'+str(self.total_case))
                               self.unexpect_case = self.unexpect_case + 1
                           else:
                               HTTP.write_succ_report(self.succ_report,\
                                                      'UR'+str(self.total_case),\
                                                      self.arg_pass_in,\
                                                      self.http.contents)
                       else:
                           print >> sys.stderr, 'Error: Invalid valid test case'
                           sys.exit(1)
                       # update arg_pass_in and arg_pass_in_msg
                       self.update_arg_pass_in('class_urn_list', cls, 1)
                       self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
                   # update arg_pass_in and arg_pass_in_msg
                   self.update_arg_pass_in('campaign_urn_list', camp, 1)
                   self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
               # update arg_pass_in and arg_pass_in_msg
               del self.arg_pass_in['client']
               self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)         
           # update arg_pass_in and arg_pass_in_msg
           del self.arg_pass_in['auth_token']
           self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
 
       ########################################################################
       ########################################################################    
       # Part II: Invalid case with one invalid argument
       for para in self.para_name_list:
           index = self.para_name_list.index(para)
           # each turn pick one as invalid argument
           self.para_name_list.remove(para)
           arg1 = para                         # invalid arg
           arg2 = self.para_name_list[0]       # valid arg   
           arg3 = self.para_name_list[1]       # valid arg
           arg4 = self.para_name_list[2]       # valid arg
           # Add arg 1
           for a1 in self.invalid_arg[arg1]:
               self.arg_pass_in = {}
               self.arg_pass_in_msg = []
               self.update_arg_pass_in(arg1, a1, 0)
               self.arg_pass_in_msg.append(self.invalid_arg_msg[arg1][self.invalid_arg[arg1].index(a1)])
               # Add arg 2
               for a2 in self.valid_arg[arg2]:
                   self.update_arg_pass_in(arg2, a2, 0)
                   self.arg_pass_in_msg.append(self.valid_arg_msg[arg2][self.valid_arg[arg2].index(a2)])
                   # Add arg 3
                   for a3 in self.valid_arg[arg3]:
                       self.update_arg_pass_in(arg3, a3, 0)
                       self.arg_pass_in_msg.append(self.valid_arg_msg[arg3][self.valid_arg[arg3].index(a3)])
                       # Add arg 4
                       for a4 in self.valid_arg[arg4]:
                           self.update_arg_pass_in(arg4, a4, 0)
                           self.arg_pass_in_msg.append(self.valid_arg_msg[arg4][self.valid_arg[arg4].index(a4)])
                           # Result determine
                           exp_result = self.result_det(self.arg_pass_in_msg)
                           # HTTP request
                           # Increment the total and invalid cases at the same time
                           self.http.set_pass_in(self.arg_pass_in)
                           self.http.request(0)
                           self.total_case = self.total_case + 1
                           print 'Processing Case ID {0}.\n{1}% to finish User Read API.'.format('UR'+str(self.total_case), self.total_case*100/TOTAL_CASE)
                           # result check
                           if exp_result == gconst.AUTH_FAIL:
                               if (self.http.http_code != 200) or \
                                  (self.http.cont_dict['result'] != 'failure') or \
                                  (self.http.cont_dict['errors'][0]['code'] != gconst.AUTH_FAIL):
                                   HTTP.write_err_report(self.err_report,\
                                                        'UR'+str(self.total_case),\
                                                        self.arg_pass_in,\
                                                        self.http.contents,\
                                                        gconst.AUTH_FAIL+': '+gconst.ERROR[gconst.AUTH_FAIL])
                                   # increment the invalid case id list and unexpected case counter
                                   self.invalid_case_id_list.append('UR'+str(self.total_case))
                                   self.unexpect_case = self.unexpect_case + 1
                               else:
                                   HTTP.write_succ_report(self.succ_report,\
                                                          'UR'+str(self.total_case),\
                                                          self.arg_pass_in,\
                                                          self.http.contents)
                           elif exp_result == gconst.CLT_TOO_LONG:
                               if (self.http.http_code != 200) or \
                                  (self.http.cont_dict['result'] != 'failure') or \
                                  (self.http.cont_dict['errors'][0]['code'] != gconst.CLT_TOO_LONG):
                                   HTTP.write_err_report(self.err_report,\
                                                        'UR'+str(self.total_case),\
                                                        self.arg_pass_in,\
                                                        self.http.contents,\
                                                        gconst.CLT_TOO_LONG+': '+gconst.ERROR[gconst.CLT_TOO_LONG])
                                   # increment the invalid case id list and unexpected case counter
                                   self.invalid_case_id_list.append('UR'+str(self.total_case))
                                   self.unexpect_case = self.unexpect_case + 1
                               else:
                                   HTTP.write_succ_report(self.succ_report,\
                                                          'UR'+str(self.total_case),\
                                                          self.arg_pass_in,\
                                                          self.http.contents)
                           elif exp_result == gconst.NO_PERM_IN_CAMP:
                               if (self.http.http_code != 200) or \
                                  (self.http.cont_dict['result'] != 'failure') or \
                                  (self.http.cont_dict['errors'][0]['code'] != gconst.NO_PERM_IN_CAMP):
                                   HTTP.write_err_report(self.err_report,\
                                                        'UR'+str(self.total_case),\
                                                        self.arg_pass_in,\
                                                        self.http.contents,\
                                                        gconst.NO_PERM_IN_CAMP+': '+gconst.ERROR[gconst.NO_PERM_IN_CAMP])
                                   # increment the invalid case id list and unexpected case counter
                                   self.invalid_case_id_list.append('UR'+str(self.total_case))
                                   self.unexpect_case = self.unexpect_case + 1
                               else:
                                   HTTP.write_succ_report(self.succ_report,\
                                                          'UR'+str(self.total_case),\
                                                          self.arg_pass_in,\
                                                          self.http.contents)
                           elif exp_result == gconst.INVALID_CAMP_URN:
                               if (self.http.http_code != 200) or \
                                  (self.http.cont_dict['result'] != 'failure') or \
                                  (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_CAMP_URN):
                                   HTTP.write_err_report(self.err_report,\
                                                        'UR'+str(self.total_case),\
                                                        self.arg_pass_in,\
                                                        self.http.contents,\
                                                        gconst.INVALID_CAMP_URN+': '+gconst.ERROR[gconst.INVALID_CAMP_URN])
                                   # increment the invalid case id list and unexpected case counter
                                   self.invalid_case_id_list.append('UR'+str(self.total_case))
                                   self.unexpect_case = self.unexpect_case + 1
                               else:
                                   HTTP.write_succ_report(self.succ_report,\
                                                          'UR'+str(self.total_case),\
                                                          self.arg_pass_in,\
                                                          self.http.contents)
                           elif exp_result == gconst.INVALID_CLS_URN:
                               if (self.http.http_code != 200) or \
                                  (self.http.cont_dict['result'] != 'failure') or \
                                  (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_CLS_URN):
                                   HTTP.write_err_report(self.err_report,\
                                                        'UR'+str(self.total_case),\
                                                        self.arg_pass_in,\
                                                        self.http.contents,\
                                                        gconst.INVALID_CLS_URN+': '+gconst.ERROR[gconst.INVALID_CLS_URN])
                                   # increment the invalid case id list and unexpected case counter
                                   self.invalid_case_id_list.append('UR'+str(self.total_case))
                                   self.unexpect_case = self.unexpect_case + 1
                               else:
                                   HTTP.write_succ_report(self.succ_report,\
                                                          'UR'+str(self.total_case),\
                                                          self.arg_pass_in,\
                                                          self.http.contents)
                           elif exp_result == gconst.NO_PERM_IN_CLS:
                               if (self.http.http_code != 200) or \
                                  (self.http.cont_dict['result'] != 'failure') or \
                                  (self.http.cont_dict['errors'][0]['code'] != gconst.NO_PERM_IN_CLS):
                                   HTTP.write_err_report(self.err_report,\
                                                        'UR'+str(self.total_case),\
                                                        self.arg_pass_in,\
                                                        self.http.contents,\
                                                        gconst.NO_PERM_IN_CLS+': '+gconst.ERROR[gconst.NO_PERM_IN_CLS])
                                   # increment the invalid case id list and unexpected case counter
                                   self.invalid_case_id_list.append('UR'+str(self.total_case))
                                   self.unexpect_case = self.unexpect_case + 1
                               else:
                                   HTTP.write_succ_report(self.succ_report,\
                                                          'UR'+str(self.total_case),\
                                                          self.arg_pass_in,\
                                                          self.http.contents)
                           else:
                               print >> sys.stderr, 'Error: Unexpected single argument invalid test case'
                               sys.exit(1)
                           # update arg_pass_in and arg_pass_in_msg
                           self.update_arg_pass_in(arg4, a4, 1)
                           self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
                       # update arg_pass_in and arg_pass_in_msg
                       self.update_arg_pass_in(arg3, a3, 1)
                       self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
                   # update arg_pass_in and arg_pass_in_msg
                   self.update_arg_pass_in(arg2, a2, 1)
                   self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
               # update arg_pass_in and arg_pass_in_msg
               self.update_arg_pass_in(arg1, a1, 1)
               self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
           # restore the para_name_list
           self.para_name_list.insert(index, para)
           
       ########################################################################
       ########################################################################    
       # Part III: Invalid case with two invalid arguments
       # Get first invalid arg
       for arg1 in self.para_name_list:
           index1 = self.para_name_list.index(arg1)
           # each turn pick one as invalid argument
           self.para_name_list.remove(arg1)
           # Get second invalid arg
           for arg2 in self.para_name_list[index1:]:          # reduce half of the redundency
               index2 = self.para_name_list.index(arg2)
               self.para_name_list.remove(arg2)
               # Get other two arg
               arg3 = self.para_name_list[0]
               arg4 = self.para_name_list[1]
               # Add arg 1
               for a1 in self.invalid_arg[arg1]:
                   self.arg_pass_in = {}
                   self.arg_pass_in_msg = []
                   self.update_arg_pass_in(arg1, a1, 0)
                   self.arg_pass_in_msg.append(self.invalid_arg_msg[arg1][self.invalid_arg[arg1].index(a1)])
                   # Add arg 2
                   for a2 in self.invalid_arg[arg2]:
                       self.update_arg_pass_in(arg2, a2, 0)
                       self.arg_pass_in_msg.append(self.invalid_arg_msg[arg2][self.invalid_arg[arg2].index(a2)])
                       # Add arg 3
                       for a3 in self.valid_arg[arg3]:
                           self.update_arg_pass_in(arg3, a3, 0)
                           self.arg_pass_in_msg.append(self.valid_arg_msg[arg3][self.valid_arg[arg3].index(a3)])
                           # Add arg 4
                           for a4 in self.valid_arg[arg4]:
                               self.update_arg_pass_in(arg4, a4, 0)
                               self.arg_pass_in_msg.append(self.valid_arg_msg[arg4][self.valid_arg[arg4].index(a4)])
                               # Result determine
                               exp_result = self.result_det(self.arg_pass_in_msg)
                               # HTTP request
                               # Increment the total and invalid cases at the same time
                               self.http.set_pass_in(self.arg_pass_in)
                               self.http.request(0)
                               self.total_case = self.total_case + 1
                               print 'Processing Case ID {0}.\n{1}% to finish User Read API.'.format('UR'+str(self.total_case), \
                                      self.total_case*100/TOTAL_CASE)
                               # Result Check
                               if exp_result == gconst.AUTH_FAIL:
                                   if (self.http.http_code != 200) or \
                                      (self.http.cont_dict['result'] != 'failure') or \
                                      (self.http.cont_dict['errors'][0]['code'] != gconst.AUTH_FAIL):
                                       HTTP.write_err_report(self.err_report,\
                                                             'UR'+str(self.total_case),\
                                                             self.arg_pass_in,\
                                                             self.http.contents,\
                                                             gconst.AUTH_FAIL+': '+gconst.ERROR[gconst.AUTH_FAIL])
                                       # increment the invalid case id list and unexpected case counter
                                       self.invalid_case_id_list.append('UR'+str(self.total_case))
                                       self.unexpect_case = self.unexpect_case + 1
                                   else:
                                       HTTP.write_succ_report(self.succ_report,\
                                                              'UR'+str(self.total_case),\
                                                              self.arg_pass_in,\
                                                              self.http.contents)
                               elif exp_result == gconst.NO_PERM_IN_CAMP:
                                   if (self.http.http_code != 200) or \
                                      (self.http.cont_dict['result'] != 'failure') or \
                                      (self.http.cont_dict['errors'][0]['code'] != gconst.NO_PERM_IN_CAMP):
                                       HTTP.write_err_report(self.err_report,\
                                                             'UR'+str(self.total_case),\
                                                             self.arg_pass_in,\
                                                             self.http.contents,\
                                                             gconst.NO_PERM_IN_CAMP+': '+gconst.ERROR[gconst.NO_PERM_IN_CAMP])
                                       # increment the invalid case id list and unexpected case counter
                                       self.invalid_case_id_list.append('UR'+str(self.total_case))
                                       self.unexpect_case = self.unexpect_case + 1
                                   else:
                                       HTTP.write_succ_report(self.succ_report,\
                                                              'UR'+str(self.total_case),\
                                                              self.arg_pass_in,\
                                                              self.http.contents)
                               elif exp_result == gconst.INVALID_CAMP_URN:
                                   if (self.http.http_code != 200) or \
                                      (self.http.cont_dict['result'] != 'failure') or \
                                      (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_CAMP_URN):
                                       HTTP.write_err_report(self.err_report,\
                                                             'UR'+str(self.total_case),\
                                                             self.arg_pass_in,\
                                                             self.http.contents,\
                                                             gconst.INVALID_CAMP_URN+': '+gconst.ERROR[gconst.INVALID_CAMP_URN])
                                       # increment the invalid case id list and unexpected case counter
                                       self.invalid_case_id_list.append('UR'+str(self.total_case))
                                       self.unexpect_case = self.unexpect_case + 1
                                   else:
                                       HTTP.write_succ_report(self.succ_report,\
                                                              'UR'+str(self.total_case),\
                                                              self.arg_pass_in,\
                                                              self.http.contents)
                               elif exp_result == gconst.INVALID_CLS_URN:
                                   if (self.http.http_code != 200) or \
                                      (self.http.cont_dict['result'] != 'failure') or \
                                      (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_CLS_URN):
                                       HTTP.write_err_report(self.err_report,\
                                                             'UR'+str(self.total_case),\
                                                             self.arg_pass_in,\
                                                             self.http.contents,\
                                                             gconst.INVALID_CLS_URN+': '+gconst.ERROR[gconst.INVALID_CLS_URN])
                                       # increment the invalid case id list and unexpected case counter
                                       self.invalid_case_id_list.append('UR'+str(self.total_case))
                                       self.unexpect_case = self.unexpect_case + 1
                                   else:
                                       HTTP.write_succ_report(self.succ_report,\
                                                              'UR'+str(self.total_case),\
                                                              self.arg_pass_in,\
                                                              self.http.contents)
                               elif exp_result == gconst.NO_PERM_IN_CLS:
                                   if (self.http.http_code != 200) or \
                                      (self.http.cont_dict['result'] != 'failure') or \
                                      (self.http.cont_dict['errors'][0]['code'] != gconst.NO_PERM_IN_CLS):
                                       HTTP.write_err_report(self.err_report,\
                                                             'UR'+str(self.total_case),\
                                                             self.arg_pass_in,\
                                                             self.http.contents,\
                                                             gconst.NO_PERM_IN_CLS+': '+gconst.ERROR[gconst.NO_PERM_IN_CLS])
                                       # increment the invalid case id list and unexpected case counter
                                       self.invalid_case_id_list.append('UR'+str(self.total_case))
                                       self.unexpect_case = self.unexpect_case + 1
                                   else:
                                       HTTP.write_succ_report(self.succ_report,\
                                                          'UR'+str(self.total_case),\
                                                          self.arg_pass_in,\
                                                          self.http.contents)
                               else:
                                   print >> sys.stderr, 'Error: Unexpected single argument invalid test case'
                                   sys.exit(1)
                               # update arg_pass_in and arg_pass_in_msg
                               self.update_arg_pass_in(arg4, a4, 1)
                               self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
                           # update arg_pass_in and arg_pass_in_msg
                           self.update_arg_pass_in(arg3, a3, 1)
                           self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
                       # update arg_pass_in and arg_pass_in_msg
                       self.update_arg_pass_in(arg2, a2, 1)
                       self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
                   # update arg_pass_in and arg_pass_in_msg
                   self.update_arg_pass_in(arg1, a1, 1)
                   self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
               # restore the para_name_list
               self.para_name_list.insert(index2, arg2)
           # restore the para_name_list
           self.para_name_list.insert(index1, arg1)