* collection in setUp(), but that caused problems when a tester changed the
   * value of set or collection but not both.
   */
  protected final Set<E> getSet() {
    return (Set<E>) collection;
  }

    val realChain = chain as RealInterceptorChain
    val exchange = realChain.call.initExchange(realChain)
    val connectedChain = realChain.copy(exchange = exchange)
    return connectedChain.proceed(realChain.request)
  }

  }

  public void testOverriddenInSubclassNowhereAnnotated() {
    assertThat(getSubscriber().overriddenInSubclassNowhereAnnotatedEvents).isEmpty();
  }

  @Override
  SubClass createSubscriber() {
    return new SubClass();
  }

    } else if (firstChar == '0' && stringValue.length() > 1) {
      rawValue = stringValue.substring(1);
      radix = 8;
    } else {
      rawValue = stringValue;
      radix = 10;
    }

    return new ParseRequest(rawValue, radix);
  }

 */
abstract class AbstractEventBusTest<H> extends TestCase {
  static final Object EVENT = new Object();

  abstract H createSubscriber();

  private @Nullable H subscriber;

  H getSubscriber() {
    return subscriber;
  }

  @Override
  protected void setUp() throws Exception {
    subscriber = createSubscriber();
    EventBus bus = new EventBus();
    bus.register(subscriber);
    bus.post(EVENT);
  }

     * Determines which of the specified versions of an artifact to use when there are conflicting declarations.
     *
     * @param node1 the first artifact declaration
     * @param node2 the second artifact declaration
     * @return the artifact declaration to use: <code>node1</code>; <code>node2</code>; or <code>null</code>if
     *         this conflict cannot be resolved
     * @since 3.0
     */

     */
    public ContentOutputStream(final int threshold, final File tmpDir) {
        super(threshold, PREFIX, SUFFIX, tmpDir);
    }

    @Override
    public File getFile() {
        done = true;
        return super.getFile();
    }

    /**
     * Closes the stream and deletes the temporary file if it was not retrieved.
     * If an error occurs during file deletion, it is logged but not thrown to avoid

    @BeforeEach
    void setUp() {
        mockOrchestrator = mock(StrategyOrchestrator.class);
        applyGoal = new Apply(mockOrchestrator);
    }

    private UpgradeContext createMockContext() {
        return TestUtils.createMockContext();
    }

    @Nested
    @DisplayName("Modification Behavior")
    class ModificationBehaviorTests {

        @Test
        @DisplayName("should save modifications to disk")

    // Helper methods

    private Object getFieldValue(Object obj, String fieldName) {
        try {
            Field field = getField(obj.getClass(), fieldName);
            field.setAccessible(true);
            return field.get(obj);
        } catch (Exception e) {
            throw new RuntimeException("Failed to get field value: " + fieldName, e);
        }
    }

        val shortenedSubprojectName = subProjectName.replace("internal", "i").replace("Testing", "T")
        if (shortenedSubprojectName.length + prefix.length <= 80) {
            return shortenedSubprojectName
        }
        return shortenedSubprojectName.replace(Regex("[aeiou]"), "")
    }

    fun asName(): String =
        listOf(
            testType.name
                .lowercase()
                .toCamelCase()