云南大学软件学院期末课程报告
Final Course Report
School of Software, Yunnan University
个人成绩
序号 1 2 3 4 5 6 学号 姓名 成绩
学 期： 2012 秋季学期 课程名称: 软件测试技术 任课教师: 代 飞 组长姓名: 联系电话: 年 级:
作业截止时间：2012年12月27日
I
评分标准
指标内容 分值 对程序代码进行详尽、准确分析，设计测试用例合理 对设计文档进行详尽、准确分析，设计测试用例合理 对产品规格说明书进行详尽、准确分析，设计测试用例合理 指标内涵及评估标准 对程序代码进行较准确地分析，设计测试用例较合理 对设计文档进行较准确地分析，设计测试用例较合理 对产品规格说明书进行较准确分析，设计测试用例较合理 对程序代码对程序代码进行分析较差，设一般地分析，设计测试用例计测试用例一般 不合理 对设计文档对设计文档进行分析较差，设一般地分析，设计测试用例计测试用例一般 不合理 对产品规格说明书进行一般地分析，设计测试用例一般 对产品规格说明书分析较差，设计测试用例不合理 单元测试 20 集成测试 15 功能测试 20 非功能测试 15 5 5 根据产品规格说明书，对系统进行性能测试、压力测试、容量测试、安全性测试、可靠性测试、容错性测试等。 报告非常完整 逻辑结构清晰 内容非常丰富 文字表达非常好 图表制作非常专业化 整体效果很好 报告比较完整 完整程度一般 逻辑组织较好 逻辑组织一般 内容较丰富 内容一般 报告不完整 逻辑不清 内容欠缺 文字表达差，意思不明了 图件制作效果差 整体效果差 报告撰写质量 （30分） 5 5 5 5 文字表达较好 文字表达一般 图件制作良好 图件制作一般 整体效果良好 整体效果一般
II
小组成员及分工
学号 姓名 角色 电话 详细工作介绍 签名
III
《软件测试技术》成绩考核表（每人填一份）
年级： 本人所做工作及排名： 统筹全局，复查文档，单元测试，调整测试程序 排名1 指标内容 分值 指标内涵及评估标准 得分 技术路线的可合理可行，具体且有不够合理或不10 合理可行，具体 基本合理可行 行程度 创新 够具体 程序或系统思路程序或系统思路清程序或系统思程序或系统设程序或系统思路非10 基本清晰、运行晰、环境配置错误路不清晰，程序 计思路 常清晰、运行正确 正确 无法运行 无法运行 小组成员的工高出平均要求工作高出平均要求工达到平均要求工作低于平均要求作量（每个人分15 量的15%以上 作量 量 的工作量 别打分） 用理论知识对程用理论知识对程序序设计方法、思理论知识应用设计方法、思路和代15 路和代码进行较理论知识应用一般 理论知识差 水平 码进行详尽、准确地准确地分析和总分析和总结 结 达到预期目标10 完全达到 基本达到 无法预见 未能达到 的程度 很强的团队合作精合作不好，各自团队合作精神 10 合作情况良好 合作情况一般 神 为政 5 5 报告撰写质量 （30分） 5 5 5 5 综合得分（满分100分） 报告非常完整 逻辑结构清晰 内容非常丰富 文字表达非常好 图表制作非常专业化 整体效果很好 报告比较完整 逻辑组织较好 内容较丰富 文字表达较好 图件制作良好 整体效果良好 完整程度一般 逻辑组织一般 内容一般 文字表达一般 图件制作一般 整体效果一般 报告不完整 逻辑不清 内容欠缺 文字表达差，意思不明了 图件制作效果差 整体效果差 评语 IV
《软件测试技术》成绩考核表（每人填一份）
年级本人所做工作及排名： 单元测试程序及文档，集成测试，协助审查测试程序 排名2 指标内容 技术路线的可行程度 程序或系统设计思路 分值 10 合理可行，具体且有创新 程序或系统思路非常清晰、运行正确 指标内涵及评估标准 合理可行，具体 程序或系统思路基本清晰、运行正确 基本合理可行 程序或系统思路清晰、环境配置错误无法运行 不够合理或不够具体 程序或系统思路不清晰，程序无法运行 得分 10 小组成员的工作量（每个人分别打分） 15 高出平均要求工作量的15%以上 高出平均要求工作量 达到平均要求工作量 低于平均要求的工作量 理论知识应用水平 15 用理论知识对程序设计方法、思路和代码进行详尽、准确地分析和总结 用理论知识对程序设计方法、思路和代码进行较准确地分析和总结 理论知识应用一般 理论知识差 达到预期目标的程度 团队合作精神 10 完全达到 很强的团队合作精神 报告非常完整 逻辑结构清晰 内容非常丰富 文字表达非常好 图表制作非常专业化 整体效果很好 基本达到 无法预见 未能达到 合作不好，各自为政 报告不完整 逻辑不清 内容欠缺 文字表达差，意思不明了 图件制作效果差 整体效果差 10 5 5 5 5 5 5 合作情况良好 报告比较完整 逻辑组织较好 内容较丰富 文字表达较好 图件制作良好 整体效果良好 合作情况一般 完整程度一般 逻辑组织一般 内容一般 文字表达一般 图件制作一般 整体效果一般 报告撰写质量 （30分） 综合得分（满分100分） 评语 V
《软件测试技术》成绩考核表（每人填一份）
年级： 本人所做工作及排名： 代码复杂度测试、集成测试、测试总结和结果分析 排名3 指标内容 技术路线的可行程度 程序或系统设计思路 分值 10 合理可行，具体且有创新 程序或系统思路非常清晰、运行正确 指标内涵及评估标准 合理可行，具体 程序或系统思路基本清晰、运行正确 基本合理可行 程序或系统思路清晰、环境配置错误无法运行 不够合理或不够具体 程序或系统思路不清晰，程序无法运行 得分 10 小组成员的工作量（每个人分别打分） 15 高出平均要求工作量的15%以上 高出平均要求工作量 达到平均要求工作量 低于平均要求的工作量 理论知识应用水平 15 用理论知识对程序设计方法、思路和代码进行详尽、准确地分析和总结 用理论知识对程序设计方法、思路和代码进行较准确地分析和总结 理论知识应用一般 理论知识差 达到预期目标的程度 团队合作精神 10 完全达到 很强的团队合作精神 报告非常完整 逻辑结构清晰 内容非常丰富 文字表达非常好 图表制作非常专业化 整体效果很好 基本达到 无法预见 未能达到 合作不好，各自为政 报告不完整 逻辑不清 内容欠缺 文字表达差，意思不明了 图件制作效果差 整体效果差 10 5 5 5 5 5 5 合作情况良好 报告比较完整 逻辑组织较好 内容较丰富 文字表达较好 图件制作良好 整体效果良好 合作情况一般 完整程度一般 逻辑组织一般 内容一般 文字表达一般 图件制作一般 整体效果一般 报告撰写质量 （30分） 综合得分（满分100分） 评语 VI
《软件测试技术》成绩考核表（每人填一份）
年级： 本人所做工作及排名： 功能测试及文档撰写 排名4 指标内容 技术路线的可行程度 程序或系统设计思路 分值 10 合理可行，具体且有创新 程序或系统思路非常清晰、运行正确 指标内涵及评估标准 合理可行，具体 程序或系统思路基本清晰、运行正确 基本合理可行 程序或系统思路清晰、环境配置错误无法运行 不够合理或不够具体 程序或系统思路不清晰，程序无法运行 得分 10 小组成员的工作量（每个人分别打分） 15 高出平均要求工作量的15%以上 高出平均要求工作量 达到平均要求工作量 低于平均要求的工作量 理论知识应用水平 15 用理论知识对程序设计方法、思路和代码进行详尽、准确地分析和总结 用理论知识对程序设计方法、思路和代码进行较准确地分析和总结 理论知识应用一般 理论知识差 达到预期目标的程度 团队合作精神 10 完全达到 很强的团队合作精神 报告非常完整 逻辑结构清晰 内容非常丰富 文字表达非常好 图表制作非常专业化 整体效果很好 基本达到 无法预见 未能达到 合作不好，各自为政 报告不完整 逻辑不清 内容欠缺 文字表达差，意思不明了 图件制作效果差 整体效果差 10 5 5 5 5 5 5 合作情况良好 报告比较完整 逻辑组织较好 内容较丰富 文字表达较好 图件制作良好 整体效果良好 合作情况一般 完整程度一般 逻辑组织一般 内容一般 文字表达一般 图件制作一般 整体效果一般 报告撰写质量 （30分） 综合得分（满分100分） 评语 VII
《软件测试技术》成绩考核表（每人填一份）
年级：本人所做工作及排名： 功能测试及文档撰写 排名5 指标内容 技术路线的可行程度 程序或系统设计思路 分值 10 合理可行，具体且有创新 程序或系统思路非常清晰、运行正确 指标内涵及评估标准 合理可行，具体 程序或系统思路基本清晰、运行正确 基本合理可行 程序或系统思路清晰、环境配置错误无法运行 不够合理或不够具体 程序或系统思路不清晰，程序无法运行 得分 10 小组成员的工作量（每个人分别打分） 15 高出平均要求工作量的15%以上 高出平均要求工作量 达到平均要求工作量 低于平均要求的工作量 理论知识应用水平 15 用理论知识对程序设计方法、思路和代码进行详尽、准确地分析和总结 用理论知识对程序设计方法、思路和代码进行较准确地分析和总结 理论知识应用一般 理论知识差 达到预期目标的程度 团队合作精神 10 完全达到 很强的团队合作精神 报告非常完整 逻辑结构清晰 内容非常丰富 文字表达非常好 图表制作非常专业化 整体效果很好 基本达到 无法预见 未能达到 合作不好，各自为政 报告不完整 逻辑不清 内容欠缺 文字表达差，意思不明了 图件制作效果差 整体效果差 10 5 5 5 5 5 5 合作情况良好 报告比较完整 逻辑组织较好 内容较丰富 文字表达较好 图件制作良好 整体效果良好 合作情况一般 完整程度一般 逻辑组织一般 内容一般 文字表达一般 图件制作一般 整体效果一般 报告撰写质量 （30分） 综合得分（满分100分） 评语 VIII
《软件测试技术》成绩考核表（每人填一份）
年级： 本人所做工作及排名： 审查文档，调整文档格式，审查测试程序 排名6 指标内容 技术路线的可行程度 程序或系统设计思路 分值 10 合理可行，具体且有创新 程序或系统思路非常清晰、运行正确 指标内涵及评估标准 合理可行，具体 基本合理可行 程序或系统思路基本清晰、运行正确 程序或系统思路清晰、环境配置错误无法运行 不够合理或不够具体 程序或系统思路不清晰，程序无法运行 得分 10 小组成员的工作量（每个人分别打分） 15 高出平均要求工作量的15%以上 高出平均要求工作量 达到平均要求工作量 低于平均要求的工作量 理论知识应用水平 15 用理论知识对程序设计方法、思路和代码进行详尽、准确地分析和总结 用理论知识对程序设计方法、思路和代码进行较准确地分析和总结 理论知识应用一般 理论知识差 达到预期目标的程度 团队合作精神 10 完全达到 很强的团队合作精神 报告非常完整 逻辑结构清晰 内容非常丰富 文字表达非常好 图表制作非常专业化 整体效果很好 基本达到 无法预见 未能达到 合作不好，各自为政 报告不完整 逻辑不清 内容欠缺 文字表达差，意思不明了 图件制作效果差 整体效果差 10 5 5 5 5 5 5 合作情况良好 报告比较完整 逻辑组织较好 内容较丰富 文字表达较好 图件制作良好 整体效果良好 合作情况一般 完整程度一般 逻辑组织一般 内容一般 文字表达一般 图件制作一般 整体效果一般 报告撰写质量 （30分） 综合得分（满分100分） 评语 IX
目录
第1章 测试概述..................................................... 3
1.1 编写目的 .................................................... 3 1.2 项目背景和简介 .............................................. 3 1.3 项目的产品规格说明书（Specification） ....................... 4
1.3.1 需求概述............................................... 4 1.3.2 需求规格............................................... 6 1.3.3 CSCI能力需求 .......................................... 8 1.3.4 保密性需求............................................. 9 1.3.5 CSCI环境需求 ......................................... 10 1.3.6 计算机资源需求........................................ 10 1.4 项目的设计文档 ............................................. 10
1.4.1课程资源操作子系统 .................................... 10 1.5 测试范围 ................................................... 13 1.6 测试环境与配置 ............................................. 13 第2章 测试用例设计................................................ 14
2.1 单元测试 ................................................... 14
2.1.1代码复杂度测试 ........................................ 14 2.1.2单元测试的用例设计 .................................... 17 2.2 集成测试的用例设计 ......................................... 37 2.3 功能测试的用例设计 ......................................... 43
2.3.1教师资源模块 .......................................... 43 2.3.2教室信息录入功能 ...................................... 44 2.3.3时间段信息录入功能 .................................... 45 2.3.4课程信息录入功能 ...................................... 46 2.4 非功能测试的用例设计 ....................................... 48 第3章 测试总结.................................................... 50
3.1 测试用例执行结果 ........................................... 50
3.1.1黑盒测试中对于类的测试结果 ............................ 50
1
3.2.2集成测试结果 .......................................... 52 3.2 测试问题解决 ............................................... 53 3.3 测试结果分析 ............................................... 54 第4章 综合评价.................................................... 55
4.1软件能力.................................................... 55
4.1.1 功能性................................................ 55 4.1.2 易用性................................................ 55 4.1.3 可靠性................................................ 55 4.1.4 兼容性................................................ 55 4.1.5 安全性................................................ 55 4.2建议........................................................ 56
2
第1章 测试概述
1.1 编写目的
本报告为软件工程课程的大作业排课系统的测试报告，目的在于总结测试阶段的测试以及分析测试结果，找出系统存在的BUG，以期系统符合软件工程课程的大作业需求。
1.2 项目背景和简介
（1）排课表是一个学校日常教学工作和其他各项活动的指挥调度表。它不仅是学生和教师日常课程的依据，对学校其他工作的统一安排也有直接影响。高校排课工作是执行教学计划、实现学校培养目标的重要一环，是学校教学教务管理工作中最基本而又非常重要的一项，它是学校建立稳定的教学秩序的最根本的保证，是学校贯彻教育方针、培养合格人才的具体体现，并对学生的学习效果和课堂的教学质量有直接的影响。它不仅可以从侧面反映出学校领导的办学思想，也能体现出学校教育教学管理的能力和水平。
在高校的各项教学管理工作中，排课一直是最基本的、最重要的工作，其实质就是给教学计划中设置的课程安排合适的时间和地点，保证整个教学工作能够顺利的进行；同时，排课工作也是一项很复杂的工作，排课是一个NP问题，就是始终找不到一个最优的方法能够解决问题，因为这个问题涉及了多种因素进行组合规划，有教师、学生的因素，也有教室的因素。尤其在目前各高校规模不断扩大，教学资源面临紧张，教室总数不足的前提下，排课工作问题更为突出。
（2）随着计算机技术的飞速发展，特别是计算机的应用已普及到经济和社会生活的各个领域。使原本的旧的管理方法越来越不适应现在社会的发展，许多人还停留在以前的手工排课方法，这在很大程度制约了开学前的教学任务开展，降低了工作效率。为了适应现在社会人们高度强烈的时间观念，利用计算机实现高校排课系统势在必行，对于各大高校来说，利用计算机支持学校管理员排课，是适应现在学校的制度要求、推动学校管理走向科学化、系统化、规范化的必要
3
条件，从而达到提高高校管理效率的目的，给同学和老师带来方便。
（3）本系统使用JAVA语言，使用eclipse工具进行编写。
1.3 项目的产品规格说明书（Specification）
1.3.1 需求概述 目标：
（1）高校排课系统开发意图
高校扩招导致的课程量增大及排课数据量的加大，放大了原始手动排课的弊端。
通常采用手工的方法进行，这大大加大了手工劳动的工作量，而且影响排课效率，对于既定的课程，如果需要修改，往往需要花费很大的时间进行调整，所以需要一套可用的高校排课系统，使得排课系统效率化，方便随时的调整与更新。
（2）高校排课系统目标
本系统的目标在于根据所在学校的课程实际情况排课，提高学校排课的效率，方便学校对课程的编排和管理，减少排课的人力，根据教师和学生的需求排出满足多数人要求的课程表，提高学校教务信息化管理的程度。
1）短期目标
实现教师、教室、课程的管理排课冲突排除； 提升工作效率。 2）最终目标
实现教务管理信息化、网络化； .实现教学管理系统化； 实现学院管理信息化； 提升学院的管理竞争力；
为我校竞争进入全国前50强做贡献。 3）高校排课系统作用范围
高校排课系统的短期使用对象是软南大学软件学院，更进一步对象希望是应用到整个校园。
4）高校排课系统与其它软件关系
4
高校排课系统是一个独立的软件，可能需要与已有的软件系统存在数据共享与接口关系，其它内容全部自含。 运行环境：
软件环境：兼容当前主流的操作系统windows XP/7。
硬件环境：Pentium 4 3.0GHZ以上处理器，内存512MB以上。 用户的特点：
（1）操作人员
软件学院内部管理电脑化，操作人员有着丰富的计算机操作与管理的经验，能满足系统平台的建设并由此产生符合软件系统操作所要求的适应性和可操作性。
（2）维护人员
软件学院的专业教师、技术维护人员具备较高的软件开发水平，熟悉学院教学教务的业务流程，能够配合承担软件开发者提供最直接的业务和技术支持，能够独立维护系统出现的一些简单的问题。
（3）软件使用频度
高校排课系统作为高校期初必备的业务操作系统，因此使用频度将比较频繁，特别是排课过程与课程的调整过程将非常频繁的发生。 约束条件：
（1）开发时间
4个月，该系统的完成期限为2013年1月。 （2）系统运行寿命的最小值 系统运行寿命的最小值应为3年。 （3）法律和政策方面限制
该系统的开发和运行完全按照有关法律法规进行，绝不逾越。 （4）可利用的信息和资源
互联网上的相关的开源及免费资源和涉及该系统的算法，以及其他类似可参考的系统。
（5）时间特性要求
响应时间要求：对于管理人员输入的用户信息应该在人们所能接受的等待时
5
间来确定，通常为2-5 s。
更新处理时间要求：用户输入数据后，对于该操作人员输入的数据处理时间应该是毫秒级的。数据的转换和传输时间的要求也应该在人们的接受的等待时间内。
（6）灵活性
在设计界面结构和数据结构是应留有对以后扩充系统功能的余地，如可以在每个数据字段上设计多个自定义字段。
（7）输入输出要求
对输入的数据的输入媒体应是文字形式，若对于浮点类型的数来说，其数值范围应该进行约束。输入格式应与规定表的格式相对应，以减少输入格式的设计难度。 1.3.2 需求规格
软件系统对象结构如图1.1所示，总体功能如图1.2所示。
教务管理人员 管理数据 查询课表 编辑课表 打印机 打印信息 计算机 辅助排课系统
图1.1对象结构图
6
排课系统 课程资源操作 查看课表 打印课表 手动排课 课程资源录入 信息排列 课程资源删除 排课 冲突检查 冲突解决 课程信息录入 时间段信息录入 教室信息录入 教师信息录入 课程时间删除 时间段信息删除 教室信息删除 教师信息删除
图1.2总体功能图
描述约定：
数据字典（data dictionary）：有关对问题域重要的数据元素、结构和属性的定义的集合。
数据流图（data flow diagram）：一种分析模型，它描绘了过程、数据集合、端点、以及它们之间的流，这种流表现了业务过程或软件系统的行为特点。
实体-关系图（entity-relationship diagram）：一种分析模型，它确认了一对实体之间的逻辑关系。
业务规则（business rule）：定义或约束业务某些方面的政策、原则、标准
7
或规则。
用例（use case）：描述了执行者与系统之间逻辑上相关的可能交互集，系统的输出为执行者提供了价值。用例可以包含多个场景。
规格说明（specification）：将系统需求以结构化的、共享的和可管理的形式编写成文档的过程，同样，产品也要经过这一过程。 1.3.3 CSCI能力需求 系统总体功能描述：
项目小组开发的排课系统致力于通过对现有课程资源（教师资源、教室资源、时间段资源和课程资源）进行操作，系统对课表进行冲突检查，并通过人工对冲突的处理排出互不冲突的课表，课程资源子系统为排课子系统提供输入数据工期处理，因此，排课系统由课程资源子系统和手动排课子系统，另外，系统提供了附加功能：对生成课表的查看以及与外部打印机接口的交互实现课表的打印功能。
手动排课子系统：
手动排课系统是通过对课程资源子系统中各类资源的操作，人为对数据进行组合，系统对人为地组合数据进行冲突检查，最终排出无冲突的课表。
手动排课子系统功能包括排课、冲突检查和冲突解决模块，三大模块之间是紧密联系的。
排课模块：人为选择各类课程资源，并人为地自由组合，得到一个课表，但不能保证没有冲突。
冲突检查：一旦课表生成，系统就会对课表进行检查，并对冲突进行说明，系统中包含的冲突包含教室冲突、教师冲突、时间段冲突或三者之间的组合。
冲突解决：系统给出冲突状况，人为对课表进行修改。 查看课表子功能：
查看课表子功能是在课表经系统处理之后基本确定的前提下查看现有条件下的课表情况。课表表现形式以图表的形式体现。 打印课表子功能：
打印课表的子功能依赖于课表排好之后的课表，在此基础上可以打印出排好的课表（此项为可选实现）。
8
1.3.4 保密性需求
保密性是指不允许未经授权的用户存取数据。一般要求对用户的身份进行标
识与鉴别，并采取相应的存取控制策略以保证用户仅能访问授权数据，同一组数据的不同用户可以被赋予不同的存取权限。同时，还应能够对用户的访问操作进行跟踪和审计。此外，还应该控制用户通过推理的方式从经过授权的已知数据获取未经授权的数据，造成信息泄漏。
本系统已经针对此做了设计，而关键因素在于系统管理员能否保证数据库的安全同时数据库的存放也较为关键，不可让无关人员访问。
为防止人员、环境潜在的威胁，我们采用密码匹配的方法，对匹配次数进行限制。并在用户输入密码后，进行验证码匹配，同样对匹配次数进行限制。 采取的保密措施： 建立操作规程：
将操作过程或流程规范化，并形成指导运行管理人员工作的操作规程，操作规程作为正式文件处理。 操作过程记录
对运行管理人员按照操作规程执行的操作过程形成相关的记录文件，可能是日志文件，记录操作的时间和人员、正常或异常等信息。 安全事件上报
根据安全状态分析报告分析可能的安全事件，对接报的安全事件进行分析，明确安全事件等级、影响程度以及优先级等，按照安全事件报告程序上报安全事件，确定是否应对安全事件启动应急预案。 安全事件处置
对于应该启动应急预案的安全事件按照应急预案响应机制进行安全事件处置。对未知安全事件的处置，应根据安全事件的等级，制定安全事件处置方案，包括安全事件处置方法以及应采取的措施等；并按照安全事件处置流程和方案对安全事件进行处置。 安全事件总结和报告
一旦安全事件得到解决，对于未知的安全事件进行事件记录，分析记录信息并补充所需信息，使安全事件成为已知事件，并文档化；对安全事件处置过程进
9
行总结，制定安全事件处置报告，并保存。 1.3.5 CSCI环境需求 计算机硬件需求
该软件的计算机软件配置项CSCI运行的计算机硬件需求为： CPU：core i3或者以上配置 内存：1G或以上 显卡：显存512M或以上 计算机操作系统需求
该软件的计算机软件配置项CSCI运行的计算机操作系统需求为： 目前仅支持的操作系统为Windows平台，包括Windows XP/7。 1.3.6 计算机资源需求 计算机硬件需求
处理器：CPU core i3或以上配置 内部存储器：内存1G或以上 外部存储器：硬盘内存320G或以上
输入/输出设备：键盘、鼠标、显示器等基本设备 计算机软件需求
操作系统：Windows XP/Windows 7 数据库管理系统：Microsoft SQL Sever 2008 测试软件：findbugs-1.3.9 java (java代码检查工具) Meter Apache (基于java的压力测试工具) 开发软件：Eclipse -SDK-4.2
1.4 项目的设计文档
1.4.1课程资源操作子系统
课程资源子系统由四大模块构成，课程资源模块、教师资源模块、教室资源模块、时间段模块，功能上实现对各资源的录入、删除和信息排列功能。
10
1）课程资源模块
数据块包含课程的性质代号、课程代号、授课教师、学时等内容，课程性质代号是指课程所属的门类，课程代号是指课程的编号，授课教师采用标示其姓名的方式是课表更加直观，学时供排课者合理非配课时。
在数据操作上，一要实现对课程资源的录入，用户通过一定的录入渠道，录入课程资源的相关信息值，作为排课的资源信息，录入的资源要保存；二要实现对课程资源的删除，用户可以选择性的对录入的信息进行删除操作；另外，为方便用户查看，系统还要实现对所录入信息的排列，使信息更加直观。
2）教师资源模块
数据块包含教师的姓名，教师的代号和其职称，姓名属性更加直观，代号属性使数据处理更加方便。
数据操作上，一要实现对教师资源的录入；二要实现对教师资源的删除，用户可以选择性的对录入的信息进行删除操作；另外，为方便用户查看，系统还要实现对所录入信息的排列，使信息更加直观。
3）教室资源模块
数据块包含教室相关信息如教室编号和容量，教室编号提供了分配教室的惟一标识。
数据操作，一要实现对教室资源的录入；二要实现对教室资源的删除，用户可以选择性的对录入的信息进行删除操作；另外，为方便用户查看，系统还要实现对所录入信息的排列，使信息更加直观。
4）时间段资源模块
时间段资源用于人为定义该校的上课时间段，一要实现对时间段资源的录入；二要实现对时间段资源的删除，用户可以选择性的对录入的信息进行删除操作；另外，为方便用户查看，系统还要实现对所录入信息的排列，使信息更加直观。
由上面四个模块我们在分析后得到我们排课系统最终的功能构成模块，我们的排课系统可以对课程资源模块、教师资源模块、教室资源模块、时间段模块，功能上实现对各资源的录入、删除和信息排列功能。
课程资源子系统的功能构成图如图1.3所示。
11
课程资源操作 课程资源录入 信息排列 课程资源删除 课程信息录入 时间段信息录入 教室信息录入 教师信息录入 课程时间删除 时间段信息删除 教室信息删除 教师信息删除
图1.3 系统功能构成图
课程资源子系统中数据删除操作的流程图如图1.4所示。
开始 否 删除？ 是 资源查询 否 提示错误资源存在 是 删除数据 结束
图1.4 数据删除操作的流程图
12
1.5 测试范围
测试主要依据产品规格说明书和设计文档对系统进行测试，包括单元测试、集成测试、功能测试和系统测试，具体测试内容、测试目的和测试所用的工具和方法如表1.1所示。
表1.1 测试内容表
测试类型 单元测试 测试内容 1、 代码复杂度测试 2、 判断代码覆盖情况 集成测试 功能测试 测试目的 检验代码的复杂度及精简性 采用黑盒测试，进测试方法和工具 1、检验排课系统是否在排课系统能否完功能上能完成对于数据库内容的添加修改删除功能。 2、检验排课系统能否按照需求完成对于课程的安排。 成所需求的功能。 行手工测试 非功能性测试 代码的完整性，精简性 对代码的进一步完善 使用白盒测试 1.6 测试环境与配置
表1.2 测试环境及配置 资源名称/类型 测试PC 应用服务器 数据库管理系统 集成开发环境 代码检测工具 负载性能测试工具
13
配 置 Inter(R) Pentium(R) CPU P6000 @ 1.87GHz 1.87GHz SQL2000 eclipse JUnit单元测试工具；check Jmeter2.3.4
第2章 测试用例设计
2.1 单元测试
2.1.1代码复杂度测试
一个程序的代码复杂度越高则越容易出现错误并且难以维护，相反降低复杂度后程序易于维护，并且出现复杂错误的几率也会下降。
这里使用软件SourceMonitor检查sortclass项目内的代码复杂度。 用SourceMonitor载入项目后的结果如图2.1，图2.2所示：
图2.1 代码复杂度结果1
图2.2代码复杂度结果2
该项目的文件数为：47个 代码行数为：8891 纯代码行数：4751 分支比率为：9.4% 注释比率为：20.1% 最大复杂度为：25 最大深度为：8 平均深度为：2.31 平均复杂度为：2.20
Classroom类的度量细节如图2.3所示，可以查看到该类中各方法的复杂度，分支语句数，最大深度。从左下角的图中可知，该类的注释比率不达标。
14
图2.3 Classroom类的度量细节图
Conflict类的度量细节如图2.4所示，由图中所知该类的注释比率不够，其他比如平均复杂度，平均深度等都在标准范围内。
图2.4 Conflict类的度量细节图
15
Course类的度量细节如图2.5所示，由该图所知，该类的注释比率，方法与类的比都不符合标准，不过复杂度和深度都符合标准。
图2.5 Course类的度量细节图
SchedCourse类的度量细节如图2.6所示，从图中所知该类复杂度较高，平均深度也比较高，总体代码比较复杂。
图2.6 SchedCourse类的度量细节图
16
CRTime类的度量细节如图2.7所示，由图中所知该类的平均复杂度，平均深度等都符合标准，总体复杂度不高，但是注释量仍然不大。
图2.7 CRTime类图
2.1.2单元测试的用例设计
（1）测试代码流程图，如图2.8所示
图2.8 测试代码流程图
17
测试代码：
public boolean equals(Object obj) {
if (!(obj instanceof TimeSlot)) return false; TimeSlot slot2 = (TimeSlot) obj; boolean result = false; if (start.equals(slot2.start) && stop.equals(slot2.stop) &&
daysEqual(daysOfWeek, slot2.daysOfWeek)) return true; return false; }
（2）语句覆盖
语句覆盖保证程序中的每条语句至少能够执行一次，在所选的测试程序中有两个判定条件，为保证每条预计至少一次吗，保证①M为真（执行完即结束），②M为假，N为真，③M为假，N为假。语句覆盖代码： import static org.junit.Assert.*; import junit.framework.TestCase; import org.junit.Test;
public class StatementCoverage extends TestCase {
public void testEquals() throws CRTimeException {
boolean[] daysOfWeek1 = { false, false, true, false, false, false, false,
false };
CRTime crtimeStart1 = new CRTime(150); CRTime crtimeStart2 = new CRTime(0); CRTime crtimeEnd1 = new CRTime(220); CRTime crtimeEnd2 = new CRTime(200); TimeSlot
timeslot1
=
new
TimeSlot(daysOfWeek1,
crtimeStart1,
crtimeEnd1);
TimeSlot
crtimeEnd2);
18
timeslot2 = new TimeSlot(daysOfWeek1, crtimeStart2,
}
}
assertEquals(false, timeslot1.equals(crtimeEnd1)); assertEquals(true, timeslot1.equals(timeslot1)); assertEquals(false,timeslot1.equals(timeslot2));
public static void main(String [] args) { }
junit.textui.TestRunner.run(StatementCoverage.class);
得到结果，如图2.9所示。
图2.9 语句覆盖测试结果
（3）判定覆盖或分支覆盖
判定覆盖或分支覆盖保证程序中的每个分支至少执行一次，根据程序的流程图可知，程序代码有三个分支构成，因此需要三个测试用例。 import static org.junit.Assert.*; import junit.framework.TestCase; import org.junit.Test;
public class BranchCoverage extends TestCase {
public void testEquals() throws CRTimeException {
boolean[] daysOfWeek1 = { false, false, true, false, false, false, false,false }; CRTime crtimeStart1 = new CRTime(150); CRTime crtimeStart2 = new CRTime(0); CRTime crtimeEnd1 = new CRTime(220); CRTime crtimeEnd2 = new CRTime(200);
TimeSlot timeslot1 = new TimeSlot(daysOfWeek1, crtimeStart1,
19
crtimeEnd1);
TimeSlot timeslot2 = new TimeSlot(daysOfWeek1, crtimeStart2,
crtimeEnd2); }
结果如图2.10所示。
}
public static void main(String [] args) { }
junit.textui.TestRunner.run(BranchCoverage.class); assertEquals(false, timeslot1.equals(crtimeEnd1)); assertEquals(true, timeslot1.equals(timeslot1)); assertEquals(false,timeslot1.equals(timeslot2));
图2.10 判定覆盖或分支覆盖结果
（4）条件覆盖
条件覆盖保证当判定式中含有多个条件时，要求每个条件的取值均得到检验。 import static org.junit.Assert.*; import junit.framework.TestCase; import org.junit.Test;
public class ConditionCoverage extends TestCase {
public void testEquals() throws CRTimeException {
boolean[] daysOfWeek1 = { false, false, true, false, false, false, false,false }; boolean[] daysOfWeek2 = { false, false, false, true, false, false,
false,false };
CRTime crtimeStart1 = new CRTime(100); CRTime crtimeStart2 = new CRTime(50); CRTime crtimeEnd1 = new CRTime(210);
20
CRTime crtimeEnd2 = new CRTime(200); TimeSlot
timeslot1
=
new
TimeSlot(daysOfWeek1,
crtimeStart1,
crtimeEnd1);
TimeSlot timeslot2 = new TimeSlot(daysOfWeek2, crtimeStart2,
crtimeEnd2); }
结果如图2.11所示。
}
public static void main(String [] args) { }
junit.textui.TestRunner.run(ConditionCoverage.class); assertEquals(false, timeslot1.equals(crtimeEnd1)); assertEquals(true, timeslot1.equals(timeslot1)); assertEquals(false, timeslot1.equals(timeslot2));
图2.11条件覆盖结果
（5）判定-条件覆盖
判定-条件覆盖使得判定中每个条件的所有可能取值至少满足一次，同时使每个分支也至少执行一次。 import static org.junit.Assert.*; import junit.framework.TestCase; import org.junit.Test;
public class BranchConditionCoverage extends TestCase {
public void test() throws CRTimeException {
boolean[] daysOfWeek1 = { false, false, true, false, false, false, false,
false };
CRTime crtimeStart1 = new CRTime(150);
21
CRTime crtimeStart2 = new CRTime(60); CRTime crtimeEnd1 = new CRTime(220); CRTime crtimeEnd2 = new CRTime(200);
TimeSlot timeslot1 = new TimeSlot(daysOfWeek1, crtimeStart1,
crtimeEnd1);
TimeSlot timeslot2 = new TimeSlot(daysOfWeek1, crtimeStart2,
crtimeEnd2); }
结果如图2.12所示。
}
public static void main(String [] args) { }
junit.textui.TestRunner.run(BranchConditionCoverage.class); assertEquals(true, timeslot1.equals(timeslot1)); assertEquals(false, timeslot1.equals(crtimeEnd1)); assertEquals(false,timeslot1.equals(timeslot2));
图2.12判定-条件覆盖结果
（6）条件组合覆盖
条件组合覆盖使得每个条件表达式中的每个项的所有可能至少出现一次，且每个条件表达式的判定结果也至少出现一次。 import static org.junit.Assert.*; import junit.framework.TestCase; import org.junit.Test;
public class Conditioncombinationcoverage extends TestCase {
public void testEquals() throws CRTimeException {
boolean[] daysOfWeek1 = { false, false, true, false, false, false, false,false };
22
boolean[] daysOfWeek2 = { false, false, false,true, false, false, false,false }; CRTime crtimeStart1 = new CRTime(150); CRTime crtimeStart2 = new CRTime(0); CRTime crtimeEnd1 = new CRTime(220); CRTime crtimeEnd2 = new CRTime(200);
TimeSlot
timeslot1
=
new
TimeSlot(daysOfWeek1,
crtimeEnd1);
TimeSlot
timeslot2
=
new
TimeSlot(daysOfWeek2,
crtimeEnd1);
TimeSlot
timeslot3
=
new
TimeSlot(daysOfWeek1,
crtimeEnd2);
TimeSlot
timeslot4
=
new
TimeSlot(daysOfWeek2,
crtimeEnd2);
TimeSlot
timeslot5
=
new
TimeSlot(daysOfWeek1,
crtimeEnd1);
TimeSlot
timeslot6
=
new
TimeSlot(daysOfWeek2,
crtimeEnd1);
TimeSlot
timeslot7
=
new
TimeSlot(daysOfWeek1,
crtimeEnd2);
TimeSlot
timeslot8
=
new
TimeSlot(daysOfWeek2,
crtimeEnd2); assertEquals(false, timeslot1.equals(crtimeEnd1)); assertEquals(true, timeslot1.equals(timeslot1)); assertEquals(false, timeslot1.equals(timeslot2)); assertEquals(false, timeslot1.equals(timeslot3)); assertEquals(false, timeslot1.equals(timeslot4)); assertEquals(false, timeslot1.equals(timeslot5)); assertEquals(false, timeslot1.equals(timeslot6)); assertEquals(false, timeslot1.equals(timeslot7));
assertEquals(false, timeslot1.equals(timeslot8));
23
crtimeStart1,
crtimeStart1,
crtimeStart1,
crtimeStart1,
crtimeStart2,
crtimeStart2,
crtimeStart2,
crtimeStart2,
}
}
public static void main(String [] args) { }
junit.textui.TestRunner.run(Conditioncombinationcoverage.class);
结果如图2.13所示。
图2.13条件组合覆盖结果
（7）路径覆盖
径覆盖保证程序中的所有路径至少执行一次。在该段程序代码中共有三条路径。 import static org.junit.Assert.*; import junit.framework.TestCase; import org.junit.Test;
public class PathCoverage extends TestCase {
public void testEquals() throws CRTimeException {
boolean[] daysOfWeek1 = { false, false, true, false, false, false, false,
false };
CRTime crtimeStart1 = new CRTime(150); CRTime crtimeStart2 = new CRTime(100); CRTime crtimeEnd1 = new CRTime(190); CRTime crtimeEnd2 = new CRTime(200);
TimeSlot timeslot1 = new TimeSlot(daysOfWeek1, crtimeStart1,
crtimeEnd1);
TimeSlot timeslot2 = new TimeSlot(daysOfWeek1, crtimeStart2,
crtimeEnd2);
assertEquals(false, timeslot1.equals(crtimeEnd1));
24
}
}
assertEquals(true, timeslot1.equals(timeslot1)); assertEquals(false,timeslot1.equals(timeslot2));
public static void main(String [] args){ }
junit.textui.TestRunner.run(PathCoverage.class);
结果如图2.14所示：
图2.14路径覆盖结果
（8）黑盒测试
接下来是对程序中的几个类进行单元测试 1）Classroom类的测试： package resources;
import junit.framework.TestCase;
public class TestClassroom extends TestCase {
Classroom classroom = new Classroom(\"格物楼\public final void testgetCapacity() { }
public final void testgetBuilding() { }
public final void testgetRoomName() { }
public final void testequals() {
25
this.assertEquals(100, classroom.getCapacity());
this.assertEquals(\"格物楼\
this.assertEquals(\"1101\
}
}
Classroom classroom1 = new Classroom(\"格物楼his.assertEquals(true, classroom.equals(classroom1));
public final void testcompareTo() { }
public static void main(String[] args) { }
junit.textui.TestRunner.run(TestClassroom.class);
Classroom classroom2 = new Classroom(\"格物楼his.assertEquals(0, classroom.compareTo(classroom2));
2）Conflict类的测试： package resources;
import junit.framework.TestCase;
public class TestConflict extends TestCase { }
26
private SchedCourse sched1, sched2;
Conflict conflict = new Conflict(sched1, sched2, 3); public final void testgetReason() { }
public final void testgetSched1() { }
public final void testgetSched2() { }
public static void main(String[] args) { }
junit.textui.TestRunner.run(TestConflict.class); this.assertEquals(sched2, conflict.getSched2()); this.assertEquals(sched1, conflict.getSched1()); this.assertEquals(3, conflict.getReason());
3）Course类的测试： package resources;
import junit.framework.TestCase; public class TestCourse extends TestCase {
Course course = new Course(\"Field\
\"sectionPrefix\
public final void testcomperTo() { }
public final void testequals() { }
public final void testgetCourseName() { }
public final void testgetCourseNumber() { }
public final void testgetCreditHours() { }
public final void testgetField() { }
public final void testgetIsScheduled() {
this.assertEquals(false, course.getIsScheduled());
27
Course course1 = new Course(\"Field\
\"sectionPrefix\
this.assertEquals(0, course.compareTo(course1));
Course course2 = new Course(\"Field\
\"sectionPrefix\
this.assertEquals(true, course.equals(course2));
this.assertEquals(\"courseName\
this.assertEquals(\"CourseNumber\
this.assertEquals(5, course.getCreditHours());
this.assertEquals(\"Field\
}
}
public final void testgetSectionNumber() { }
public final void testgetSectionString() { }
public final void testtoString() { }
public static void main(String[] args) { }
junit.textui.TestRunner.run(TestCourse.class);
this.assertEquals(\"FieldCourseNumber courseNamehis.assertEquals(\"sectionPrefix-3his.assertEquals(3, course.getSectionNumber());
4）CRTime类的测试： package resources;
import junit.framework.TestCase;
public class TestCRTime extends TestCase { }
5）DialogCellEditor类的测试： package resources; import javax.swing.JButton; import javax.swing.JTable;
28
public final void testequals() { }
try {
CRTime crtime = new CRTime(900);
} catch (Exception e) { }
System.out.println(e);
import junit.framework.TestCase;
public class TestDialogCellEditor extends TestCase { }
6）Professor类的测试： package resources;
import junit.framework.TestCase;
public class TestProfessor extends TestCase {
Professor
professor
=
new
Professor(\"王建磊\
\"111101\
private String value; private JButton component; private JTable table;
DialogCellEditor dialogCellEditor = new DialogCellEditor(); public final void testgetCellEditorValue() { }
public final void testshouldSelectCell() { }
public static void main(String[] args) { }
junit.textui.TestRunner.run(TestDialogCellEditor.class); this.assertEquals(false, dialogCellEditor.shouldSelectCell(null)); this.assertEquals(\"点击编辑\
Professor.PROFESSOR);
public final void testgetId() { }
public final void testgetName() { }
public final void testgerStatus() {
this.assertEquals(Professor.PROFESSOR, professor.getStatus());
29
this.assertEquals(\"111101\
this.assertEquals(\"王建磊\
}
}
public final void testcompareTo() { }
public final void testequals() { }
public static void main(String[] args) { }
junit.textui.TestRunner.run(TestProfessor.class);
Professor professor2 = new Professor(\"王建磊\
Professor.PROFESSOR);
Professor professor1 = new Professor(\"王建磊\
Professor.PROFESSOR);
this.assertEquals(0, professor.compareTo(professor1));
this.assertEquals(true, professor.equals(professor2));
7）ProfessorSummary类测试： package resources;
import junit.framework.TestCase;
public class TestProfessorSummary extends TestCase {
private Professor professor;
ProfessorSummary professorSummary = new ProfessorSummary(professor); public final void testgetCreditHours() { }
public final void testgetProfessor() { }
public final void testgetSections() { }
30
this.assertEquals(0, professorSummary.getCreditHours());
this.assertEquals(professor, professorSummary.getProfessor());
this.assertEquals(0, professorSummary.getSections());
\ }
public final void testtoString() {
professor = new Professor(\"王建磊\professorSummary = new ProfessorSummary(professor);
this.assertEquals(\"王建磊 0 0
}
professorSummary.toString());
public static void main(String[] args) { }
junit.textui.TestRunner.run(TestProfessorSummary.class);
8）SchedCourse类的测试： package resources;
import junit.framework.TestCase;
public class TestSchedCourse extends TestCase {
private Professor professor; private Classroom classroom; private Course course; private TimeSlot timeSlot; private Conflict conflict = null; private String note = \"\";
SchedCourse schedCourse = new SchedCourse(professor, classroom, course,
timeSlot);
public final void testgetClassroom() { }
public final void testgetConflict() { }
public final void testgetCourse() {
31
this.assertEquals(classroom, schedCourse.getClassroom());
this.assertEquals(null, schedCourse.getConflict());
}
this.assertEquals(course, schedCourse.getCourse());
public final void testgetNote() { }
public final void testgetProfessor() { }
public final void testgetTimeSlot() { }
public final void testvoerlao() { }
public final void testtoString() {
Professor colin = new Professor(\"liming\Classroom room = new Classroom(\"力行楼\
Course course = new Course(\"1\
32
this.assertEquals(professor, schedCourse.getProfessor());
this.assertEquals(timeSlot, schedCourse.getTimeSlot());
Professor colin = new Professor(\"liming\Classroom room = new Classroom(\"力行楼\
Course course = new Course(\"1\CRTime start = null, stop = null;
boolean days[] = { false, false, true, false, true, true, true, false }; try {
start = new CRTime(299); stop = new CRTime(350);
} catch (CRTimeException crtE) { }
TimeSlot slot = new TimeSlot(days, start, stop);
SchedCourse schedCourse = new SchedCourse(colin, room, course, slot); this.assertEquals(true, schedCourse.overlap(schedCourse));
System.out.println(crtE);
CRTime start = null, stop = null;
boolean days[] = { false, false, true, false, true, true, true, false }; try {
start = new CRTime(299); stop = new CRTime(350);
} catch (CRTimeException crtE) { }
TimeSlot slot = new TimeSlot(days, start, stop);
SchedCourse schedCourse = new SchedCourse(colin, room, course, slot); this.assertEquals(
System.out.println(crtE);
\"12700 Intro to Java星期五11:59am-12:50pm 力行楼1129(60) liming \
schedCourse.toString());
}
9）TimeSlot类的测试： package resources;
import junit.framework.TestCase;
public class TestTimeSlot extends TestCase {
private String[] day = { \"\星期天\星期一\星期二\星期三\星期四\}
public static void main(String[] args) { }
junit.textui.TestRunner.run(TestSchedCourse.class);
\"星期五\星期六\" };
private boolean[] daysOfWeek; private CRTime start, stop; public final void testcompareTo() {
boolean days[] = { false, false, true, false, true, true, true, false }; try {
start = new CRTime(299);
33
}
stop = new CRTime(350);
} catch (CRTimeException crtE) { }
TimeSlot timeSlot = new TimeSlot(days, start, stop); TimeSlot timeSlot1 = new TimeSlot(days, start, stop); this.assertEquals(0, timeSlot.compareTo(timeSlot1));
System.out.println(crtE);
public final void testequals() { }
public final void testgetDaysOfWeek() {
boolean days[] = { false, false, true, false, true, true, true, false }; try {
start = new CRTime(299); stop = new CRTime(350);
boolean days[] = { false, false, true, false, true, true, true, false }; try {
start = new CRTime(299); stop = new CRTime(350);
} catch (CRTimeException crtE) { }
TimeSlot timeSlot = new TimeSlot(days, start, stop); TimeSlot timeSlot2 = new TimeSlot(days, start, stop); this.assertEquals(true, timeSlot.equals(timeSlot2));
System.out.println(crtE);
} catch (CRTimeException crtE) { }
TimeSlot timeSlot = new TimeSlot(days, start, stop); this.assertEquals(days, timeSlot.getDaysOfWeek());
34
System.out.println(crtE);
}
public final void testgetMinutes() { }
public final void testgetStartTime() { }
public final void testoverlap() {
boolean days[] = { false, false, true, false, true, true, true, false }; try {
start = new CRTime(299); stop = new CRTime(350);
boolean days[] = { false, false, true, false, true, true, true, false }; try {
start = new CRTime(299); stop = new CRTime(350);
boolean days[] = { false, false, true, false, true, true, true, false }; try {
start = new CRTime(299); stop = new CRTime(350);
} catch (CRTimeException crtE) { }
TimeSlot timeSlot = new TimeSlot(days, start, stop); this.assertEquals(51, timeSlot.getMinutes());
System.out.println(crtE);
} catch (CRTimeException crtE) { }
TimeSlot timeSlot = new TimeSlot(days, start, stop); this.assertEquals(start, timeSlot.getStartTime());
System.out.println(crtE);
} catch (CRTimeException crtE) {
System.out.println(crtE);
35
}
}
TimeSlot timeSlot = new TimeSlot(days, start, stop); TimeSlot timeSlot3 = new TimeSlot(days, start, stop); this.assertEquals(true, timeSlot.overlap(timeSlot3));
public final void testtoDaysString() { }
public final void testtoString() { }
public final void testtoTimeString() {
boolean days[] = { false, false, true, false, true, true, true, false }; try {
36
boolean days[] = { false, false, true, false, true, true, true, false }; try {
start = new CRTime(299); stop = new CRTime(350);
} catch (CRTimeException crtE) { }
TimeSlot timeSlot = new TimeSlot(days, start, stop); this.assertEquals(\"星期五\
System.out.println(crtE);
boolean days[] = { false, false, true, false, true, true, true, false }; try {
start = new CRTime(299); stop = new CRTime(350);
} catch (CRTimeException crtE) { }
TimeSlot timeSlot = new TimeSlot(days, start, stop);
this.assertEquals(\"星期五 11:59am-12:50pm\
System.out.println(crtE);
}
}
start = new CRTime(299); stop = new CRTime(350);
} catch (CRTimeException crtE) { }
TimeSlot timeSlot = new TimeSlot(days, start, stop);
this.assertEquals(\"11:59am-12:50pm\
System.out.println(crtE);
public static void main(String[] args) { }
junit.textui.TestRunner.run(TestTimeSlot.class);
2.2 集成测试的用例设计
（1）测试场景
SchedCourse类和Professor类、Classroom类、Course类、TimeSlot类的集成。 （2）我们采用的测试方法是自底向上的测试方法。模块关系如图2.15所示。
图2.15 模块关系图
（3）测试用例 测试代码：
public class Driver_SchedCourse {
private static Professor professor; private static Professor professor2;
37
private static Classroom classroom; private static Classroom classroom2; private static Course course; private static Course course2; private static TimeSlot timeSlot; private static TimeSlot timeSlot2;
private static boolean days[] = { false, false, true, false, true, true,
true, false };
public static void main(String[] args) {
try {
CRTime start = new CRTime(299); CRTime stop = new CRTime(300); timeSlot = new TimeSlot(days, start, stop); timeSlot2 = new TimeSlot(days, start, stop);
} catch (CRTimeException e) { }
professor = new Professor(\"陈凤强\professor2 = new Professor(\"陈凤强\classroom = new Classroom(\"格物楼\classroom2 = new Classroom(\"格物楼\
course = new Course(\"1\程序设计\course2 = new Course(\"1\程序设计\SchedCourse schedCourse1 = new SchedCourse(professor, classroom,
course, timeSlot);
// TODO 自动生成的 catch 块 e.printStackTrace();
SchedCourse schedCourse2 = new SchedCourse(professor, classroom,
course, timeSlot);
System.out.println(schedCourse1.getProfessor().toString()); System.out.println(schedCourse1.getClassroom().toString());
38
System.out.println(schedCourse1.getCourse().toString()); System.out.println(schedCourse1.getTimeSlot().toString()); if (professor.compareTo(professor2) == 0) {
System.out
.println(\"\\nThe method named compareTo of the class Professor
is OK\");
} else {
System.out
.println(\"The method named compareTo of the class Professor is
WRONG\");
}
if (professor.equals(professor2) == true) {
System.out
.println(\"The method named equal of the class Professor is
OK\");
} else {
System.out
.println(\"The method named equal of the class Professor is
WRONG\");
}// 驱动测试compareTo函数
if (classroom.compareTo(classroom2) == 0) {
System.out
.println(\"\\nThe method named compareTo of the class
Classroom is OK\");
} else {
System.out
.println(\"The method named compareTo of the class Classroom
is WRONG\");
}// 驱动测试equal()函数
if (classroom.equals(classroom2) == true) {
39
System.out
.println(\"The method named equals of the class Classroom is
OK\");
} else {
System.out
.println(\"The method named equals of the class Classroom is
WRONG\");
}// 驱动测试toString()函数
if (classroom.toString().equals(\"格物楼1101(80)\")) {
System.out
.println(\"The method named toString of the class Classroom is
OK\");
} else {
System.out
.println(\"The method named toString of the class Classroom is
WRONG\");
}// 驱动测试compareTo函数 if (course.compareTo(course2) == 0) {
System.out
.println(\"\\nThe method named compareTo of the class Course is
OK\");
} else {
System.out
.println(\"The method named compareTo of the class Course is
WRONG\");
}// 驱动测试equal函数
if (course.equals(course2) == true) {
System.out
.println(\"The method named equal of the class Course is OK\");
} else {
40
System.out
.println(\"The method named equal of the class Course is
WRONG\");
}// 驱动测试toString函数
if (course.toString().equals(\"1 201201120053 Java程序设计\")) {
System.out
.println(\"The method named toString of the class Course is
OK\");
} else {
System.out
.println(\"The method named toString of the class Course is
WRONG\");
}
if (timeSlot.compareTo(timeSlot2) == 0) {
System.out
.println(\"\\nThe method named compareTo of the class TimeSlot
is OK\");
} else {
System.out
.println(\"The method named compareTo of the class TimeSlot is
WRONG\");
}
if (timeSlot.equals(timeSlot2) == true) {
System.out
.println(\"The method named equal of the class TimeSlot is
OK\");
} else {
System.out
.println(\"The method named equal of the class TimeSlot is
WRONG\");
41
}
if (timeSlot.toString().equals(\"星期五 11:59am-12:00am\")) {
System.out
.println(\"The method named toString of the class TimeSlot is
OK\");
} else {
System.out
.println(\"The method named toString of the class TimeSlot is
WRONG\");
}
if (schedCourse1.compareTo(schedCourse2) == 0) {
System.out
.println(\"\\nThe method named compareTo of the class
SchedCourse is OK\");
} else {
System.out
.println(\"The method named compareTo of the class
SchedCourset is WRONG\");
}
if (schedCourse1
.toString()
.equals(\"1 201201120053 Java程序设计 星期五
11:59am-12:00am 格物楼1101(80) 陈凤强 \")) {
System.out
.println(\"The method named toString of the class SchedCourse
is OK\");
} else {
System.out
.println(\"The method named toString of the class SchedCourse
42
is WRONG\"); }
}
}
2.3 功能测试的用例设计
2.3.1教师资源模块
增加教师操作及结果如表2.1所示：
表2.1 增加教师操作测试结果
输入
姓名 王建磊 ABCDEFJHIJKLMN
mdigdgseg45';'';
'
阿斯达发送方
Linda
教师代号 111110 20101120270 110100203 sdfgcsfegs29283
2012jsm
教授/讲师 讲师 教授 讲师 讲师 教授
操作 结果 成功 成功 成功 成功 成功
测试报告：
添加教师操作基本的功能都能实现，姓名输入框，对于中文名、英文名都能接受，教师代号输入框对于报告数字、英文字符和特殊符号也都能接受，单选框教授和讲师都能正确的插入到相应的教师信息表中。然而，教师输入框和教师代后输入框并没有规定相应的有效输入范围。 删除教师操作：
对于选中的行，删除所选教师都能将相应的教师从教师信息框中删除。 例如：选中Linda教师行。
43
图2.16 选择教师表格中的Linda记录
点击“删除所选教师”，结果如图2.17所示。
图2.17 删除所选教师结果
Linda教师的信息已经从教师信息栏中删除。 测试报告：
“删除教师操作”能完成删除教师的功能。 2.3.2教室信息录入功能 增加教师操作：
增加教师信息表如表2.2所示：
表2.2 增加教室测试结果
输入
教学楼
sdfsf 格物楼 力行楼 &*ssnf2 格物楼
教室 dssdfs 1101 1201s S1212 1101
容量 sfs 900 -1 10000 900
操作结果 成功（容量变为0）
成功 成功 成功 成功
测试报告：
“增加教师”操作能完成相应的功能，但是对于输入的数据没有相应的限制，而且两次输入相同的信息，都能正确的插入到教室信息表中。
44
图2.18 添加教室测试结果
删除所选教室操作：
选中信息“格物楼 1101 900”，如图2.19所示。
图2.19 选中教室表中的某条记录
点击“删除所选教室”结果：
图2.20删除所选教室结果
该教室信息已经被删除。 测试报告：
删除教师信息操作能完成相应的功能。 2.3.3时间段信息录入功能 时间段信息表如表2.3所示：
表2.3 时间段信息表
45
输入
星期 一
一二三四 五六七 四 五 二 天 五
开始 9:02am 8:00am 6:70am 6:30am 6:59am 7:00am 12:00am
结束 8:02am 8:45am 8:00am 7:15am 7:45am 7:45am 2:00pm
操作结果
成功
失败(正能插入周六的一条记
录)
分钟溢出
失败（7点之前无课） 失败（7点之前无课）
成功 成功
测试报告：
增加时间段操作虽然能完成其相应的操作，但是对于一些非法输入没有进行处理，造成一些非法输入，系统还能接收，星期复选框并没有实现复选框的功能。 删除时间段操作：
选中信息“星期天 9:02am 8:02am”。
图2.21选中时间段表中的某条记录
点击删除时间段操作：
图2.22删除所选时间段结果
相应信息已经被删除。 测试报告：
删除时间段按钮能完成相应的操作。 2.3.4课程信息录入功能
表2.4 增加课程信息表
46
输入
课程性质代号
1 2
S 1 10
课程代号 20120053 20120000 mfies 20120054 789&*（
课程名称 C
JAVA程序设计 马克思基本原理概论
算法设计与分析 软件测试
学分 3 4 10 -1 -1
时间段代号 1 2 1
时间段数量
1 3
10
操作结果
成功
成功（三条记录） 成功 成功 失败
增加课程信息表如表2.4所示： 测试报告：
课程信息录入功能，能完成其相应操作，但是时间段数量对应着插入的课程
记录条数，这样将会使课程信息表格中充满冗余的记录。 删除课程操作： 选择某条信息如图：
图2.23选中课程信息表中的某条记录
点击“删除课程”。
图2.24删除所选课程记录结果
47
课程信息已经被删除。 测试报告：
删除课程操作能完成相应的操作。
2.4 非功能测试的用例设计
软件兼容性测试：
我们对于排课系统的软件进行了多种系统的操作运行，我们找到了使用Windows7系统 Windows8 系统，并且每个系统找到了多台PC进行测试，所使用的软件都为Eclipse。
部分测试机信息如图2.25 图2.26 图2.27所示
图2.25 windows7系统测试机
48
图2.26 windows8系统测试机
图2.27 windows7系统测试机
测试结果：
经过不同PC测试机进行测试，所有功能均可正常实现，但是在Eclipse不同版本之间仍存在无法通用的问题，并且在JDK版本不同的测试机上要将JDK都统一为开发PC所使用的JDK版本，否则将不能正常运行。 但将JDK同意并将Eclipse版本统一后，软件均可正常运行。
49
第3章 测试总结
3.1 测试用例执行结果
3.1.1黑盒测试中对于类的测试结果 接下来是对程序中的几个类进行单元测试
图3.1 Classroom类的测试
图3.2 Conflict类的测试
图3.3 Course类的测试
50
图3.4 CRTime类的测试
图3.5 DialogCellEditor类的测试
图3.6 Professor类的测试
图3.7 ProfessorSummary类测试
51
图3.8 SchedCourse类的测试
图3.9 TimeSlot类的测试
测试结果总结：
经过对上述几个类进行测试，我们可以的得到所测类的代码执行情况与预期结果相一致，代码运行正确。 3.2.2集成测试结果 测试结果：
The method named compareTo of the class Professor is OK The method named equal of the class Professor is OK The method named compareTo of the class Classroom is OK The method named equals of the class Classroom is OK
52
The method named toString of the class Classroom is OK The method named compareTo of the class Course is OK The method named equal of the class Course is OK The method named toString of the class Course is OK The method named compareTo of the class TimeSlot is OK The method named equal of the class TimeSlot is OK The method named toString of the class TimeSlot is OK The method named compareTo of the class SchedCourse is OK The method named toString of the class SchedCourse is OK
图3.10 集成测试结果
测试结果：集成测试所得结果与预期相一致，且检查代码并无错误，程序可以正常执行。
3.2 测试问题解决
我们经过对我们排课系统这个软件的测试，得到下面几个问题： （1） 代码复杂度较高 （2） 命名不规范
53
（3） 测试人员经常变换 （4） 测试程度较浅 （5） 没有足够多的测试次数
但由于时间与人员问题，我们的测试问题并未得到解决，我们争取在接下来的时间完善对于本系统的测试。 3.3 测试结果分析 测试结果总结：
经过对上述几个类进行测试，我们可以的得到所测类的代码执行情况与预期结果相一致，代码运行正确。集成测试所得结果与预期相一致，且检查代码并无错误，程序可以正常执行。
经过对测试结果的观察分析，我们得到：测试与预期结果大致相符，但还在测试中出现了许多问题，我们将会在以后的时间对这些问题逐步进行改进。
54
第4章 综合评价
4.1软件能力
4.1.1 功能性
该排课系统正确实现了课程信息的录入，对录入的课程信息进行手动排课处理，能从不同的角度查看课表的内容，实现了友好的用户界面。利用图表形象而直观的实现了对教师信息、教室信息、时间段信息和课程信息的管理操作，并提供了课表和视图的打印功能，可以将课表和视图信息打印出来更为直观的方便用户对课表信息进行相应的查看和修改。另外，系统还专门为课表信息创建了一种新的文件，只能由本系统识别和使用，增加了信息的安全性。 4.1.2 易用性
现有系统实现了如下易用性：查询，添加，删除，修改操作相关提示信息的一致性，可理解性 。 4.1.3 可靠性
现有系统的可靠性较高。无论从文件系统的可靠性和JAVA程序的可靠性考虑，都有较高的可靠性。该系统独有的文件系统，使得其他软件或系统不能读取其中的数据，因此该系统的可靠性比较高。 4.1.4 兼容性
现有系统支持window下的JAVA环境运行，兼容性良好。 现有系统未进行其他兼容性测试。 4.1.5 安全性
由于软件由JAVA语言编写，继承了JAVA语言的安全性。
55
4.2建议
该排课系统能对学院级别的课程进行排课处理，如果课程的规模再大一些就凸显出这个排课系统一些致命的缺点：操作太过复杂，手动录入教师信息、教室信息、时间段信息和课程信息工作量大而且繁杂等。我们软件测试小组对这个方面给出的建议是：简化排课系统的操作，最好根据录入的课程资源实现自动排课，在自动排课得到相应的课表后，再对课表进行相应的调整。
在课程资源录入模块，该排课系统虽然能很好的接收相应的信息，但是也一并接收了错误的信息，并没有对不合法的信息进行拒绝接收的处理，导致用户在输入了不合法的信息后，系统能像接收合法信息和数据那样将不合法的信息和数据一并接收，这样用户就不能及时地发现错误的输入信息并及时的处理，到最后排课的时候会造成很大的麻烦。我们软件测试小组对这个方面给出的建议是：对用户输入的信息和数据进行合法性验证，在验证通过后接收该条信息和数据，验证未通过时给出用户相应的提示，使得用户能及时的处理。
56
因篇幅问题不能全部显示，请点此查看更多更全内容