* ```
 */
class MockWebServerRule : ExternalResource() {
  val server: MockWebServer = MockWebServer()

  override fun before() {
    try {
      server.start()
    } catch (e: IOException) {
      throw RuntimeException(e)
    }
  }

  override fun after() {
    server.close()
  }

            fail("Should throw exception");
        } catch (Exception e) {
            // Expected
        }
    }

    @Test
    public void test_getJobExecutor_withoutSuffix() {
        try {
            ComponentUtil.getJobExecutor("test");
            fail("Should throw exception");
        } catch (Exception e) {
            // Expected
        }
    }

    @Test

            .isNotEqualTo(paramType);
      } catch (IllegalArgumentException notSubtype1) {
        // The raw class isn't even a subclass.
      }
    }
    if (!spec.suppressGetSupertype()) {
      try {
        assertThat(getSupertype(paramType, TypeToken.of(returnType).getRawType()))
            .isNotEqualTo(returnType);
      } catch (IllegalArgumentException notSubtype2) {

      // This set never contains null.  We need to explicitly check here
      // because some comparator might throw NPE (e.g. the natural ordering).
      return object != null && sortedDelegate.contains(object);
    } catch (ClassCastException e) {
      return false;
    }
  }

  @Override
  public boolean containsAll(Collection<?> targets) {
    for (Object target : targets) {
      if (target == null) {

  @Override
  public boolean equals(@Nullable Object obj) {
    if (obj instanceof Cut) {
      // It might not really be a Cut<C>, but we'll catch a CCE if it's not
      Cut<C> that = (Cut<C>) obj;
      try {
        int compareResult = compareTo(that);
        return compareResult == 0;
      } catch (ClassCastException wastNotComparableToOurType) {
        return false;
      }
    }
    return false;
  }

            } catch (final Throwable ignore) {
                // Fall through to next option
            }
        }

        // Check for Commons Logging
        if (isClassAvailable("org.apache.commons.logging.LogFactory")) {
            try {
                return new JclLoggerAdapterFactory();
            } catch (final Throwable ignore) {

        try {
            final SimpleTemplateEngine engine = new SimpleTemplateEngine();
            engine.createTemplate(template).make(bindings).writeTo(writer);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }

        return writer.toString().replace("\\r", "");
    }

            if (path == null) {
                path = '' // Catch requests to the root...
            } else {
                path = path.replace('<', '%3C').replace('>', '%3E')
            }
            current.println("  - do:")
            if (catchPart != null) {
                current.println("      catch: $catchPart")
            }
            if (false == warnings.isEmpty()) {

  @Override
  public void run() {
    T result = null;
    Throwable error = null;
    if (isDone()) {
      return;
    }
    try {
      result = runInterruptibly();
    } catch (Throwable t) {
      error = t;
    }
    if (error == null) {
      // The cast is safe because of the `run` and `error` checks.
      afterRanInterruptiblySuccess(uncheckedCastNullableTToT(result));
    } else {

      boolean isPowerOf2 = BigIntegerMath.isPowerOfTwo(x);
      try {
        assertEquals(x, ZERO.setBit(BigIntegerMath.log2(x, UNNECESSARY)));
        assertTrue(isPowerOf2);
      } catch (ArithmeticException e) {
        assertFalse(isPowerOf2);
      }
    }
  }

  public void testLog2HalfUp() {
    for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) {