Scopes

Gradle scopes are much like Maven's. The one big difference is between api and implementation. Maven has just the compile scope. Gradle splits it into two.

1. api - A dependency in this scope adds its transitive dependencies to the final jar too.
2. implementation - The dependency is an internal detail of the module. It isn't exported to the module's consumers. The module itself still compiles. Gradle keeps the dependency on its classpath.

Understanding the names

At first, the name api sounds like it holds only APIs and no implementation.

It's the opposite though. Here api means the producer adds that dependency to its final jar.

api scoped dependencies are larger than implementation scoped ones.

what happens at runtime?

At runtime, Gradle is gone. Gradle only builds the jar the right way. If a class is missing, the JVM throws an error.

Test Fixtures

Gradle handles shared test libraries in its own way. In Maven, all tests and shared test code go under the tests folder. In Gradle, you can use the testFixtures folder for shared test code.

Test fixtures specific scope

Test fixtures have their own scopes - testFixturesImplementation and testFixturesApi. They work just like api and implementation do for productive code.

Gradle uses these dependencies only for code in the testFixtures folder. It sets a separate classpath for the fixtures. It also controls what the consumers of the fixtures module see.

which code sees which dependencies?

1. Productive code - sees only api and implementation dependencies.
2. Test code - sees productive code plus testImplementation dependencies.
3. Test fixtures code - sees only testFixturesImplementation and testFixturesApi dependencies.