assertTrue(multimap().containsKey(null));
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)
  public void testContainsKeyNullAbsent() {
    assertFalse(multimap().containsKey(null));
  }

  @MapFeature.Require(absent = ALLOWS_NULL_KEY_QUERIES)
  public void testContainsKeyNullDisallowed() {
    assertThrows(NullPointerException.class, () -> multimap().containsKey(null));
  }

            .withPluginClasspath()
            .withArguments(":binary-compatibility:checkBinaryCompatibility", "-s")

        val (buildResult, failure) = try {
            runner.build()!! to null
        } catch (ex: UnexpectedBuildFailure) {
            ex.buildResult!! to ex
        }

        println(buildResult.output)

        remaining,
        dataLength,
        dataOffset,
        off;
    private byte[] b;
    private long offset;

private int pad;

    int writeMode;

    SmbComWriteAndX() {
        super( null );
        command = SMB_COM_WRITE_ANDX;
    }
    SmbComWriteAndX( int fid, long offset, int remaining,
                    byte[] b, int off, int len, ServerMessageBlock andx ) {
        super( andx );

        assertThrows(
                NoSuchFileException.class, () -> MavenPropertiesLoader.loadProperties(p, mavenUserProps, null, false));

        Path another = propsPath.resolveSibling("another.properties");
        Files.writeString(another, "bar = chti${java.version}\n");
        MavenPropertiesLoader.loadProperties(p, mavenUserProps, null, false);
        assertEquals("chti11z", p.getProperty("fro"));
    }

    @Test

	purge "${MC_BUILD_DIR}"

	"${MINIO_OLD[@]}" --address ":$start_port" "${WORK_DIR}/xl{1...16}" >"${WORK_DIR}/server1.log" 2>&1 &
	pid=$!
	disown $pid

	"${WORK_DIR}/mc" ready minio/

	if ! ps -p ${pid} 1>&2 >/dev/null; then
		echo "server1 log:"
		cat "${WORK_DIR}/server1.log"
		echo "FAILED"
		purge "$WORK_DIR"
		exit 1
	fi

	"${WORK_DIR}/mc" mb minio/healing-rewrite-bucket --quiet --with-lock
	"${WORK_DIR}/mc" cp \

      try {
        closeable.close();
      } catch (Throwable e) {
        if (throwable == null) {
          throwable = e;
        } else {
          suppressor.suppress(closeable, throwable, e);
        }
      }
    }

    if (thrown == null && throwable != null) {
      throwIfInstanceOf(throwable, IOException.class);
      throwIfUnchecked(throwable);

 *       typically because the type forbids nullable type arguments: For example, {@code
 *       ImmutableList.get} returns {@code E}, but that value is never {@code null}. (Accordingly,
 *       {@code ImmutableList} is declared to forbid {@code ImmutableList<@Nullable String>}.)
 *   <li>methods whose return type is a type variable but which can return {@code null} regardless

        project.setArtifacts( project.createArtifacts( null ) );

        String key = ArtifactUtils.versionlessKey( groupId, artifactId );

        Map artifactMap = project.getArtifactMap();

        assertNotNull( artifactMap, "artifact-map should not be null." );
        assertEquals( 1, artifactMap.size(), "artifact-map should contain 1 element." );

 */
fun main(vararg args: String) {
  System.setProperty("junit.jupiter.extensions.autodetection.enabled", "true")

  val inputFile = if (args.isNotEmpty()) File(args[0]) else null
  val selectors = testSelectors(inputFile)

  val summaryListener = SummaryGeneratingListener()
  val treeListener = treeListener()

  val jupiterTestEngine = buildTestEngine()

  val config =

                    throwValidationErrorApi(messages -> messages.addErrorsCrudCouldNotFindCrudTable(GLOBAL, id));
                    return null;
                })).status(Status.OK).result());
    }

    // PUT /api/admin/boostdoc/setting
    @Execute
    public JsonResponse<ApiResult> put$setting(final CreateBody body) {