享受每一天,Just Enjoy !

0%

1.生成器
  • Generator是一个用于创建迭代器的简单而强大的工具。 它们的写法类似标准的函数

    2.创建生成器的两中方法
    (一)yield 编写生成器函数,函数的返回值就是生成器
  • 承接上文迭代器,还是用游戏中的英雄技能举例子

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    #!/usr/bin/python

    def hero(*skills):
    print('英雄的释放技能分别如下')
    for release_skill in skills:
    yield release_skill


    skill = hero('一骑当千','单刀赴会','青龙偃月','刀锋铁骑')
    for s in skill:
    print(s)
  • hero函数中传入英雄的1-4技能

  • 来看一下运行结果

    1
    2
    3
    4
    5
    6
    (yiluo) ➜  Code python hero.py
    英雄的释放技能分别如下
    一骑当千
    单刀赴会
    青龙偃月
    刀锋铁骑
  • 这样使用比迭代器的好处是,生成器不会像迭代器放在内存中,是用户传入数值动态生成的

    (二)生成器表达式
  • 另一种创建生成器的方式就是通过表达式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    (yiluo) ➜  Code python3
    Python 3.7.5 (default, Nov 29 2019, 14:32:46)
    [Clang 9.0.0 (clang-900.0.39.2)] on darwin
    Type "help", "copyright", "credits" or "license" for more information.
    >>> s = (x+x for x in range(0,4))
    >>> s
    <generator object <genexpr> at 0x1058537d0>
    >>> for x in s:
    ... print(x)
    ...
    0
    2
    4
    6
  • s 就是生成器,然后遍历查看结果

    ……待续

    在这里插入图片描述

    享受每一天,Just Enjoy !

关注公众号获取更多内容

1.迭代器
  • 大多数容器对象都可以使用 for 语句,承接上文装饰器的例子,还是拿英雄的技能举例子
  • 王者荣耀中英雄关羽的技能有一骑当千 单刀赴会 青龙偃月 刀锋铁骑for语句分别迭代出1-4技能
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    (yiluo) ➜  Code python3
    Python 3.7.5 (default, Nov 29 2019, 14:32:46)
    [Clang 9.0.0 (clang-900.0.39.2)] on darwin
    Type "help", "copyright", "credits" or "license" for more information.
    >>> skills = ['一骑当千','单刀赴会','青龙偃月','刀锋铁骑']
    >>> for skill in skills:
    ... print(skill)
    ...
    一骑当千
    单刀赴会
    青龙偃月
    刀锋铁骑
  • 在幕后,for 语句会调用容器对象中的 iter()。 该函数返回一个定义了 __next__() 方法的迭代器对象,该方法将逐一访问容器中的元素
  • 我们现在利用一下 iter()函数 和 next()函数
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    >>> skills = ['一骑当千','单刀赴会','青龙偃月','刀锋铁骑']
    >>> skill = iter(skills)
    >>> print(skill)
    <list_iterator object at 0x1037ea5d0>
    >>> next(skill)
    '一骑当千'
    >>> next(skill)
    '单刀赴会'
    >>> next(skill)
    '青龙偃月'
    >>> next(skill)
    '刀锋铁骑'
    >>> next(skill)
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    StopIteration
  • skill就是迭代器
  • next迭代到没有值的时候就会报错
    在这里插入图片描述

    享受每一天,Just Enjoy !

关注公众号获取更多内容

1.装饰器定义
  • 装饰器本质上是一个函数,可以接受一个函数作为参数
    2.装饰器简单的例子
  • 承接之前的内容,英雄释放火焰技能。打印出英雄释放技能的时间
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #!/usr/bin/python
    from datetime import datetime

    def release_skills(hero):
    def release_skill(*skill, **skills):
    print(datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
    return hero(*skill, **skills)
    return release_skill


    @release_skills
    def hero(name, skill):
    return (name + '-->'+'释放技能:'+ skill)


    print(hero('关羽', 'fire'))
    print(hero.__name__)
  • 如上,release_skills装饰器负责打印释放技能的时间
    1
    2
    3
    4
    (yiluo) ➜  Code python hero.py
    2019-12-12 11:11:49
    关羽-->释放技能:fire
    release_skill
  • 我们运行hero函数的时候,同时打印出了英雄释放火焰技能的时间
  • 可是我们发现了一个比较严重的问题,hero 函数应变成了release_skill函数了,看上面的代码,确实hero已经被release_skill改变了
  • 那如何解决这个被改变的问题呢? 总不能用完装饰器,被装饰的函数已经不是之前的函数吧,还好Python 提供了方法解决这个问题
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    #!/usr/bin/python
    from datetime import datetime
    from functools import wraps

    def release_skills(hero):
    @wraps(hero)
    def release_skill(*skill, **skills):
    print(datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
    return hero(*skill, **skills)
    return release_skill


    @release_skills
    def hero(name, skill):
    return (name + '-->'+'释放技能:'+ skill)


    print(hero('关羽', 'fire'))
    print(hero.__name__)
  • 上面的代码用到了wraps(),然后我们运行一下看下结果函数是否被改变
    1
    2
    3
    4
    (yiluo) ➜  Code python hero.py
    2019-12-12 11:25:38
    关羽-->释放技能:fire
    hero
  • 函数依旧是hero,看来是完美解决了这个问题
  • @Python 提供的语法糖,语法糖指计算机语言中添加的某种语法,这种语法对语言的功能并没有影响,但是更方便程序员使用
    3.带参数的装饰器(……待续)
    在这里插入图片描述

    享受每一天,Just Enjoy !

关注公众号获取更多内容

软件测试用例设计

1.测试用例的主要构成元素
  • 测试用例的基本要素包括:测试用例编号、测试标题、重要级别、测试数据输入、操作步骤、预期结果,实际结果
  • 测试用例是软件测试团队的主要工作成果之一
  • 测试用例的质量与写该用例的测试人员的水平关系极大
  • 执行测试用例:当一个软件版本被测试时,测试人员会使用一整套的测试用例(或者筛选其中的一部分),将这些用例逐个在被测的软件上执行,并判断其结果是否和预期相符,并以此评价软件版本的质量
    2.测试用例设计需要注意

    1.用语简洁清晰,但不能过于简单

2.用语无歧义,尽量少用过长的句子
3.用例的各个基本要素要齐备,不能缺失
4.用例的步骤应该足够详细 ,操作应该明确
5.容易被其它测试工程师读懂 ,并能顺利执行

3.如何设计测试用例
  • 等价类
  • 边界值
  • 场景法
  • 错误推测法
  • 因果图
  • 正交试验法
    4. 测试用例的粒度

    1.粒度,指的是粗细 程度。粒度大,就是说一个用例所涵盖的关注内容比较多 ,反之同理

2.用例的粒度大,则总的用例数就少,用例看起来也简洁
3.用例的粒度小,则单条用例关注的测试点很集中,不容易遗漏,并且执行需要的时间比较好估计

5. 测试用例的整合
  • 优秀的测试用例写作者,具有的是灵活发散的思维,和全面的视野,写出的用例套能保证涉及软件运行时的各个关键要点,在执行完这样的用例并且没有发现问题,我们就可以对软件的质量下一个良好的结论
    ……待续
    在这里插入图片描述

    享受每一天,Just Enjoy !

关注公众号获取更多内容

1.Selenium介绍
2.Selenium的安装
1
2
3
4
5
6
(yiluo) ➜  ~ pip install selenium
Collecting selenium
Using cached https://files.pythonhosted.org/packages/80/d6/4294f0b4bce4de0abf13e17190289f9d0613b0a44e5dd6a7f5ca98459853/selenium-3.141.0-py2.py3-none-any.whl
Requirement already satisfied: urllib3 in ./yiluo/lib/python3.7/site-packages (from selenium) (1.25.7)
Installing collected packages: selenium
Successfully installed selenium-3.141.0
3.安装谷歌浏览器驱动
4.简单的尝试打开简书
1
2
3
4
5
6
7
8
9
#!/usr/bin/python3

import time
from selenium import webdriver

driver = webdriver.Chrome()
driver.get('https://www.jianshu.com/u/3c9531339206')
time.sleep(3)
driver.close()
1
(yiluo) ➜  Code python web.py

自动打开的网页

6.定位元素的一些方式

id
name
class name
tag name
link text
partial link text
xpath
css selector
######7. Python webdriver 中的使用方法

find_element_by_id()
find_element_by_name()
find_element_by_class_name()
find_element_by_tag_name()
find_element_by_link_text()
find_element_by_partial_link_text()
find_element_by_xpath()
find_element_by_css_selector()

8.实例软件测试网站Testerhome的登陆脚本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#!/usr/bin/python3

from selenium import webdriver
from time import sleep


driver = webdriver.Chrome()

driver.get("https://testerhome.com/")
# 放大窗口
driver.maximize_window()
sleep(3)

# 进入登陆页面
driver.find_element_by_xpath('//*[@id="main-page"]/div[1]/nav/div/ul[1]/li[2]/a').click()

sleep(3)

# 输入账号
driver.find_element_by_id('user_login').send_keys('你的账户')
# 输入密码
driver.find_element_by_id('user_password').send_keys('你的密码')
# 点击登陆按钮
driver.find_element_by_xpath('//*[@id="new_user"]/div[4]/input').click()

sleep(3)
# 关闭窗口
driver.close()

登陆成功

……待续


在这里插入图片描述

享受每一天,Just Enjoy !

关注公众号获取更多内容

1.测试方案的目的
  • 所以测试方案目的是: 在方向上明确要测什么、怎么测,以及达到什么样质量标准
  • 软件测试方案有助于软件项目成员理解和执行测试过程中的各项活动,同时测试方案也有助于测试活动的管理
    2.测试计划和测试方案的区别
  • 测试方案需要在测试计划的指导下进行,测试计划提出“做什么”,而测试方案明确“怎么做”
    3.如何编写有效的测试方案
  • 测试需求分析
  • 测试策略
  • 测试资源
  • 测试进度计划
  • 风险管理
  • 质量

4. 测试需求分析
  • 测试需求分析就是把产品需求和对用户的理解(用户体验)转化、分解成测试功能 点,产品需求是我们测试需求主要输入,但不是全部,我们还需要仔细分析产品设计说明,可以产出更多可测试的功能点(这些功能点往往没有包含在产品需求 中)。还要加入对性能、安全、接口和回归测试范围分析。测试需求是确定测试进度计划和资源的主要依据
  • 评估风险并确定测试优先级
    5.测试策略
  • 制定测试策略
  • 测试进度计划
    根据测试需求和策略,结合项目优先级和测试资源情况,评估测试进度计划
    6.测试类型

    测试类型
    功能测试
    界面测试
    安全测试
    数据库测试
    可靠性测试
    集成测试
    兼容性测试
    自动化测试
    性能测试
    回归测试

    …..待续
    在这里插入图片描述

    享受每一天,Just Enjoy !

关注公众号获取更多内容

1.私有属性和方法
  • Python 在属性方法名前添加 __两个下划线 __)来拒绝外部的访问
  • 两个下划线是设置私有属性/方法的标准样式, 还有一种设置私有属性/方法的样式,就是在属性/方法名字前加一个下划线_ 但是其实这样的私有属性/方法只仅仅是视为不能直接访问,但是实际上还是可以访问的
    2.类属性,类方法
    类属性类方法是可以直接使用类访问,不需要实例化
  • 类属性
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    >>> class Hero(object):
    ... skill = 'fire'
    ... def __init__(self, name):
    ... self._name = name
    ...
    >>> Hero.skill
    'fire'
    >>> xiangyu= Hero('项羽')
    >>> xiangyu.skill
    'fire'

    1.创建一个英雄类

2.英雄的技能是火焰
3.初始化英雄的名字
4.实例一个英雄
5.调用英雄的技能属性

  • 类方法
    类方法用装饰器 @classmethod装饰,类方法中可以访问类属性
    类方法的第一个参数传入的是类对象,而不是实例对象,约定俗成的,类方法中要指代类对象本身都使用 cls
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    >>> class Hero(object):
    ... skill = 'fire'
    ... def __init__(self, name):
    ... self._name = name
    ... @classmethod
    ... def get_skill(cls):
    ... return cls.skill
    ...
    >>> Hero.get_skill()
    'fire'
    >>> liubei = Hero('刘备')
    >>> liubei._name
    '刘备'
    >>> liubei.get_skill()
    'fire'

    1.不需要实例化就可以调用

  • 静态方法
    静态方法用装饰器 @staticmethod 装饰,和 @classmethod 有点类似。静态方法在运行时不需要实例的参与,并且也不需要传递cls
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #!/usr/bin/python3

    class Hero(object):
    skill = 'fire'
    def __init__(self, name):
    self._name = name
    @staticmethod
    def release_skills():
    print(guanyu._name + ' ' +'释放技能' + ': '+ Hero.skill)

    guanyu = Hero('关羽')
    Hero.release_skills()

    1.静态方法 ,英雄释放技能

2.不需要实例化直接释放火焰技能

1
2
(yiluo) ➜  Code python test.py
关羽 释放技能: fire

3.property 装饰器

@property 装饰器可以将一个方法变成一个属性来使用,通过 @property 装饰器可以获得和修改对象的某一个属性

@property 表示只读
@property 和 @.setter 表示可读可写
@property、@
.setter、和 @.deleter 表示可读可写可删除
@property 必须定义在 @
.setter 的前面
类必须继承 object 父类,否则 @property 不会生效

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#!/usr/bin/python3

class Hero(object):
skill = 'fire'
def __init__(self, name):
self._name = name
@property
def name(self):
return self._name
@name.setter
def name(self, value):
if isinstance(value, str):
self._name = value
else:
raise ValueError
@name.deleter
def name(self):
print('del name')
del self._name


liubei = Hero('刘备')
print(liubei.name)
liubei.name = '关羽'
print(liubei.name)
liubei.name = 100
1
2
3
4
5
6
7
8
9
(yiluo) ➜  Code python test.py
刘备
关羽
Traceback (most recent call last):
File "test.py", line 26, in <module>
liubei.name = 100
File "test.py", line 15, in name
raise ValueError
ValueError

1.这样的好处是可以在方法中对用户传入的数据进行校验(校验了英雄名称是字符串)

  • 删除英雄
    1
    2
    3
    4
    5
    6
    liubei = Hero('刘备')
    print(liubei.name)
    liubei.name = '关羽'
    print(liubei.name)
    del liubei.name
    print(liubei.name)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    (yiluo) ➜  Code python test.py
    刘备
    关羽
    删除名字
    Traceback (most recent call last):
    File "test.py", line 27, in <module>
    print(liubei.name)
    File "test.py", line 9, in name
    return self._name
    AttributeError: 'Hero' object has no attribute '_name'

    1.英雄已经被成功删除

    ……待续
    在这里插入图片描述

    享受每一天,Just Enjoy !

关注公众号获取更多内容

1. 面向对象编程简介

面向对象程序设计(英语:Object-oriented programming,缩写:OOP)是种具有对象概念的程序编程典范,同时也是一种程序开发的抽象方针。它可能包含数据属性代码方法。对象则指的是的实例。它将对象作为程序的基本单元,将程序和数据封装其中,以提高软件的重用性、灵活性和扩展性,对象里的程序可以访问及经常修改对象相关连的数据。在面向对象程序编程里,计算机程序会被设计成彼此相关的对象(引自维基百科)

2.面向对象4个核心概念
  • 抽象

  • 封装

  • 继承

  • 多态

    3.类的定义
  • 类和对象
    面向对象的两个基本概念实例,而实例是根据类创建出来的一个个具体的“对象”,一个类中既会定义属性,也会定义方法

  • 类的命名规则遵循大驼峰命名法:每个单词的第一个字母都大写,私有类使用下划线开头

    1
    2
    3
    4
    5
    6
    class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>
  • 下面定义一个People的类,并且实例化为student

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    >>> class People():
    ... pass
    ...
    >>> student = People()
    >>> print(student)
    <__main__.People object at 0x10e1796d0>
    >>> People()
    <__main__.People object at 0x10e179750>
    >>> People
    <class '__main__.People'>
    >>> student.name = 'yiluo'
    >>> student.name
    'yiluo'
  • 0x10e1796d0为内存地址

  • 实例方法
    Python 中只要新建一个类就会自动创建它的内置类方法属性,可以通过 dir(类名)查看

    1
    2
    3
    4
    5
    >>> class People():
    ... pass
    ...
    >>> dir(People)
    ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
  • 其中最常用的是 __init__ 方法,它可以对实例进行初始化设置(类的内置方法前后各有两个下划线 _,简称:“双下划线”)

  • 下面重新写一个类并初始化名字

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    (yiluo) ➜  Code touch people.py
    (yiluo) ➜ Code vim people.py
    #!/usr/bin/python3

    class People():
    def __init__(self):
    self.name = 'yiluo'


    student = People()
    print(student.name)
  • 执行文件打印出了名字

    1
    2
    (yiluo) ➜  Code python people.py
    yiluo
  • 类中的函数通常称作方法,self所指的是就是实例本身,下面修改下类中的属性,也就是年龄

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    #!/usr/bin/python3

    class People():
    def __init__(self, name):
    self.name = name
    self.age = '20'

    student = People('yiluo')
    print(student.name)
    student.age = '18'
    print(student.age)
  • 年龄被修改为了18岁

    1
    2
    3
    (yiluo) ➜  Code python people.py
    yiluo
    18
  • __repr__ 来格式化实例的打印格式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #!/usr/bin/python3

    class People():
    def __init__(self, name, age):
    self.name = name
    self.age = age

    def __repr__(self):
    return 'Student: {}'.format(self.name)


    student = People('yiluo', 20)
    print(student.name)
    print(student.age)
    print(student)
  • 格式化打印输出

    1
    2
    3
    4
    (yiluo) ➜  Code python people.py
    yiluo
    20
    Student:yiluo

    在这里插入图片描述

4.类的封装

面向对象的语言中,封装就是用类将数据基于数据的操作封装在一起,隐藏内部数据,对外提供公共的访问

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#!/usr/bin/python3

class People():
def __init__(self, name, age):
self._name = name
self._age = age

def get_name(self):
return self._name

def get_age(self):
return self._age

def set_name(self, name):
self._name = name

def set_age(self, age):
self._age = age

def score(self, score):
print('姓名:{}'.format(self.get_name()) + ' '+ '年龄:{}'.format(self.get_age())+ ' ' + '得分:{}'.format(score) )

# 创建实例对象student
student = People('yiluo', '20')
student.get_name()
student.get_age()
student.score('98')

#重新设置名字和年龄
student.set_name('luoyi')
student.set_age('19')

#重新获得名字和年龄
student.get_name()
student.get_age()
student.score('99')
  • Python 的私有属性用一个或两个下划线开头表示,一个下划线表示外部调用者不应该直接调用这个属性,但其实还是可以调用的; 如果是两个下划线就不能调用
  • 执行一下,看下结果
    1
    2
    3
    (yiluo) ➜  Code python people.py
    姓名:yiluo 年龄:20 得分:98
    姓名:luoyi 年龄:19 得分:99
    5.类的继承与方法重写
  • 继承分为两种:单继承多继承单继承是指子类只继承于一个父类,相应的多继承是指子类继承于多个父类
  • 单继承方法重写
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    #!/usr/bin/python3

    class People(object):
    def __init__(self, name, age):
    self._name = name
    self._age = age

    def get_name(self):
    return self._name

    def get_age(self):
    return self._age

    def set_name(self, name):
    self._name = name

    def set_age(self, age):
    self._age = age

    def title(self):
    pass


    class Student(People):
    def title(self):
    print('姓名{}'.format(self.get_name()) + ' ' + '年龄{}'.format(self.get_age()) + ' ' + '职业:学生')


    class Teacher(People):
    def title(self):
    print('姓名{}'.format(self.get_name()) + ' ' + '年龄{}'.format(self.get_age()) + ' ' + '职业:教师')


    student = Student('yiluo', '20')
    teacher = Teacher('luoyi', '19')
    student.title()
1
2
3
(yiluo) ➜  Code python people.py
姓名yiluo 年龄20 职业:学生
姓名luoyi 年龄19 职业:教师
  • 所谓重写父类的方法就是指:在子类中定义和父类同名的方法,那么子类中的该方法就会覆盖掉父类中对应的方法
    6.类的多继承
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    class Name():
    def __init__(self):
    self.name = 'yiluo'
    def demo1(self):
    print('打印名字')

    class Age():
    def __init__(self):
    self.age = 20
    def demo2(self):
    print('打印年龄')


    class Somebody(Name, Age):
    def __init__(self):
    Name.__init__(self)
    Age.__init__(self)
    def demo3(self):
    print('打印某人')

    somebody = Somebody()
    print(somebody.name)
    print(somebody.age)
    somebody.demo1()
    somebody.demo2()
    somebody.demo3()
    1
    2
    3
    4
    5
    6
    yiluo) ➜  Code python demo.py
    yiluo
    20
    打印名字
    打印年龄
    打印某人
    7.多态
    多态就是使用同一方法对不同对象可以产生不同的结果
    …..待续
    在这里插入图片描述

    享受每一天,Just Enjoy!

关注公众号获取更多内容

1.测试计划

1.什么是测试计划
测试人员能够了解整个项目测试情况以及项目测试不同阶段的所要进行的工作

2.测试计划谁来编写
具有丰富经验的项目测试负责人

2.测试计划的定义

被测试项目的背景、目标、范围、方式、资源、进度安排、测试组织、测试执行进入与退出标准、本测试计划的审批与变更方式,以及与测试有关的风险等方面

3.制定测试计划
  • 认真做好测试资料的搜集整理工作
  • 明确测试的目标增强测试计划实用性
  • 坚持“5W”规则,明确内容过程
  • 采用评审和更新机制,保证测试计划满足实际需求
    4.测试计划包含内容
  • 测试环境
    包括:软件+硬件+网络+数据准备+测试工具
    测试环境是测试人员为进行软件测试而搭建的环境
  • 硬件环境,软件环境
  • 测试开始,测试结束条件
  • 测试进度跟踪
  • 测试风险解决
    确定测试需求,风险评估,确定测试对象优先级,确定测试对象优先顺序
    …….待续

    享受每一天,Just Enjoy !

    在这里插入图片描述
    关注公众号获取更多内容

1.软件测试流程
  • 测试需求分析
  • 编写测试计划
  • 编写测试方案
  • 测试用例设计
  • 执行测试,提交缺陷
  • 编写测试报告
2.软件测试简要流程

开始,测试设计,设计评审,测试执行,修复问题,回归测试,测试结束

3.测试需求分析
  • 什么是测试需求

    1.测试需求主要解决“测什么”的问题 ,用来识别什么内容是需要进行测试的

2.测试需求通常是以软件开发需求为基础进行分析,通过对开发需求的细化和分解,形成可测试的内容
3.测试需求应全部覆盖已定义的业务流程,以及功能和非功能方面的需求,不需要实际的数据出现

  • 测试需求来自哪里

    1.业务需求
    2.功能内部逻辑(需求规格说明书)

3.MRD(市场需求文档)
4.技术设计方案

4.测试需求分析
  • 需求采集
  • 测试需求分析
  • 测试需求评审
5.测试要点分析

1.测试要点是对原始测试需求表每一条开发需求的细化和分解,形成的可测试的分层描述的软件需求
2.通过分析每条开发需求描述中的输入、输出、处理、限制、约束等,给出对应的验证内容
3.通过分析各个功能模块之间的业务顺序,和各个功能模块之间传递的信息和数据(功能交互分析) 对存在功能交互的功能项,给出对应的验证内容

……待续

享受每一天,Just Enjoy !

在这里插入图片描述
关注公众号获取更多内容