import org.gradle.api.tasks.TaskAction


/**
 * This [Task][org.gradle.api.Task] reorders the changes in an accepted API changes files
 * so that they are alphabetically sorted (by type, then member).
 */
@CacheableTask
abstract class SortAcceptedApiChangesTask : AbstractAcceptedApiChangesMaintenanceTask() {

    @TaskAction
    fun execute() {

   *
   * @param collection the presumed-immutable collection
   * @param sampleElement an element of the same type as that contained by {@code collection}.
   *     {@code collection} may or may not have {@code sampleElement} as a member.
   */
  public static <E extends @Nullable Object> void assertCollectionIsUnmodifiable(
      Collection<E> collection, E sampleElement) {
    Collection<E> siblingCollection = new ArrayList<>();

      "IF SUSER_ID (N'gorm') IS NULL CREATE LOGIN gorm WITH PASSWORD = 'LoremIpsum86';" \
      "IF USER_ID (N'gorm') IS NULL CREATE USER gorm FROM LOGIN gorm; ALTER SERVER ROLE sysadmin ADD MEMBER [gorm];"
    do
      SQLCMDPASSWORD=LoremIpsum86 sqlcmd -U sa -S localhost:9930 -Q "$query" > /dev/null || true
    done
  else
    MSSQL_IMAGE=mcr.microsoft.com/mssql/server docker compose up -d --wait
  fi
  cd ..

   reported vulnerability and how it might be exploited. Alternatively,
   a well-established vulnerability identifier, e.g. CVE number, can be
   used instead.

Based on the description mentioned above, a MinIO engineer or security team
member investigates:

- Whether the reported vulnerability exists.
- The conditions that are required such that the vulnerability can be exploited.

- If you receive no response: ******@****.***

### Disclosure Process

MinIO uses the following disclosure process:

1. Once the security report is received one member of the security team tries to verify and reproduce
   the issue and determines the impact it has.
2. A member of the security team will respond and either confirm or reject the security report.
   If the report is rejected the response explains why.

/**
 * A set of goals to execute.
 *
 * @version $Revision$ $Date$
 */
@SuppressWarnings("all")
public class Execution implements java.io.Serializable {

    // --------------------------/
    // - Class/Member Variables -/
    // --------------------------/

    /**
     * Configuration to pass to the goals.
     */
    private Object configuration;

    /**
     * Field goals.
     */

        interfaces = ['internal': internalInterface,
                      'incubating': incubatingInterface]
    }

    def "#member change should not be reported"() {
        expect:
        noViolation(rule)

        where:
        member << [Mock(JApiMethod), Mock(JApiField), Mock(JApiImplementedInterface), Mock(JApiConstructor)]
    }

    def "nothing should be reported if no changes"() {

    MethodsRemovedInInternalSuperClassRule(Map<String, Object> params) {
        super(params)
    }

    protected boolean changed(JApiCompatibility member) {
        return member.compatibilityChanges.any { it.type == METHOD_REMOVED_IN_SUPERCLASS }
    }

    protected Violation checkSuperClassChanges(JApiClass c, CtClass oldClass, CtClass newClass) {

    #    ; map:{code=1; name=True ; alias=Checked  ; comment=means yes; sisterCode=true}
    #    ; map:{code=0; name=False; alias=Unchecked; comment=means no ; sisterCode=false}
    #}
    # example for table classification
    #; MemberStatus = list:{
    #    ; map:{topComment=status of member from entry to withdrawal; codeType=String}
    #    ; map:{

package jcifs.smb1.dcerpc.msrpc;

/**
 * MSRPC implementation for retrieving members of an alias.
 * This class provides functionality to get the list of security identifiers (SIDs)
 * that are members of a specific alias using the SAMR RPC interface.
 */
public class MsrpcGetMembersInAlias extends samr.SamrGetMembersInAlias {

    /**
     * Creates a new request to get members of an alias.
     *
     * @param aliasHandle the handle to the alias