}

	switch minioErr.Code {
	case "SlowDownWrite":
		err = InsufficientWriteQuorum{Bucket: bucket, Object: object}
	case "SlowDownRead":
		err = InsufficientReadQuorum{Bucket: bucket, Object: object}
	case "PreconditionFailed":
		err = PreConditionFailed{}
	case "InvalidRange":
		err = InvalidRange{}
	case "BucketAlreadyOwnedByYou":
		err = BucketAlreadyOwnedByYou{}
	case "BucketNotEmpty":
		err = BucketNotEmpty{}

   * {@link #add(Object)} or {@link #pollFirstEntry}. This skeleton implementation correctly
   * delegates each of its operations to the appropriate methods of this {@code
   * ForwardingSortedMultiset}.
   *
   * <p>In many cases, you may wish to override {@link #descendingMultiset()} to return an instance
   * of a subclass of {@code StandardDescendingMultiset}.
   */
  protected abstract class StandardDescendingMultiset extends DescendingMultiset<E> {

        // Windows reserved names should be caught regardless of case
        try {
            validator.validatePath("\\share\\con");
            fail("Should block lowercase reserved name");
        } catch (SmbException e) {
            // Expected
        }

        try {
            validator.validatePath("\\share\\Con");
            fail("Should block mixed case reserved name");
        } catch (SmbException e) {

</p>

<pre>
switch tag {
default: s3()
case 0, 1, 2, 3: s1()
case 4, 5, 6, 7: s2()
}

switch x := f(); {  // missing switch expression means "true"
case x &lt; 0: return -x
default: return x
}

switch {
case x &lt; y: f1()
case x &lt; z: f2()
case x == 4: f3()
}
</pre>

<p>

	switch {
	case ctx.IsSet("config-dir"):
		ctxt.ConfigDir = ctx.String("config-dir")
		ctxt.configDirSet = true
	case ctx.GlobalIsSet("config-dir"):
		ctxt.ConfigDir = ctx.GlobalString("config-dir")
		ctxt.configDirSet = true
	}

	switch {
	case ctx.IsSet("certs-dir"):
		ctxt.CertsDir = ctx.String("certs-dir")
		ctxt.certsDirSet = true
	case ctx.GlobalIsSet("certs-dir"):

   * #expectContents(Object[]) expectContents(E...)} and other convenience methods. The creation of
   * multiple containers in a single method is discouraged in most cases, but it is vital to the
   * iterator tests.
   *
   * @return the new container instance
   * @param newValue the new container instance
   */
  @CanIgnoreReturnValue
  protected C resetContainer(C newValue) {

        when(mockNameServiceClient.getNodeStatus(nbtAddress)).thenThrow(new UnknownHostException());

        assertNull(nbtAddress.nextCalledName(mockContext));
        verify(mockNameServiceClient).getNodeStatus(nbtAddress);
    }

    @Test
    void testNextCalledName_OtherCases() {

In this case, we pass a dependency function `get_current_active_user` to `Security` (the same way we would do with `Depends`).

But we also pass a `list` of scopes, in this case with just one scope: `items` (it could have more).

   * #sizeIfKnown}, returning true if it's known to be zero and false if it's known to be non-zero.
   * If the size is not known, it falls back to opening a stream and checking for EOF.
   *
   * <p>Note that, in cases where {@code sizeIfKnown} returns zero, it is <i>possible</i> that bytes
   * are actually available for reading. (For example, some special files may return a size of 0

	}

	return latestFileInfo, nil
}

// validates functionality provided to find most common
// time occurrence from a list of time.
func TestCommonTime(t *testing.T) {
	// List of test cases for common modTime.
	testCases := []struct {
		times  []time.Time
		time   time.Time
		quorum int
	}{
		{
			// 1. Tests common times when slice has varying time elements.
			[]time.Time{