Question

我在让Spock模拟一个接受单个byte[]作为参数的方法时遇到了问题。

一个简单的玩具示例，其失败方式与我的生产代码相同：

import java.util.function.Consumer
import spock.lang.Specification

class ConsumerSpec extends Specification {
    // ... elided ...

    def '4: parameter is of an array type using single typed argument'() {
        given:
        def consumer = Mock(Consumer)

        when:
        consumer.accept([20, 21] as byte[])

        then:
        consumer.accept(_) >> { byte[] arg ->
            assert arg[0] == 20
            assert arg[1] == 21
        }
    }

    // ... elided ...
}

失败消息是

ConsumerSpec > 4: parameter is of an array type using single typed argument FAILED
    org.codehaus.groovy.runtime.typehandling.GroovyCastException: Cannot cast object '[[B@43562196]' with class 'java.util.Arrays$ArrayList' to class 'java.lang.Byte'
        at groovy.lang.Closure.call(Closure.java:423)
        at org.spockframework.mock.response.CodeResponseGenerator.invokeClosure(CodeResponseGenerator.java:53)
        at org.spockframework.mock.response.CodeResponseGenerator.doRespond(CodeResponseGenerator.java:36)
        at org.spockframework.mock.response.SingleResponseGenerator.respond(SingleResponseGenerator.java:31)
        at org.spockframework.mock.response.ResponseGeneratorChain.respond(ResponseGeneratorChain.java:45)
        at org.spockframework.mock.runtime.MockInteraction.accept(MockInteraction.java:76)
        at org.spockframework.mock.runtime.MockInteractionDecorator.accept(MockInteractionDecorator.java:46)
        at org.spockframework.mock.runtime.InteractionScope$1.accept(InteractionScope.java:41)
        at org.spockframework.mock.runtime.MockController.handle(MockController.java:39)
        at org.spockframework.mock.runtime.JavaMockInterceptor.intercept(JavaMockInterceptor.java:72)
        at org.spockframework.mock.runtime.DynamicProxyMockInterceptorAdapter.invoke(DynamicProxyMockInterceptorAdapter.java:28)
        at ConsumerSpec.4: parameter is of an array type using single typed argument(ConsumerSpec.groovy:52)

我依赖于基于交互的测试中针对Computing Return Values的Spock文档中描述的行为。我有选择地转录下面的相关位：

如果闭包声明了一个无类型参数，它会传递方法的参数列表... 如果闭包声明了多个参数或单个类型参数，则方法参数将逐个映射到闭包参数......

我在上面的规范中添加了一些其他测试，看看我是否理解这些陈述。完整的MCVE如下：

$ gradle --version

------------------------------------------------------------
Gradle 2.13
------------------------------------------------------------

Build time:   2016-04-25 04:10:10 UTC
Build number: none
Revision:     3b427b1481e46232107303c90be7b05079b05b1c

Groovy:       2.4.4
Ant:          Apache Ant(TM) version 1.9.6 compiled on June 29 2015
JVM:          1.8.0_91 (Oracle Corporation 25.91-b14)
OS:           Linux 4.4.8-300.fc23.x86_64 amd64

// build.gradle

plugins {
  id 'groovy'
}

repositories {
  mavenCentral()
}

dependencies {
  testCompile(
    [group: 'org.spockframework', name: 'spock-core', version: '1.0-groovy-2.4']
  )
}

// src / test / groovy / ConsumerSpec.groovy

import java.util.function.Consumer
import spock.lang.Specification

class ConsumerSpec extends Specification {
    def '1: parameter is of a non-array type using single untyped argument'() {
        given:
        def consumer = Mock(Consumer)

        when:
        consumer.accept('value')

        then:
        consumer.accept(_) >> { args ->
            String arg = args[0]
            assert arg == 'value'
        }
    }

    def '2: parameter is of a non-array type using single typed argument'() {
        given:
        def consumer = Mock(Consumer)

        when:
        consumer.accept('value')

        then:
        consumer.accept(_) >> { String arg ->
            assert arg == 'value'
        }
    }

    def '3: parameter is of an array type using single untyped argument'() {
        given:
        def consumer = Mock(Consumer)

        when:
        consumer.accept([20, 21] as byte[])

        then:
        consumer.accept(_) >> { args ->
            byte[] arg = args[0]
            assert arg[0] == 20
            assert arg[1] == 21
        }
    }

    def '4: parameter is of an array type using single typed argument'() {
        given:
        def consumer = Mock(Consumer)

        when:
        consumer.accept([20, 21] as byte[])

        then:
        consumer.accept(_) >> { byte[] arg ->
            assert arg[0] == 20
            assert arg[1] == 21
        }
    }

    def '5: parameter is of an array type without using Mock'() {
        given:
        def consumer = { byte[] arg ->
            assert arg[0] == 20
            assert arg[1] == 21
        } as Consumer<byte[]>

        expect:
        consumer.accept([20, 21] as byte[])
    }
}

再次，唯一失败的测试是（4）。

基于失败消息，几乎就像Spock或Groovy想要将模拟方法视为Byte的varargs方法并且正在解包byte[]参数。我能够找到的唯一报告的问题听起来有点像我的问题GROOVY-4843，它是针对内置的Groovy模拟框架提出的，并且没有解决方案。

有没有办法让test（4）按预期运行？也就是说，能够在一个参数的闭包中使用类型数组参数吗？或者我使用form（3）并且必须从无类型的闭包参数中提取实际的方法参数？

Answer 1

简短的回答：没有正常的方法，因为它是一个错误。只有黑客和技巧。

以下是解释：您的闭包是在CodeResponseGenerator :: invokeClosure中调用的。

  private Object invokeClosure(IMockInvocation invocation) {
    Class<?>[] paramTypes = code.getParameterTypes();
    if (paramTypes.length == 1 && paramTypes[0] == IMockInvocation.class) {
      return GroovyRuntimeUtil.invokeClosure(code, invocation);
    }

    code.setDelegate(invocation);
    code.setResolveStrategy(Closure.DELEGATE_FIRST);
    return GroovyRuntimeUtil.invokeClosure(code, invocation.getArguments());
  }

invocation.getArguments返回一个参数列表。

public static <T> T invokeClosure(Closure<T> closure, Object... args)

invokeClosure需要varargs，这样当它获取参数列表时，它会用列表包装列表。因此，spock将Object [] {ArrayList [byte []]}传递给闭包。同时，闭包知道它接受varargs（当你声明byte []）时，所以它期望传递Object [{byte []}]。在这里我们得到例外。我相信它是一个错误，spock不必用JavaMockInterceptor :: intercept中的数组包装所有参数。

PS：还有一个有趣的错误

这个工作正常

def test() {
    given:
    Consumer<Set<Integer>> consumer = Mock()
    when:
    consumer.accept([1,2,3] as Set)
    then:
    consumer.accept(_) >> { Set<Integer> integer ->
        assert integer.size() == 3
    }
}

让我们用List替换Set

def test() {
    given:
    Consumer<List<Integer>> consumer = Mock()
    when:
    consumer.accept([1,2,3])
    then:
    consumer.accept(_) >> { List<Integer> integer ->
        assert integer.size() == 3
    }
}

我们得到了

integer.size() == 3
|       |      |
|       1      false
[[1, 2, 3]]

你可以看到而不是List＆lt;整数＆GT;我们得到List＆lt;列表与LT;整数＆GT;取代。为了理解它为什么会发生，让我们回到传递的参数。在这种情况下，它看起来像Object [] {ArrayList [ArrayList]}。 Closure知道输入参数是一个列表，所以它需要它能找到的第一个并使用它。

Spock：如何模拟接受单个byte []参数的方法？

1 个答案: