try {
                final Auth auth = new Auth(getSettings(), request, response);
                final AuthnRequestParams authnRequestParams = new AuthnRequestParams(false, false, true);
                final String loginUrl = auth.login(null, authnRequestParams, true);
                request.getSession().setAttribute(SAML_STATE, UuidUtil.create());

        assertArgumentNotNull("file", file);
        assertArgumentNotEmpty("encoding", encoding);

        try {
            return new InputStreamReader(new FileInputStream(file), encoding);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Reads a single line from the given {@link BufferedReader}.
     *
     * @param reader

    @Test
    public void testSIllegalStateExceptionStringThrowable() {
        final ClIllegalStateException clIllegalStateException = new ClIllegalStateException("hoge", new NullPointerException());
        assertThat(clIllegalStateException.getMessage(), is("hoge"));
        assertThat(clIllegalStateException.getCause(), instanceOf(NullPointerException.class));
    }

    /**
     * Test method for

          sumOfSquaresOfDeltas = t;
        }
        return new MeanAndVariance(mean, sumOfSquaresOfDeltas / values.length);
      }
    },
    KNUTH {
      @Override
      MeanAndVariance variance(double[] values, MeanAlgorithm meanAlgorithm) {
        if (meanAlgorithm != MeanAlgorithm.KNUTH) {
          throw new SkipThisScenarioException();
        }
        double mean = values[0];

          sumOfSquaresOfDeltas = t;
        }
        return new MeanAndVariance(mean, sumOfSquaresOfDeltas / values.length);
      }
    },
    KNUTH {
      @Override
      MeanAndVariance variance(double[] values, MeanAlgorithm meanAlgorithm) {
        if (meanAlgorithm != MeanAlgorithm.KNUTH) {
          throw new SkipThisScenarioException();
        }
        double mean = values[0];

      @Nullable Object p4) {
    if (reference == null) {
      throw new NullPointerException(Platform.lenientFormat(errorMessageTemplate, p1, p2, p3, p4));
    }
    return reference;
  }

  /*
   * All recent hotspots (as of 2009) *really* like to have the natural code
   *
   * if (guardExpression) {
   *    throw new BadException(messageExpression);
   * }
   *

        return getStdoutLines(new String[] {"git", "diff", "--name-only", commit + "^1.." + commit});
    }

    private static List<String> branchesOf(String commit) throws IOException, InterruptedException, ExecutionException {
        List<String> lines = getStdoutLines(new String[] {"git", "branch", "-r", "--contains", commit});
        List<String> out = new ArrayList<>();
        for (String line : lines) {

    }

    private JvmObj getJvmObj() {
        final JvmObj jvmObj = new JvmObj();
        final JvmStats jvmStats = JvmStats.jvmStats();
        final Mem mem = jvmStats.getMem();
        final JvmMemoryObj jvmMemoryObj = new JvmMemoryObj();
        jvmObj.memory = jvmMemoryObj;
        final JvmMemoryHeapObj jvmMemoryHeapObj = new JvmMemoryHeapObj();
        jvmMemoryObj.heap = jvmMemoryHeapObj;

    assertTrue(TypeToken.of(subclass).isSubtypeOf(supertype));
  }

  @SuppressWarnings("RestrictedApiChecker") // crashes under JDK8, which EP no longer supports
  public void testSubtypeOfInnerClass_nonStaticAnonymousClass_typeParameterOfOwnerTypeNotMatch() {
    TypeToken<?> supertype = new TypeToken<Mall<Outdoor>.Shop<Electronics>>() {};

    extends AbstractMapBasedMultiset<E> {

  /** Creates a new, empty {@code LinkedHashMultiset} using the default initial capacity. */
  public static <E extends @Nullable Object> LinkedHashMultiset<E> create() {
    return new LinkedHashMultiset<>();
  }

  /**
   * Creates a new, empty {@code LinkedHashMultiset} with the specified expected number of distinct
   * elements.
   *