}
      };

  /**
   * A Throwable used to record a stack trace that illustrates an example of a specific lock
   * acquisition ordering. The top of the stack trace is truncated such that it starts with the
   * acquisition of the lock in question, e.g.
   *
   * <pre>
   * com...ExampleStackTrace: LockB -&gt; LockC
   *   at com...CycleDetectingReentrantLock.lock(CycleDetectingLockFactory.java:443)

    // Once the journal has a failure, subsequent writes aren't permitted.
    filesystem.setFaultyWrite(journalFile, false)
    assertThat(cache.edit("d")).isNull()

    // Confirm that the fault didn't corrupt entries stored before the fault was introduced.
    cache.close()
    cache =
      DiskLruCache(filesystem, cacheDir, appVersion, 2, Int.MAX_VALUE.toLong(), taskRunner).also {
        toClose.add(it)
      }

        NdrBuffer derivedBuffer = ndrBuffer.derive(10);

        // Verify derived buffer properties
        assertSame(buffer, derivedBuffer.buf);
        assertEquals(0, derivedBuffer.start); // Derived buffer starts from the original buffer's start
        assertEquals(10, derivedBuffer.index);
        assertSame(ndrBuffer.deferred, derivedBuffer.deferred); // Deferred should be the same as original

```

Follow the MinIO Client [Quickstart Guide](https://docs.min.io/community/minio-object-store/reference/minio-mc.html#quickstart) for further instructions.

## Explore Further

- [The MinIO documentation website](https://docs.min.io/community/minio-object-store/index.html)
- [MinIO Erasure Code Overview](https://docs.min.io/community/minio-object-store/operations/concepts/erasure-coding.html)

	// This will prevent downgrades to incompatible versions.
	xlVersionMajor = 1

	// Non breaking changes.
	// Bumping this is informational, but should be done
	// if any change is made to the data stored, bumping this
	// will allow to detect the exact version later.
	xlVersionMinor = 1
)

func init() {
	binary.LittleEndian.PutUint16(xlVersionCurrent[0:2], xlVersionMajor)

// Name - returns the Name of the target.
func (target *MySQLTarget) Name() string {
	return target.ID().String()
}

// Store returns any underlying store if set.
func (target *MySQLTarget) Store() event.TargetStore {
	return target.store
}

// IsActive - Return true if target is up and active
func (target *MySQLTarget) IsActive() (bool, error) {
	if err := target.init(); err != nil {
		return false, err
	}

        SMBUtil.writeInt4(6, buffer, notifyOffset + 8); // 6 bytes filename
        System.arraycopy("abc".getBytes("UnicodeLittleUnmarked"), 0, buffer, notifyOffset + 12, 6);

        // Second notification starts at aligned offset
        notifyOffset = 108; // 80 + 28
        SMBUtil.writeInt4(0, buffer, notifyOffset);
        SMBUtil.writeInt4(2, buffer, notifyOffset + 4);
        SMBUtil.writeInt4(8, buffer, notifyOffset + 8);

      while (elements.hasNext()) {
        add(elements.next());
      }
      return this;
    }

    @CanIgnoreReturnValue
    @SuppressWarnings("unchecked") // ArrayBasedBuilder stores its elements as Object.
    Builder<E> combine(Builder<E> other) {
      if (hashTable != null) {
        for (int i = 0; i < other.size; ++i) {

 * arrange). The rules for creating such tests are:
 *
 * <ol>
 *   <li>All assertions in code running in generated threads must use the forms {@link
 *       #threadUnexpectedException} or {@link #threadRecordFailure} (which is called by {@link
 *       CheckedRunnable} and {@link CheckedCallable}).

 *    IP address (`74.122.190.80`), or a hostname pattern (`*.api.squareup.com`).
 *
 *  * **A validity interval.** A certificate should not be used before its validity interval starts
 *    or after it ends.
 *
 *  * **A public key.** This cryptographic key is used for asymmetric encryption digital signatures.
 *    Note that the private key is not a part of the certificate!
 *