writer.println("rud a chur ar an méar fhada");
    writer.close();

    // First check that we can't find it without setting the context loader.
    // This is a sanity check that the test doesn't spuriously pass because
    // the resource is visible to the system class loader.
    assertThrows(IllegalArgumentException.class, () -> Resources.getResource(tempFile.getName()));

    writer.println("rud a chur ar an méar fhada");
    writer.close();

    // First check that we can't find it without setting the context loader.
    // This is a sanity check that the test doesn't spuriously pass because
    // the resource is visible to the system class loader.
    assertThrows(IllegalArgumentException.class, () -> Resources.getResource(tempFile.getName()));

   * href="#bitEquals">bitwise equal</a> to the expected value.
   *
   * <p>May <a
   * href="https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html#Spurious">
   * fail spuriously</a> and does not provide ordering guarantees, so is only rarely an appropriate
   * alternative to {@code compareAndSet}.
   *
   * @param expect the expected value
   * @param update the new value

          //                ||----w |
          //                ||     ||
          // We need to clear the interrupted bit prior to calling park and maintain it in case we
          // wake up spuriously.
          restoreInterruptedBit = Thread.interrupted() || restoreInterruptedBit;
          LockSupport.park(blocker);
        }
      } else {
        Thread.yield();
      }
      state = get();
    }

   * value is <a href="#bitEquals">bitwise equal</a> to the expected value.
   *
   * <p>May <a
   * href="https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html#Spurious">
   * fail spuriously</a> and does not provide ordering guarantees, so is only rarely an appropriate
   * alternative to {@code compareAndSet}.
   *
   * @param i the index
   * @param expect the expected value

- Prevent the replicaset controller from spuriously reconciling while its own writes have not been read. ([#137212](https://github.com/kubernetes/kubernetes/pull/137212), [@michaelasp](https://github.com/michaelasp)) [SIG Apps]

   * converts that into a <a
   * href="https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/concurrent/locks/Condition.html#implementation-considerations-heading">spurious
   * wakeup</a>. This means that resulting wait is not "uninterruptible" in the normal sense of
   * {@link Uninterruptibles}. Still, this method allows callers to write <a

  static void parkNanos(@Nullable Object blocker, long nanos) {
    // Even in the extremely unlikely event that a thread unblocks itself early after only 68 years,
    // this is indistinguishable from a spurious wakeup, which LockSupport allows.
    LockSupport.parkNanos(blocker, min(nanos, MAX_NANOSECONDS_THRESHOLD));
  }

   * occur except for those produced by awaitUninterruptibly itself in response to interrupts.
   *
   * This isn't guaranteed to work, so any further spurious wakeups would probably cause failures in
   * tests that assert that a certain amount of time has passed, that the method returned `false`,
   * or even that an interrupt occurred (if the spurious wakeup happens before the interrupt).
   *

   * occur except for those produced by awaitUninterruptibly itself in response to interrupts.
   *
   * This isn't guaranteed to work, so any further spurious wakeups would probably cause failures in
   * tests that assert that a certain amount of time has passed, that the method returned `false`,
   * or even that an interrupt occurred (if the spurious wakeup happens before the interrupt).
   *