@Before
    @BeforeClass
    @After
    @AfterClass
    
    @Test
    @Ignore 

    <dependencies>
        <!-- Spock需要的groovy依赖 -->
        <dependency>
            <groupId>org.codehaus.groovy</groupId>
            <artifactId>groovy-all</artifactId>
            <version>2.4.15</version>
        </dependency>
        <dependency>
            <groupId>org.spockframework</groupId>
            <artifactId>spock-core</artifactId>
            <version>1.2-groovy-2.4</version>
            <scope>test</scope>
        </dependency>
        <!-- spring spock -->
        <dependency>
            <groupId>org.spockframework</groupId>
            <artifactId>spock-spring</artifactId>
            <version>1.2-groovy-2.4</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

import spock.lang.Specification

class CalculateSpec extends Specification {
    // 初始化
    def setupSpec() {
        calculateService = new CalculateService()
        println ">>>>>>   setupSpec"
    }
    def setup() {
        println ">>>>>>   setup"
    }
    def cleanup() {
        println ">>>>>>   cleanup"
    }
    def cleanupSpec() {
        println ">>>>>>   cleanupSpec"
    }

    def "test life cycle"() {
        given:
        def a = 1
        def b = 2

        expect:
        a < b

        println "test method finished!"
    }
}

    def "test person use with(p)"() {
        given: "init a person"
        Date now = new Date()
        Person p = new Person(name: "yawn", age: 18, birthday:   now)

        expect: "测试p"
        with(p) {
            name == "yawn"
            age < 20
            birthday == now
        }
    }

    def "多次执行测试语句"() {
        given:
        def a = 0

        expect: "aaa"
        3 * calculateService.plusPlus(a) == 3

        // 执行3次后结果为 3
    }

    /**
     * 测试一个方法抛出异常，可以使用try-catch在when语句块中捕获验证，但是写起来比较繁琐
     * 所以，Spock测试框架中可以使用thrown()来表示这种现象，并且可以返回异常的实例
     */
    def "test Thrown"() {
        when:
        int a = 1
        int b = 0
        int c = 2
        c = (a / b)
        then:
        def ex = thrown(Exception)
        ex instanceof ArithmeticException
        // ArithmeticException 异常时我们预料之中的
    }

    /**
     * notThrown() 表示被测试的方法不会抛出某种异常
     */
    def "HashMap accepts null key"() {
        given:
        def map = new HashMap()
        when:
        map.put(null, "elem")
        then:
        notThrown(NullPointerException)
    }

import static spock.util.matcher.HamcrestSupport.expect
import static spock.util.matcher.HamcrestMatchers.closeTo

class HamcrestSupportSpec extends Specification {

    def "test for closeTo()"() {
        given:
        int a = 101256
        when:
        int b = a / 10
        then:
//        HamcrestSupport.expect(b, HamcrestMatchers.closeTo(10000, 200))
//        expect(b, closeTo(10000, 200))
        expect b, closeTo(10000, 200)
    }
}

    def "maximum of two numbers"() {
      expect:
      Math.max(a, b) == c
      where:
      a << [1, 7, 0]
      b << [3, 4, 0]
      c << [3, 7, 0] 
    }

    @Shared sql = Sql.newInstance("jdbc:mysql://localhost:3306/test", "com.mysql.jdbc.Driver", "root", "root")
    
    def "maximum of two numbers"() {
      expect:
      Math.max(a, b) == c
      where: "多变量的数据管道"
      [a, b, c] << sql.rows("select a, b, c from maxdata") 
      // [[a, b, c], [a, c]] 这种写法类似于Matlab和Lisp语言中二维表、多维表的写法（Lisp中使用小括号）
    }

    def "maximum of two numbers"() {
        expect:
        Math.max(a, b) == c
        where:
        a | b || c
        1 | 3 || 3
        7 | 4 || 7
        0 | 0 || 0
    }

@SpringBootTest
@ContextConfiguration
class SpringBootSpec extends Specification {

    @Shared
    CalculateService calculateService

    def "spring boot test"() {
        expect: "asas"
        z == calculateService.minus(x, y)

        where:
        x << [9, 8, 7]
        y << [6, 5, 4]
        z << [3, 3, 3]
    }

    def "spring boot test2"() {
        expect: "asas"
        z == calculateService.minus(x, y)

        where:
        x | y | z
        9 | 8 | 1
        6 | 5 | 1
        3 | 3 | 0
    }
}

    def "Stub 测试桩"() {
        given: "构造测试桩"
        CalculateInterface calculateService = Stub(CalculateInterface)
        calculateService.plusPlus(_) >> 1

        when:
        int x = calculateService.plusPlus(12)
        int y = calculateService.plusPlus(3)

        then:
        x == 1
        y == 1
    }

    def subscriber = Mock(Subscriber)   // 1. 创建一个mock对象

    def "should send messages subscriber"() {
        when:
        publisher.send("hello")         // 2. publisher 发送一个“hello”
        then:
        1 * subscriber.receive("hello") // 3. subscriber 接收到一个“hello”
        1 * subscriber.messageCount == 1
    }

    def url = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC&characterEncoding=UTF-8&useUnicode=true"
    def sql = Sql.newInstance(url, "root", "root", "com.mysql.cj.jdbc.Driver")
    List<GroovyRowResult> testList = sql.rows("select * from test")
    for (GroovyRowResult row : testList) {
        println row
        println row.get("id")
        println row.get("name")
        println row.get("remark")
    }
    println testList
    sql.close()

git clone https://gitee.com/yawensilence/demo-spock.git