}
        return false;
    }

    /**
     * Releases the operation lock by deleting the operation document.
     * Safe to call multiple times; does nothing if the document is already deleted.
     *
     * @param operationName the operation name whose lock should be released.
     */
    public void completeOperation(final String operationName) {

	// was created.
	err = removeAll(pathJoin(disk.String(), bucket, object))
	if err != nil {
		t.Fatal(err)
	}

	// Checking abandoned parts should do nothing
	err = er.checkAbandonedParts(ctx, bucket, object, madmin.HealOpts{ScanMode: madmin.HealNormalScan, Remove: true})
	if err != nil {
		t.Fatal(err)
	}

    assertThat(FluentIterable.of(1, 2, 3).stream().filter(n -> n > 1)).containsExactly(2, 3);
  }

  private static void assertCanIterateAgain(Iterable<?> iterable) {
    for (Object unused : iterable) {
      // do nothing
    }
  }

  private static FluentIterable<Integer> fluent(Integer... elements) {
    return FluentIterable.from(Lists.newArrayList(elements));
  }

                if (parameters.length == 0) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("No valid parameters found in request. Nothing to store.");
                    }
                    return;
                }
                try {
                    final String encoded = serializeParameters(parameters);

    out of its utilization of rights under this License and You agree to
    work with Initial Developer and Contributors to distribute such
    responsibility on an equitable basis. Nothing herein is intended or
    shall be deemed to constitute any admission of liability.

------------------------------------------------------------------------

        return parentIndex;
      }
      queue[index] = x;
      return index;
    }

    // About the term "aunt node": it's better to leave gender out of it, but for this the English
    // language has nothing for us. Except for the whimsical neologism "pibling" (!) which we
    // obviously could not expect to increase anyone's understanding of the code.

    /**

         * - For FAIL_AT_END: Blacklists the project and its dependents, which causes executePlan to skip them
         * - For FAIL_NEVER: Does nothing special, allowing all projects to continue building
         * <p>
         * Note: TEARDOWN steps are not executed for failed or blacklisted projects, as they're designed for
         * successful project completions.

		totalBatch += batch
		return nil
	}); result.Error == nil || result.RowsAffected > 0 {
		t.Fatal("expected errors to have occurred, but nothing happened")
	}
	if totalBatch != 0 {
		t.Fatalf("incorrect total batch, expected: %v, got: %v", 0, totalBatch)
	}

      Double expectedDouble = null;
      try {
        expectedDouble = BigIntegerMath.roundToDouble(BigInteger.valueOf(candidate), UNNECESSARY);
      } catch (ArithmeticException expected) {
        // do nothing
      }

      if (expectedDouble != null) {
        assertThat(LongMath.roundToDouble(candidate, UNNECESSARY)).isEqualTo(expectedDouble);
      } else {
        assertThrows(

        .removeHeader("Content-Length")
        .build()
    server.enqueue(responseWithoutBody)
    val call = client.newCall(Request(server.url("/foo")))
    val response = call.execute()

    // Body contains nothing.
    assertThat(response.body.bytes().size).isEqualTo(0)
    assertThat(response.body.contentLength()).isEqualTo(0)

    // Content-Length header doesn't exist in a 204 response.