groovy

so seems here is null somehow i need to pass some value to projects i guess

(example:  in this class, with a reasonable amount of code inside, it only recognized 2 lines as code  - and both constructor code, but the 3rd line, which is exact same as the 2nd one (initializing fields) is not recognized as code at all - nor do the next 80 or so lines

Silly question of the day, it is possible to create a “matrix” data driven test? Like if I have a list of test values a and a list of values b - is there a way to create a run for each combination of a and b?

I suppose I can pre-process the data in spec_setup - but seems like maybe there is a more direct method

Once <https://github.com/spockframework/spock/pull/1298> is in, you could do
```where:
    a &lt;&lt; aValues
    combined:
    b &lt;&lt; bValues```
currently you would do something like
```where:
    [a, b] &lt;&lt; [
        [aValues].transpose(),
        [bValues].transpose()
    ].combinations()*.flatten()```

nvm, I must be doing something wrong, cant recreate the behavior I am seeing in a minimalistic setup

Anyone interested in doing a Spock talk for ApacheCon/Community over Code (Halifax, October 7-10)? Here is the CFP:
<https://communityovercode.org/call-for-presentations/>

If you can tease out a replicator, we should be able to work out if it's on the Groovy or Spock side of things. In fact, if you can create the replicator without Spock, we'll know it's on the Groovy side and then we can work out if there is some reason why it would be intentional. Also, did you change Groovy or Spock version or just JDK version?

```
import spock.lang.Specification

class ReplicatorSpec extends Specification {

  static abstract class AbstractClass {

  }

  def "Works Test"() {
    expect: 'simple test to show it works'
      'var' == 'var'
  }

  def "Broken anon.test() Test"() {
    given: 'An Anonymous Class'
      AbstractClass anon = Spy(new AbstractClass() {
        def test() {
          return 'actual'
        }
      })

    when: 'we call test method'
      def result = anon.test()
    then: 'it was called'
      1 * anon.test() &gt;&gt; 'called'
    and: 'value is correct'
      result == 'called'
  }
}```

```java.lang.ClassFormatError: Illegal method name "Broken anon.test() Test" in class tests/ReplicatorSpec$1
	at java.base/java.lang.ClassLoader.defineClass(ClassLoader.java:1017)
	at java.base/java.security.SecureClassLoader.defineClass(SecureClassLoader.java:174)
	at java.base/jdk.internal.loader.BuiltinClassLoader.defineClass(BuiltinClassLoader.java:800)
	at java.base/jdk.internal.loader.BuiltinClassLoader.findClassOnClassPathOrNull(BuiltinClassLoader.java:698)
	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClassOrNull(BuiltinClassLoader.java:621)
	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:579)
	at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:178)
	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:522)
	at repl.ReplicatorSpec.Broken anon.test() Test(ReplicatorSpec.groovy:18)```

There is probably some problem with the AST transformation I guess. Because after the transformation, the method would not have that name anymore.

its odd that it started with Java 11 language spec specifically,  Using JDK11 with 8 spec works

Seeing your other thread I have seen this thread again and remembered, that I also had found this problem 3.5 years ago.

It was indeed a bug in the AST transformations that I fixed for Spock 2.0.

And I also have a work-around that you can use. You just need to have this AST Transformation in your test classes <https://github.com/Vampire/command-framework/blob/7574ecdef8be3995ce4d814fd286989191a92c69/src/spock/java/net/kautler/test/spock/AnonymousClassTransform.java|https://github.com/Vampire/command-framework/blob/7574ecdef8be3995ce4d814fd2869891[…]/spock/java/net/kautler/test/spock/AnonymousClassTransform.java> and have a file `META-INF/services/org.codehaus.groovy.transform.ASTTransformation` in your test source set that contains the FQCN of the `AnonymousClassTransform` class, then it works.

Thanks, now I will need to figure out how to do this :slightly_smiling_face: I really have not messed with AST directly yet

Copy in the file as source, and create that other file with the FQCN, nothing else needed

(sorry for the stupid question) the AST directory name is as specified with dots or is it a package representation where dots really mean folder separator?

Ah wait, I told non-sense.
It of course cannot be in your normal test sources.
You need to have a separate source set or separate project in the build where you build that file and have the service defintion, otherwise it is not available for the Groovy compiler of course.

And `org.codehaus.groovy.transform.ASTTransformation` is the actual file name

ok, in this case it is a gradle build, I will need to wrap my head around how to do another source to pre-build before building test code so that it is available during the test code building :confused:

Looking at that example - for one, I never bothered to learn kotlin, so thats a bit fun, but more specifically, your gradle config is all plugins, is it safe to assume those are all local in buildSrc ?

Yeah, the example is actually a bit loaded :smile:

You basically just
• create a new source set (in my case `spock`)
• Add Groovy and Spock in your versions to the `spockCompileOnly` configuration
• make `testCompileOnly` depend on `spock`
• put the class I linked you to in your source set and also the resource file I described (and can be found at <https://github.com/Vampire/command-framework/blob/7574ecdef8be3995ce4d814fd286989191a92c69/src/spock/resources/META-INF/services/org.codehaus.groovy.transform.ASTTransformation|https://github.com/Vampire/command-framework/blob/7574ecdef8be3995ce4d814fd2869891[…]TA-INF/services/org.codehaus.groovy.transform.ASTTransformation>)

I got the first and last bit done - now need to do the rest

erm, is `spockCompileOnly` something custom? google of that term only brings up one hit, the above repo :smile:

or is “spock” the name from sourceset?

getting closer - but still no joy - I think I got #2 working, but not sure how to do the dependency of test on testSupport(my version of your “spock”)

I tried to add this in test SourceSet: `compileClasspath += testSupport.output`  - which triggered testSupport to compile (I don’t think it was compilinig prior) but I am not seeing the problem fixed

not sure if the override/additional code is running or note

harder to do as it is the entire repo at play here - but I am pretty sure I am not even executing the additional transform

&gt;  make `testCompileOnly` depend on `spock`

being that it is a sourceSet and not an external dependency

I added a `System.err.println()` into the transform code and I am not seeing it

<https://github.com/Vampire/command-framework/blob/7574ecdef8be3995ce4d814fd286989191a92c69/buildSrc/src/main/kotlin/net/kautler/tests.gradle.kts#L97>

hmm, does this not do same thing?
``` sourceSets {
  ....
  test {
    groovy {
      srcDirs = ['test/src', 'test/vars']
    }
    resources {
      srcDirs = ['test/resources']
    }
    compileClasspath += testSupport.output
  }
}```

Actually you don't need the `runtimeClasspath`

As you only have `compileOnly` dependencies for that sourceset

well, runtimeClasspath does not work either there, let me try it in the dependencies

well, added `testCompileOnly(sourceSets.testSupport.output)`  still not seeing it run - maybe I got the resource wrong

Things work much better when you spell services “services” and not “support”

it runs now, and the specific errors I had disappeared - yet one of the tests is failing now

*sigh* - so I am pretty sure this test returned wrong result and the dev who wrote it just matched expected output to actual output  :disappointed: (On the bright side, the dev in question was already fired) - but in trying to fix it I ran into a weird behavior - is there a limit to memory that a spock test can handle? this code loads a ~250KB file, processes it and returns a ~650k processed version - both input and output are loaded from disk in the test - the code does not seem to crash, but the spock test seems to dump a whole bunch of hex (stack trace?)

I think it is an IntelliJ problem - no base64 in command line run

ok, that seems to be (mostly) user error - looks like you should not put too much data in the `then` clause - when I do the computation in `when`  it works without going boom - and it makes sense why

Here is the minimal POC: (this now demonstrates the issue correctly)

TesterSpec.groovy.cpp

Seems to be a Spock bug.
Even with current `master` version I get
&gt; MissingMethodException: No signature of method: TestClass.getBob()
assuming this is also what you see.

You should report it as bug if there is no ticket for it yet.

did not find mention of it, submitted <https://github.com/spockframework/spock/issues/1815>

NVM, I just put the flattening logic into a method and used that - works fine

You can do it in the where block directly.
What you actually wait for is probably <https://github.com/spockframework/spock/issues/1062|https://github.com/spockframework/spock/issues/1062> which also has in a comment by me a way to do it with Groovy magic right now.

I think I did it wrong to begin with, I had data being generated by a number of nested loops, and in the middle of it I had `test &lt;&lt; singleTest` - which would make sense it test was a plain list in plain groovy code, but not is transformed where statement. It is much cleaner to do it in a method and do something like

```  where: 'data is'
    test &lt;&lt; flatTestData
}

protected List getFlatTestData(){
   ...
}```

but it likely had worked if I generated all the list by some form of nested collects

I there a way to auto-explode the test into variables?

Like today it is either
```where: 'data is'
  test &lt;&lt; testListOfMaps
  arg1 = test.arg1
  arg2 = test.arg2```
or I have to use it as “test.arg1” - not a big deal, but gets annoying when the test is complex and has a lot of arguments (probably a mistake to begin with, but that is another story)

would be nice to have some form of `**test` that auto-expands all the map keys to variables

If it is an ordered map, you could do it like `[arg1, arg2] &lt;&lt; [[arg1: 'foo', arg2: 'bar']]`
But I don't think by map key.
The left-hand side is at compile-time translated to method parameters for the test.
But the right-hand side could be different on each run at execution time, and also the maps could have different keys in the list.

I will learn to live with it :slightly_smiling_face:

I don't think we use categories much, but we provide a way to use them declaratively. Custom metaclasses are used for Groovy Mocks as far as I remember.

Guys, there is a regression in the newest IDEA 2024.3 which makes running Spock tests in Gradle and Maven projects problematic:
<https://youtrack.jetbrains.com/issue/IDEA-363841|https://youtrack.jetbrains.com/issue/IDEA-363841>

If you use Spock and hit that problem in IDEA (or will hit after an upgrade), please vote on that issue and/or comment that you are affected, to - hopefully - make it fixed sooner.

Thanks guys! Thanks to your contribution, it was escalated today and changed to 'critical'. Hopefully, there will be a fix 'soon'

In fact, I see it was already fixed in the meantime :+1: