*
     * @return JSON response containing system information
     */
    // GET /api/admin/systeminfo
    @Execute
    public JsonResponse<ApiResult> get$index() {
        final List<Map<String, String>> bugReportItems = getBugReportItems();
        final List<Map<String, String>> envItems = getEnvItems();
        final List<Map<String, String>> fessPropItems = getFessPropItems(fessConfig);

    E[] array = createSamplesArray();
    array[getNumElements() / 2] = e0();
    collection = getSubjectGenerator().create(array);
    assertEquals(
        "lastIndexOf(duplicate) should return index of last occurrence",
        getNumElements() / 2,
        getList().lastIndexOf(e0()));
  }

import org.apache.hc.core5.http.io.entity.EntityUtils
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Test

/**
 * Apache HttpClient 5.x.
 *
 * https://hc.apache.org/httpcomponents-client-5.0.x/index.html
 *
 * Baseline test if we ned to validate OkHttp behaviour against other popular clients.
 */
class ApacheHttpClientTest {
  private val httpClient = HttpClients.createDefault()

  @StartStop

- [Use `minio-go` SDK with MinIO Server](https://docs.min.io/community/minio-object-store/developers/go/minio-go.html)

            for (int i = 0; i < flags.length; i++) {
                for (int j = i + 1; j < flags.length; j++) {
                    assertEquals(0, flags[i] & flags[j], String.format("Flags at index %d and %d should not overlap", i, j));
                }
            }
        }
    }

    @Nested
    @DisplayName("Action Constants Tests")
    class ActionConstantsTests {

        @Test

  val boundary: String
    get() = boundaryByteString.utf8()

  /** The number of parts in this multipart body. */
  @get:JvmName("size")
  val size: Int
    get() = parts.size

  fun part(index: Int): Part = parts[index]

  override fun isOneShot(): Boolean = parts.any { it.body.isOneShot() }

  /** A combination of [type] and [boundaryByteString]. */
  override fun contentType(): MediaType = contentType

		p.errorf("%s: expected integer constant; found %s", op, obj.Dconv(prog, addr))
	}
	return addr.Offset
}

// getRegister checks that addr represents a register and returns its value.
func (p *Parser) getRegister(prog *obj.Prog, op obj.As, addr *obj.Addr) int16 {
	if addr.Type != obj.TYPE_REG || addr.Offset != 0 || addr.Name != 0 || addr.Index != 0 {

    val now = taskRunner.backend.nanoTime()
    val executeNanoTime = now + delayNanos

    // If the task is already scheduled, take the earlier of the two times.
    val existingIndex = futureTasks.indexOf(task)
    if (existingIndex != -1) {
      if (task.nextExecuteNanoTime <= executeNanoTime) {
        taskRunner.logger.taskLog(task, this) { "already scheduled" }
        return false
      }

			if err != nil {
				writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
				return
			}
			if dstOpts.IndexCB != nil {
				dstOpts.IndexCB = compressionIndexEncrypter(objEncKey, dstOpts.IndexCB)
			}
			dstOpts.EncryptFn = metadataEncrypter(objEncKey)
		}
	}

	srcInfo.PutObjReader = pReader

    public byte[] getKey() {
        return Arrays.copyOf(key, LEASE_KEY_SIZE);
    }

    /**
     * Write the lease key to a buffer
     *
     * @param dst destination buffer
     * @param dstIndex starting index in destination buffer
     */
    public void encode(byte[] dst, int dstIndex) {
        System.arraycopy(key, 0, dst, dstIndex, LEASE_KEY_SIZE);
    }

    /**
     * Check if this is a zero key (all bytes are zero)