JUnit5学习之六：参数化测试(Parameterized Tests)基础

青旅半醒 2022-12-12 04:34 160阅读 0赞

### 欢迎访问我的GitHub ###

> 这里分类和汇总了欣宸的全部原创(含配套源码)：[https://github.com/zq2599/blog\_demos][https_github.com_zq2599_blog_demos]

### 关于《JUnit5学习》系列 ###

《JUnit5学习》系列旨在通过实战提升SpringBoot环境下的单元测试技能，一共八篇文章，链接如下：

1.  [基本操作][Link 1]
2.  [Assumptions类][Assumptions]
3.  [Assertions类][Assertions]
4.  [按条件执行][Link 2]
5.  [标签(Tag)和自定义注解][Tag]
6.  [参数化测试(Parameterized Tests)基础][Parameterized Tests]
7.  [参数化测试(Parameterized Tests)进阶][Parameterized Tests 1]
8.  [综合进阶（终篇）][Link 3]

### 本篇概览 ###

*  本文是《JUnit5学习》系列的第六篇，一起来实战强大参数化测试(Parameterized Tests)，即多次执行同一个测试方法，每次使用不同的参数；
 *  由于参数化测试功能强大，内容也比前几篇的知识点多，为了方便大家阅读和实践，这里分为《基础》和《进阶》两篇来介绍，本篇以学习参数化测试(Parameterized Tests)的基础知识为主，包含以下内容：

1.  极速体验；
2.  版本依赖；
3.  ValueSource数据源
4.  null、空字符串数据源
5.  枚举数据源
6.  方法数据源
7.  Csv格式数据源
8.  Csv文件数据源

### 源码下载 ###

1.  如果您不想编码，可以在GitHub下载所有源码，地址和链接信息如下表所示：

<table> 
 <thead> 
  <tr> 
   <th align="left">名称</th> 
   <th align="left">链接</th> 
   <th align="left">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">项目主页</td> 
   <td align="left">https://github.com/zq2599/blog_demos</td> 
   <td align="left">该项目在GitHub上的主页</td> 
  </tr> 
  <tr> 
   <td align="left">git仓库地址(https)</td> 
   <td align="left">https://github.com/zq2599/blog_demos.git</td> 
   <td align="left">该项目源码的仓库地址，https协议</td> 
  </tr> 
  <tr> 
   <td align="left">git仓库地址(ssh)</td> 
   <td align="left">git@github.com:zq2599/blog_demos.git</td> 
   <td align="left">该项目源码的仓库地址，ssh协议</td> 
  </tr> 
 </tbody> 
</table>

1.  这个git项目中有多个文件夹，本章的应用在junitpractice文件夹下，如下图红框所示：  
    ![在这里插入图片描述][20200926101440540.jpg_pic_center]
2.  junitpractice是父子结构的工程，本篇的代码在parameterized子工程中，如下图：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center]

### 极速体验 ###

1.  现在，咱们以最少的步骤体验最简单的参数化测试；
2.  在父工程junitpractice里新建名为parameterized的子工程，pom.xml内容如下：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>com.bolingcavalry</groupId>
            <artifactId>junitpractice</artifactId>
            <version>1.0-SNAPSHOT</version>
            <relativePath>../pom.xml</relativePath>
        </parent>
        <groupId>com.bolingcavalry</groupId>
        <artifactId>parameterized</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>parameterized</name>
        <description>Demo project for parameterized expirence in Spring Boot junit</description>
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.junit</groupId>
                    <artifactId>junit-bom</artifactId>
                    <version>5.7.0</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
    
        </dependencyManagement>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.jupiter</groupId>
                        <artifactId>junit-jupiter</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
    
            <dependency>
                <groupId>org.junit.jupiter</groupId>
                <artifactId>junit-jupiter</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    </project>

1.  新建测试类HelloTest.java，在这个位置：junitpractice\\parameterized\\src\\test\\java\\com\\bolingcavalry\\parameterized\\service\\impl，内容如下：

package com.bolingcavalry.parameterized.service.impl;
    
    import lombok.extern.slf4j.Slf4j;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.MethodOrderer;
    import org.junit.jupiter.api.Order;
    import org.junit.jupiter.api.TestMethodOrder;
    import org.junit.jupiter.params.ParameterizedTest;
    import org.junit.jupiter.params.provider.ValueSource;
    import org.springframework.boot.test.context.SpringBootTest;
    import static org.junit.jupiter.api.Assertions.assertTrue;
    
    @SpringBootTest
    @Slf4j
    @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
    public class HelloTest { 
    
        @Order(1)
        @DisplayName("多个字符串型入参")
        @ParameterizedTest
        @ValueSource(strings = {  "a", "b", "c" })
        void stringsTest(String candidate) { 
            log.info("stringsTest [{}]", candidate);
            assertTrue(null!=candidate);
        }
    }

1.  执行该测试类，结果如下图：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 1]
2.  从上图可见执行参数化测试需要两步：首先用@ParameterizedTest取代@Test，表名此方法要执行参数化测试，然后用@ValueSource指定每次测试时的参数来自字符串类型的数组：\{ “a”, “b”, “c” \}，每个元素执行一次；
3.  至此，咱们已体验过最简单的参数化测试，可见就是想办法使一个测试方法多次执行，每次都用不同的参数，接下来有关参数化测试的更多配置和规则将配合实战编码逐个展开，一起来体验吧；

### 版本要求 ###

*  先看看SpringBoot-2.3.4.RELEASE间接依赖的junit-jupiter-5.6.2版本中，ParameterizedTest的源码，如下图红框所示，此时的ParameterizedTest还只是体验版：  
    ![在这里插入图片描述][20201006084545848.jpg_pic_center]
 *  再看看junit-jupiter-5.7.0版本的ParameterizedTest源码，此时已经是稳定版了：  
    ![在这里插入图片描述][20201006085132156.jpg_pic_center]
 *  综上所述，如果要使用参数化测试，最好是将junit-jupiter升级到5.7.0或更高版本，如果您的应用使用了SpringBoot框架，junit-jupiter是被spring-boot-starter-test间接依赖进来的，需要排除这个间接依赖，再手动依赖进来才能确保使用指定版本，在pom.xml中执行如下三步操作：

1.  dependencyManagement节点添加junit-bom，并指定版本号：

<dependencyManagement>
      <dependencies>
        <dependency>
          <groupId>org.junit</groupId>
          <artifactId>junit-bom</artifactId>
          <version>5.7.0</version>
          <type>pom</type>
          <scope>import</scope>
        </dependency>
      </dependencies>
    </dependencyManagement>

1.  排除spring-boot-starter-test和junit-jupiter的间接依赖关系：

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
      <exclusions>
        <exclusion>
          <groupId>org.junit.jupiter</groupId>
          <artifactId>junit-jupiter</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

1.  添加junit-jupiter依赖，此时会使用dependencyManagement中指定的版本号：

<dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <scope>test</scope>
    </dependency>

1.  如下图，刷新可见已经用上了5.7.0版本：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 2]

*  版本问题解决了，接下来正式开始学习Parameterized Tests，先要了解的是有哪些数据源；

### ValueSource数据源 ###

1.  ValueSource是最简单常用的数据源，支持以下类型的数组：

short
    
        byte
    
        int
    
        long
    
        float
    
        double
    
        char
    
        boolean
    
        java.lang.String
        
        java.lang.Class

1.  下面是整形数组的演示：

@Order(2)
        @DisplayName("多个int型入参")
        @ParameterizedTest
        @ValueSource(ints = {  1,2,3 })
        void intsTest(int candidate) { 
            log.info("ints [{}]", candidate);
            assertTrue(candidate<3);
        }

1.  从上述代码可见，入参等于3的时候assertTrue无法通过，测试方法会失败，来看看实际执行效果，如下图：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 3]

### null、空字符串数据源 ###

1.  在用字符串作为入参时，通常要考虑入参为null的情况，此时ValueSource一般会这样写：

@ValueSource(strings = {  null, "a", "b", "c" })

1.  此时可以使用@NullSource注解来取代上面的null元素，下面这种写法和上面的效果一模一样：

@NullSource
        @ValueSource(strings = {  "a", "b", "c" })

1.  执行结果如下图红框，可见null作为入参被执行了一次：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 4]
2.  与@NullSource代表null入参类似，@EmptySource代表空字符串入参，用法和执行结果如下图所示：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 5]
3.  如果想同时用null和空字符串做测试方法的入参，可以使用@NullAndEmptySource，用法和执行结果如下图所示：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 6]

### 枚举数据源(EnumSource) ###

1.  EnumSource可以让一个枚举类中的全部或者部分值作为测试方法的入参；
2.  创建枚举类Types.java，用于接下来的实战，如下，很简单只有三个值：

public enum Types { 
        SMALL,
        BIG,
        UNKNOWN
    }

1.  先尝试用Types的每个值作为入参执行测试，可见只要添加@EnumSource即可，JUnit根据测试方法的入参类型知道要使用哪个枚举：

@Order(6)
        @DisplayName("多个枚举型入参")
        @ParameterizedTest
        @EnumSource
        void enumSourceTest(Types type) { 
            log.info("enumSourceTest [{}]", type);
        }

1.  执行结果如下图所示：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 7]
2.  如果不想执行枚举的所有值，而只要其中一部分，可以在name属性中指定：

@EnumSource(names={ "SMALL", "UNKNOWN"})

1.  执行结果如下图所示：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 8]
2.  也可以指定哪些值不被执行，此时要添加mode属性并设置为EXCLUDE（mode属性如果不写，默认值是INCLUDE，前面的例子中就是默认值）：

@EnumSource(mode= EnumSource.Mode.EXCLUDE, names={ "SMALL", "UNKNOWN"})

1.  执行结果如下，可见SMALL和UNKNOWN都没有执行：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 9]

### 方法数据源(MethodSource) ###

1.  @MethodSource可以指定一个方法名称，该方法返回的元素集合作为测试方法的入参；
2.  先来定义一个方法，该方法一般是static类型(否则要用@TestInstance修饰)，并且返回值是Stream类型：

static Stream<String> stringProvider() { 
            return Stream.of("apple1", "banana1");
        }

1.  然后，测试方法用@MethodSource，并指定方法名stringProvider：

@Order(9)
        @DisplayName("静态方法返回集合，用此集合中每个元素作为入参")
        @ParameterizedTest
        @MethodSource("stringProvider")
        void methodSourceTest(String candidate) { 
            log.info("methodSourceTest [{}]", candidate);
        }

1.  上面的stringProvider方法和测试方法methodSourceTest在同一个类中，如果它们不在同一个类中，就要指定静态方法的整个package路径、类名、方法名，如下所示，类名和方法名之间用\#连接：

@Order(10)
        @DisplayName("静态方法返回集合，该静态方法在另一个类中")
        @ParameterizedTest
        @MethodSource("com.bolingcavalry.parameterized.service.impl.Utils#getStringStream")
        void methodSourceFromOtherClassTest(String candidate) { 
            log.info("methodSourceFromOtherClassTest [{}]", candidate);
        }

1.  如果不在@MethodSource中指定方法名，JUnit会寻找和测试方法同名的静态方法，举例如下，静态方法methodSourceWithoutMethodNameTest会被作为测试方法的数据来源：

static Stream<String> methodSourceWithoutMethodNameTest() { 
            return Stream.of("apple3", "banana3");
        }
    
        @Order(11)
        @DisplayName("静态方法返回集合，不指定静态方法名，自动匹配")
        @ParameterizedTest
        @MethodSource
        void methodSourceWithoutMethodNameTest(String candidate) { 
            log.info("methodSourceWithoutMethodNameTest [{}]", candidate);
        }

1.  执行结果如下：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 10]

### Csv格式数据源(CsvSource) ###

1.  前面的测试方法入参都只有一个，在面对多个入参的测试方法时，@CsvSource就派上用场了，演示代码如下所示，可见数据是普通的CSV格式，每条记录有两个字段，对应测试方法的两个入参：

@Order(12)
        @DisplayName("CSV格式多条记录入参")
        @ParameterizedTest
        @CsvSource({ 
                "apple1, 11",
                "banana1, 12",
                "'lemon1, lime1', 0x0A"
        })
        void csvSourceTest(String fruit, int rank) { 
            log.info("csvSourceTest, fruit [{}], rank [{}]", fruit, rank);
        }

1.  执行结果如下，通过日志可以确定，每条记录的两个字段能匹配到测试方法的两个入参中：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 11]
2.  另外@CsvSource还提供了一个属性nullValues，作用是将指定的字符串识别为null，下面这个设置就是把CSV数据中所有的NIL识别为null，再传给测试方法：

@Order(13)
        @DisplayName("CSV格式多条记录入参(识别null)")
        @ParameterizedTest
        @CsvSource(value = { 
                "apple2, 21",
                "banana2, 22",
                "'lemon2, lime2', 0x0A",
                "NIL, 3" },
                nullValues = "NIL"
        )
        void csvSourceWillNullTokenTest(String fruit, int rank) { 
            log.info("csvSourceWillNullTokenTest, fruit [{}], rank [{}]", fruit, rank);
        }

1.  执行结果如下，可见字符串NIL到测试方法后已变成null：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 12]

### Csv文件数据源 ###

1.  @CsvSource解决了测试方法入参有多个字段的问题，但是把作为入参的测试数据写在源文件中似乎不合适，尤其是数据量很大的情况下，这种场景适合用@CsvFileSource，该注解用于指定csv文件作为数据源，注意numLinesToSkip属性指定跳过的行数，可以用来跳过表头：

@Order(14)
        @DisplayName("CSV文件多条记录入参")
        @ParameterizedTest
        @CsvFileSource(files = "src/test/resources/two-column.csv", numLinesToSkip = 1)
        void csvFileTest(String country, int reference) { 
            log.info("csvSourceTest, country [{}], reference [{}]", country, reference);
        }

1.  在src/test/resources/创建文件two-column.csv，内容如下：

Country, reference
    Sweden, 1
    Poland, 2
    "United States of America", 3

1.  上述代码执行结果如下，代码中没有测试数据，显得更加简洁一些：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 13]

### 期待《进阶》篇 ###

*  至此，咱们队JUnit5的参数化测试(Parameterized)有了初步的了解，可以通过各种数据源注解给测试方法制造更多的参数，但仅掌握这些还是不够的，依然有一些问题待解决，例如更自由的数据源定制、跟完善的多字段处理方案等等，下一篇[《进阶》][Parameterized Tests 1]咱们一起来体验更多参数化测试的高级功能；

### 欢迎关注公众号：程序员欣宸 ###

> 微信搜索「程序员欣宸」，我是欣宸，期待与您一同畅游Java世界…

[https_github.com_zq2599_blog_demos]: https://github.com/zq2599/blog_demos
[Link 1]: https://blog.csdn.net/boling_cavalry/article/details/108810587
[Assumptions]: https://blog.csdn.net/boling_cavalry/article/details/108861185
[Assertions]: https://blog.csdn.net/boling_cavalry/article/details/108899437
[Link 2]: https://blog.csdn.net/boling_cavalry/article/details/108909107
[Tag]: https://blog.csdn.net/boling_cavalry/article/details/108914091
[Parameterized Tests]: https://blog.csdn.net/boling_cavalry/article/details/108930987
[Parameterized Tests 1]: https://blog.csdn.net/boling_cavalry/article/details/108942301
[Link 3]: https://blog.csdn.net/boling_cavalry/article/details/108952500
[20200926101440540.jpg_pic_center]: /images/20221123/d62d1e676ba048b49d3fd370ab281280.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/1d969e706ebb49e593c00b6bae2883d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/ddcbee241b0f45bb99eaed971989fe8f.png
[20201006084545848.jpg_pic_center]: /images/20221123/a672d223aaa94195abd39948f9556a69.png
[20201006085132156.jpg_pic_center]: /images/20221123/c9fa8f5e4afd46e5b25ba141dd5db8db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/d7e482a202c24553ab0236ecb391880f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/e62c94f1c36b4c4483dd43d534486285.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/95847e31d4f344faad4ca6a077310ac8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/673bf4ed43f54c56ba1e4f98c2ac7921.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/75f9fd6b1ce74b61a6b97f743b0216e8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/a6be085b0a22421c8ec836be56b9703e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221123/426bd148048b4281b3cd20bb89911f5d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221123/dcf545fccee94ec99052276a2d5aae10.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221123/2d002573ab1d45699a3d766e9e654c4a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221123/b7c5dffcafbd48ba84677be35ab6c972.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20221123/b0d01d024009459e8d8c64f2acbb0cb8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20221123/4dd5398e0b184ec1b797a5a1ecacbada.png