return set;
    }

    /**
     * Guaranteed to throw an exception and leave the collection unmodified.
     *
     * @throws UnsupportedOperationException always
     * @deprecated Unsupported operation.
     */
    @CanIgnoreReturnValue
    @Deprecated
    @Override
    @DoNotCall("Always throws UnsupportedOperationException")
    public final boolean add(@ParametricNullness E e) {

	}
	return false, nil
}

func newWarmBackendGCS(conf madmin.TierGCS, tier string) (*warmBackendGCS, error) {
	// Validation code
	if conf.Creds == "" {
		return nil, errors.New("empty credentials unsupported")
	}

	if conf.Bucket == "" {
		return nil, errors.New("no bucket name was provided")
	}

	credsJSON, err := conf.GetCredentialJSON()
	if err != nil {
		return nil, err
	}

        enterSatisfyGuardAndLeaveInCurrentThread();
        Thread.currentThread().interrupt();
        break;
      default:
        throw new AssertionError("unsupported scenario: " + scenario);
    }
  }

  private void runWaitTest() {
    assertFalse(Thread.currentThread().isInterrupted());
    assertFalse(monitor.isOccupiedByCurrentThread());
    monitor.enter();

		switch strings.ToLower(args.Endpoint.Scheme) {
		case "http":
			target.addr += ":80"
		case "https":
			target.addr += ":443"
		default:
			return nil, errors.New("unsupported scheme")
		}
	}

	if target.store != nil {
		store.StreamItems(target.store, target, target.cancelCh, target.loggerOnce)
	}

	return target, nil

                    throw new SmbException("Server does advertise any supported mechanism");
                }
            }
        } else if (spToken instanceof final NegTokenTarg targ) {
            if (this.firstResponse) {
                if (!this.mechContext.isSupported(targ.getMechanism())) {
                    throw new SmbException("Server chose an unsupported mechanism " + targ.getMechanism());
                }

        } else if (STRATEGY_SELF_FIRST.equals(classLoadingStrategy)) {
            realm.setParentRealm(parentRealm);
        } else {
            throw new IllegalArgumentException("Unsupported class-loading strategy '"
                    + classLoadingStrategy + "'. Supported values are: " + STRATEGY_PARENT_FIRST
                    + ", " + STRATEGY_PLUGIN + " and " + STRATEGY_SELF_FIRST);
        }

        case KerberosConstants.DES_ENC_TYPE -> decryptDES(data, key, cipher);
        case KerberosConstants.RC4_ENC_TYPE -> decryptRC4(data, key);
        default -> throw new GeneralSecurityException("Unsupported encryption type " + type);
        };
        return decrypt;
    }

    /**
     * @param data
     * @param key
     * @return
     * @throws GeneralSecurityException

Once the response has been received, the connection will be returned to the pool so it can be reused for a future request. Connections are evicted from the pool after a period of inactivity.

        /** Authentication and authorization errors */
        AUTHENTICATION,
        /** File system errors (not found, access denied, etc.) */
        FILE_SYSTEM,
        /** Protocol errors (invalid message, unsupported operation, etc.) */
        PROTOCOL,
        /** Resource errors (out of memory, disk space, etc.) */
        RESOURCE,
        /** Configuration errors */
        CONFIGURATION,

            assertTrue(response.getInfo() instanceof FileInternalInfo);
        }
    }

    @Test
    @DisplayName("Test readDataWireFormat with unsupported information level")
    void testReadDataWireFormatWithUnsupportedLevel() throws SMBProtocolDecodingException {
        byte unsupportedLevel = (byte) 0xFF;