}

  @J2ktIncompatible
  @GwtIncompatible
  public void testAsAsyncCallable_exception() throws Exception {
    final Exception expected = new IllegalArgumentException();
    Callable<String> callable =
        new Callable<String>() {
          @Override
          public String call() throws Exception {
            throw expected;
          }
        };

    AsyncCallable<String> asyncCallable =

            if ( ! ( e.getCause() instanceof GSSException ) ) {
                throw e;
            }
            log.error("Kerberos problem", e);
            Assume.assumeTrue("Kerberos problem, clockskew?", false);
        }
    }


    public static Subject getInitiatorSubject ( KeyTab keytab, final KerberosPrincipal principal ) throws Asn1Exception, KrbException, IOException {

		name    string
		state   flagState
		want    string
		wantErr bool
	}{
		{
			name:    "resetState.run() should throw an error if the /scopej endpoint is missing",
			state:   &resetState{client: ctrzClientNoScopejHandler},
			wantErr: true,
		},
		{
			name: "logLevelState.run() should throw an error if the /scopej endpoint is missing",
			state: &logLevelState{
				client:         ctrzClientNoScopejHandler,

    new Thread(
            new Runnable() {
              @Override
              public void run() {
                try {
                  barrier.await();
                } catch (Exception e) {
                  throw new AssertionError(e);
                }

                dispatcher.dispatch(2, integerSubscribers.iterator());
                latch.countDown();
              }
            })
        .start();

            case HALF_UP:
              return (sign(x) >= 0) ? roundCeilingAsDouble : roundFloorAsDouble;
            default:
              throw new AssertionError("impossible");
          }
        }
    }
    throw new AssertionError("impossible");
  }

     * AccessResult)
     */
    @Override
    public void store(final AccessResultImpl<Long> accessResult) {
        if (accessResult == null) {
            throw new CrawlerSystemException("AccessResult is null.");
        }

        synchronized (idCountLock) {
            idCount++;
            accessResult.setId(idCount);

      try {
        field.set(instance, value);
      } catch (IllegalAccessException impossible) {
        throw new AssertionError(impossible);
      }
    }

    void set(T instance, int value) {
      try {
        field.set(instance, value);
      } catch (IllegalAccessException impossible) {
        throw new AssertionError(impossible);
      }
    }
  }

                throw new SsoLoginException("could not validate nonce");
            }

            final String nonce = (String) claimsSet.getClaim("nonce");
            if (logger.isDebugEnabled()) {
                logger.debug("nonce: {}", nonce);
            }
            if (StringUtils.isEmpty(nonce) || !nonce.equals(stateData.getNonce())) {
                throw new SsoLoginException("could not validate nonce");

        Objects.requireNonNull(output, "output cannot be null");
        Objects.requireNonNull(settings, "settings cannot be null");

        try (Writer out = output) {
            new SettingsStaxWriter().write(out, settings.getDelegate());
        } catch (XMLStreamException e) {
            throw new IOException("Error writing settings", e);
        }
    }

      throw new UnsupportedOperationException();
    }

    @Override
    public boolean putAll(@ParametricNullness K key, Iterable<? extends V> values) {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean putAll(Multimap<? extends K, ? extends V> multimap) {
      throw new UnsupportedOperationException();
    }

    @Override