How to copy the dependencies of main into testFixtures?

I have a typical Architectury project structure, i.e. a common module and a fabric and a neoforge module, both depending on the former. I wanted to make tests for both fabric and neoforge in the common module, but that didn't work because there I don't have a platform. So my next best idea was to write the tests in common under testFixtures and import them in the other two subprojects, based on this answer. That almost works, but in testFixtures the Minecraft code isn't recognized at all (didn't have that problem in main or test). How can I recognize it?

This is my root gradle:

plugins {
    id 'dev.architectury.loom' version '1.11-SNAPSHOT' apply false
    id 'architectury-plugin' version '3.4-SNAPSHOT'
    id 'com.github.johnrengelman.shadow' version '8.1.1' apply false
}

architectury {
    minecraft = project.minecraft_version
}

allprojects {
    group = rootProject.maven_group
    version = rootProject.mod_version
}

subprojects {
    apply plugin: 'dev.architectury.loom'
    apply plugin: 'architectury-plugin'
    apply plugin: 'maven-publish'

    base {
        // Set up a suffixed format for the mod jar names, e.g. `example-fabric`.
        archivesName = "$rootProject.archives_name-$project.name"
    }

    repositories {
        // Add repositories to retrieve artifacts from in here.
        // You should only use this when depending on other mods because
        // Loom adds the essential maven repositories to download Minecraft and libraries from automatically.
        // See https://docs.gradle.org/current/userguide/declaring_repositories.html
        // for more information about repositories.
    }

    test {
        useJUnitPlatform()
    }

    dependencies {
        minecraft "net.minecraft:minecraft:$rootProject.minecraft_version"
        mappings loom.officialMojangMappings()
    }

    java {
        // Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the "build" task
        // if it is present.
        // If you remove this line, sources will not be generated.
        withSourcesJar()

        sourceCompatibility = JavaVersion.VERSION_21
        targetCompatibility = JavaVersion.VERSION_21
    }

    tasks.withType(JavaCompile).configureEach {
        it.options.release = 21
    }

    // Configure Maven publishing.
    publishing {
        publications {
            mavenJava(MavenPublication) {
                artifactId = base.archivesName.get()
                from components.java
            }
        }

        // See https://docs.gradle.org/current/userguide/publishing_maven.html for information on how to set up publishing.
        repositories {
            // Add repositories to publish to here.
            // Notice: This block does NOT have the same function as the block in the top level.
            // The repositories here will be used for publishing your artifact, not for
            // retrieving dependencies.
        }
    }
}

This is my common gradle:

plugins {
    id 'java-library'
    id 'java-test-fixtures'
}

architectury {
    common rootProject.enabled_platforms.split(',')
}

dependencies {
    // We depend on Fabric Loader here to use the Fabric @Environment annotations,
    // which get remapped to the correct annotations on each platform.
    // Do NOT use other classes from Fabric Loader.
    modImplementation "net.fabricmc:fabric-loader:$rootProject.fabric_loader_version"

    modImplementation "dev.architectury:architectury:$rootProject.architectury_api_version"

    testFixturesImplementation "dev.architectury:architectury:$rootProject.architectury_api_version"
    testFixturesImplementation "org.junit.jupiter:junit-jupiter-api:5.8.1"
}

sourceSets {
    main {
        resources {
            srcDirs("src/main/generated")
        }
    }
}

This is my fabric gradle:

plugins {
    id 'com.github.johnrengelman.shadow'
    id 'java-library'
}

architectury {
    platformSetupLoomIde()
    fabric()
}

configurations {
    common {
        canBeResolved = true
        canBeConsumed = false
    }
    compileClasspath.extendsFrom common
    runtimeClasspath.extendsFrom common
    developmentFabric.extendsFrom common

    // Files in this configuration will be bundled into your mod using the Shadow plugin.
    // Don't use the `shadow` configuration from the plugin itself as it's meant for excluding files.
    shadowBundle {
        canBeResolved = true
        canBeConsumed = false
    }
}

dependencies {
    modImplementation "net.fabricmc:fabric-loader:$rootProject.fabric_loader_version"

    modImplementation "net.fabricmc.fabric-api:fabric-api:$rootProject.fabric_api_version"

    modImplementation "dev.architectury:architectury-fabric:$rootProject.architectury_api_version"

    common(project(path: ':common', configuration: 'namedElements')) { transitive false }

    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
    testImplementation(testFixtures(project(":common")))

    shadowBundle project(path: ':common', configuration: 'transformProductionFabric')
}

processResources {
    inputs.property 'version', project.version

    filesMatching('fabric.mod.json') {
        expand version: project.version
    }
}

shadowJar {
    configurations = [project.configurations.shadowBundle]
    archiveClassifier = 'dev-shadow'
}

remapJar {
    input.set shadowJar.archiveFile
}