def xmindToDict(self, filename):
file_str = "./xmind/" + "/" + filename + ".xmind"
if os.path.exists(file_str):
out = xmind_to_dict(file_str)
else:
out = None
return out
def read_xmind(self, filename):
'''读取xmind内容，返回case列表'''
# xmind内容
xmind_content = xmind_to_dict(filename)[0]['topic']
# 模块内容
module_name = self.xmind_title(xmind_content)
# 二级模块的数量
module_num = self.topics_num(xmind_content)
# 用例列表
case_list = []
for i in range(module_num):
case_num = self.topics_num(xmind_content['topics'][i])
if case_num == 0:
print(f'第{i + 1}个功能模块下，测试的功能点数量为0，请确认用例是否编写完成')
else:
tag = self.xmind_title(xmind_content['topics'][i])
case_point_num = self.topics_num(xmind_content['topics'][i])
for j in range(case_point_num):
case = []
if case_point_num == 0:
print('测试用例为空，请确认用例是否编写完成')
else:
case_point = self.xmind_title(xmind_content['topics'][i]['topics'][j])
case_step = self.xmind_title(xmind_content['topics'][i]['topics'][j]['topics'][0])
expected_result = self.xmind_title(xmind_content['topics'][i]['topics'][j]['topics'][0]['topics'][0])
case_title = "【" + tag + "】" + case_point
case.append(module_name)
case.append(case_title)
case.append(case_step)
case.append(expected_result)
case_list.append(case)
def read_XMind_to_list(XMindName) -> list:
"""
获取XMind文件所有的内容
:param XMindName:
:return: list
"""
return xmind_to_dict(XMindName)
def __init__(self):
self.name = input("请输入绝对路径:")
self.data = xmind_to_dict(self.name)
# 获取测试用例dict格式
self.dict_data = self.data[0]
# 实例化execlConfig
self.execl = ExcelConfig()
def xmind2dict(xmind_path):
xdict = xmind_to_dict(xmind_path)
print(xdict)
root = xdict[0]["topic"]
# print(root)
path_list = []
_analysisXmind(root, "", path_list)
return path_list
def xmind_to_dict(self, ):
"""
xmind转化成dict
:return:
"""
out = xmind_to_dict(self.xmind_file)
b = out[0]["topic"]["topics"]
return b
def xmind_cat(self, filename):
'''调试函数，打印内容用的'''
self.out = xmind_to_dict(filename)
self.story = self.out[0]['topic']['topics']
self.num = len(self.story)
print(self.out)
print(self.out[0]['topic']['title'])
return self.story, self.num
def main(filename):
dat = xmind_to_dict(filename)[0]['topic']
title = _norm_name(dat.get('title'))
with open(RESULT_FNAME, 'w') as f:
write_hub_to_conf(f,
host_name=title,
real_name=dat.get('title'),
parents=None)
parse_node(f, topics=dat['topics'], parent_device=title)
def __init__(self, name):
"""调用类时，读取xmind文件，并生成excel表格"""
try:
self.xm = xmind_to_dict(name)[0]['topic']
except Exception as e:
print(f"打开xmind文件失败:{e}")
self.workbook = xlwt.Workbook(encoding='utf-8') # 创建workbook对象
self.worksheet = self.workbook.add_sheet(
self.xm["title"], cell_overwrite_ok=True) # 创建工作表
def parseModel(filename, task=None):
xminddict = xmind_to_dict(filename)
global TASK
TASK = task
xmindtopic = Node(xminddict[0]["topic"])
root = Root(xmindtopic)
pprint(root)
return root
def to_dict(self, path):
data = xmind_to_dict(path)
a_str = str(data)
data_dict = eval(
a_str.replace('<',
'(').replace('>',
')').replace('"',
'“').replace('/', '//'))
return data_dict
def __init__(self, xmind_path, xmind_file, name):
self.xmind_file_path = xmind_path + xmind_file
self.data_dict = xmind_to_dict(self.xmind_file_path)
self.xls_path = xmind_path + 'xls\\' + name + '.xls'
self.workbook = xlwt.Workbook()
self.worksheet = self.workbook.add_sheet(
self.data_dict[0]['topic']['title'])
# self.workbook.save(self.xls_path)
self.ex_row = 0
def open_and_cache_xmind(xmind_file):
if not cache:
cache['sheet'] = xmind_to_dict(xmind_file)
cache['root'] = get_default_sheet(cache['sheet'])['topic']
root_topics = cache['root'].get('topics', [])
assert len(root_topics) > 0, "Invalid Xmind, should have at least 1 topic!"
cache['root']['topics'] = ignore_filter(root_topics)
cache['name'] = xmind_file
get_logger().debug('Cached xmind: {}'.format(cache))
def load_xmind(self, filename, template):
self.out = xmind_to_dict(filename)
self.story = self.out[0]['topic']['topics']
self.top_titile = self.out[0]['topic']['title']
self.branch_code = self.get_branch_code(template)
self.excel_public_name = filename.split('/')[-1].split(
'.')[0] + '_public.xlsx'
self.excel_candao_name = filename.split('/')[-1].split(
'.')[0] + '_candao.xlsx'
self.zip_name = filename.split('/')[-1].split('.')[0] + '.rar'
self.creat_xlsx()
def get_xmind_testsuites(xmind_file):
"""Load the XMind file and parse to `xmind2testcase.metadata.TestSuite` list"""
xmind_file = get_absolute_path(xmind_file)
xmind_content_dict = xmindparser.xmind_to_dict(xmind_file)
logging.debug("loading XMind file(%s) dict data: %s", xmind_file,
xmind_content_dict)
if xmind_content_dict:
testsuites = xmind_to_testsuites(xmind_content_dict)
return testsuites
else:
logging.error('Invalid XMind file(%s): it is empty!', xmind_file)
return []
def main():
xm = xmind_to_dict("团队学习-我的推课.xmind")[0]['topic']
# print(json.dumps(xm, indent=2, ensure_ascii=False)) # indent为显示json格式，ensure_ascii为显示为中文，不显示ASCII码
workbook = xlwt.Workbook(encoding='utf-8') # 创建workbook对象
worksheet = workbook.add_sheet(xm["title"],
cell_overwrite_ok=True) # 创建工作表
row0 = [
"testcaseid", '需求名称', '测试用例名称', '执行步骤', '预期结果', '服务名称', '版本', '执行人员'
]
sizes = [10, 11, 30, 60, 50, 11, 11, 11]
dicts = {"horz": "CENTER", "vert": "CENTER"}
style2 = styles()
style2.alignment = alignments(**dicts)
style2.font = fonts()
style2.borders = borders()
style2.pattern = patterns(7)
heights(worksheet, 0)
for i in range(len(row0)):
worksheet.write(0, i, row0[i], style2)
widths(worksheet, i, size=sizes[i])
style = styles()
style.borders = borders()
x = 0 # 写入数据的当前行数
z = 0 # 用例的编号
for i in range(len(xm["topics"])):
test_module = xm["topics"][i]
for j in range(len(test_module["topics"])):
test_suit = test_module["topics"][j]
for k in range(len(test_suit["topics"])):
test_case = test_suit["topics"][k]
z += 1
c1 = len(test_case["topics"]) # 执行步骤有几个
for n in range(len(test_case["topics"])):
x += 1
test_step = test_case["topics"][n]
test_except = test_step["topics"][0]
worksheet.write(x, 4, f"{n + 1}." + test_except["title"],
style) # 预期结果
worksheet.write(x, 3, f"{n + 1}." + test_step["title"],
style) # 执行步骤
worksheet.write_merge(x - c1 + 1, x, 0, 0, z,
style) # testcaseid
worksheet.write_merge(x - c1 + 1, x, 1, 1,
test_module["title"], style) # 测试需求名称
worksheet.write_merge(x - c1 + 1, x, 2, 2, test_case["title"],
style) # 测试用例名称
workbook.save(xm["title"] + ".xls") # xls名称取xmind主题名称
def __get_dic_content(self, filename):
"""
#从Xmind读取字典形式的数据
:param filename: xmind文件路径
:return:
"""
if not os.path.exists(filename):
print("[ERROR] 文件不存在")
sys.exit(-1)
out = xmind_to_dict(filename)
dic_content = out[0]
canvas_name = dic_content.get('title') # 获取画布名称
cavas_values = dic_content.get('topic')
if cavas_values:
excel_title = cavas_values.get('title') # 获取模块名称
content = [dic_content.get('topic')]
return content, canvas_name, excel_title
def create_case():
import xlwt # 导入模块
from xmindparser import xmind_to_dict
xm = xmind_to_dict("团队学习-我的推课.xmind")[0]['topic'] # 读取xmind数据
workbook = xlwt.Workbook(encoding='utf-8') # 创建workbook对象
worksheet = workbook.add_sheet(
xm["title"], cell_overwrite_ok=True) # 创建工作表，并设置可以重写单元格内容
row0 = [
"testcaseid", '需求名称', '测试用例名称', '执行步骤', '预期结果', '服务名称', '版本', '执行人员'
] # 写成excel表格用例的要素
# 添加excel标题
for i in range(len(row0)):
worksheet.write(0, i, row0[i])
x = 0 # 写入数据的当前行数
z = 0 # 用例的编号
# 遍历所有需求
for i in range(len(xm["topics"])):
test_module = xm["topics"][i]
for j in range(len(test_module["topics"])):
test_suit = test_module["topics"][j]
for k in range(len(test_suit["topics"])):
test_case = test_suit["topics"][k]
z += 1
c1 = len(test_case["topics"]) # 执行步骤有几个
for n in range(len(test_case["topics"])):
x += 1
test_step = test_case["topics"][n]
test_except = test_step["topics"][0]
worksheet.write(x, 4,
f"{n + 1}." + test_except["title"]) # 预期结果
worksheet.write(x, 3,
f"{n + 1}." + test_step["title"]) # 执行步骤
worksheet.write_merge(x - c1 + 1, x, 0, 0, z) # testcaseid
worksheet.write_merge(x - c1 + 1, x, 1, 1,
test_module["title"]) # 测试需求名称
worksheet.write_merge(x - c1 + 1, x, 2, 2,
test_case["title"]) # 测试用例名称
workbook.save(xm["title"] + ".xls") # xls名称取xmind主题名称
def get_cases_list_from_xmind_file(xmind_file):
# 获取需求数据
story_data = xmind_to_dict(xmind_file)[0]['topic']['topics']
# 创建包含文件中所有用例的列表
case_list = []
for story in story_data:
# 获取模块数据
module_data = story['topics']
for module in module_data:
# 获取目录数据
index_data = module['topics']
for index in index_data:
# 获取用例数据
case_data = index['topics']
for case in case_data:
# 创建单个用例的数据列表，并添加需求名称，模块名称，目录名称和用例名称
lst = [
story['title'], module['title'], index['title'],
case['title']
]
# 获取用例内容
case_content_data = case['topics']
# 添加前置条件和级别到用例列表中
lst.append(case_content_data[0]['title'])
lst.append(case_content_data[1]['title'])
for i in range(0, len(case_content_data) - 2):
# 获取用例步骤并添加到用例列表中
step_data = case_content_data[i + 2]
lst.append(step_data['title'])
# 获取用例执行结果并添加到用例列表中
result_data = step_data['topics']
for result in result_data:
lst.append(result['title'])
# 将该条用例添加到所有用例列表中
case_list.append(lst)
return case_list
def post(self, request):
# xind测试用例导入
sprint_name_id = request.data.get('sprint_name_id')
file_path = request.data.get(r'file_path')
if file_path:
content = xmind_to_dict(file_path) # Xmind文件解析为字典格式
xmind_cases = content[0]['topic']['topics'] # 用例集
module_len = len(xmind_cases[0])
for i in range(0, module_len + 1):
module_name = xmind_cases[i]['title'] # 模块名称
case_len = len(xmind_cases[i]['topics']) # 各模块用例数
module_case = xmind_cases[i]['topics'] # 各模块用例集
i += 1
for j in range(0, case_len):
case_description = module_case[j]['title'] # 用例描述
cases.objects.create(module_name=module_name,
case_description=case_description,
sprint_name_id=sprint_name_id)
result = {"status": "200", "data": {'msg': 'OK'}}
return Response(result, status=status.HTTP_200_OK)
else:
result = {"status": "500", "data": {'msg': '导入失败'}}
return Response(result,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def maintest(filename):
out = xmind_to_dict(filename)
excelname = filename.split('/')[-1].split('.')[0] + '.xls'
xmind_cat(out[0]['topic']['topics'], excelname)
# dfs function
def s(a, parent):
for i in a:
for key in i:
if isinstance(i[key], str):
data = [i[key], uuid.uuid3(uuid.NAMESPACE_DNS, i[key]), uuid.uuid3(uuid.NAMESPACE_DNS, parent), CLASSIFYING_SYSTEM, \
ISVALID, ISEDIT, REVISER, TECH_FIELD, '']
writer.writerow(data)
else:
s(i[key], i['title'])
# xmind to dict
xmind_dict = xmind_to_dict('集成电路技术.xmind')
main_dict = xmind_dict[0]['topic']
# config
HEADERS = [
'name', 'number', 'parent_number', 'classifying_system', 'isValid',
'isEdit', 'reviser', 'tech_field', 'synonym'
]
CLASSIFYING_SYSTEM = '自定义分类技术体系'
ISVALID = 1
ISEDIT = 0
REVISER = 'root'
TECH_FIELD = main_dict['title']
with open('集成电路技术.csv', 'w', newline='') as csvfile:
writer = csv.writer(csvfile)
#!usr/bin/env python
# -*- coding:utf-8 -*-
"""
@author:doulihang
@file: xmind_study.py
@time: 2021/03/31
@remark：
"""
from xmindparser import xmind_to_dict
import json
xm = xmind_to_dict("团队学习-我的推课.xmind")[0]['topic']
# indent为显示json格式，ensure_ascii未显示为中文，不显示ASCII码
print(json.dumps(xm, indent=2, ensure_ascii=False))
def get_xmind_json(self):
"""
将xmind转json格式
:return:
"""
# 获取到xmind的基本信息
xmind_file_dic = xmind_to_dict(self.xmind_path)[0]['topic']
xmind_title = self.GET_DIC_VALUE.get_value_key_is_title(xmind_file_dic)
xmind_topics = self.GET_DIC_VALUE.get_value_key_is_topics(
xmind_file_dic)
# 用列表的形式存放模块信息
moudle_names_list = []
moudle_topics_list = []
for i in xmind_topics:
moudle_names_list.append(
self.GET_DIC_VALUE.get_value_key_is_title(i))
moudle_topics_list.append(
self.GET_DIC_VALUE.get_value_key_is_topics(i))
for j in range(0, len(moudle_names_list)):
"""
获取模块名称
"""
moudle_name = moudle_names_list[j]
moudle_topics = moudle_topics_list[j]
self.rowNum = 1
for t1 in range(0, len(moudle_topics)):
"""
获取用例等级、标题1
"""
title_level = ''
title_tag = ''
# 用例等级
if "makers" in moudle_topics[t1].keys():
for t1_i in moudle_topics[t1]["makers"]:
if len(t1_i) > 7:
if t1_i[:8] == 'priority':
title_level = t1_i
title_level = self.get_level_word(title_level)
# 用例类型
if "labels" in moudle_topics[t1].keys():
title_tag = moudle_topics[t1]["labels"][0]
title_names = ["", "", ""]
title_names[0] = self.GET_DIC_VALUE.get_value_key_is_title(
moudle_topics[t1])
title_topics1 = self.GET_DIC_VALUE.get_value_key_is_topics(
moudle_topics[t1])
for t2 in range(0, len(title_topics1)): #title_topics1:
"""
获取标题2
"""
# 用例等级
if "makers" in title_topics1[t2].keys():
for t2_1 in title_topics1[t2]["makers"]:
if len(t2_1) > 7:
if t2_1[:8] == 'priority':
title_level = t2_1
title_level = self.get_level_word(
title_level)
# 用例类型
if "labels" in title_topics1[t2].keys():
title_tag = title_topics1[t2]["labels"][0]
title_names[1] = self.GET_DIC_VALUE.get_value_key_is_title(
title_topics1[t2])
title_topics2 = self.GET_DIC_VALUE.get_value_key_is_topics(
title_topics1[t2])
for t3 in range(0, len(title_topics2)):
"""
用例等级、用例类型
获取标题3
"""
# 用例等级
if "makers" in title_topics2[t3].keys():
for t3_1 in title_topics2[t3]["makers"]:
if len(t3_1) > 7:
if t3_1[:8] == 'priority':
title_level = t3_1
title_level = self.get_level_word(
title_level)
# 用例类型
if "labels" in title_topics2[t3].keys():
title_tag = title_topics2[t3]["labels"][0]
title_names[
2] = self.GET_DIC_VALUE.get_value_key_is_title(
title_topics2[t3])
title_topics3 = self.GET_DIC_VALUE.get_value_key_is_topics(
title_topics2[t3])
# title_name = title_names[0] + " - " + title_names[1] + " - " + title_names[2]
title_name = ''
for t in range(0, len(title_names)):
if t == 0:
title_name += title_names[t]
else:
title_name += ' - ' + title_names[t]
title_preset = ""
title_step = ""
title_pre_step = ""
if title_topics3 is not None:
step_num = 1
for s in range(0, len(title_topics3)):
"""
获取前置步骤、执行步骤
"""
# 前置步骤在最前
if s == 0 and "makers" in title_topics3[
s].keys():
if 'flag-red' in self.GET_DIC_VALUE.get_value_key_is_makers(
title_topics3[s]):
title_pre_step = self.GET_DIC_VALUE.get_value_key_is_title(
title_topics3[s])
continue
# 前置步骤在最末
if s == len(
title_topics3
) - 1 and "makers" in title_topics3[s].keys():
if 'flag-red' in self.GET_DIC_VALUE.get_value_key_is_makers(
title_topics3[s]):
title_pre_step = self.GET_DIC_VALUE.get_value_key_is_title(
title_topics3[s])
continue
step = ""
if len(title_topics3) > 1:
step = "步骤" + str(step_num) + ": "
step_num += 1
title_step += step + self.GET_DIC_VALUE.get_value_key_is_title(
title_topics3[s]) + "\n"
else:
title_step += self.GET_DIC_VALUE.get_value_key_is_title(
title_topics3[s]) + "\n"
title_presets = self.GET_DIC_VALUE.get_value_key_is_topics(
title_topics3[s])
if title_presets is not None:
"""
获取预期结果
"""
for p in range(0, len(title_presets)):
if len(title_presets) == 1 or p == 0:
title_preset += step + self.GET_DIC_VALUE.get_value_key_is_title(
title_presets[p])
if (p == 0):
title_preset += "\n"
else:
title_preset += self.GET_DIC_VALUE.get_value_key_is_title(
title_presets[p]) + "\n"
xmind_dic = {}
xmind_dic["用例目录"] = ""
xmind_dic["用例名称"] = title_name
xmind_dic["需求ID"] = ""
xmind_dic["前置条件"] = title_pre_step
xmind_dic["用例步骤"] = title_step
xmind_dic["预期结果"] = title_preset
xmind_dic["用例类型"] = title_tag
xmind_dic["用例状态"] = ""
xmind_dic["用例等级"] = title_level
xmind_dic["创建人"] = ""
xmind_dic["用例类型自定义"] = ""
if self.is_need_num == 1:
# if type(moudle_name) is int:
xmind_dic["需求ID"] = moudle_name
# else:
# print("需求id非int格式，需求ID生成失败")
# return "需求id非int格式，需求ID生成失败"
# xmind_dic["模块"] = moudle_name
self.xmind_list.append(xmind_dic)
# print(xmind_dic["用例等级"], xmind_dic["用例名称"],xmind_dic["用例类型"])
self.rowNum = self.rowNum + 1
self.EXCEL_WRITE_READ.excel_write(
self.rowNum, xmind_dic, moudle_name)
def xmindTodict(fileName):
return xmind_to_dict(fileName)
__author__ = 'wangxiao'
__author__ = 'wangxiao'
from xmindparser import xmind_to_dict
data = xmind_to_dict("test module.xmind")
print(data)
priority = "S"
elif get_priority == "priority-2":
priority = "A"
elif get_priority == "priority-3":
priority = "B"
else:
priority = "C"
print("优先级：", priority)
#获取前置步骤
step_first = get_case[b]["topics"][0]["title"]
print("前置步骤：", step_first)
#获取操作步骤
step = get_case[b]["topics"][1]["title"]
print("操作步骤：", step)
#获取期望结果
hole_result = get_case[b]["topics"][1]["topics"][0][
"title"]
print("期望结果", hole_result)
if __name__ == "__main__":
#读取文件
data = xmind_to_dict("D:\登录注册.xmind")
#获取列表中的字典
get_dict = data[0]
#获取需求的名称
title = get_dict["topic"]["title"]
getcase(title, get_dict)
return 1
if __name__ == "__main__":
#设置日志日式
logging.basicConfig(
level=logging.INFO,
filename='log.log',
filemode='w',
format=
'%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s'
)
count = 1
#读取文件
try:
root = tk.Tk()
root.withdraw()
f_path = filedialog.askopenfilename()
data = xmind_to_dict(f_path)
logging.info("开始读取文件")
# 获取列表中的字典
get_dict = data[0]
logging.info("文件读取成功")
# 获取需求的名称
title = get_dict["topic"]["title"]
logging.info("获取需求名称")
sheets = getcase(title, get_dict, count)
logging.info("完成")
except Exception as ex:
logging.info("出现错误，如下：")
logging.error(ex)
# -*- coding: utf-8 -*-
# @Time : 2020/2/3 23:54
# @Author : dashenN72
from xmindparser import xmind_to_dict
from tools import xmind
from tools import excel
import config
FileName = '.\\input\\app测试用例.xmind'
XmindContent = xmind_to_dict(FileName)[0]['topic'] # xmind内容
print("原始内容：\n" + str(XmindContent))
list_xmind_content = xmind.XmindCase().xmind_case(XmindContent['topics'])
print("case数：%d \n"
"xmind内容转换成list：%s\n" %
(len(list_xmind_content), str(list_xmind_content)))
# excel名称即xmind中0级名称，1级开始才是用例
with excel.ExcelWriter(XmindContent['title'] + '.xlsx',
config.module_excel[0][0]) as ew:
ew.init_title() # 创建excel表格sheet标题，从配置文件
ew.write_rows(list_xmind_content) # 将xmind内容写入excel
def write_excel(self,
xmind_file,
servicename='',
editionname='',
performer=''):
'''生成excel文件函数'''
self.f = xlwt.Workbook()
self.sheet1 = self.f.add_sheet('sheet1', cell_overwrite_ok=True)
self.row0 = [
"storyid", '需求名称', '测试用例名称', '执行步骤', '预期结果', '服务名称', '版本', '执行人员'
]
#生成第一行
for i in range(0, len(self.row0)):
self.sheet1.write(0, i, self.row0[i])
self.out = xmind_to_dict(xmind_file)
self.xls_name = self.out[0]['topic']['title']
self.story = self.out[0]['topic']['topics']
self.storynum = len(self.story)
j = 1 #用例计算器
z = 0 # 用例结果数计数器
for i in range(0, self.storynum):
self.storyname = self.story[i]['title']
print(self.storyname)
self.regex_str = ".*[\[【](.+?)[\]】].*"
self.storyid_reg = re.match(self.regex_str, self.storyname)
if self.storyid_reg:
self.storyid = self.storyid_reg.group(1) #正则取出用例编号
#print(self.storyid_reg.group(1))
self.testcase_num = self.xmind_num(self.story[i]['topics'][0])
for k in range(0, self.testcase_num):
self.testcase = self.story[i]['topics'][0]['topics'][k]
self.testcase_name = self.xmind_title(self.testcase)
self.testcase_stepnum = self.xmind_num(
self.testcase) #每个用例的步骤数量
self.sheet1.write(k + i + z + j, 2, self.testcase_name)
self.sheet1.write(k + i + z + j, 0, self.storyid)
self.sheet1.write(k + i + z + j, 1, self.storyname)
self.sheet1.write(k + i + z + j, 5, servicename)
self.sheet1.write(k + i + z + j, 6, editionname)
self.sheet1.write(k + i + z + j, 7, performer)
for x in range(0, self.testcase_stepnum):
self.testcase_step = self.testcase['topics'][x]
self.teststep_title = self.xmind_title(
self.testcase_step) #用例步骤名称
self.teststep_num = self.xmind_num(
self.testcase_step) #用例步骤个数
if self.teststep_num != 0:
for y in range(0, self.teststep_num):
self.test_results = self.testcase_step['topics'][y]
self.test_result = self.xmind_title(
self.test_results) #用例结果
self.sheet1.write(k + i + z + j + y + 1, 3,
self.teststep_title)
self.sheet1.write(k + i + z + j + y + 1, 4,
self.test_result)
z = z + y + 1
else:
self.test_result = ' '
self.sheet1.write(k + i + z + j + 1, 3,
self.teststep_title)
self.sheet1.write(k + i + z + j + 1, 4,
self.test_result)
z = z + 1
j = j + k
self.f.save(self.xls_name + '.xls') #xls名称取xmind主题名称
