return request(Method.PUT, path).header("Content-Type", "application/json");
    }

    public CurlRequest delete(final String path) {
        return request(Method.DELETE, path).header("Content-Type", "application/json");
    }

    public CurlRequest request(final Method method, final String path) {
        return request(new FesenRequest(new CurlRequest(method, null), nodeManager, path));
    }

   * without having to add {@code @SuppressWarnings}, the code can call this method.
   *
   * <p>Why <i>not</i> just add {@code SuppressWarnings}? The problem is that this method is
   * typically useful for {@code return} statements. That leaves the code with two options: Either
   * add the suppression to the whole method (which turns off checking for a large section of code),

/**
 * Static convenience methods that help a method or constructor check whether it was invoked
 * correctly (that is, whether its <i>preconditions</i> were met).
 *
 * <p>If the precondition is not met, the {@code Preconditions} method throws an unchecked exception
 * of a specified type, which helps the method in which the exception was thrown communicate that

    // we create a test suite containing a test for every FuturesTest test method and we
    // set it as the name of the test.  Then in runTest we can reflectively load and invoke the
    // corresponding method on FuturesTest in the correct classloader.
    TestSuite suite = new TestSuite(AggregateFutureStateFallbackAtomicHelperTest.class.getName());
    for (Method method : FuturesTest.class.getDeclaredMethods()) {

    return suite;
  }

  protected Collection<Method> suppressForCheckedNavigableSet() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForEmptySet() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForEmptyNavigableSet() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForEmptySortedSet() {
    return Collections.emptySet();

    /**
     * @see org.junit.rules.ExpectedException
     */
    @Rule
    public ExpectedException exception = ExpectedException.none();

    /**
     * Test method for
     * {@link org.codelibs.core.io.PropertiesUtil#load(java.util.Properties, java.io.InputStream)}
     * .
     */
    @Test
    public void testLoadPropertiesInputStream() {

    for (final Method method : testMethods) {
      suite.addTest(new ByteSinkTester(factory, bytes, name, desc, method));
    }
    return suite;
  }

  private ByteSink sink;

  ByteSinkTester(
      ByteSinkFactory factory, byte[] data, String suiteName, String caseDesc, Method method) {
    super(factory, data, suiteName, caseDesc, method);
  }

  @Override

      String name, CharSinkFactory factory, String string, String desc) {
    TestSuite stringSuite = new TestSuite(name + " [" + desc + "]");
    for (final Method method : testMethods) {
      stringSuite.addTest(new CharSinkTester(factory, string, name, desc, method));
    }
    return stringSuite;
  }

  private final ImmutableList<String> lines;
  private final ImmutableList<String> expectedLines;

    }
  }

  /**
   * Inserts the specified element into this priority queue. As the queue is unbounded this method
   * will never block.
   *
   * @param e the element to add
   * @param timeout This parameter is ignored as the method never blocks
   * @param unit This parameter is ignored as the method never blocks
   * @return {@code true}

            "Method" to "$containingType.getBarExt(java.lang.String)",
            "Method" to "$containingType.getBazar()",
            "Method" to "$containingType.getBazarExt(int)",
        ) + (if (isEnum) listOf(
            "Method" to "$containingType.getEntries()",
        ) else emptyList()) + listOf(
            "Method" to "$containingType.setBazar(java.lang.String)",