@Test
void siblings() throws InterruptedException {
    TestObservationRegistry registry = TestObservationRegistry.builder()
        .validateScopesClosedInReverseOrderOfOpening(true)
        .build();
    registry.observationConfig().observationHandler(new ObservationTextPublisher());

//        Forcing the following order but scope 1 and scope2 are siblings
//            - scope1.open
//            - scope2.open
//            - scope1.close
//            - scope2.close

    CountDownLatch scopeOneOpenLatch = new CountDownLatch(1);
    CountDownLatch scopeTwoOpenLatch = new CountDownLatch(1);
    CountDownLatch scopeOneCloseLatch = new CountDownLatch(1);

    AtomicReference<Exception> error = new AtomicReference<>();
    Thread thread1 = new Thread(() -> {
        Observation observation1 = Observation.start("one", registry);
        try {
            Scope scope1 = observation1.openScope();
            scopeOneOpenLatch.countDown();
            scopeTwoOpenLatch.await();
            scope1.close();
            scopeOneCloseLatch.countDown();
        }
        catch (Exception e) {
            error.set(e);
        }
        finally {
            scopeOneCloseLatch.countDown();
        }
    });
    Thread thread2 = new Thread(() -> {
        try {
            scopeOneOpenLatch.await();
            Observation observation2 = Observation.start("two", registry);
            Scope scope2 = observation2.openScope();
            scopeTwoOpenLatch.countDown();
            scopeOneCloseLatch.await();
            scope2.close();
            observation2.stop();
        }
        catch (Exception e) {
            // noop
        }
    });

    thread1.start();
    thread2.start();
    thread1.join();
    thread2.join();

    assertThat(error.get()).isNull();
}