diff --git a/.claude/docs/ci.md b/.claude/docs/ci.md
index e22a60c3eba..6e67dc20173 100644
--- a/.claude/docs/ci.md
+++ b/.claude/docs/ci.md
@@ -4,7 +4,7 @@
 
 - `code-style`: `mvn -T 1C formatter:validate`
 - `tests` (ubuntu + windows matrix): `mvn clean install -P unit-tests`
-- `integration-tests-h2` / `-postgresql`: the **full** Selenide IT suite, `mvn clean install -P integration-tests` with the matching `DIRIGIBLE_DATASOURCE_DEFAULT_*` env vars (MSSQL is no longer a CI leg — removed in #6150). Each DB leg is **sharded into four parallel matrix jobs** selected by tag expression — `api` (`!ui & !slow`), `ui` (`ui & !slow & !sample & !camel`), `samples` (`ui & !slow & (sample | camel)`), `slow` (`slow`) — so the run's wall clock is the slowest shard, not the whole ~2h30 suite. The shards partition the suite; keep them disjoint and complete when adding tags. **Measured on nightly run 34428729298 (h2 / postgresql): `api` 57 / 62 min, `slow` 42, `ui` 36 / 36, `samples` 13 / 13**, against a `timeout-minutes: 90` per job (see the budget note below).
+- `integration-tests-h2` / `-postgresql`: the **full** Selenide IT suite, `mvn clean install -P integration-tests` with the matching `DIRIGIBLE_DATASOURCE_DEFAULT_*` env vars (MSSQL is no longer a CI leg — removed in #6150). Each DB leg is **sharded into four parallel matrix jobs** selected by tag expression — `api` (`!ui & !slow & !upgrade`, itself run as two hash partitions `api-1` / `api-2`, see the budget note below), `ui` (`ui & !slow & !sample & !camel`), `samples` (`ui & !slow & (sample | camel)`), `slow` (`slow`) — so the run's wall clock is the slowest shard, not the whole ~2h30 suite. The shards partition the suite; keep them disjoint and complete when adding tags. **Measured on nightly run 34428729298 (h2 / postgresql): `api` 57 / 62 min, `slow` 42, `ui` 36 / 36, `samples` 13 / 13**, against a `timeout-minutes: 90` per job (see the budget note below).
 - `build-deploy`: `mvn clean install -P quick-build` then Docker buildx multi-arch image push to `dirigiblelabs/dirigible`
 
 ### PR gate vs full suite (smoke / nightly split)
@@ -17,7 +17,7 @@ The full Selenide UI suite takes ~1.5h per DB, so it does **not** run on every P
 **The job budget, and how a shard that runs out of it reads (#7283).** `timeout-minutes` is **90** on every IT job (150 on the PR `smoke-tests` job) - comfortably above the measured times above, because a job cancelled at its cap reads as infrastructure rather than as a test result. At 60 the PostgreSQL `api` shard of the nightly was killed **two classes short of finishing** and that looked exactly like a hang. Two things to know before concluding "wedged IT" from a cancelled shard:
 
 - **Check the last `[INFO] Running org.eclipse...` line against the cancellation timestamp.** In the run that raised the issue the JVM was healthy: it kept starting one IT class per ~40 s until 10 minutes before the cancel, and the class suspected of hanging (`EdmModelRoundTripIT`) had passed in 50.51 s. Searching the downloaded log for a class name lands on its *last* mention, which is its own completion line - everything after it belongs to the next classes.
-- **`api` cannot be rebalanced with `@Tag("slow")`.** Its 83 classes cost a near-uniform ~40 s each, nearly all of it the Spring context each class boots (`@DirtiesContext` `AFTER_EACH_TEST_METHOD`), so the shard grows ~40 s per IT class added and has no long pole to move out. Splitting it needs a partition mechanism, not a tag - and a name-pattern split (`-Dit.test`) would risk silently dropping classes that match neither half, which is the #7215 failure mode.
+- **`api` cannot be rebalanced with `@Tag("slow")`.** Its classes cost a near-uniform ~40-60 s each, nearly all of it the Spring context each class boots (`@DirtiesContext` `AFTER_EACH_TEST_METHOD`), so the shard grows by that much per IT class added and has no long pole to move out. A name-pattern split (`-Dit.test`) would risk silently dropping classes that match neither half, which is the #7215 failure mode. So it is split by a **partition**: by October 2026 it had grown to ~133 classes / ~83 min and was cancelled at the 90-minute cap on every master and nightly run, and it now runs as `api-1` / `api-2`, each `-Dit.groups="!ui & !slow & !upgrade" -Dit.partition=k/2`. `ClassPartitionFilter` (tests-integrations `support/`, a JUnit `PostDiscoveryFilter` registered through `META-INF/services`, applied after the tag filter) keeps the classes whose **top-level** class name hashes into partition `k` of `n` - disjoint and complete by construction, nested classes stay with their enclosing class, nothing to tag. Without `-Dit.partition` it keeps everything. When a partition nears the cap again, go to `/3` rather than reshuffling tags; `-Djunit.platform.execution.dryRun.enabled=true` counts what each partition selects in about a minute.
 
 **A hang costs one class, not the shard.** `IntegrationTest` carries a class-level **`@Timeout(15, MINUTES)`** (inherited; per test *and* per lifecycle method - the Spring context start is an extension callback and is not counted), so a method that never returns fails its own class and the run continues and reports. The slowest measured method in the suite is 456 s (`CreateNewFileIT`, one `@Test`), so 15 minutes is roughly twice the worst legitimate case; a class needing a different bound declares its own `@Timeout`, which overrides the inherited one (`JavaLspIT`, `JavaDebugIT`, `SchemaTemplateForeignKeyIT` each declare a tighter one). There is deliberately **no `forkedProcessTimeoutInSeconds`**: it bounds the whole fork, and the jobs sharing this configuration range from 13 to 91 minutes, so one value would either be useless or kill the longest job.
 
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 23619a66441..4fb3c972c7e 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -162,7 +162,8 @@ jobs:
 
   # The full IT suite is split ("sharded") into four disjoint slices selected by JUnit 5 tags, so
   # the wall-clock time of a run is the slowest shard instead of the whole suite (~2h30 serial):
-  #   api     - every HTTP-level IT (untagged, i.e. everything not tagged "ui") bar the long poles
+  #   api     - every HTTP-level IT (untagged, i.e. everything not tagged "ui") bar the long poles,
+  #             run as two jobs (api-1, api-2) - see the partition note below
   #   ui      - the browser-driven ITs except the sample-project, camel and long-pole families
   #   samples - the sample-project clone/publish ITs ("sample") + the camel journeys still driven
   #             through the browser ("camel"), which is now only the two template starters - the
@@ -181,24 +182,34 @@ jobs:
   # samples 13 / 13. "api" is the critical path and the "slow" tag cannot rebalance it: its 83
   # classes cost a near-uniform ~40 s each, almost all of it the Spring context each class boots
   # (@DirtiesContext AFTER_EACH_TEST_METHOD), so the shard grows by ~40 s per IT class added and
-  # has no long pole to move out. #7283 raised the budget rather than split it; splitting "api"
-  # needs a partition mechanism, not a tag.
+  # has no long pole to move out. #7283 raised the budget rather than split it, and by October 2026
+  # the shard (~133 classes, ~83 min of test time) was cancelled at the 90-minute cap on every run.
+  # So "api" is split by a partition, not by a tag: -Dit.partition=k/n keeps the classes whose
+  # top-level class name hashes into partition k of n (ClassPartitionFilter in tests-integrations, a
+  # JUnit PostDiscoveryFilter applied after the tag filter). The partitions are disjoint and complete
+  # by construction - a new IT lands in exactly one of them without being tagged - and, the class
+  # costs being near-uniform, about even (on the 2026-10-05 h2 shard log: 64 classes / 38.5 min
+  # against 69 / 44.7). Add a third partition (1/3, 2/3, 3/3) when one of them nears the cap again.
   integration-tests-h2:
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
         shard:
-          - name: api
+          - name: api-1
             groups: "!ui & !slow & !upgrade"
+            partition: "1/2"
+          - name: api-2
+            groups: "!ui & !slow & !upgrade"
+            partition: "2/2"
           - name: ui
             groups: "ui & !slow & !sample & !camel"
           - name: samples
             groups: "ui & !slow & (sample | camel)"
           - name: slow
             groups: "slow"
-    # The slowest green shard ("api") takes ~57 min on h2 and ~62 on PostgreSQL; a heap-exhausted
-    # JVM used to thrash for 4h+ before anyone noticed. Cap the job above the healthy time so hangs
+    # The slowest green shard ("api", before its split) took ~57 min on h2 and ~62 on PostgreSQL; a
+    # heap-exhausted JVM used to thrash for 4h+ before anyone noticed. Cap the job above the healthy time so hangs
     # fail fast instead of burning runners - but far enough above it that a routine run is never
     # cancelled: at 60 the PostgreSQL "api" shard was killed two classes short of finishing, which
     # reads as infrastructure rather than as a test result (#7283). A single method can no longer
@@ -240,7 +251,7 @@ jobs:
         run: ttyd --version
 
       - name: Integration tests
-        run: mvn clean install -P integration-tests -Dit.groups='${{ matrix.shard.groups }}'
+        run: mvn clean install -P integration-tests -Dit.groups='${{ matrix.shard.groups }}' -Dit.partition='${{ matrix.shard.partition }}'
 
       # Guards #7215: a tag expression that discovers nothing leaves the reports directory absent
       # and the build green, so what ran is asserted by count instead of by the job's colour.
@@ -292,8 +303,12 @@ jobs:
       fail-fast: false
       matrix:
         shard:
-          - name: api
+          - name: api-1
+            groups: "!ui & !slow & !upgrade"
+            partition: "1/2"
+          - name: api-2
             groups: "!ui & !slow & !upgrade"
+            partition: "2/2"
           - name: ui
             groups: "ui & !slow & !sample & !camel"
           - name: samples
@@ -377,7 +392,7 @@ jobs:
             echo "::error::The datasource configuration did not reach this step - the suite would run on H2 (see #7249)"
             exit 1
           fi
-          mvn clean install -P integration-tests -Dit.groups='${{ matrix.shard.groups }}'
+          mvn clean install -P integration-tests -Dit.groups='${{ matrix.shard.groups }}' -Dit.partition='${{ matrix.shard.partition }}'
 
       # Guards #7215: a tag expression that discovers nothing leaves the reports directory absent
       # and the build green, so what ran is asserted by count instead of by the job's colour.
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index e0008c76854..d22bc7e237f 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -5,9 +5,9 @@ name: Nightly Integration Tests
 # PRs run the fast "smoke-tests" job (see pull-request.yml). Runs on a nightly schedule and on
 # demand; the same full suite also runs on every push to master (see build.yml). Like build.yml, the
 # suite is sharded into four tag-selected slices (api / ui / samples / slow) that run in parallel,
-# so the wall-clock time is the slowest shard ("api", ~57 min on h2 and ~62 on PostgreSQL), not the
-# whole suite. build.yml carries the description of what each shard selects and the measured shard
-# times behind the job timeout; keep the two matrices identical.
+# "api" itself as two hash partitions (api-1 / api-2), so the wall-clock time is the slowest shard,
+# not the whole suite. build.yml carries the description of what each shard selects and the
+# measured shard times behind the job timeout; keep the two matrices identical.
 on:
   schedule:
     - cron: '0 2 * * *'
@@ -24,8 +24,12 @@ jobs:
       fail-fast: false
       matrix:
         shard:
-          - name: api
+          - name: api-1
             groups: "!ui & !slow & !upgrade"
+            partition: "1/2"
+          - name: api-2
+            groups: "!ui & !slow & !upgrade"
+            partition: "2/2"
           - name: ui
             groups: "ui & !slow & !sample & !camel"
           - name: samples
@@ -69,7 +73,7 @@ jobs:
         run: ttyd --version
 
       - name: Integration tests
-        run: mvn clean install -P integration-tests -Dit.groups='${{ matrix.shard.groups }}'
+        run: mvn clean install -P integration-tests -Dit.groups='${{ matrix.shard.groups }}' -Dit.partition='${{ matrix.shard.partition }}'
 
       # Guards #7215: a tag expression that discovers nothing leaves the reports directory absent
       # and the build green, so what ran is asserted by count instead of by the job's colour.
@@ -183,8 +187,12 @@ jobs:
       fail-fast: false
       matrix:
         shard:
-          - name: api
+          - name: api-1
+            groups: "!ui & !slow & !upgrade"
+            partition: "1/2"
+          - name: api-2
             groups: "!ui & !slow & !upgrade"
+            partition: "2/2"
           - name: ui
             groups: "ui & !slow & !sample & !camel"
           - name: samples
@@ -268,7 +276,7 @@ jobs:
             echo "::error::The datasource configuration did not reach this step - the suite would run on H2 (see #7249)"
             exit 1
           fi
-          mvn clean install -P integration-tests -Dit.groups='${{ matrix.shard.groups }}'
+          mvn clean install -P integration-tests -Dit.groups='${{ matrix.shard.groups }}' -Dit.partition='${{ matrix.shard.partition }}'
 
       # Guards #7215: a tag expression that discovers nothing leaves the reports directory absent
       # and the build green, so what ran is asserted by count instead of by the job's colour.
diff --git a/pom.xml b/pom.xml
index 798cb735fef..0d8362f73e0 100644
--- a/pom.xml
+++ b/pom.xml
@@ -290,6 +290,10 @@
              plus the few explicitly-smoke UI journeys. -->
         <it.groups></it.groups>
         <it.excludedGroups></it.excludedGroups>
+        <!-- Integration-test partition, "k/n" (e.g. 1/2): keeps one of n hash partitions of the
+             classes the tag expression selected (ClassPartitionFilter in tests-integrations). Empty by
+             default - every selected class runs. CI splits the "api" shard with it. -->
+        <it.partition></it.partition>
     </properties>
 
     <build>
diff --git a/tests/tests-integrations/pom.xml b/tests/tests-integrations/pom.xml
index 6168de9a102..d7e372e37be 100644
--- a/tests/tests-integrations/pom.xml
+++ b/tests/tests-integrations/pom.xml
@@ -30,6 +30,12 @@
             <artifactId>junit-platform-suite</artifactId>
             <scope>compile</scope>
         </dependency>
+        <!-- PostDiscoveryFilter API for ClassPartitionFilter (-Dit.partition) -->
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-launcher</artifactId>
+            <scope>compile</scope>
+        </dependency>
         <dependency>
             <groupId>org.eclipse.dirigible</groupId>
             <artifactId>dirigible-application</artifactId>
@@ -138,6 +144,11 @@
                 <configuration>
                     <groups>${it.groups}</groups>
                     <excludedGroups>${it.excludedGroups}</excludedGroups>
+                    <!-- -Dit.partition=k/n keeps one hash partition of the selected classes
+                         (ClassPartitionFilter, registered as a JUnit PostDiscoveryFilter). -->
+                    <systemPropertyVariables>
+                        <dirigible.it.partition>${it.partition}</dirigible.it.partition>
+                    </systemPropertyVariables>
                     <!-- Fresh JVM per test class. Every IT boots a full Dirigible context per test
                          method (@DirtiesContext AFTER_EACH_TEST_METHOD) and closed contexts do not
                          release all their heap (schedulers, engine pools, statics), so a single
diff --git a/tests/tests-integrations/src/main/java/org/eclipse/dirigible/integration/tests/support/ClassPartitionFilter.java b/tests/tests-integrations/src/main/java/org/eclipse/dirigible/integration/tests/support/ClassPartitionFilter.java
new file mode 100644
index 00000000000..32612e0965e
--- /dev/null
+++ b/tests/tests-integrations/src/main/java/org/eclipse/dirigible/integration/tests/support/ClassPartitionFilter.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2010-2026 Eclipse Dirigible contributors
+ *
+ * All rights reserved. This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v2.0 which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v20.html
+ *
+ * SPDX-FileCopyrightText: Eclipse Dirigible contributors SPDX-License-Identifier: EPL-2.0
+ */
+package org.eclipse.dirigible.integration.tests.support;
+
+import java.util.Optional;
+
+import org.junit.platform.engine.FilterResult;
+import org.junit.platform.engine.TestDescriptor;
+import org.junit.platform.engine.TestSource;
+import org.junit.platform.engine.support.descriptor.ClassSource;
+import org.junit.platform.engine.support.descriptor.MethodSource;
+import org.junit.platform.launcher.PostDiscoveryFilter;
+
+/**
+ * Splits the selected test classes into {@code n} disjoint partitions and keeps only partition
+ * {@code k}, given as the system property {@value #PARTITION_PROPERTY} in the form {@code k/n} (for
+ * example {@code 1/2}). Without the property every test is kept.
+ *
+ * <p>
+ * The partition of a class is a hash of its top-level class name, so the partitions are disjoint
+ * and together complete by construction: a new IT lands in exactly one of them without anyone
+ * having to tag it, and a nested class always runs with its enclosing one. CI uses it to split a
+ * tag-selected shard whose classes cost about the same each - the HTTP-level "api" shard, which has
+ * no long pole a tag could move out.
+ *
+ * <p>
+ * Registered through {@code META-INF/services/org.junit.platform.launcher.PostDiscoveryFilter}, so
+ * the JUnit Platform launcher applies it after the tag filter of {@code -Dit.groups}.
+ */
+public final class ClassPartitionFilter implements PostDiscoveryFilter {
+
+    /** The system property that selects the partition, as {@code k/n}. */
+    public static final String PARTITION_PROPERTY = "dirigible.it.partition";
+
+    private final Optional<Partition> partition;
+
+    /**
+     * Reads the partition from {@value #PARTITION_PROPERTY}; called by the launcher's service loader.
+     */
+    public ClassPartitionFilter() {
+        this(System.getProperty(PARTITION_PROPERTY));
+    }
+
+    ClassPartitionFilter(String partition) {
+        this.partition = Partition.parse(partition);
+    }
+
+    @Override
+    public FilterResult apply(TestDescriptor descriptor) {
+        if (partition.isEmpty()) {
+            return FilterResult.included("no partition requested");
+        }
+        Optional<String> className = topLevelClassName(descriptor);
+        if (className.isEmpty()) {
+            return FilterResult.included("not a class or method");
+        }
+        return partition.get()
+                        .contains(className.get()) ? FilterResult.included("in partition " + partition.get())
+                                : FilterResult.excluded("not in partition " + partition.get());
+    }
+
+    private static Optional<String> topLevelClassName(TestDescriptor descriptor) {
+        Optional<String> className = descriptor.getSource()
+                                               .flatMap(ClassPartitionFilter::className);
+        return className.map(name -> {
+            int nested = name.indexOf('$');
+            return nested < 0 ? name : name.substring(0, nested);
+        });
+    }
+
+    private static Optional<String> className(TestSource source) {
+        if (source instanceof ClassSource classSource) {
+            return Optional.of(classSource.getClassName());
+        }
+        if (source instanceof MethodSource methodSource) {
+            return Optional.of(methodSource.getClassName());
+        }
+        return Optional.empty();
+    }
+
+    record Partition(int index, int count) {
+
+        static Optional<Partition> parse(String value) {
+            if (value == null || value.isBlank()) {
+                return Optional.empty();
+            }
+            String[] parts = value.trim()
+                                  .split("/");
+            if (parts.length != 2) {
+                throw invalid(value);
+            }
+            int index;
+            int count;
+            try {
+                index = Integer.parseInt(parts[0].trim());
+                count = Integer.parseInt(parts[1].trim());
+            } catch (NumberFormatException ex) {
+                throw invalid(value);
+            }
+            if (count < 1 || index < 1 || index > count) {
+                throw invalid(value);
+            }
+            return Optional.of(new Partition(index, count));
+        }
+
+        private static IllegalArgumentException invalid(String value) {
+            return new IllegalArgumentException(
+                    "Invalid " + PARTITION_PROPERTY + " [" + value + "]: expected k/n with 1 <= k <= n, e.g. 1/2");
+        }
+
+        boolean contains(String className) {
+            return Math.floorMod(className.hashCode(), count) == index - 1;
+        }
+
+        @Override
+        public String toString() {
+            return index + "/" + count;
+        }
+    }
+
+}
diff --git a/tests/tests-integrations/src/main/resources/META-INF/services/org.junit.platform.launcher.PostDiscoveryFilter b/tests/tests-integrations/src/main/resources/META-INF/services/org.junit.platform.launcher.PostDiscoveryFilter
new file mode 100644
index 00000000000..d68593c4496
--- /dev/null
+++ b/tests/tests-integrations/src/main/resources/META-INF/services/org.junit.platform.launcher.PostDiscoveryFilter
@@ -0,0 +1 @@
+org.eclipse.dirigible.integration.tests.support.ClassPartitionFilter
diff --git a/tests/tests-integrations/src/test/java/org/eclipse/dirigible/integration/tests/support/ClassPartitionFilterTest.java b/tests/tests-integrations/src/test/java/org/eclipse/dirigible/integration/tests/support/ClassPartitionFilterTest.java
new file mode 100644
index 00000000000..d244548eb05
--- /dev/null
+++ b/tests/tests-integrations/src/test/java/org/eclipse/dirigible/integration/tests/support/ClassPartitionFilterTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2010-2026 Eclipse Dirigible contributors
+ *
+ * All rights reserved. This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v2.0 which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v20.html
+ *
+ * SPDX-FileCopyrightText: Eclipse Dirigible contributors SPDX-License-Identifier: EPL-2.0
+ */
+package org.eclipse.dirigible.integration.tests.support;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+import java.util.stream.IntStream;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.junit.platform.engine.TestDescriptor;
+import org.junit.platform.engine.TestSource;
+import org.junit.platform.engine.UniqueId;
+import org.junit.platform.engine.support.descriptor.AbstractTestDescriptor;
+import org.junit.platform.engine.support.descriptor.ClassSource;
+import org.junit.platform.engine.support.descriptor.MethodSource;
+
+/**
+ * The partitions CI splits a shard into must be disjoint and together complete - a class in none of
+ * them would silently not run, which is the failure mode a tag- or name-based split invites.
+ */
+class ClassPartitionFilterTest {
+
+    private static final List<String> CLASS_NAMES = IntStream.range(0, 200)
+                                                             .mapToObj(i -> "org.eclipse.dirigible.integration.tests.api.Sample" + i + "IT")
+                                                             .toList();
+
+    @Test
+    void withoutAPartitionEveryClassIsIncluded() {
+        ClassPartitionFilter filter = new ClassPartitionFilter(null);
+
+        CLASS_NAMES.forEach(name -> assertTrue(included(filter, classDescriptor(name)), name));
+    }
+
+    @Test
+    void aBlankPartitionIncludesEveryClass() {
+        ClassPartitionFilter filter = new ClassPartitionFilter(" ");
+
+        CLASS_NAMES.forEach(name -> assertTrue(included(filter, classDescriptor(name)), name));
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {1, 2, 3})
+    void everyClassIsInExactlyOnePartition(int count) {
+        List<ClassPartitionFilter> partitions = IntStream.rangeClosed(1, count)
+                                                         .mapToObj(index -> new ClassPartitionFilter(index + "/" + count))
+                                                         .toList();
+
+        for (String name : CLASS_NAMES) {
+            long including = partitions.stream()
+                                       .filter(partition -> included(partition, classDescriptor(name)))
+                                       .count();
+            assertEquals(1, including, name);
+        }
+    }
+
+    @Test
+    void aNestedClassAndTheMethodsOfAClassFollowTheirTopLevelClass() {
+        for (String name : CLASS_NAMES) {
+            ClassPartitionFilter filter = new ClassPartitionFilter("1/2");
+            boolean topLevel = included(filter, classDescriptor(name));
+
+            assertEquals(topLevel, included(filter, classDescriptor(name + "$QueueTest")), name);
+            assertEquals(topLevel, included(filter, descriptor(MethodSource.from(name + "$QueueTest", "sends"))), name);
+            assertEquals(topLevel, included(filter, descriptor(MethodSource.from(name, "runs"))), name);
+        }
+    }
+
+    @Test
+    void aDescriptorWithoutAClassIsIncluded() {
+        assertTrue(included(new ClassPartitionFilter("2/2"), descriptor(null)));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"1", "0/2", "3/2", "1/0", "a/2", "1/2/3", "-1/2"})
+    void aMalformedPartitionIsRefused(String partition) {
+        assertThrows(IllegalArgumentException.class, () -> new ClassPartitionFilter(partition));
+    }
+
+    private static boolean included(ClassPartitionFilter filter, TestDescriptor descriptor) {
+        return filter.apply(descriptor)
+                     .included();
+    }
+
+    private static TestDescriptor classDescriptor(String className) {
+        return descriptor(ClassSource.from(className));
+    }
+
+    private static TestDescriptor descriptor(TestSource source) {
+        return new AbstractTestDescriptor(UniqueId.forEngine("test"), "test", source) {
+            @Override
+            public Type getType() {
+                return Type.CONTAINER;
+            }
+        };
+    }
+
+}