• 【Web UI自动化测试】Web UI自动化测试之日志收集篇(全网最全)

    本文大纲截图：

     

    1、日志介绍【文末免费分享自动化测试学习资源】

    日志： 用于记录系统运行时的信息，对一个事件的记录，也称为Log。

    日志作用：

    • 1）调试程序

    • 2）了解系统程序运行的情况是否正常

    • 3）系统程序运行故障分析与问题定位

    • 4）用来做用户行为分析和数据统计

    日志级别：

    日志级别：指日志信息的优先级、重要性或者严重程度。

    常见的日志级别： DEBUG、INFO、WARNING、ERROR、CRITICAL

    • DEBUG：调试级别，打印非常详细的日志信息，通常用于对代码的调试

    • INFO：信息级别，打印一般的日志信息，突出强调程序的运行过程

    • WARNING：警告级别，打印警告日志信息，表明会出现潜在错误的情形，一般不影响软件的正常使用

    • ERROR：错误级别，打印错误异常信息，该级别的错误可能会导致系统的一些功能无法正常使用

    • CRITICAL：严重错误级别，一个严重的错误，这表明系统可能无法继续运行

    • 代码示例：

    1. import logging
    2.  
    3.  
    4. logging.debug("这是一条调试信息")
    5. logging.info("这是一条普通信息")
    6. logging.warning("这是一条警告信息")
    7. logging.error("这是一条错误信息")
    8. logging.critical("这是一条严重错误信息")

    说明：

    • 1）上面列表中的日志级别是从上到下依次升高的，即：DEBUG < INFO < WARNING < ERROR < CRITICAL；

    • 2）当为程序指定一个日志级别后，程序会记录所有日志级别大于或等于指定日志级别的日志信息，而不是仅仅记 录指定级别的日志信息；

    • 3）一般般建议只使用DEBUG、INFO、WARNING、ERROR这四个级别。

    2、日志用法

    2.1 基本用法

    设置日志级别：

    • 默认：logging中默认的日志级别为WARNING，程序中大于等于该级别的日志才能输出，小于该级别的日志不会被打印出来。

    • 格式：logging.basicConfig(level=logging.DEBUG)

    • 如何选择日志级别？

      • 开发环境和测试环境：为了尽可能详细的查看程序的运行状态来保证上线后的稳定性，可以使用DEBUG或INFO级别的日志获取详细的日志信息，这是非常耗费机器性能的。

      • 生产环境：通常只记录程序的异常信息、错误信息等（设置成WARNING或ERROR级别），这样既可以 减小服务器的I/O压力，也可以提高获取错误日志信息的效率和方便问题的排查。

    设置日志格式：

    • 默认的日志的格式为：format=日志级别:Logger名称:日志内容

    • format参数中的格式化信息

    • 自定义日志格式：logging.basicConfig(format="%(levelname)s:%(name)s:%(message)s")

    代码示例：

    1. import logging
    2.  
    3. fmt = '%(asctime)s %(levelname)s [%(name)s] [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s'
    4. logging.basicConfig(level=logging.INFO, format=fmt)
    5.  
    6. logging.debug("调试")
    7. logging.info("信息")
    8. logging.warning("警告")
    9. logging.error("错误")

    将日志信息输出到文件中

    • 默认情况下Python的logging模块将日志打印到了标准输出中（控制台）

    • 格式：logging.basicConfig(filename="a.log")

    • 代码：

    1. import logging
    2.  
    3. fmt = '%(asctime)s %(levelname)s [%(name)s] [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s'
    4. logging.basicConfig(filename="a.log", level=logging.INFO, format=fmt)
    5.  
    6. logging.debug("调试")
    7. logging.info("信息")
    8. logging.warning("警告")
    9. logging.error("错误")

    2.2 高级用法

    logging日志模块四大组件: Logger、Handler、Formatter、Filter

    • Logger： 日志器，提供了程序使用日志的入口

    • Handler： 处理器，将logger创建的日志记录发送到合适的目的输出

    • Formatter： 格式器，决定日志记录的最终输出格式

    • Filter： 过滤器，提供了更细粒度的控制工具来决定输出哪条日志记录，丢弃哪条日志记录

    组件关系：

    • 日志器（logger）需要通过处理器（handler）将日志信息输出到目标位置，如：文件、sys.stdout、网络等；

    • 不同的处理器（handler）可以将日志输出到不同的位置；

    • 日志器（logger）可以设置多个处理器（handler）将同一条日志记录输出到不同的位置；

    • 每个处理器（handler）都可以设置自己的格式器（formatter）实现同一条日志以不同的格式输出到不同的地 方；

    • 每个处理器（handler）都可以设置自己的过滤器（filter）实现日志过滤，从而只保留感兴趣的日志。

    Logger类：

    • Logger对象的任务：向程序暴露记录日志的方法；基于日志级别或Filter对象来决定要对哪些日志进行后续处理；将日志消息传送给所有感兴趣的日志handlers

    • 创建Logger对象：

      • 格式一：logger = logging.getLogger()，返回root日志器对象

      • 格式二：logger = logging.getLogger("myLogger")，返回myLogger日志器对象

      • 说明：logging.getLogger()方法有一个可选参数name，该参数表示将要返回的日志器的名称标识，如果不提供该参数，则 返回root日志器对象。若以相同的name参数值多次调用getLogger()方法，将会返回指向同一个logger对象的引用。

    Logger常用的方法：

    • 打印日志：

      • logger.debug()

      • logger.info()

      • logger.warning()

      • logger.error()

      • logger.critical()

    • 设置日志级别：logger.setLevel()，设置日志器将会处理的日志消息的最低严重级别

    • 添加handler对象：logger.addHandler()，为该logger对象添加一个handler对象

    • 添加filter对象：logger.addFilter()，为该logger对象添加一个filter对象

    Handler类：

    • Handler对象的作用：将消息分发到handler指定的位置，比如：控制台、文件、网络、邮件等。Logger对象可以 通过addHandler()方法为自己添加多个handler对象。

    • 创建Handler对象：在程序中不应该直接实例化和使用Handler实例，因为Handler是一个基类，它只定义了Handler应该有的接口。应该使用Handler实现类来创建对象

    • 常用的Handler：

      • logging.StreamHandler：将日志消息发送到输出到Stream，如std.out, std.err或任何 file-like对象。

      • logging.FileHandler：将日志消息发送到磁盘文件，默认情况下文件大小会无限增长

      • logging.handlers.RotatingFileHandler：将日志消息发送到磁盘文件，并支持日志文件按大小切割

      • logging.hanlders.TimedRotatingFileHandler：将日志消息发送到磁盘文件，并支持日志文件按时间切割

      • logging.handlers.HTTPHandler：将日志消息以GET或POST的方式发送给一个HTTP服务器

      • logging.handlers.SMTPHandler：将日志消息发送给一个指定的email地址

    • Handler常用的方法：

      • handler.setLevel()：设置handler将会处理的日志消息的最低严重级别

      • handler.setFormatter()：为handler设置一个格式器对象

      • handler.addFilter()：为handler添加一个过滤器对象

    Formatter类：

    • Formatter对象作用：Formatter对象用于配置日志信息的格式。

    • 创建Formatter对象：formatter = logging.Formatter(fmt=None, datefmt=None, style='%')

    • 说明：

      • fmt：指定消息格式化字符串，如果不指定该参数则默认使用message的原始值

      • datefmt：指定日期格式字符串，如果不指定该参数则默认使用"%Y-%m-%d %H:%M:%S"

      • style：Python 3.2新增的参数，可取值为 '%', '{'和 '$'，如果不指定该参数则默认使用'%'

    将日志信息同时输出到控制台和文件中：

    • 步骤：

      • 1）创建日志器对象

      • 2）创建控制台处理器对象

      • 3）创建文件处理器对象

      • 4）创建格式化器对象

      • 5）把格式化器添加到处理器中

      • 6）把处理器添加到日志器中

    • 定义日志格式：

    1. # 设置日志格式
    2. fmt = '%(asctime)s %(levelname)s [%(name)s] [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s'
    3. # 创建格式化器对象
    4. formatter = logging.Formatter(fmt)

    • 把日志输出到控制台：

    1. logger = logging.getLogger()
    2. sh = logging.StreamHandler()
    3. sh.setFormatter(formatter)
    4. logger.addHandler(sh)

    • 把日志输出到文件中：

    1. fh = logging.FileHandler("./b.log")
    2. fh.setFormatter(formatter)
    3. logger.addHandler(fh)

    每日生成一个日志文件：

    • 定义Handler对象

    1. fh = logging.handlers.TimedRotatingFileHandler(filename, when='h', interval=1, backupCount=0)
    2.     # 将日志信息记录到文件中，以特定的时间间隔切换日志文件。
    3.     # filename: 日志文件名
    4.     # when: 时间单位，可选参数
    5.     #     S - Seconds
    6.     #     M - Minutes
    7.     #     H - Hours
    8.     #     D - Days
    9.     #     midnight - roll over at midnight
    10.     #     W{0-6} - roll over on a certain day; 0 - Monday
    11.     # interval: 时间间隔
    12.     # backupCount: 日志文件备份数量。
    13.     #     如果backupCount大于0，那么当生成新的日志文件时，将只保留backupCount个文件，删除最老的文件。

    • 示例代码：

    1. import logging.handlers
    2.  
    3.  
    4. logger = logging.getLogger()
    5. logger.setLevel(logging.DEBUG)
    6.  
    7. # 日志格式
    8. fmt = "%(asctime)s %(levelname)s [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s"
    9. formatter = logging.Formatter(fmt)
    10.  
    11. # 输出到文件，每日一个文件
    12. fh = logging.handlers.TimedRotatingFileHandler("./a.log", when='MIDNIGHT', interval=1, backupCount=3)
    13. fh.setFormatter(formatter)
    14. fh.setLevel(logging.INFO)
    15. logger.addHandler(fh)

    日志封装成工具（tools）：

    • 定义日志器方法，封装日志

    1. # 导包
    2. import logging.handlers
    3.  
    4.  
    5. # 定义日志器方法 ，封装日志
    6. def get_logger():
    7.     # 获取 日志器logger,并设置名称admin
    8.     logger = logging.getLogger("admin")
    9.     # 设置日志级别为info
    10.     logger.setLevel(logging.INFO)
    11.     # 获取 控制台处理器
    12.     sh = logging.StreamHandler()
    13.     # 获取 文件处理器,根据时间分割
    14.     th = logging.handlers.TimedRotatingFileHandler(filename="../log/logger.log", when="S",  interval=1, backupCount=2, encoding="utf-8")
    15.     # 设置 文件处理器 日志级别
    16.     th.setLevel(logging.ERROR)
    17.     # 获取 格式器
    18.     fmt = "%(asctime)s %(levelname)s [%(name)s] [%(filename)s (%(funcName)s %(lineno)d)] - %(message)s"
    19.     fm = logging.Formatter(fmt)
    20.     # 将 格式器 添加到 处理器中
    21.     sh.setFormatter(fm)
    22.     th.setFormatter(fm)
    23.     # 将 处理器 添加到 日志器中
    24.     logger.addHandler(sh)
    25.     logger.addHandler(th)
    26.     # 返回 logger
    27.     return logger
    28.  
    29.  
    30. if __name__ == '__main__':
    31.     logger = get_logger()
    32.     # 日志器应用
    33.     logger.info("这是info信息")
    34.     logger.warning("这是warning信息")
    35.     logger.error("这是error信息")

    3、日志应用

    日志应用：PO模式中，在base操作层、page对象层、scripts业务层都可添加日志，以及将日志用单例模式封装成工具类放在tools文件夹中。

    • base（在操作层文件中添加日志），以公共方法封装文件 base.py 为例

    • 代码示例：

    1. import time
    2. from time import sleep
    3. from selenium.webdriver.support.wait import WebDriverWait
    4. from day11_tpshop import page
    5. from day11_tpshop.base.get_logger import GetLogger
    6.  
    7. # 获取log日志器
    8. log = GetLogger().get_logger()
    9.  
    10.  
    11. class Base:
    12.     def __init__(self, driver):
    13.         log.info("[base:]正在获取初始化driver对象：{}".format(driver))
    14.         self.driver = driver
    15.  
    16.     # 查找元素方法 封装
    17.     def base_find(self, loc, timeout=30, poll=0.5):
    18.         log.info("[base]:正在定位：{}元素，默认定位超时时间为：{}".format(loc, timeout))
    19.         # 使用显式等待 查找元素
    20.         return WebDriverWait(self.driver,
    21.                              timeout=timeout,
    22.                              poll_frequency=poll).until(lambda x: x.find_element(*loc))
    23.  
    24.     # 点击元素方法 封装
    25.     def base_click(self, loc):
    26.         log.info("[base]:正在对：{}元素执行点击事件".format(loc))
    27.         self.base_find(loc).click()
    28.  
    29.     # 输入元素方法 封装
    30.     def base_input(self, loc, value):
    31.         log.info("[base]:正在获取：{}元素".format(loc))
    32.         # 获取元素
    33.         el = self.base_find(loc)
    34.         log.info("[base]:正在对：{}元素执行清空操作".format(loc))
    35.         # 输入前 清空
    36.         el.clear()
    37.         log.info("[base]:正在给{}元素输入内容：{}".format(loc, value))
    38.         # 输入
    39.         el.send_keys(value)
    40.  
    41.     # 获取文本信息方法 封装
    42.     def base_get_text(self, loc):
    43.         log.info("[base]:正在获取{}元素文本值".format(loc))
    44.         return self.base_find(loc).text
    45.  
    46.     # 截图方法 封装
    47.     def base_get_img(self):
    48.         log.info("[base]:断言出错，调用截图")
    49.         self.driver.get_screenshot_as_file("../image/{}.png".format(time.strftime("%Y_%m_%d %H_%M_%S")))
    50.  
    51.     # 判断元素是否存在方法 封装
    52.     def base_elememt_is_exist(self, loc):
    53.         try:
    54.             self.base_find(loc, timeout=2)
    55.             log.info("[base]:{}元素查找成功，存在页面".format(loc))
    56.             return True  # 代表元素存在
    57.         except:
    58.             log.info("[base]:{}元素查找失败，不存在当前页面".format(loc))
    59.             return False  # 代表元素不存在
    60.  
    61.     # 回到首页（购物车、下订单、支付）都需要用到此方法
    62.     def base_index(self):
    63.         # 暂停2秒
    64.         sleep(2)
    65.         log.info("[base]:正在打开首页")
    66.         self.driver.get(page.URL)
    67.  
    68.     # 切到frame表单方法 以元素属性切换
    69.     def base_switch_frame(self, element):
    70.         log.info("[base]:正在切换到frame表单")
    71.         self.driver.switch_to.frame(element)
    72.  
    73.     # 回到默认目录方法
    74.     def base_default_content(self):
    75.         log.info("[base]:正在返回默认目录")
    76.         self.driver.switch_to.default_content()
    77.  
    78.     # 切换窗口方法
    79.     def base_switch_to_window(self, title):
    80.         log.info("正在执行切换title值为：{}窗口".format(title))
    81.         self.base_get_title_handle(title)
    82.         # self.driver.switch_to.window(self.base_get_title_handle(title))
    83.  
    84.     # 获取指定title页面的handle方法
    85.     def base_get_title_handle(self, title):
    86.         # 获取当前页面所有的handles
    87.         handles = self.driver.window_handles
    88.         # 遍历handle
    89.         for handle in handles:
    90.             log.info("正在遍历handles：{}-->{}".format(handle, handles))
    91.             # 切换 handle
    92.             self.driver.switch_to.window(handle)
    93.             log.info("切换：{}窗口".format(handle))
    94.             # 获取当前页面title 并判断 是否等于 指定参数title
    95.             log.info("条件成立！返回当前handle{}".format(handle))
    96.             if self.driver.title == title:
    97.                 # 返回 handle
    98.                 return handle

    • page（在对象层文件中添加日志）：以登录为例，page_login.py

    • 代码示例：

    1. from day11_tpshop import page
    2. from day11_tpshop.base.base import Base
    3. from day11_tpshop.base.get_logger import GetLogger
    4.  
    5. # 获取log日志器
    6. log = GetLogger().get_logger()
    7.  
    8.  
    9. class PageLogin(Base):
    10.     # 点击 登录链接
    11.     def page_click_login_link(self):
    12.         log.info("[page_login]:执行{}元素点击链接操作".format(page.login_link))
    13.         self.base_click(page.login_link)
    14.  
    15.     # 输入用户名
    16.     def page_input_username(self, username):
    17.         log.info("[page_login]:对{}元素 输入用户名{}操作".format(page.login_username, username))
    18.         self.base_input(page.login_username, username)
    19.  
    20.     # 输入密码
    21.     def page_input_pwd(self, pwd):
    22.         log.info("[page_login]:对{}元素 输入密码{}操作".format(page.login_pwd, pwd))
    23.         self.base_input(page.login_pwd, pwd)
    24.  
    25.     # 输入验证码
    26.     def page_input_verify_code(self, verify_code):
    27.         log.info("[page_login]:对{}元素 输入验证码{}操作".format(page.login_verify_code, verify_code))
    28.         self.base_input(page.login_verify_code, verify_code)
    29.  
    30.     # 点击 登录
    31.     def page_click_login_btn(self):
    32.         log.info("[page_login]:执行{}元素点击操作".format(page.login_btn))
    33.         self.base_click(page.login_btn)
    34.  
    35.     # 获取 错误提示信息
    36.     def page_get_err_info(self):
    37.         return self.base_get_text(page.login_err_info)
    38.  
    39.     # 点击 错误提示框 确定按钮
    40.     def page_click_error_alert(self):
    41.         log.info("[page_login]:执行{}元素点击操作".format(page.login_err_ok_btn))
    42.         self.base_click(page.login_err_ok_btn)
    43.  
    44.     # 判断是否登录成功
    45.     def page_if_login_success(self):
    46.         # 注意 一定要将找元素的结果返回，True：存在
    47.         return self.base_elememt_is_exist(page.login_logout_link)
    48.  
    49.     # 点击 安全退出
    50.     def page_click_logout_link(self):
    51.         self.base_click(page.login_logout_link)
    52.  
    53.     # 判断是否退出成功
    54.     def page_if_logout_success(self):
    55.         return self.base_elememt_is_exist(page.login_link)
    56.  
    57.     # 组合业务方法 登录业务直接调用
    58.     def page_login(self, username, pwd, verify_code):
    59.         log.info("[page_login]:正在执行登录操作，用户名：{}，密码：{}，验证码：{}".format(username, pwd, verify_code))
    60.         self.page_input_username(username)
    61.         self.page_input_pwd(pwd)
    62.         self.page_input_verify_code(verify_code)
    63.         self.page_click_login_btn()
    64.  
    65.     # 组合登录业务方法 给（购物车模块、订单模块、支付模块）依赖登录使用
    66.     def page_login_success(self, username="13800001111", pwd="123456", verify_code="8888"):
    67.         # 点击登录链接
    68.         self.page_click_login_link()
    69.         log.info("[page_login]:正在执行登录操作，用户名：{}，密码：{}，验证码：{}".format(username, pwd, verify_code))
    70.         self.page_input_username(username)
    71.         self.page_input_pwd(pwd)
    72.         self.page_input_verify_code(verify_code)
    73.         self.page_click_login_btn()

    • scripts（在业务层文件中添加日志）：以登录业务为例，test01_login.py

    • 代码示例：

    1. import unittest
    2. from day11_TPshop项目.base.get_driver import GetDriver
    3. from day11_TPshop项目.base.get_logger import GetLogger
    4. from day11_TPshop项目.page.page_login import PageLogin
    5. from day11_TPshop项目.tools.read_txt import read_txt
    6. from parameterized import parameterized
    7.  
    8. # 获取log日志器
    9. log = GetLogger().get_logger()
    10.  
    11.  
    12. def get_data():
    13.     arrs = []
    14.     for data in read_txt("login.txt"):
    15.         arrs.append(tuple(data.strip().split(",")))
    16.     return arrs[1:]
    17.  
    18.  
    19. # 新建 登录测试类 并 继承 unittest.TestCase
    20. class TestLogin(unittest.TestCase):
    21.     # 新建 setUpClass
    22.     @classmethod
    23.     def setUpClass(cls) -> None:
    24.         try:
    25.             # 实例化 并获取 driver
    26.             cls.driver = GetDriver.get_driver()
    27.             # 实例化 PageLogin()
    28.             cls.login = PageLogin(cls.driver)
    29.             # 点击登录链接
    30.             cls.login.page_click_login_link()
    31.         except Exception as e:
    32.             # 截图
    33.             cls.login.base_get_img()
    34.             # 日志
    35.             log.error("错误：{}".format(e))
    36.  
    37.     # 新建 tearDownClass
    38.     @classmethod
    39.     def tearDownClass(cls) -> None:
    40.         # 关闭driver驱动对象
    41.         GetDriver.quit_driver()
    42.  
    43.     # 新建 登录测试方法
    44.     @parameterized.expand(get_data())
    45.     def test_login(self, username, pwd, verify_code, expect_result, status):
    46.         try:
    47.             # 调用 登录业务方法
    48.             self.login.page_login(username, pwd, verify_code)
    49.  
    50.             # 判断是否为正向
    51.             if status == "true":
    52.                 # 断言是否登录成功
    53.                 try:
    54.                     self.assertTrue(self.login.page_if_login_success())
    55.                 except Exception as e:
    56.                     # 截图
    57.                     self.login.base_get_img()
    58.                     # 日志
    59.                     log.error("出错了：{}".format(e))
    60.                 # 点击 安全退出
    61.                 self.login.page_click_logout_link()
    62.                 # 点击 登录链接
    63.                 self.login.page_click_login_link()
    64.             # 逆向用例
    65.             else:
    66.                 # 获取错误提示信息
    67.                 msg = self.login.page_get_err_info()
    68.                 print("msg:", msg)
    69.                 try:
    70.                     self.assertEqual(msg, expect_result)
    71.                 except Exception as e:
    72.                     # 截图
    73.                     self.login.base_get_img()
    74.                     # 日志
    75.                     log.error("出错了：{}".format(e))
    76.                 # 点击错误提示框 确定按钮
    77.                 self.login.page_click_error_alert()
    78.         except Exception as e:
    79.             # 截图
    80.             self.login.base_get_img()
    81.             # 日志
    82.             log.error("出错了：{}".format(e))

    • tools（存放封装的日志工具 get_logger.py）：使用单例封装logger日志对象

    • 代码示例：

    1. import logging.handlers
    2. import time
    3.  
    4.  
    5. class GetLogger:
    6.     logger = None
    7.  
    8.     # 获取logger
    9.     @classmethod
    10.     def get_logger(cls):
    11.         if cls.logger is None:
    12.             # 获取 logger 日志器 并设置名称为“admin”
    13.             cls.logger = logging.getLogger("admin")
    14.             # 设置日志级别
    15.             cls.logger.setLevel(logging.INFO)
    16.             # 获取 控制台处理器
    17.             sh = logging.StreamHandler()
    18.             # 获取 文件处理器 根据时间分割
    19.             th = logging.handlers.TimedRotatingFileHandler(
    20.                 filename="../log/{}.log".format(time.strftime("%Y_%m_%d %H_%M_%S")),
    21.                 when="S",
    22.                 interval=1,
    23.                 backupCount=3,
    24.                 encoding="utf-8")
    25.             # 设置 文件处理器 日志级别
    26.             th.setLevel(logging.ERROR)
    27.             # 获取 格式器
    28.             fmt = "%(asctime)s %(levelname)s [%(name)s] [%(filename)s %(funcName)s %(lineno)d] - %(message)s"
    29.             fm = logging.Formatter(fmt)
    30.             # 将 格式器 添加到 处理器
    31.             sh.setFormatter(fm)
    32.             th.setFormatter(fm)
    33.             # 将 处理器 添加到 日志器
    34.             cls.logger.addHandler(sh)
    35.             cls.logger.addHandler(th)
    36.         # 返回日志器
    37.         return cls.logger
    38.  
    39.  
    40. if __name__ == '__main__':
    41.     logger = GetLogger.get_logger()
    42.     # 日志器应用
    43.     logger.info("这是info日志信息")
    44.     logger.debug("这是debug日志信息")
    45.     logger.warning("这是warning日志信息")
    46.     logger.error("这是error日志信息")

    • log（保存日志文件）（内容略）

       自动化测试学习视频

      面试资料

      我们学习软件测试必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

      在这里插入图片描述

      在这里插入图片描述

      这些资料，对于做【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴我走过了最艰难的路程，希望也能帮助到你！凡事要趁早，特别是技术行业，一定要提升技术功底。希望对大家有所帮助…….

      加油吧，测试人！如果你需要提升规划，那就行动吧，在路上总比在起点观望的要好。
      未来的你肯定会感谢现在拼命的自己！

  • 相关阅读:
    LabVIEW利用人工神经网络辅助进行结冰检测
    编辑器报警处理
    输入年月日判断是本年的第多少天
    jmeter线程组 bzm - Concurrency Thread Group & 阶梯式压测
    conda环境里安装ffmpeg
    10_6 input输入子系统,流程解析
    空间金字塔池化Spatial Pyramid Pooling
    关于阿里云中RDS数据库的CPU使用率和内存使用率的20道面试题
    值传递还是引用传递（By Value or By Reference）
    贪心算法在找零问题中的应用
  • 原文地址：https://blog.csdn.net/IT_LanTian/article/details/127651826