logger.debug("Updating job schedule: name={}", scheduledJob.getName());
                }
                try {
                    jobHelper.register(scheduledJob);
                } catch (final Exception e) {
                    logger.warn("Failed to update schedule: job={}", scheduledJob, e);
                }
            });
            schedulerTime = now;

    assertEquals(false, tearDownOne.ran);
    assertEquals(false, tearDownTwo.ran);

    try {
      stack.runTearDown();
      fail("runTearDown should have thrown an exception");
    } catch (RuntimeException expected) {
      assertThat(expected).hasMessageThat().isEqualTo("two");
      assertThat(getOnlyElement(asList(expected.getSuppressed())))
          .hasMessageThat()
          .isEqualTo("one");
    }

        try {
            String state = mayUpdate();
            if (state == null) {
                return null;
            }
            return target.toFile();
        } catch (IOException | XMLStreamException | ModelBuilderException e) {
            throw new TransformationFailedException(e);
        }
    }

    AtomicInteger runCalled = new AtomicInteger();
    list.add(
        new Runnable() {
          @Override
          public void run() {
            try {
              okayToRun.await();
            } catch (InterruptedException e) {
              Thread.currentThread().interrupt();
              throw new RuntimeException(e);
            }
            runCalled.getAndIncrement();
          }
        },

                            .getPluginDescriptor()
                            .getLifecycleMappings()
                            .values()));
                } catch (Exception e) {
                    throw new RuntimeException("Unable to load plugin lifecycles", e);
                }
            }

            @Override
            public ClassLoader getClassLoader() {

    try {
      while (true) {
        val event = takeEvent()
        if (eventClass.isInstance(event)) {
          return eventClass.cast(event)
        }
      }
    } catch (e: NoSuchElementException) {
      throw AssertionError("full event sequence: $fullEventSequence", e)
    }
  }

  /**
   * Remove and return the next event from the recorded sequence.
   *

                sslContext.init(null, trustManagerFactory.getTrustManagers(), null);
                sslSocketFactory = sslContext.getSocketFactory();
            } catch (final Exception e) {
                logger.warn("Failed to load certificate_authorities: path={}", authorities, e);
            }
        }

        final String[] hosts = split(ResourceUtil.getFesenHttpUrl(), ",")

        // same auth instance => matches
        assertTrue(s1.matches(a1));
        // different instance but equal content => matches
        assertTrue(s1.matches(a2));
        // not equal => no match
        NtlmPasswordAuthentication other = new NtlmPasswordAuthentication("OTHER", "u", "p");
        assertFalse(s1.matches(other));
    }

    @Test
    void toStringContainsKeyFields() {

        byte[] domain = {};
        if (domainStr != null) {
            try {
                domain = domainStr.getBytes(UNI_ENCODING);
            } catch (final IOException ex) {
                log.debug("Failed to get domain bytes", ex);
            }
        }
        final int domainLength = domain.length;
        byte[] server = {};

        // Assert: first page
        assertTrue(it.hasNext(), "Iterator should have first element");
        assertSame(fe1, it.next(), "First element must match first page");
        assertTrue(it.hasNext(), "Iterator should have second element");
        assertSame(fe2, it.next(), "Second element must match first page");

        // Next page fetched via fetchMore()
        assertTrue(it.hasNext(), "Iterator should have third element after fetchMore");