text:
package com.amazonaws.services.simplesystemsmanagement.model;

import java.io.Serializable;
import javax.annotation.Generated;
import com.amazonaws.protocol.StructuredPojo;
import com.amazonaws.protocol.ProtocolMarshaller;

/**
 *

 * Information about a task defined for a maintenance window.
 *

 *
 * @see AWS API
 *      Documentation
 */
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class MaintenanceWindowTask implements Serializable, Cloneable, StructuredPojo {

    /**
     *

     * The ID of the maintenance window where the task is registered.
     *

     */
    private String windowId;
    /**
     *

     * The task ID.
     *

     */
    private String windowTaskId;
    /**
     *

     * The resource that the task uses during execution. For RUN_COMMAND and AUTOMATION task
     * types, TaskArn is the Amazon Web Services Systems Manager (SSM document) name or ARN. For
     * LAMBDA tasks, it's the function name or ARN. For STEP_FUNCTIONS tasks, it's the state
     * machine ARN.
     *

     */
    private String taskArn;
    /**
     *

     * The type of task.
     *

     */
    private String type;
    /**
     *

     * The targets (either managed nodes or tags). Managed nodes are specified using
     * Key=instanceids,Values=<instanceid1>,<instanceid2>. Tags are specified using
     * Key=<tag name>,Values=<tag value>.
     *

     */
    private com.amazonaws.internal.SdkInternalList<Target> targets;
    /**
     *

     * The parameters that should be passed to the task when it is run.
     *

     * <note>
     *

     * TaskParameters has been deprecated. To specify parameters to pass to a task when it runs, instead
     * use the Parameters option in the TaskInvocationParameters structure. For information
     * about how Systems Manager handles these options for the supported maintenance window task types, see
     * MaintenanceWindowTaskInvocationParameters.
     *

     * </note>
     */
    private java.util.Map<String, MaintenanceWindowTaskParameterValueExpression> taskParameters;
    /**
     *

     * The priority of the task in the maintenance window. The lower the number, the higher the priority. Tasks that
     * have the same priority are scheduled in parallel.
     *

     */
    private Integer priority;
    /**
     *

     * Information about an S3 bucket to write task-level logs to.
     *

     * <note>
     *

     * LoggingInfo has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3) bucket to
     * contain logs, instead use the OutputS3BucketName and OutputS3KeyPrefix options in the
     * TaskInvocationParameters structure. For information about how Amazon Web Services Systems Manager
     * handles these options for the supported maintenance window task types, see
     * MaintenanceWindowTaskInvocationParameters.
     *

     * </note>
     */
    private LoggingInfo loggingInfo;
    /**
     *

     * The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) service role to use to publish Amazon
     * Simple Notification Service (Amazon SNS) notifications for maintenance window Run Command tasks.
     *

     */
    private String serviceRoleArn;
    /**
     *

     * The maximum number of targets this task can be run for, in parallel.
     *

     * <note>
     *

     * Although this element is listed as "Required: No", a value can be omitted only when you are registering or
     * updating a targetless task You must provide a value in all other cases.
     *

     *

     * For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the
     * system inserts a placeholder value of 1. This value doesn't affect the running of your task.
     *

     * </note>
     */
    private String maxConcurrency;
    /**
     *

     * The maximum number of errors allowed before this task stops being scheduled.
     *

     * <note>
     *

     * Although this element is listed as "Required: No", a value can be omitted only when you are registering or
     * updating a targetless task You must provide a value in all other cases.
     *

     *

     * For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the
     * system inserts a placeholder value of 1. This value doesn't affect the running of your task.
     *

     * </note>
     */
    private String maxErrors;
    /**
     *

     * The task name.
     *

     */
    private String name;
    /**
     *

     * A description of the task.
     *

     */
    private String description;
    /**
     *

     * The specification for whether tasks should continue to run after the cutoff time specified in the maintenance
     * windows is reached.
     *

     */
    private String cutoffBehavior;
    /**
     *

     * The details for the CloudWatch alarm applied to your maintenance window task.
     *

     */
    private AlarmConfiguration alarmConfiguration;

    /**
     *

     * The ID of the maintenance window where the task is registered.
     *

     *
     * @param windowId
     *        The ID of the maintenance window where the task is registered.
     */

    public void setWindowId(String windowId) {
        this.windowId = windowId;
    }

    /**
     *

     * The ID of the maintenance window where the task is registered.
     *

     *
     * @return The ID of the maintenance window where the task is registered.
     */

    public String getWindowId() {
        return this.windowId;
    }

    /**
     *

     * The ID of the maintenance window where the task is registered.
     *

     *
     * @param windowId
     *        The ID of the maintenance window where the task is registered.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public MaintenanceWindowTask withWindowId(String windowId) {
        setWindowId(windowId);
        return this;
    }

    /**
     *

     * The task ID.
     *

     *
     * @param windowTaskId
     *        The task ID.
     */

    public void setWindowTaskId(String windowTaskId) {
        this.windowTaskId = windowTaskId;
    }

    /**
     *

     * The task ID.
     *

     *
     * @return The task ID.
     */

    public String getWindowTaskId() {
        return this.windowTaskId;
    }

    /**
     *

     * The task ID.
     *

     *
     * @param windowTaskId
     *        The task ID.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public MaintenanceWindowTask withWindowTaskId(String windowTaskId) {
        setWindowTaskId(windowTaskId);
        return this;
    }

    /**
     *

     * The resource that the task uses during execution. For RUN_COMMAND and AUTOMATION task
     * types, TaskArn is the Amazon Web Services Systems Manager (SSM document) name or ARN. For
     * LAMBDA tasks, it's the function name or ARN. For STEP_FUNCTIONS tasks, it's the state
     * machine ARN.
     *

     *
     * @param taskArn
     *        The resource that the task uses during execution. For RUN_COMMAND and AUTOMATION
     *        task types, TaskArn is the Amazon Web Services Systems Manager (SSM document) name or ARN.
     *        For LAMBDA tasks, it's the function name or ARN. For STEP_FUNCTIONS tasks, it's
     *        the state machine ARN.
     */

    public void setTaskArn(String taskArn) {
        this.taskArn = taskArn;
    }

    /**
     *

     * The resource that the task uses during execution. For RUN_COMMAND and AUTOMATION task
     * types, TaskArn is the Amazon Web Services Systems Manager (SSM document) name or ARN. For
     * LAMBDA tasks, it's the function name or ARN. For STEP_FUNCTIONS tasks, it's the state
     * machine ARN.
     *

     *
     * @return The resource that the task uses during execution. For RUN_COMMAND and
     *         AUTOMATION task types, TaskArn is the Amazon Web Services Systems Manager (SSM
     *         document) name or ARN. For LAMBDA tasks, it's the function name or ARN. For
     *         STEP_FUNCTIONS tasks, it's the state machine ARN.
     */

    public String getTaskArn() {
        return this.taskArn;
    }

    /**
     *

     * The resource that the task uses during execution. For RUN_COMMAND and AUTOMATION task
     * types, TaskArn is the Amazon Web Services Systems Manager (SSM document) name or ARN. For
     * LAMBDA tasks, it's the function name or ARN. For STEP_FUNCTIONS tasks, it's the state
     * machine ARN.
     *

     *
     * @param taskArn
     *        The resource that the task uses during execution. For RUN_COMMAND and AUTOMATION
     *        task types, TaskArn is the Amazon Web Services Systems Manager (SSM document) name or ARN.
     *        For LAMBDA tasks, it's the function name or ARN. For STEP_FUNCTIONS tasks, it's
     *        the state machine ARN.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public MaintenanceWindowTask withTaskArn(String taskArn) {
        setTaskArn(taskArn);
        return this;
    }

    /**
     *

     * The type of task.
     *

     *
     * @param type
     *        The type of task.
     * @see MaintenanceWindowTaskType
     */

    public void setType(String type) {
        this.type = type;
    }

    /**
     *

     * The type of task.
     *

     *
     * @return The type of task.
     * @see MaintenanceWindowTaskType
     */

    public String getType() {
        return this.type;
    }

    /**
     *

     * The type of task.
     *

     *
     * @param type
     *        The type of task.
     * @return Returns a reference to this object so that method calls can be chained together.
     * @see MaintenanceWindowTaskType
     */

    public MaintenanceWindowTask withType(String type) {
        setType(type);
        return this;
    }

    /**
     *

     * The type of task.
     *

     *
     * @param type
     *        The type of task.
     * @see MaintenanceWindowTaskType
     */

    public void setType(MaintenanceWindowTaskType type) {
        withType(type);
    }

    /**
     *

     * The type of task.
     *

     *
     * @param type
     *        The type of task.
     * @return Returns a reference to this object so that method calls can be chained together.
     * @see MaintenanceWindowTaskType
     */

    public MaintenanceWindowTask withType(MaintenanceWindowTaskType type) {
        this.type = type.toString();
        return this;
    }

    /**
     *

     * The targets (either managed nodes or tags). Managed nodes are specified using
     * Key=instanceids,Values=<instanceid1>,<instanceid2>. Tags are specified using
     * Key=<tag name>,Values=<tag value>.
     *

     *
     * @return The targets (either managed nodes or tags). Managed nodes are specified using
     *         Key=instanceids,Values=<instanceid1>,<instanceid2>. Tags are specified using
     *         Key=<tag name>,Values=<tag value>.
     */

    public java.util.List<Target> getTargets() {
        if (targets == null) {
            targets = new com.amazonaws.internal.SdkInternalList<Target>();
        }
        return targets;
    }

    /**
     *

     * The targets (either managed nodes or tags). Managed nodes are specified using
     * Key=instanceids,Values=<instanceid1>,<instanceid2>. Tags are specified using
     * Key=<tag name>,Values=<tag value>.
     *

     *
     * @param targets
     *        The targets (either managed nodes or tags). Managed nodes are specified using
     *        Key=instanceids,Values=<instanceid1>,<instanceid2>. Tags are specified using
     *        Key=<tag name>,Values=<tag value>.
     */

    public void setTargets(java.util.Collection<Target> targets) {
        if (targets == null) {
            this.targets = null;
            return;
        }

        this.targets = new com.amazonaws.internal.SdkInternalList<Target>(targets);
    }

    /**
     *

     * The targets (either managed nodes or tags). Managed nodes are specified using
     * Key=instanceids,Values=<instanceid1>,<instanceid2>. Tags are specified using
     * Key=<tag name>,Values=<tag value>.
     *

     *

     * NOTE: This method appends the values to the existing list (if any). Use
     * {@link #setTargets(java.util.Collection)} or {@link #withTargets(java.util.Collection)} if you want to override
     * the existing values.
     *

     *
     * @param targets
     *        The targets (either managed nodes or tags). Managed nodes are specified using
     *        Key=instanceids,Values=<instanceid1>,<instanceid2>. Tags are specified using
     *        Key=<tag name>,Values=<tag value>.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public MaintenanceWindowTask withTargets(Target... targets) {
        if (this.targets == null) {
            setTargets(new com.amazonaws.internal.SdkInternalList<Target>(targets.length));
        }
        for (Target ele : targets) {
            this.targets.add(ele);
        }
        return this;
    }

    /**
     *

     * The targets (either managed nodes or tags). Managed nodes are specified using
     * Key=instanceids,Values=<instanceid1>,<instanceid2>. Tags are specified using
     * Key=<tag name>,Values=<tag value>.
     *

     *
     * @param targets
     *        The targets (either managed nodes or tags). Managed nodes are specified using
     *        Key=instanceids,Values=<instanceid1>,<instanceid2>. Tags are specified using
     *        Key=<tag name>,Values=<tag value>.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public MaintenanceWindowTask withTargets(java.util.Collection<Target> targets) {
        setTargets(targets);
        return this;
    }

    /**
     *

     * The parameters that should be passed to the task when it is run.
     *

     * <note>
     *

     * TaskParameters has been deprecated. To specify parameters to pass to a task when it runs, instead
     * use the Parameters option in the TaskInvocationParameters structure. For information
     * about how Systems Manager handles these options for the supported maintenance window task types, see
     * MaintenanceWindowTaskInvocationParameters.
     *

     * </note>
     *
     * @return The parameters that should be passed to the task when it is run.
 <note>
     *

     *         TaskParameters has been deprecated. To specify parameters to pass to a task when it runs,
     *         instead use the Parameters option in the TaskInvocationParameters structure.
     *         For information about how Systems Manager handles these options for the supported maintenance window task
     *         types, see MaintenanceWindowTaskInvocationParameters.
     *

     */

    public java.util.Map<String, MaintenanceWindowTaskParameterValueExpression> getTaskParameters() {
        return taskParameters;
    }

    /**
     *

     * The parameters that should be passed to the task when it is run.
     *

     * <note>
     *

     * TaskParameters has been deprecated. To specify parameters to pass to a task when it runs, instead
     * use the Parameters option in the TaskInvocationParameters structure. For information
     * about how Systems Manager handles these options for the supported maintenance window task types, see
     * MaintenanceWindowTaskInvocationParameters.
     *

     * </note>
     *
     * @param taskParameters
     *        The parameters that should be passed to the task when it is run.
 <note>
     *

     *        TaskParameters has been deprecated. To specify parameters to pass to a task when it runs,
     *        instead use the Parameters option in the TaskInvocationParameters structure. For
     *        information about how Systems Manager handles these options for the supported maintenance window task
     *        types, see MaintenanceWindowTaskInvocationParameters.
     *

     */

    public void setTaskParameters(java.util.Map<String, MaintenanceWindowTaskParameterValueExpression> taskParameters) {
        this.taskParameters = taskParameters;
    }

    /**
     *

     * The parameters that should be passed to the task when it is run.
     *

     * <note>
     *

     * TaskParameters has been deprecated. To specify parameters to pass to a task when it runs, instead
     * use the Parameters option in the TaskInvocationParameters structure. For information
     * about how Systems Manager handles these options for the supported maintenance window task types, see
     * MaintenanceWindowTaskInvocationParameters.
     *

     * </note>
     *
     * @param taskParameters
     *        The parameters that should be passed to the task when it is run.
 <note>
     *

     *        TaskParameters has been deprecated. To specify parameters to pass to a task when it runs,
     *        instead use the Parameters option in the TaskInvocationParameters structure. For
     *        information about how Systems Manager handles these options for the supported maintenance window task
     *        types, see MaintenanceWindowTaskInvocationParameters.
     *

     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public MaintenanceWindowTask withTaskParameters(java.util.Map<String, MaintenanceWindowTaskParameterValueExpression> taskParameters) {
        setTaskParameters(taskParameters);
        return this;
    }

    /**
     * Add a single TaskParameters entry
     *
     * @see MaintenanceWindowTask#withTaskParameters
     * @returns a reference to this object so that method calls can be chained together.
     */

    public MaintenanceWindowTask addTaskParametersEntry(String key, MaintenanceWindowTaskParameterValueExpression value) {
        if (null == this.taskParameters) {
            this.taskParameters = new java.util.HashMap<String, MaintenanceWindowTaskParameterValueExpression>();
        }
        if (this.taskParameters.containsKey(key))
            throw new IllegalArgumentException("Duplicated keys (" + key.toString() + ") are provided.");
        this.taskParameters.put(key, value);
        return this;
    }

    /**
     * Removes all the entries added into TaskParameters.
     *
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public MaintenanceWindowTask clearTaskParametersEntries() {
        this.taskParameters = null;
        return this;
    }

    /**
     *

     * The priority of the task in the maintenance window. The lower the number, the higher the priority. Tasks that
     * have the same priority are scheduled in parallel.
     *

     *
     * @param priority
     *        The priority of the task in the maintenance window. The lower the number, the higher the priority. Tasks
     *        that have the same priority are scheduled in parallel.
     */

    public void setPriority(Integer priority) {
        this.priority = priority;
    }

    /**
     *

     * The priority of the task in the maintenance window. The lower the number, the higher the priority. Tasks that
     * have the same priority are scheduled in parallel.
     *

     *
     * @return The priority of the task in the maintenance window. The lower the number, the higher the priority. Tasks
     *         that have the same priority are scheduled in parallel.
     */

    public Integer getPriority() {
        return this.priority;
    }

    /**
     *

     * The priority of the task in the maintenance window. The lower the number, the higher the priority. Tasks that
     * have the same priority are scheduled in parallel.
     *

     *
     * @param priority
     *        The priority of the task in the maintenance window. The lower the number, the higher the priority. Tasks
     *        that have the same priority are scheduled in parallel.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public MaintenanceWindowTask withPriority(Integer priority) {
        setPriority(priority);
        return this;
    }

    /**
     *

     * Information about an S3 bucket to write task-level logs to.
     *

     * <note>
     *

     * LoggingInfo has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3) bucket to
     * contain logs, instead use the OutputS3BucketName and OutputS3KeyPrefix options in the
     * TaskInvocationParameters structure. For information about how Amazon Web Services Systems Manager
     * handles these options for the supported maintenance window task types, see
     * MaintenanceWindowTaskInvocationParameters.
     *

     * </note>
     *
     * @param loggingInfo
     *        Information about an S3 bucket to write task-level logs to.
 <note>
     *

     *        LoggingInfo has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3)
     *        bucket to contain logs, instead use the OutputS3BucketName and OutputS3KeyPrefix
     *        options in the TaskInvocationParameters structure. For information about how Amazon Web
     *        Services Systems Manager handles these options for the supported maintenance window task types, see
     *        MaintenanceWindowTaskInvocationParameters.
     *

     */

    public void setLoggingInfo(LoggingInfo loggingInfo) {
        this.loggingInfo = loggingInfo;
    }

    /**
     *

     * Information about an S3 bucket to write task-level logs to.
     *

     * <note>
     *

     * LoggingInfo has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3) bucket to
     * contain logs, instead use the OutputS3BucketName and OutputS3KeyPrefix options in the
     * TaskInvocationParameters structure. For information about how Amazon Web Services Systems Manager
     * handles these options for the supported maintenance window task types, see
     * MaintenanceWindowTaskInvocationParameters.
     *

     * </note>
     *
     * @return Information about an S3 bucket to write task-level logs to.
 <note>
     *

     *         LoggingInfo has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3)
     *         bucket to contain logs, instead use the OutputS3BucketName and
     *         OutputS3KeyPrefix options in the TaskInvocationParameters structure. For
     *         information about how Amazon Web Services Systems Manager handles these options for the supported
     *         maintenance window task types, see MaintenanceWindowTaskInvocationParameters.
     *

     */

    public LoggingInfo getLoggingInfo() {
        return this.loggingInfo;
    }

    /**
     *

     * Information about an S3 bucket to write task-level logs to.
     *

     * <note>
     *

     * LoggingInfo has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3) bucket to
     * contain logs, instead use the OutputS3BucketName and OutputS3KeyPrefix options in the
     * TaskInvocationParameters structure. For information about how Amazon Web Services Systems Manager
     * handles these options for the supported maintenance window task types, see
     * MaintenanceWindowTaskInvocationParameters.
     *

     * </note>
     *
     * @param loggingInfo
     *        Information about an S3 bucket to write task-level logs to.
 <note>
     *

     *        LoggingInfo has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3)
     *        bucket to contain logs, instead use the OutputS3BucketName and OutputS3KeyPrefix
     *        options in the TaskInvocationParameters structure. For information about how Amazon Web
     *        Services Systems Manager handles these options for the supported maintenance window task types, see
     *        MaintenanceWindowTaskInvocationParameters.
     *

     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public MaintenanceWindowTask withLoggingInfo(LoggingInfo loggingInfo) {
        setLoggingInfo(loggingInfo);
        return this;
    }

    /**
     *

     * The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) service role to use to publish Amazon
     * Simple Notification Service (Amazon SNS) notifications for maintenance window Run Command tasks.
     *

     *
     * @param serviceRoleArn
     *        The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) service role to use to publish
     *        Amazon Simple Notification Service (Amazon SNS) notifications for maintenance window Run Command tasks.
     */

    public void setServiceRoleArn(String serviceRoleArn) {
        this.serviceRoleArn = serviceRoleArn;
    }

    /**
     *

     * The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) service role to use to publish Amazon
     * Simple Notification Service (Amazon SNS) notifications for maintenance window Run Command tasks.
     *

     *
     * @return The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) service role to use to publish
     *         Amazon Simple Notification Service (Amazon SNS) notifications for maintenance window Run Command tasks.
     */

    public String getServiceRoleArn() {
        return this.serviceRoleArn;
    }

    /**
     *

     * The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) service role to use to publish Amazon
     * Simple Notification Service (Amazon SNS) notifications for maintenance window Run Command tasks.
     *

     *
     * @param serviceRoleArn
     *        The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) service role to use to publish
     *        Amazon Simple Notification Service (Amazon SNS) notifications for maintenance window Run Command tasks.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public MaintenanceWindowTask withServiceRoleArn(String serviceRoleArn) {
        setServiceRoleArn(serviceRoleArn);
        return this;
    }

    /**
     *

     * The maximum number of targets this task can be run for, in parallel.
     *

     * <note>
     *

     * Although this element is listed as "Required: No", a value can be omitted only when you are registering or
     * updating a targetless task You must provide a value in all other cases.
     *

     *

     * For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the
     * system inserts a placeholder value of 1. This value doesn't affect the running of your task.
     *

     * </note>
     *
     * @param maxConcurrency
     *        The maximum number of targets this task can be run for, in parallel.
 <note>
     *

     *        Although this element is listed as "Required: No", a value can be omitted only when you are registering or
     *        updating a targetless task You must provide a value in all other cases.
     *

     *

     *        For maintenance window tasks without a target specified, you can't supply a value for this option.
     *        Instead, the system inserts a placeholder value of 1. This value doesn't affect the running
     *        of your task.
     *

     */

    public void setMaxConcurrency(String maxConcurrency) {
        this.maxConcurrency = maxConcurrency;
    }

    /**
     *

     * The maximum number of targets this task can be run for, in parallel.
     *

     * <note>
     *

     * Although this element is listed as "Required: No", a value can be omitted only when you are registering or
     * updating a targetless task You must provide a value in all other cases.
     *

     *

     * For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the
     * system inserts a placeholder value of 1. This value doesn't affect the running of your task.
     *

     * </note>
     *
     * @return The maximum number of targets this task can be run for, in parallel.
 <note>
     *

     *         Although this element is listed as "Required: No", a value can be omitted only when you are registering
     *         or updating a targetless task You must provide a value in all other cases.
     *

     *

     *         For maintenance window tasks without a target specified, you can't supply a value for this option.
     *         Instead, the system inserts a placeholder value of 1. This value doesn't affect the running
     *         of your task.
     *

     */

    public String getMaxConcurrency() {
        return this.maxConcurrency;
    }

    /**
     *

     * The maximum number of targets this task can be run for, in parallel.
     *

     * <note>
     *

     * Although this element is listed as "Required: No", a value can be omitted only when you are registering or
     * updating a targetless task You must provide a value in all other cases.
     *

     *

     * For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the
     * system inserts a placeholder value of 1. This value doesn't affect the running of your task.
     *

     * </note>
     *
     * @param maxConcurrency
     *        The maximum number of targets this task can be run for, in parallel.
 <note>
     *

     *        Although this element is listed as "Required: No", a value can be omitted only when you are registering or
     *        updating a targetless task You must provide a value in all other cases.
     *

     *

     *        For maintenance window tasks without a target specified, you can't supply a value for this option.
     *        Instead, the system inserts a placeholder value of 1. This value doesn't affect the running
     *        of your task.
     *

     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public MaintenanceWindowTask withMaxConcurrency(String maxConcurrency) {
        setMaxConcurrency(maxConcurrency);
        return this;
    }

    /**
     *

     * The maximum number of errors allowed before this task stops being scheduled.
     *

     * <note>
     *

     * Although this element is listed as "Required: No", a value can be omitted only when you are registering or
     * updating a targetless task You must provide a value in all other cases.
     *

     *

     * For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the
     * system inserts a placeholder value of 1. This value doesn't affect the running of your task.
     *

     * </note>
     *
     * @param maxErrors
     *        The maximum number of errors allowed before this task stops being scheduled.
 <note>
     *

     *        Although this element is listed as "Required: No", a value can be omitted only when you are registering or
     *        updating a targetless task You must provide a value in all other cases.
     *

     *

     *        For maintenance window tasks without a target specified, you can't supply a value for this option.
     *        Instead, the system inserts a placeholder value of 1. This value doesn't affect the running
     *        of your task.
     *

     */

    public void setMaxErrors(String maxErrors) {
        this.maxErrors = maxErrors;
    }

    /**
     *

     * The maximum number of errors allowed before this task stops being scheduled.
     *

     * <note>
     *

     * Although this element is listed as "Required: No", a value can be omitted only when you are registering or
     * updating a targetless task You must provide a value in all other cases.
     *

     *

     * For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the
     * system inserts a placeholder value of 1. This value doesn't affect the running of your task.
     *

     * </note>
     *
     * @return The maximum number of errors allowed before this task stops being scheduled.
 <note>
     *

     *         Although this element is listed as "Required: No", a value can be omitted only when you are registering
     *         or updating a targetless task You must provide a value in all other cases.
     *

     *

     *         For maintenance window tasks without a target specified, you can't supply a value for this option.
     *         Instead, the system inserts a placeholder value of 1. This value doesn't affect the running
     *         of your task.
     *

     */

    public String getMaxErrors() {
        return this.maxErrors;
    }

    /**
     *

     * The maximum number of errors allowed before this task stops being scheduled.
     *

     * <note>
     *

     * Although this element is listed as "Required: No", a value can be omitted only when you are registering or
     * updating a targetless task You must provide a value in all other cases.
     *

     *

     * For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the
     * system inserts a placeholder value of 1. This value doesn't affect the running of your task.
     *

     * </note>
     *
     * @param maxErrors
     *        The maximum number of errors allowed before this task stops being scheduled.
 <note>
     *

     *        Although this element is listed as "Required: No", a value can be omitted only when you are registering or
     *        updating a targetless task You must provide a value in all other cases.
     *

     *

     *        For maintenance window tasks without a target specified, you can't supply a value for this option.
     *        Instead, the system inserts a placeholder value of 1. This value doesn't affect the running
     *        of your task.
     *

     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public MaintenanceWindowTask withMaxErrors(String maxErrors) {
        setMaxErrors(maxErrors);
        return this;
    }

    /**
     *

     * The task name.
     *

     *
     * @param name
     *        The task name.
     */

    public void setName(String name) {
        this.name = name;
    }

    /**
     *

     * The task name.
     *

     *
     * @return The task name.
     */

    public String getName() {
        return this.name;
    }

    /**
     *

     * The task name.
     *

     *
     * @param name
     *        The task name.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public MaintenanceWindowTask withName(String name) {
        setName(name);
        return this;
    }

    /**
     *

     * A description of the task.
     *

     *
     * @param description
     *        A description of the task.
     */

    public void setDescription(String description) {
        this.description = description;
    }

    /**
     *

     * A description of the task.
     *

     *
     * @return A description of the task.
     */

    public String getDescription() {
        return this.description;
    }

    /**
     *

     * A description of the task.
     *

     *
     * @param description
     *        A description of the task.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public MaintenanceWindowTask withDescription(String description) {
        setDescription(description);
        return this;
    }

    /**
     *

     * The specification for whether tasks should continue to run after the cutoff time specified in the maintenance
     * windows is reached.
     *

     *
     * @param cutoffBehavior
     *        The specification for whether tasks should continue to run after the cutoff time specified in the
     *        maintenance windows is reached.
     * @see MaintenanceWindowTaskCutoffBehavior
     */

    public void setCutoffBehavior(String cutoffBehavior) {
        this.cutoffBehavior = cutoffBehavior;
    }

    /**
     *

     * The specification for whether tasks should continue to run after the cutoff time specified in the maintenance
     * windows is reached.
     *

     *
     * @return The specification for whether tasks should continue to run after the cutoff time specified in the
     *         maintenance windows is reached.
     * @see MaintenanceWindowTaskCutoffBehavior
     */

    public String getCutoffBehavior() {
        return this.cutoffBehavior;
    }

    /**
     *

     * The specification for whether tasks should continue to run after the cutoff time specified in the maintenance
     * windows is reached.
     *

     *
     * @param cutoffBehavior
     *        The specification for whether tasks should continue to run after the cutoff time specified in the
     *        maintenance windows is reached.
     * @return Returns a reference to this object so that method calls can be chained together.
     * @see MaintenanceWindowTaskCutoffBehavior
     */

    public MaintenanceWindowTask withCutoffBehavior(String cutoffBehavior) {
        setCutoffBehavior(cutoffBehavior);
        return this;
    }

    /**
     *

     * The specification for whether tasks should continue to run after the cutoff time specified in the maintenance
     * windows is reached.
     *

     *
     * @param cutoffBehavior
     *        The specification for whether tasks should continue to run after the cutoff time specified in the
     *        maintenance windows is reached.
     * @see MaintenanceWindowTaskCutoffBehavior
     */

    public void setCutoffBehavior(MaintenanceWindowTaskCutoffBehavior cutoffBehavior) {
        withCutoffBehavior(cutoffBehavior);
    }

    /**
     *

     * The specification for whether tasks should continue to run after the cutoff time specified in the maintenance
     * windows is reached.
     *

     *
     * @param cutoffBehavior
     *        The specification for whether tasks should continue to run after the cutoff time specified in the
     *        maintenance windows is reached.
     * @return Returns a reference to this object so that method calls can be chained together.
     * @see MaintenanceWindowTaskCutoffBehavior
     */

    public MaintenanceWindowTask withCutoffBehavior(MaintenanceWindowTaskCutoffBehavior cutoffBehavior) {
        this.cutoffBehavior = cutoffBehavior.toString();
        return this;
    }

    /**
     *

     * The details for the CloudWatch alarm applied to your maintenance window task.
     *

     *
     * @param alarmConfiguration
     *        The details for the CloudWatch alarm applied to your maintenance window task.
     */

    public void setAlarmConfiguration(AlarmConfiguration alarmConfiguration) {
        this.alarmConfiguration = alarmConfiguration;
    }

    /**
     *

     * The details for the CloudWatch alarm applied to your maintenance window task.
     *

     *
     * @return The details for the CloudWatch alarm applied to your maintenance window task.
     */

    public AlarmConfiguration getAlarmConfiguration() {
        return this.alarmConfiguration;
    }

    /**
     *

     * The details for the CloudWatch alarm applied to your maintenance window task.
     *

     *
     * @param alarmConfiguration
     *        The details for the CloudWatch alarm applied to your maintenance window task.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public MaintenanceWindowTask withAlarmConfiguration(AlarmConfiguration alarmConfiguration) {
        setAlarmConfiguration(alarmConfiguration);
        return this;
    }

    /**
     * Returns a string representation of this object. This is useful for testing and debugging. Sensitive data will be
     * redacted from this string using a placeholder value.
     *
     * @return A string representation of this object.
     *
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("{");
        if (getWindowId() != null)
            sb.append("WindowId: ").append(getWindowId()).append(",");
        if (getWindowTaskId() != null)
            sb.append("WindowTaskId: ").append(getWindowTaskId()).append(",");
        if (getTaskArn() != null)
            sb.append("TaskArn: ").append(getTaskArn()).append(",");
        if (getType() != null)
            sb.append("Type: ").append(getType()).append(",");
        if (getTargets() != null)
            sb.append("Targets: ").append(getTargets()).append(",");
        if (getTaskParameters() != null)
            sb.append("TaskParameters: ").append("***Sensitive Data Redacted***").append(",");
        if (getPriority() != null)
            sb.append("Priority: ").append(getPriority()).append(",");
        if (getLoggingInfo() != null)
            sb.append("LoggingInfo: ").append(getLoggingInfo()).append(",");
        if (getServiceRoleArn() != null)
            sb.append("ServiceRoleArn: ").append(getServiceRoleArn()).append(",");
        if (getMaxConcurrency() != null)
            sb.append("MaxConcurrency: ").append(getMaxConcurrency()).append(",");
        if (getMaxErrors() != null)
            sb.append("MaxErrors: ").append(getMaxErrors()).append(",");
        if (getName() != null)
            sb.append("Name: ").append(getName()).append(",");
        if (getDescription() != null)
            sb.append("Description: ").append("***Sensitive Data Redacted***").append(",");
        if (getCutoffBehavior() != null)
            sb.append("CutoffBehavior: ").append(getCutoffBehavior()).append(",");
        if (getAlarmConfiguration() != null)
            sb.append("AlarmConfiguration: ").append(getAlarmConfiguration());
        sb.append("}");
        return sb.toString();
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;

        if (obj instanceof MaintenanceWindowTask == false)
            return false;
        MaintenanceWindowTask other = (MaintenanceWindowTask) obj;
        if (other.getWindowId() == null ^ this.getWindowId() == null)
            return false;
        if (other.getWindowId() != null && other.getWindowId().equals(this.getWindowId()) == false)
            return false;
        if (other.getWindowTaskId() == null ^ this.getWindowTaskId() == null)
            return false;
        if (other.getWindowTaskId() != null && other.getWindowTaskId().equals(this.getWindowTaskId()) == false)
            return false;
        if (other.getTaskArn() == null ^ this.getTaskArn() == null)
            return false;
        if (other.getTaskArn() != null && other.getTaskArn().equals(this.getTaskArn()) == false)
            return false;
        if (other.getType() == null ^ this.getType() == null)
            return false;
        if (other.getType() != null && other.getType().equals(this.getType()) == false)
            return false;
        if (other.getTargets() == null ^ this.getTargets() == null)
            return false;
        if (other.getTargets() != null && other.getTargets().equals(this.getTargets()) == false)
            return false;
        if (other.getTaskParameters() == null ^ this.getTaskParameters() == null)
            return false;
        if (other.getTaskParameters() != null && other.getTaskParameters().equals(this.getTaskParameters()) == false)
            return false;
        if (other.getPriority() == null ^ this.getPriority() == null)
            return false;
        if (other.getPriority() != null && other.getPriority().equals(this.getPriority()) == false)
            return false;
        if (other.getLoggingInfo() == null ^ this.getLoggingInfo() == null)
            return false;
        if (other.getLoggingInfo() != null && other.getLoggingInfo().equals(this.getLoggingInfo()) == false)
            return false;
        if (other.getServiceRoleArn() == null ^ this.getServiceRoleArn() == null)
            return false;
        if (other.getServiceRoleArn() != null && other.getServiceRoleArn().equals(this.getServiceRoleArn()) == false)
            return false;
        if (other.getMaxConcurrency() == null ^ this.getMaxConcurrency() == null)
            return false;
        if (other.getMaxConcurrency() != null && other.getMaxConcurrency().equals(this.getMaxConcurrency()) == false)
            return false;
        if (other.getMaxErrors() == null ^ this.getMaxErrors() == null)
            return false;
        if (other.getMaxErrors() != null && other.getMaxErrors().equals(this.getMaxErrors()) == false)
            return false;
        if (other.getName() == null ^ this.getName() == null)
            return false;
        if (other.getName() != null && other.getName().equals(this.getName()) == false)
            return false;
        if (other.getDescription() == null ^ this.getDescription() == null)
            return false;
        if (other.getDescription() != null && other.getDescription().equals(this.getDescription()) == false)
            return false;
        if (other.getCutoffBehavior() == null ^ this.getCutoffBehavior() == null)
            return false;
        if (other.getCutoffBehavior() != null && other.getCutoffBehavior().equals(this.getCutoffBehavior()) == false)
            return false;
        if (other.getAlarmConfiguration() == null ^ this.getAlarmConfiguration() == null)
            return false;
        if (other.getAlarmConfiguration() != null && other.getAlarmConfiguration().equals(this.getAlarmConfiguration()) == false)
            return false;
        return true;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int hashCode = 1;

        hashCode = prime * hashCode + ((getWindowId() == null) ? 0 : getWindowId().hashCode());
        hashCode = prime * hashCode + ((getWindowTaskId() == null) ? 0 : getWindowTaskId().hashCode());
        hashCode = prime * hashCode + ((getTaskArn() == null) ? 0 : getTaskArn().hashCode());
        hashCode = prime * hashCode + ((getType() == null) ? 0 : getType().hashCode());
        hashCode = prime * hashCode + ((getTargets() == null) ? 0 : getTargets().hashCode());
        hashCode = prime * hashCode + ((getTaskParameters() == null) ? 0 : getTaskParameters().hashCode());
        hashCode = prime * hashCode + ((getPriority() == null) ? 0 : getPriority().hashCode());
        hashCode = prime * hashCode + ((getLoggingInfo() == null) ? 0 : getLoggingInfo().hashCode());
        hashCode = prime * hashCode + ((getServiceRoleArn() == null) ? 0 : getServiceRoleArn().hashCode());
        hashCode = prime * hashCode + ((getMaxConcurrency() == null) ? 0 : getMaxConcurrency().hashCode());
        hashCode = prime * hashCode + ((getMaxErrors() == null) ? 0 : getMaxErrors().hashCode());
        hashCode = prime * hashCode + ((getName() == null) ? 0 : getName().hashCode());
        hashCode = prime * hashCode + ((getDescription() == null) ? 0 : getDescription().hashCode());
        hashCode = prime * hashCode + ((getCutoffBehavior() == null) ? 0 : getCutoffBehavior().hashCode());
        hashCode = prime * hashCode + ((getAlarmConfiguration() == null) ? 0 : getAlarmConfiguration().hashCode());
        return hashCode;
    }

    @Override
    public MaintenanceWindowTask clone() {
        try {
            return (MaintenanceWindowTask) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new IllegalStateException("Got a CloneNotSupportedException from Object.clone() " + "even though we're Cloneable!", e);
        }
    }

    @com.amazonaws.annotation.SdkInternalApi
    @Override
    public void marshall(ProtocolMarshaller protocolMarshaller) {
        com.amazonaws.services.simplesystemsmanagement.model.transform.MaintenanceWindowTaskMarshaller.getInstance().marshall(this, protocolMarshaller);
    }
}


text:
using System.Collections.Generic;

namespace Contour
{
    /// <summary>
    /// Хранилище заголовков входящих сообщений.
    /// </summary>
    public interface IIncomingMessageHeaderStorage
    {
        /// <summary>
        /// Сохраняет заголовки входящего сообщения.
        /// </summary>
        /// <param name="headers">Заголовки входящего сообщения.</param>
        void Store(IDictionary<string, object> headers);

        /// <summary>
        /// Возвращает сохраненные заголовки входящего сообщения.
        /// </summary>
        /// <returns>Заголовки входящего сообщения.</returns>
        IDictionary<string, object> Load();
    }
}

redpajama_set_name: RedPajamaGithub


text:
package gov.nasa.arc.spife.rcp.internal;

import gov.nasa.arc.spife.rcp.Activator;
import gov.nasa.ensemble.common.ui.IconLoader;
import gov.nasa.ensemble.common.ui.mission.MissionUIConstants;

import org.eclipse.swt.graphics.Image;
import org.osgi.framework.Bundle;

public class SPIFeUIConstants extends MissionUIConstants {
	/**
	 * Return an image icon for a given event type.
	 *
	 * @param imageName
	 * @return
	 */
	@Override
	public Image getIcon(String imageName) {
		if (imageName == null) {
			return super.getIcon(imageName);
		}
		Bundle bundle = Activator.getDefault().getBundle();
		Image image = IconLoader.getIcon(bundle, "icons/activities/" + imageName.toLowerCase() + ".png");
		if(image == null)
			image = IconLoader.getIcon(bundle, "icons/activities/" + imageName + ".png");
		if(image == null)
			image = IconLoader.getIcon(bundle, "icons/activities/" + imageName.toUpperCase() + ".png");
		if (image == null) {
			image = super.getIcon(imageName);
		}
		return image;
	}
}


text:
/*
This file contains global variables for header file.
*/

////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////

//static variables

const float limits_base<float>::Lowest = -FLT_MAX;
const float limits_base<float>::Min = FLT_MIN;
const float limits_base<float>::Max = FLT_MAX;

const double limits_base<double>::Lowest = -DBL_MAX;
const double limits_base<double>::Min = DBL_MIN;
const double limits_base<double>::Max = DBL_MAX;

////////////////////////////////////////////////////////////////////////////////


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/loading"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:orientation="vertical" >

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/loading_data" />

    <ProgressBar
        style="?android:attr/progressBarStyle"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

</LinearLayout>


text:
<link href="<?=base_url()?>assets/font-awesome/css/font-awesome.min.css" rel="stylesheet" type="text/css">

     Login Credentials Invalid

    Click <a href="<?=base_url()?>">here to go to the main page


text:
package com.frameworkset.platform.cms.imagemanager;

import java.awt.Color;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.IOException;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.frameworkset.platform.cms.channelmanager.ChannelManagerException;
import com.frameworkset.platform.cms.sitemanager.Site;
import com.frameworkset.platform.cms.sitemanager.SiteManagerException;
import com.frameworkset.platform.cms.util.CMSUtil;
import com.frameworkset.platform.security.AccessControl;
import com.frameworkset.platform.sysmgrcore.manager.LogManager;
import com.frameworkset.platform.sysmgrcore.manager.SecurityDatabase;
import com.frameworkset.common.poolman.DBUtil;

public class ImageManagerImpl implements ImageManager{
	private CMSUtil util = new CMSUtil();
	private final static String WATERIMAGE_FORDER = "/waterImages/";
	private final static String NORMALIMAGE_FORDER = "/normalImages/";
	private final static String MIXIMAGE_FORDER = "/mixImages/";
	protected final static int NOWATER = 0;//无水印
	protected final static int WATERED_NOBACKUP = 1;//有水印 无备份
	protected final static int WATERED_BACKUP = 2;//有水印 有备份

	/**
	 * 生成加图片水印图片
	 * @param String img 被加水印图片路径
	 * @param String watermark 水印图片路径
	 * @param String waterStr 水印文字描述
	 * @param String fontType 水印文字字体类型
	 * @param Color fontColor 水印文字字体颜色
	 * @param int fontSize 水印文字字体大小
	 * @param int position 水印文字/图片粘贴位置
	 * ImageManagerImpl.java
	 * @author: 陶格
	 */
	public void genWaterImage(String img,
			                  String watermark,
			                  String waterStr,
			                  String fontType,
			                  Color fontColor,
                              int fontSize,
                              int position){
		util.genWaterImage(img,watermark,waterStr, fontType,fontColor,fontSize,position);
	}

    /**
     * 把原始图片拷贝到 normalImages 文件夹下 以备恢复
     * @param img
     * ImageManagerImpl.java
     * @author: 陶格
     */
    public void backupImg(String rootPath,String img){
    	String src = rootPath + WATERIMAGE_FORDER + img;
    	String desc = rootPath + NORMALIMAGE_FORDER + img;
    	File srcFile = new File(src);
    	if(srcFile.exists()){
    		this.copyFile(src,desc);
    	}
    }

    /**
     * 关键 from-in to-out
     * @param srcFile
     * @param descFile
     * @param suffix 备份文件的后缀
     * ImageManagerImpl.java
     * @author: 陶格
     */
    public void copyFile(String srcFile,String descFile){
    	File in = new File(srcFile);
    	File out = new File(descFile);
    	InputStream inStream = null;
	    OutputStream outStream = null;
    	if(in.exists()){
    		try{
    		    inStream = new FileInputStream(in);
    		    outStream = new FileOutputStream(out);
    		    byte[] bytes = new byte[1024];
    		    int size = 0;
    		    while((size=inStream.read(bytes))!=-1){
    		    	//outStream.write(size);
    		    	outStream.write(bytes,0,size);
    		    	outStream.flush();
    		    }
    		}catch(Exception e){
    			e.printStackTrace();
    		}finally{
    			try {
					inStream.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					inStream = null;
					e.printStackTrace();
				}
    		    try {
					outStream.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					outStream = null;
					e.printStackTrace();
				}
    		}

    	}
    }

    /**
     * 重命名
     * @param fileName
     * @param suffix
     * ImageManagerImpl.java
     * @author: ge.tao
     */
    public void ReName(String fileName,String suffix){
    	String newFileName = fileName.substring(0,fileName.lastIndexOf(suffix));
    	File oldF = new File(fileName);
    	File newF = new File(newFileName);
    	oldF.renameTo(newF);
    }

    /**
     * 移动文件
     * @param from
     * @param to
     * ImageManagerImpl.java
     * @author: ge.tao
     */
    public boolean moveFile(String from ,String to){
    	File f = new File(from);
    	File t = new File(to);
    	return f.renameTo(t);

    }

    /**
     * 删除文件
     * @param path
     * ImageManagerImpl.java
     * @author: 陶格
     */
    public boolean deleteFile(String path){
    	File file = new File(path);
    	if(file.exists()){
    		file.delete();
    		return true;
    	}else{
    		return false;
    	}
    }

    /**
     *
     * @param rootPath
     * @param imageType 0: 原始图片; 1: 水印图片; 2: 混合后的图片
     * @return List
     * ImageManagerImpl.java
     * @author: 陶格
     */
	public List getImagesList(String rootPath,int imageType){
		List list = new ArrayList();
		String path = "";
		if(imageType == 0){
			path = rootPath + NORMALIMAGE_FORDER;
		}else if(imageType == 1){
			path = rootPath + WATERIMAGE_FORDER;
		}else{
			path = rootPath + MIXIMAGE_FORDER;
		}
		File file = null;
		try {
			file = new File(path);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		File[] files = {};
		if (file.isDirectory()) {
			files = file.listFiles();
			for (int i = 0; i < files.length; i++) {
				File tmp = files[i];
				try {
					String absolutePath = tmp.getAbsolutePath();
					String fileName = tmp.getName();
					list.add(new String[]{fileName,absolutePath});
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		return list;
	}

	/**
	 * 对数据库表进行操作
	 * @param sqlstr
	 * ImageManagerImpl.java
	 * @author: 陶格
	 */
	public void execute(String sqlstr){
		DBUtil db = new DBUtil();
		try {
			//System.out.println("sql in imageManagerImpl.java-------------------"+sqlstr);
			db.executeSql(sqlstr);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 图片是否被加水印
	 * @param path
	 * @return flag
	 *         0 NOWATER          //无水印
	 *         1 WATERED_NOBACKUP //有水印 无备份
	 *         2 WATERED_BACKUP   //有水印 有备份
	 * ImageManagerImpl.java
	 * @author: 陶格
	 */
	public int isAddedWaterImage(String path){
		int flag = this.NOWATER;
		StringBuffer sqlstr =  new StringBuffer();
		sqlstr.append("select isbackup  from TD_CMS_ADDWATERIMAGE where url='")
		      .append(path).append("'");
		DBUtil db = new DBUtil();
		try {
			db.executeSelect(sqlstr.toString());
			if(db.size()>0) {
			    int isbackup = db.getInt(0,"isbackup");
			    if(isbackup == 1) flag = this.WATERED_BACKUP;
			    else flag = this.WATERED_NOBACKUP;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return flag;
	}

	/**
	 * 判断记录是否存在
	 * @param url
	 * @param backup
	 * @return
	 * ImageManagerImpl.java
	 * @author: ge.tao
	 */
	public boolean isExist(String url,int backup){
		String sqlstr = "select count(*) as num from TD_CMS_ADDWATERIMAGE where "
			          + "URL='"+url+"' and ISBACKUP="+backup;
		DBUtil db = new DBUtil();
		try {
			db.executeSelect(sqlstr.toString());
			if(db.size()>0) {
				return db.getInt(0,0)>0;
			}else{
				return false;
			}
		} catch (Exception e) {
			//e.printStackTrace();
			return false;
		}

	}

	/**
	 * 记录日志
	 * @param openModle 模块名称
	 * @param operContent 操作内容
	 * @param request
	 * @param response
	 * @throws SiteManagerException
	 * ImageManagerImpl.java
	 * @author: ge.tao
	 */
	public void logWaterImageMsg(String openModle,String operContent ,HttpServletRequest request, HttpServletResponse response) throws SiteManagerException
	{
		try
		{
			AccessControl control = AccessControl.getInstance();
			control.checkAccess(request,response);
	        String operSource=control.getMachinedID();//request.getRemoteAddr();
	        String userName = control.getUserName();
	        String description="";
	        LogManager logManager = SecurityDatabase.getLogManager();
	        logManager.log(control.getUserAccount(),operContent,openModle,operSource,description);
		}
        catch(Exception e)
        {
        	e.printStackTrace();
        	throw new SiteManagerException(e.getMessage());
        }
	}

	public static String getNORMALIMAGE_FORDER() {
		return NORMALIMAGE_FORDER;
	}

	public static String getWATERIMAGE_FORDER() {
		return WATERIMAGE_FORDER;
	}

	public static String getMIXIMAGE_FORDER() {
		return MIXIMAGE_FORDER;
	}

	public static void main(String args[]){

	}
	//获取图片宽度
	//param base_path 根目录
	//param path 图片路径
	public int getImageWidth(String base_path,String path)
	{
		java.io.File file = new java.io.File(base_path+path.substring(1));
		  Image src = null;
		try {
			src = javax.imageio.ImageIO.read(file);
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}                     //构造Image对象

		    return src.getWidth(null);
	}

//	获取图片高度
	//param base_path 根目录
	//param path 图片路径
	public int getImageHeight(String base_path,String path)
	{
		java.io.File file = new java.io.File(base_path+path.substring(1));
		  Image src = null;
		try {
			src = javax.imageio.ImageIO.read(file);
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}                     //构造Image对象
		    return src.getHeight(null);
	}

}


text:
package main

import (
	"flag"
	"fmt"
	"log"
	"os"
	"os/exec"
	"strings"
	"sync"
)

type syncer struct {
	quiet        bool
	protocol     string
	dryrun       bool
	concurrency  int
	skipFork     bool
	skipArchived bool
	localPath    string
	mu           sync.Mutex
}

func (s *syncer) run(cmd *exec.Cmd) error {
	if s.dryrun {
		// Prevent overlapping output
		s.mu.Lock()
		defer s.mu.Unlock()
		fmt.Println(strings.Join(cmd.Args, " "))
		return nil
	}
	if err := cmd.Run(); err != nil {
		return err
	}
	return nil
}

func (s *syncer) sync(g *git, r repository) error {
	var url string
	switch s.protocol {
	case "ssh":
		url = r.SSHURL
	case "git":
		url = r.GitURL
	default:
		url = r.CloneURL
	}
	localDir := repositoryPath(s.localPath, r.Name)
	syncCmd := g.sync(url, localDir)
	return s.run(syncCmd)
}

func (s *syncer) syncAll(g *git, repos []repository) {
	sem := make(chan bool, s.concurrency)
	for _, r := range repos {
		if s.skipFork && r.Fork {
			continue
		}
		if s.skipArchived && r.Archived {
			continue
		}
		sem <- true
		go func(r repository) {
			defer func() { <-sem }()
			if err := s.sync(g, r); err != nil {
				log.Fatal(err)
			}
		}(r)
	}
	// Wait for remaining goroutines to finish
	for i := 0; i < cap(sem); i++ {
		sem <- true
	}
}

func main() {
	log.SetPrefix("ghm: ")
	log.SetFlags(log.Lshortfile)
	flag.Usage = func() {
		out := flag.CommandLine.Output()
		fmt.Fprintf(out, "Usage of %s:\n", os.Args[0])
		flag.PrintDefaults()
		fmt.Fprintln(out, "\nArguments:\n  <github-user>\tGitHub username")
		fmt.Fprintln(out, "  <path>\tPath where repositories should be mirrored")
	}
	quiet := flag.Bool("q", false, "Only print errors")
	dryrun := flag.Bool("n", false, "Print commands that would be run and exit")
	protocol := flag.String("p", "ssh", "Protocol to use for mirroring [git|https|ssh]")
	skipFork := flag.Bool("s", false, "Skip forked repositories")
	skipArchived := flag.Bool("a", false, "Skip archived repositories")
	concurrency := flag.Int("c", 1, "Number of repositories to mirror concurrently")
	flag.Parse()
	args := flag.Args()
	if len(args) < 2 {
		flag.Usage()
		return
	}
	if *concurrency < 1 {
		log.Fatal("invalid concurrency level")
	}

	g, err := gitCommand(!*quiet)
	if err != nil {
		log.Fatal(err)
	}
	githubUser := args[0]
	path := args[1]
	syncer := syncer{
		dryrun:       *dryrun,
		protocol:     *protocol,
		skipFork:     *skipFork,
		skipArchived: *skipArchived,
		concurrency:  *concurrency,
		localPath:    path,
	}
	repos, err := listAllRepositories(githubUser)
	if err != nil {
		log.Fatal(err)
	}
	syncer.syncAll(g, repos)
}


text:
<!--@'# ' + pkg.name-->
# mos-plugin-package-json
<!--/@-->

<!--@'> ' + pkg.description-->
> A mos plugin that makes the package.json available in the markdown scope
<!--/@-->

<!--@shields.flatSquare('npm')-->
[![npm version](https://img.shields.io/npm/v/mos-plugin-package-json.svg?style=flat-square)](https://www.npmjs.com/package/mos-plugin-package-json)
<!--/@-->

## Installation

```sh
npm install --save mos-plugin-package-json
```

## Usage

```md
<!--@'# ' + pkg.name-->
# my-awesome-module
<!--/@-->
```

## License

[MIT](./LICENSE) © [Zoltan Kochan](http://kochan.io)


text:
CXXTEST_SUITE(AcquisitionUnitConverterTest)
{
  CXXTEST_TEST(NoInputNoConversion)
  {
    btk::AcquisitionUnitConverter::Pointer uc = btk::AcquisitionUnitConverter::New();
    uc->Update();
    btk::Acquisition::Pointer output = uc->GetOutput();
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Marker), "mm");
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Angle), "deg");
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Force), "N");
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Moment), "Nmm");
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Power), "W");
  };

  CXXTEST_TEST(NoInputConversionToMeter)
  {
    btk::AcquisitionUnitConverter::Pointer uc = btk::AcquisitionUnitConverter::New();
    uc->SetUnit(btk::AcquisitionUnitConverter::Length, "m");
    uc->SetUnit(btk::AcquisitionUnitConverter::Moment, "Nm");
    uc->Update();
    btk::Acquisition::Pointer output = uc->GetOutput();
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Marker), "mm");
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Angle), "deg");
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Force), "N");
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Moment), "Nmm");
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Power), "W");
  };

  CXXTEST_TEST(ConversionToMeter)
  {
    double *a, *b;
    btk::Acquisition::Pointer input = btk::Acquisition::New();
    input->Init(2,5);
    btk::Point::Pointer p1 = input->GetPoint(0);
    a = p1->GetValues().data();
    a[0] = 1234.56; a[1] = 34.65; a[2] = 98.08; a[3] = 987.12; a[4] = 654.12;
    btk::Point::Pointer p2 = input->GetPoint(1);
    p2->SetType(btk::Point::Moment);
    b = p2->GetValues().data();
    b[0] = 1234.56; b[1] = 1134.65; b[2] = 1000.54; b[3] = 987.12; b[4] = 1435.896;

    btk::AcquisitionUnitConverter::Pointer uc = btk::AcquisitionUnitConverter::New();
    uc->SetInput(input);
    uc->SetUnit(btk::AcquisitionUnitConverter::Length, "m");
    uc->SetUnit(btk::AcquisitionUnitConverter::Moment, "Nm");
    uc->Update();
    btk::Acquisition::Pointer output = uc->GetOutput();
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Marker), "m");
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Angle), "deg");
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Force), "N");
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Moment), "Nm");
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Power), "W");

    p1 = output->GetPoint(0);
    a = p1->GetValues().data();
    p2 = output->GetPoint(1);
    b = p2->GetValues().data();

    TS_ASSERT_DELTA(a[0], 1.23456, 1e-10);
    TS_ASSERT_DELTA(a[1], 0.03465, 1e-10);
    TS_ASSERT_DELTA(a[2], 0.09808, 1e-10);
    TS_ASSERT_DELTA(a[3], 0.98712, 1e-10);
    TS_ASSERT_DELTA(a[4], 0.65412, 1e-10);

    TS_ASSERT_DELTA(b[0], 1.23456, 1e-10);
    TS_ASSERT_DELTA(b[1], 1.13465, 1e-10);
    TS_ASSERT_DELTA(b[2], 1.00054, 1e-10);
    TS_ASSERT_DELTA(b[3], 0.98712, 1e-10);
    TS_ASSERT_DELTA(b[4], 1.435896, 1e-10);
  };

  CXXTEST_TEST(ConversionForAnalog)
  {
    double *a, *b;
    btk::Acquisition::Pointer input = btk::Acquisition::New();
    input->Init(0,5,2);
    btk::Analog::Pointer a1 = input->GetAnalog(0);
    a1->SetUnit("Nmm");
    a = a1->GetValues().data();
    a[0] = 1234.56; a[1] = 34.65; a[2] = 98.08; a[3] = 987.12; a[4] = 654.12;
    btk::Analog::Pointer a2 = input->GetAnalog(1);
    b = a2->GetValues().data();
    b[0] = 1.56; b[1] = 1.65; b[2] = 1.54; b[3] = 0.98712; b[4] = 1.8964;

    btk::AcquisitionUnitConverter::Pointer uc = btk::AcquisitionUnitConverter::New();
    uc->SetInput(input);
    uc->SetUnit(btk::AcquisitionUnitConverter::Length, "m");
    uc->SetUnit(btk::AcquisitionUnitConverter::Moment, "Nm");
    uc->Update();
    btk::Acquisition::Pointer output = uc->GetOutput();
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Marker), "m");
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Angle), "deg");
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Force), "N");
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Moment), "Nm");
    TS_ASSERT_EQUALS(output->GetPointUnit(btk::Point::Power), "W");

    a1 = output->GetAnalog(0);
    a = a1->GetValues().data();
    a2 = output->GetAnalog(1);
    b = a2->GetValues().data();

    TS_ASSERT_DELTA(a[0], 1.23456, 1e-10);
    TS_ASSERT_DELTA(a[1], 0.03465, 1e-10);
    TS_ASSERT_DELTA(a[2], 0.09808, 1e-10);
    TS_ASSERT_DELTA(a[3], 0.98712, 1e-10);
    TS_ASSERT_DELTA(a[4], 0.65412, 1e-10);

    TS_ASSERT_DELTA(b[0], 1.5600, 1e-10);
    TS_ASSERT_DELTA(b[1], 1.6500, 1e-10);
    TS_ASSERT_DELTA(b[2], 1.5400, 1e-10);
    TS_ASSERT_DELTA(b[3], 0.98712, 1e-10);
    TS_ASSERT_DELTA(b[4], 1.8964, 1e-10);
  };

  CXXTEST_TEST(ConversionFromFile)
  {
    btk::AcquisitionFileReader::Pointer reader = btk::AcquisitionFileReader::New();
    reader->SetFilename(C3DFilePathIN + "sample09/PlugInC3D.c3d");
    //reader->Update();
    btk::Acquisition::Pointer acq = reader->GetOutput();

    btk::AcquisitionUnitConverter::Pointer uc = btk::AcquisitionUnitConverter::New();
    uc->SetInput(acq);
    uc->SetUnit(btk::AcquisitionUnitConverter::Length, "m");
    uc->SetUnit(btk::AcquisitionUnitConverter::Angle, "rad");
    uc->SetUnit(btk::AcquisitionUnitConverter::Moment, "Nm");
    uc->Update();

    btk::Acquisition::Pointer acq2 = uc->GetOutput();
    TS_ASSERT_EQUALS(acq2->GetPointUnit(btk::Point::Scalar), "m");
    TS_ASSERT_EQUALS(acq->GetFirstFrame(), acq2->GetFirstFrame());
    TS_ASSERT_EQUALS(acq->GetPointFrequency(), acq2->GetPointFrequency());
    TS_ASSERT_EQUALS(acq->GetPointNumber(), acq2->GetPointNumber());
    TS_ASSERT_EQUALS(acq->GetPointFrameNumber(), acq2->GetPointFrameNumber());
    TS_ASSERT_EQUALS(acq->GetAnalogFrequency(), acq2->GetAnalogFrequency());
    TS_ASSERT_EQUALS(acq->GetAnalogNumber(), acq2->GetAnalogNumber());

    for (int j = 0 ; j < acq->GetPointNumber() ; ++j)
    {
      double s = 1.0;
      btk::Point::Type t = acq->GetPoint(j)->GetType();
      if ((t == btk::Point::Marker) || (t == btk::Point::Scalar))
        s = 0.001;
      else if (t == btk::Point::Angle)
        s = 1.745329251994e-02;
      else if (t == btk::Point::Moment)
        s = 0.001;
      for (int i = 1 ; i < 50 ; ++i)
      {
        TS_ASSERT_DELTA(acq->GetPoint(j)->GetValues()(i,0) * s, acq2->GetPoint(j)->GetValues()(i,0), 1e-10);
        TS_ASSERT_DELTA(acq->GetPoint(j)->GetValues()(i,1) * s, acq2->GetPoint(j)->GetValues()(i,1), 1e-10);
        TS_ASSERT_DELTA(acq->GetPoint(j)->GetValues()(i,2) * s, acq2->GetPoint(j)->GetValues()(i,2), 1e-10);
      }
    }
    for (int j = 0 ; j < acq->GetAnalogNumber() ; ++j)
    {
      double s = 1.0;
      std::string unit = acq->GetAnalog(j)->GetUnit();
      if (unit.compare("Nmm") == 0)
        s = 0.001;
      for (int i = 1 ; i < 50 ; ++i)
      {
        TS_ASSERT_DELTA(acq->GetAnalog(j)->GetValues()(i) * s, acq2->GetAnalog(j)->GetValues()(i), 1e-10);
      }
    }

    TS_ASSERT_DELTA(acq->GetMetaData()->GetChild("SEG")->GetChild("MARKER_DIAMETER")->GetInfo()->ToDouble(0) * 0.001,
                    acq2->GetMetaData()->GetChild("SEG")->GetChild("MARKER_DIAMETER")->GetInfo()->ToDouble(0), 1e-5);
  };

  CXXTEST_TEST(ConversionFromFileCalMatrix_Type4)
  {
    btk::AcquisitionFileReader::Pointer reader = btk::AcquisitionFileReader::New();
    reader->SetFilename(C3DFilePathIN + "sample10/TYPE-4.C3D");
    btk::Acquisition::Pointer acq = reader->GetOutput();

    btk::AcquisitionUnitConverter::Pointer uc = btk::AcquisitionUnitConverter::New();
    uc->SetInput(acq);
    uc->SetUnit(btk::AcquisitionUnitConverter::Length, "m");
    uc->SetUnit(btk::AcquisitionUnitConverter::Moment, "Nm");

    btk::ForcePlatformsExtractor::Pointer pfe1 = btk::ForcePlatformsExtractor::New();
    pfe1->SetInput(acq);
    btk::ForcePlatformsExtractor::Pointer pfe2 = btk::ForcePlatformsExtractor::New();
    pfe2->SetInput(uc->GetOutput());

    btk::GroundReactionWrenchFilter::Pointer grwf1 = btk::GroundReactionWrenchFilter::New();
    grwf1->SetInput(pfe1->GetOutput());
    grwf1->Update();
    btk::Wrench::Pointer grw1 = grwf1->GetOutput()->GetItem(0);

    btk::GroundReactionWrenchFilter::Pointer grwf2 = btk::GroundReactionWrenchFilter::New();
    grwf2->SetInput(pfe2->GetOutput());
    grwf2->Update();
    btk::Wrench::Pointer grw2 = grwf2->GetOutput()->GetItem(0);

    // NaN in the computation of the moment!
    TS_ASSERT_EIGEN_DELTA(pfe2->GetOutput()->GetItem(0)->GetChannel(0)->GetValues(), pfe1->GetOutput()->GetItem(0)->GetChannel(0)->GetValues(), 1e-15);
    TS_ASSERT_EIGEN_DELTA(pfe2->GetOutput()->GetItem(0)->GetChannel(1)->GetValues(), pfe1->GetOutput()->GetItem(0)->GetChannel(1)->GetValues(), 1e-15);
    TS_ASSERT_EIGEN_DELTA(pfe2->GetOutput()->GetItem(0)->GetChannel(2)->GetValues(), pfe1->GetOutput()->GetItem(0)->GetChannel(2)->GetValues(), 1e-15);
    // Frame #21: NaN?
    TS_ASSERT((pfe2->GetOutput()->GetItem(0)->GetChannel(3)->GetValues()-(pfe1->GetOutput()->GetItem(0)->GetChannel(3)->GetValues() * 0.001)).block(0,0,20,1).rowwise().norm().sum() < 1e-5);
    TS_ASSERT((pfe2->GetOutput()->GetItem(0)->GetChannel(4)->GetValues()-(pfe1->GetOutput()->GetItem(0)->GetChannel(4)->GetValues() * 0.001)).block(0,0,20,1).rowwise().norm().sum() < 1e-5);
    TS_ASSERT((pfe2->GetOutput()->GetItem(0)->GetChannel(5)->GetValues()-(pfe1->GetOutput()->GetItem(0)->GetChannel(5)->GetValues() * 0.001)).block(0,0,20,1).rowwise().norm().sum() < 1e-5);
    TS_ASSERT((grw2->GetPosition()->GetValues() - (grw1->GetPosition()->GetValues() * 0.001)).block(0,0,20,3).rowwise().norm().sum() < 1e-5);
    TS_ASSERT((grw2->GetMoment()->GetValues() - (grw1->GetMoment()->GetValues() * 0.001)).block(0,0,20,3).rowwise().norm().sum() < 1e-5);
    TS_ASSERT_EIGEN_DELTA(grw2->GetForce()->GetValues(), grw1->GetForce()->GetValues(), 1e-9);
  };

  CXXTEST_TEST(ConversionFromFileCalMatrix_Type4a)
  {
    btk::AcquisitionFileReader::Pointer reader = btk::AcquisitionFileReader::New();
    reader->SetFilename(C3DFilePathIN + "sample10/type-4a.c3d");
    btk::Acquisition::Pointer acq = reader->GetOutput();

    btk::AcquisitionUnitConverter::Pointer uc = btk::AcquisitionUnitConverter::New();
    uc->SetInput(acq);
    uc->SetUnit(btk::AcquisitionUnitConverter::Length, "m");
    uc->SetUnit(btk::AcquisitionUnitConverter::Moment, "Nm");

    btk::ForcePlatformsExtractor::Pointer pfe1 = btk::ForcePlatformsExtractor::New();
    pfe1->SetInput(acq);
    btk::ForcePlatformsExtractor::Pointer pfe2 = btk::ForcePlatformsExtractor::New();
    pfe2->SetInput(uc->GetOutput());

    btk::GroundReactionWrenchFilter::Pointer grwf1 = btk::GroundReactionWrenchFilter::New();
    grwf1->SetInput(pfe1->GetOutput());
    grwf1->Update();

    btk::GroundReactionWrenchFilter::Pointer grwf2 = btk::GroundReactionWrenchFilter::New();
    grwf2->SetInput(pfe2->GetOutput());
    grwf2->Update();

    // FP1
    TS_ASSERT_EIGEN_DELTA(pfe2->GetOutput()->GetItem(0)->GetChannel(0)->GetValues(), pfe1->GetOutput()->GetItem(0)->GetChannel(0)->GetValues(), 1e-15);
    TS_ASSERT_EIGEN_DELTA(pfe2->GetOutput()->GetItem(0)->GetChannel(1)->GetValues(), pfe1->GetOutput()->GetItem(0)->GetChannel(1)->GetValues(), 1e-15);
    TS_ASSERT_EIGEN_DELTA(pfe2->GetOutput()->GetItem(0)->GetChannel(2)->GetValues(), pfe1->GetOutput()->GetItem(0)->GetChannel(2)->GetValues(), 1e-15);
    TS_ASSERT((pfe2->GetOutput()->GetItem(0)->GetChannel(3)->GetValues()-(pfe1->GetOutput()->GetItem(0)->GetChannel(3)->GetValues() * 0.001)).rowwise().norm().sum() < 1e-3);
    TS_ASSERT((pfe2->GetOutput()->GetItem(0)->GetChannel(4)->GetValues()-(pfe1->GetOutput()->GetItem(0)->GetChannel(4)->GetValues() * 0.001)).rowwise().norm().sum() < 1e-3);
    TS_ASSERT((pfe2->GetOutput()->GetItem(0)->GetChannel(5)->GetValues()-(pfe1->GetOutput()->GetItem(0)->GetChannel(5)->GetValues() * 0.001)).rowwise().norm().sum() < 1e-3);
    btk::Wrench::Pointer grw1 = grwf1->GetOutput()->GetItem(0);
    btk::Wrench::Pointer grw2 = grwf2->GetOutput()->GetItem(0);
    TS_ASSERT((grw2->GetPosition()->GetValues() - (grw1->GetPosition()->GetValues() * 0.001)).rowwise().norm().sum() < 1e-3);
    TS_ASSERT((grw2->GetMoment()->GetValues() - (grw1->GetMoment()->GetValues() * 0.001)).rowwise().norm().sum() < 1e-3);
    TS_ASSERT_EIGEN_DELTA(grw2->GetForce()->GetValues(), grw1->GetForce()->GetValues(), 1e-9);

    // FP2
    TS_ASSERT_EIGEN_DELTA(pfe2->GetOutput()->GetItem(1)->GetChannel(0)->GetValues(), pfe1->GetOutput()->GetItem(1)->GetChannel(0)->GetValues(), 1e-15);
    TS_ASSERT_EIGEN_DELTA(pfe2->GetOutput()->GetItem(1)->GetChannel(1)->GetValues(), pfe1->GetOutput()->GetItem(1)->GetChannel(1)->GetValues(), 1e-15);
    TS_ASSERT_EIGEN_DELTA(pfe2->GetOutput()->GetItem(1)->GetChannel(2)->GetValues(), pfe1->GetOutput()->GetItem(1)->GetChannel(2)->GetValues(), 1e-15);
    TS_ASSERT((pfe2->GetOutput()->GetItem(1)->GetChannel(3)->GetValues()-(pfe1->GetOutput()->GetItem(1)->GetChannel(3)->GetValues() * 0.001)).rowwise().norm().sum() < 1e-3);
    TS_ASSERT((pfe2->GetOutput()->GetItem(1)->GetChannel(4)->GetValues()-(pfe1->GetOutput()->GetItem(1)->GetChannel(4)->GetValues() * 0.001)).rowwise().norm().sum() < 1e-3);
    TS_ASSERT((pfe2->GetOutput()->GetItem(1)->GetChannel(5)->GetValues()-(pfe1->GetOutput()->GetItem(1)->GetChannel(5)->GetValues() * 0.001)).rowwise().norm().sum() < 1e-3);
    grw1 = grwf1->GetOutput()->GetItem(1);
    grw2 = grwf2->GetOutput()->GetItem(1);
    TS_ASSERT((grw2->GetPosition()->GetValues() - (grw1->GetPosition()->GetValues() * 0.001)).rowwise().norm().sum() < 1e-3);
    TS_ASSERT((grw2->GetMoment()->GetValues() - (grw1->GetMoment()->GetValues() * 0.001)).rowwise().norm().sum() < 1e-3);
    TS_ASSERT_EIGEN_DELTA(grw2->GetForce()->GetValues(), grw1->GetForce()->GetValues(), 1e-9);
  };
};

CXXTEST_SUITE_REGISTRATION(AcquisitionUnitConverterTest)
CXXTEST_TEST_REGISTRATION(AcquisitionUnitConverterTest, NoInputNoConversion)
CXXTEST_TEST_REGISTRATION(AcquisitionUnitConverterTest, NoInputConversionToMeter)
CXXTEST_TEST_REGISTRATION(AcquisitionUnitConverterTest, ConversionToMeter)
CXXTEST_TEST_REGISTRATION(AcquisitionUnitConverterTest, ConversionForAnalog)
CXXTEST_TEST_REGISTRATION(AcquisitionUnitConverterTest, ConversionFromFile)
CXXTEST_TEST_REGISTRATION(AcquisitionUnitConverterTest, ConversionFromFileCalMatrix_Type4)
CXXTEST_TEST_REGISTRATION(AcquisitionUnitConverterTest, ConversionFromFileCalMatrix_Type4a)
#endif


text:
/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.facebook.presto.execution;

import com.facebook.presto.metadata.Metadata;
import com.facebook.presto.security.AccessControl;
import com.facebook.presto.sql.tree.Deallocate;
import com.facebook.presto.transaction.TransactionManager;

import java.util.concurrent.CompletableFuture;

import static java.util.concurrent.CompletableFuture.completedFuture;

public class DeallocateTask
        implements DataDefinitionTask<Deallocate>
{
    @Override
    public String getName()
    {
        return "DEALLOCATE";
    }

    @Override
    public CompletableFuture<?> execute(Deallocate statement, TransactionManager transactionManager, Metadata metadata, AccessControl accessControl, QueryStateMachine stateMachine)
    {
        String statementName = statement.getName();
        stateMachine.removePreparedStatement(statementName);
        return completedFuture(null);
    }
}


text:
<TITLE>Review for Chocolat (2000)</TITLE>
<LINK REL="STYLESHEET" TYPE="text/css" HREF="/ramr.css">

Chocolat (2000)

reviewed by
Harvey S. Karten

CHOCOLAT

 Reviewed by Harvey Karten
 Miramax Films
 Director: Lasse Hallstrom
 Writer:  Joanne Harris (Novel) Robert Nelson Jacobs
 Cast: Juliette Binoche, Victoire Thivisol, Johnny Depp, Alfred
Molina, Hugh O'Conor,Lena Olin, Peter Stormare, Judi
Dench, Carrie-Anne Moss

   Although chocolate is a high-calorie food, health honchos
have discovered that it has benefits aside from its heavenly
taste.  Chocolate releases hormones that affect our mood
and our feelings of love--but then we guys who have been
giving boxes of the stuff to our women friends along with the
flowers always knew that.  Chocolate in moderate quantities
has been found not to elevate cholesterol and some
researchers even believe that it has anti-carcinogenic
properties.  No wonder, then, that this enchanted confection
can change the attitudes of an entire town, as we see in a
wonderfully atmospheric, exquisitely paced fable called
"Chocolat."  Though the principal performer is French and all
action takes place in an isolated French village, the dialogue
is English--which should be a selling point for the ninety-nine
percent of American moviegoers who seem to eschew any
film that requires the reading of subtitles.

  As Roger Pratt's camera brings us to another world, the
fictional village of Lansquenet that would be the delight of
tourists but would bore the breeches off any urban traveler in
two days, we wonder whether we are in the year 1363 rather
than the actual time of the setting eighteen years after World
War II.  The cobblestone streets that embrace the shadow of
the town's single church form the pavement for a group of
citizens who appear alike in their beliefs but whose
experiences run the gamut from a crotchety grandmother to
an abused wife to an uptight mayor and a sex-starved
matron.

   As the entire hamlet pays homage to God on one blustery
Sunday, in walks unwed mother Vianne Rocher (Juliette
Binoche) together with her young daughter, Anouk (Victoire
Thivisol).  She is introduced to us as a wanderer whose
agenda may be more than the mere opening of a chocolate
shop.  Renting a storefront from the grouchy old Armande
Voizin (Judi Dench), she tries to coax the townspeople into
patronage by offering free samples of her wares, but those
not biting include the reactionary mayor, the Comte de
Reynaud (Alfred Molina)--whose ancestor once chased the
"radical" Huguenots out of the town and whose statue frowns
down on the citizenry--and Josephine Muscat (Lena Olin),
who is more interested in shoplifting a small box of goodies
than in honest patronage.

  Though the mayor, allied with the reluctant priest
Pere Henri (Hugh O'Conor), urge a boycott of the store since
it has opened during the Lenten season, most of the folks
cannot resist taking in the aromas of the divine food.  Vianne
even wins over the kleptomaniac Josephine, who has been
abused by her boorish husband Serge (Peter Stormare), and
becomes an assistant in the shop regularly turning out Venus
Nipples and an array of confections that would make New
York's Godiva fans drool.  When Vianne--whose refuses to go
to church like the rest of the town--begins hanging out with
the knavish Irish gypsy Roux (Johnny Depp), the lines are
firmly drawn.  Townspeople like up behind their mayor in
favor of ridding the hamlet of both Vianne and the gypsy
band, while others like Josephine and the newly cheerful
grandmother, ally themselves with the newcomer.

   Lasse Hallstrom's film, based on an adaptation of Joanne
Harris's novel by Robert Nelson Jacobs, shares a motif with
Gary Ross's "Pleasantville" (a brother and sister infiltrate a
narrow-minded environs with their cosmopolitan sensibilities),
with "Gabriel Axel's "Babette's Feast" (about people using
religion as a substitute for life who are at least temporarily
converted to worldliness via a gourmet dinner), and with
Stanley Tucci's "Big Night" (immigrants trying to survive as
restaurateurs against the competition of an established food
emporium).  "Chocolat," which is as light and fluffy as a
bonbon, does not quite support the weight of its message--
that people everywhere must learn to tolerate those who are
different from them--though the picture does most adequately
convey the notion that we should all lighten up.  One movie
buff in effect mentions on an Internet site that the religious
townspeople are made to look like ignorant hillbillies while the
agnostic, nature-worshipping Vianne is the bearer of truth:
that the film condescends, taking sides with the sophisticated
wanderer who seems to need no money (she hands out more
samples than she sells).  This criticism has merit, just as
does the similar point made about "Pleasantville."  On the
whole, "Chocolat" must be accepted as a fairy tale, beckoning
the audience to suspend disbelief and to go with the central
idea that conventional views ought to be challenged, that
change is the nature of things, that life is not a dress
rehearsal.  "Chocolat" is a lovely, atmosphere-rich tale, a
heartfelt, Capra-esque fable well suited to the coming holiday
season.

Rated PG-13.  Running time: 121 minutes.  (C) 2000 by
Harvey Karten, film_critic@compuserve.com

The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).

The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.

Please direct comments/criticisms of the review to relevant newsgroups.

Broken URLs inthe reviews are the responsibility of the author.

The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.

Related links: index of all rec.arts.movies.reviews reviews


text:
#include <stdio.h>
#include <string.h>
#include <clBLAS.h>

#include <devinfo.h>
#include "clblas-internal.h"
#include "solution_seq.h"

clblasStatus
doRotmg(
	CLBlasKargs *kargs,
    cl_mem D1,
    size_t offD1,
    cl_mem D2,
    size_t offD2,
    cl_mem X1,
    size_t offX1,
    cl_mem Y1,
    size_t offY1,
    cl_mem param,
    size_t offParam,
    cl_uint numCommandQueues,
    cl_command_queue *commandQueues,
    cl_uint numEventsInWaitList,
    const cl_event *eventWaitList,
    cl_event *events)
	{
		cl_int err;
		ListHead seq;
        clblasStatus retCode = clblasSuccess;

		if (!clblasInitialized) {
        return clblasNotInitialized;
		}

		/* Validate arguments */

        retCode = checkMemObjects(D1, D2, X1, true, X_VEC_ERRSET, Y_VEC_ERRSET, X_VEC_ERRSET );
		if (retCode) {      // for mem objects A, B
			printf("Invalid mem object..\n");
            return retCode;
		}
		retCode = checkMemObjects(Y1, param, Y1, false, X_VEC_ERRSET, Y_VEC_ERRSET, X_VEC_ERRSET );
		if (retCode) {      // for mem objects C, S
			printf("Invalid mem object..\n");
            return retCode;
		}

		// Check wheather enough memory was allocated

		if ((retCode = checkVectorSizes(kargs->dtype, 1, D1, offD1, 1, X_VEC_ERRSET))) {
			printf("Invalid Size for D1\n");
            return retCode;
		}
		if ((retCode = checkVectorSizes(kargs->dtype, 1, D2, offD2, 1, Y_VEC_ERRSET))) {
			printf("Invalid Size for D2\n");
            return retCode;
		}
		if ((retCode = checkVectorSizes(kargs->dtype, 1, X1, offX1, 1, X_VEC_ERRSET))) {
			printf("Invalid Size for X1\n");
            return retCode;
		}
		if ((retCode = checkVectorSizes(kargs->dtype, 1, Y1, offY1, 1, Y_VEC_ERRSET))) {
			printf("Invalid Size for Y1\n");
            return retCode;
		}
		if ((retCode = checkVectorSizes(kargs->dtype, 1, param, offParam, 1, Y_VEC_ERRSET))) {
			printf("Invalid Size for PARAM\n");
            return retCode;
		}
		///////////////////////////////////////////////////////////////

		if ((commandQueues == NULL) || (numCommandQueues == 0))
		{
			return clblasInvalidValue;
		}

		/* numCommandQueues will be hardcoded to 1 as of now. No multi-gpu support */
		numCommandQueues = 1;
		if (commandQueues[0] == NULL)
		{
			return clblasInvalidCommandQueue;
		}

		if ((numEventsInWaitList !=0) && (eventWaitList == NULL))
		{
			return clblasInvalidEventWaitList;
		}

		kargs->A = D1;
    	kargs->B = D2;
		kargs->C = X1;
    	kargs->D = Y1;
    	kargs->E = param;
		kargs->offa = offD1;
		kargs->offb = offD2;
        kargs->offc = offX1;
        kargs->offd = offY1;
        kargs->offe = offParam;

		listInitHead(&seq);
		err = makeSolutionSeq(CLBLAS_ROTMG, kargs, numCommandQueues, commandQueues,
        					        numEventsInWaitList, eventWaitList, events, &seq);
		if (err == CL_SUCCESS) {
       		err = executeSolutionSeq(&seq);
		}

		freeSolutionSeq(&seq);

		return (clblasStatus)err;
	}

clblasStatus
clblasSrotmg(
    cl_mem SD1,
    size_t offSD1,
    cl_mem SD2,
    size_t offSD2,
    cl_mem SX1,
    size_t offSX1,
    const cl_mem SY1,
    size_t offSY1,
    cl_mem SPARAM,
    size_t offSparam,
    cl_uint numCommandQueues,
    cl_command_queue *commandQueues,
    cl_uint numEventsInWaitList,
    const cl_event *eventWaitList,
    cl_event *events)
	{
		CLBlasKargs kargs;

		memset(&kargs, 0, sizeof(kargs));
		kargs.dtype = TYPE_FLOAT;

		return doRotmg(&kargs, SD1, offSD1, SD2, offSD2, SX1, offSX1, SY1, offSY1, SPARAM, offSparam,
						numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);
	}

clblasStatus
clblasDrotmg(
    cl_mem DD1,
    size_t offDD1,
    cl_mem DD2,
    size_t offDD2,
    cl_mem DX1,
    size_t offDX1,
    const cl_mem DY1,
    size_t offDY1,
    cl_mem DPARAM,
    size_t offDparam,
    cl_uint numCommandQueues,
    cl_command_queue *commandQueues,
    cl_uint numEventsInWaitList,
    const cl_event *eventWaitList,
    cl_event *events)
	{
		CLBlasKargs kargs;

		memset(&kargs, 0, sizeof(kargs));
		kargs.dtype = TYPE_DOUBLE;

		return doRotmg(&kargs, DD1, offDD1, DD2, offDD2, DX1, offDX1, DY1, offDY1, DPARAM, offDparam,
						numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);
	}


text:
import { assert } from "chai";
import * as ConfigLib from "../lib/config";
import * as ErrorsLib from "../lib/common/errors";
import * as FsLib from "../lib/common/file-system";
import * as HostInfoLib from "../lib/common/host-info";
import * as LoggerLib from "../lib/common/logger/logger";
import * as NpmLib from "../lib/node-package-manager";
import * as YarnLib from "../lib/yarn-package-manager";
import * as PnpmLib from "../lib/pnpm-package-manager";
import * as PackageManagerLib from "../lib/package-manager";
import * as PackageInstallationManagerLib from "../lib/package-installation-manager";
import * as OptionsLib from "../lib/options";
import * as StaticConfigLib from "../lib/config";
import * as yok from "../lib/common/yok";
import ChildProcessLib = require("../lib/common/child-process");
import { SettingsService } from "../lib/common/test/unit-tests/stubs";
import { ProjectDataService } from "../lib/services/project-data-service";
import { ProjectConfigServiceStub, ProjectDataStub } from "./stubs";
import { IInjector } from "../lib/common/definitions/yok";
import * as _ from "lodash";
import { IDictionary } from "../lib/common/declarations";

function createTestInjector(): IInjector {
	const testInjector = new yok.Yok();

	testInjector.register("projectData", ProjectDataStub);
	testInjector.register("config", ConfigLib.Configuration);
	testInjector.register("logger", LoggerLib.Logger);
	testInjector.register("errors", ErrorsLib.Errors);
	testInjector.register("options", OptionsLib.Options);
	testInjector.register("fs", FsLib.FileSystem);
	testInjector.register("hostInfo", HostInfoLib.HostInfo);
	testInjector.register("staticConfig", StaticConfigLib.StaticConfig);
	testInjector.register("childProcess", ChildProcessLib.ChildProcess);
	testInjector.register("settingsService", SettingsService);
	testInjector.register("projectDataService", ProjectDataService);
	testInjector.register("devicePlatformsConstants", {});
	testInjector.register("androidResourcesMigrationService", {});

	testInjector.register("httpClient", {});
	testInjector.register("pacoteService", {
		manifest: () => Promise.resolve(),
	});
	testInjector.register("userSettingsService", {
		getSettingValue: async (settingName: string): Promise<void> => undefined,
	});
	testInjector.register("npm", NpmLib.NodePackageManager);
	testInjector.register("yarn", YarnLib.YarnPackageManager);
	testInjector.register("pnpm", PnpmLib.PnpmPackageManager);
	testInjector.register("packageManager", PackageManagerLib.PackageManager);
	testInjector.register("projectConfigService", ProjectConfigServiceStub);
	testInjector.register(
		"packageInstallationManager",
		PackageInstallationManagerLib.PackageInstallationManager
	);

	return testInjector;
}

function mockNpm(
	testInjector: IInjector,
	versions: string[],
	latestVersion: string
) {
	testInjector.register("npm", {
		view: async (packageName: string, config: any): Promise<string[]> => {
			if (config.versions) {
				return versions;
			}

			throw new Error(`Unable to find propertyName ${config}.`);
		},
	});
}

interface ITestData {
	/**
	 * All versions of the package, including the ones from another tags.
	 */
	versions: string[];

	/**
	 * The version under latest tag.
	 */
	packageLatestVersion: string;

	/**
	 * Version of nativescript-cli, based on which the version of the package that will be installed is detected.
	 */
	cliVersion: string;

	/**
	 * Version, based on which the version of the package that will be installed is detected.
	 * Used when semantically the correct reference version is different than the CLI version.
	 * (e.g. inspector package version should be determined by the project's ios runtime version)
	 */
	referenceVersion?: string;

	/**
	 * Expected result
	 */
	expectedResult: string;
}

describe("Npm installation manager tests", () => {
	describe("getLatestCompatibleVersion", () => {
		const testData: IDictionary<ITestData> = {
			"when there's only one available version and it matches CLI's version": {
				versions: ["1.4.0"],
				packageLatestVersion: "1.4.0",
				cliVersion: "1.4.0",
				expectedResult: "1.4.0",
			},

			"when there's only one available version and it is higher than match CLI's version": {
				versions: ["1.4.0"],
				packageLatestVersion: "1.4.0",
				cliVersion: "1.2.0",
				expectedResult: "1.4.0",
			},

			"when there's only one available version and it is lower than CLI's version": {
				versions: ["1.4.0"],
				packageLatestVersion: "1.4.0",
				cliVersion: "1.6.0",
				expectedResult: "1.4.0",
			},

			"when there are multiple package versions and the latest one matches ~<cli-version>": {
				versions: ["1.2.0", "1.3.0", "1.3.1", "1.3.2", "1.3.3", "1.4.0"],
				packageLatestVersion: "1.3.3",
				cliVersion: "1.3.0",
				expectedResult: "1.3.3",
			},

			"when there are multiple package versions and the latest one matches ~<cli-version> when there are newer matching versions but they are not under latest tag": {
				versions: ["1.2.0", "1.3.0", "1.3.1", "1.3.2", "1.3.3", "1.4.0"],
				packageLatestVersion: "1.3.2",
				cliVersion: "1.3.0",
				expectedResult: "1.3.2",
			},

			"when there are multiple package versions and the latest one is lower than ~<cli-version>": {
				versions: ["1.2.0", "1.3.0", "1.3.1", "1.3.2", "1.3.3", "1.4.0"],
				packageLatestVersion: "1.4.0",
				cliVersion: "1.5.0",
				expectedResult: "1.4.0",
			},

			"when there are multiple package versions and there's beta version matching CLI's semver": {
				versions: ["1.2.0", "1.3.0", "1.3.1", "1.4.0", "1.5.0-2016-02-25-182"],
				packageLatestVersion: "1.4.0",
				cliVersion: "1.5.0",
				expectedResult: "1.4.0",
			},

			"when there are multiple package versions and package's latest version is greater than CLI's version": {
				versions: [
					"1.2.0",
					"1.3.0",
					"1.3.1",
					"1.4.0",
					"1.5.0-2016-02-25-182",
					"1.5.0",
					"1.6.0",
				],
				packageLatestVersion: "1.6.0",
				cliVersion: "1.5.0",
				expectedResult: "1.5.0",
			},

			"when there are multiple versions latest one does not match CLI's semver and other versions are not matching either": {
				versions: [
					"1.0.0",
					"1.0.1",
					"1.2.0",
					"1.3.1",
					"1.4.0",
					"1.5.0-2016-02-25-182",
					"1.5.0",
				],
				packageLatestVersion: "1.0.0",
				cliVersion: "1.1.0",
				expectedResult: "1.0.0",
			},

			"when CLI's version is beta (has dash) latest matching beta version is returned": {
				versions: [
					"1.0.0",
					"1.0.1",
					"1.4.0",
					"1.5.0-2016-02-25-182",
					"1.5.0-2016-02-26-202",
				],
				packageLatestVersion: "1.4.0",
				cliVersion: "1.5.0-182",
				expectedResult: "1.5.0-2016-02-26-202",
			},

			"when CLI's version is beta (has dash) latest matching official version is returned when beta versions do not match": {
				versions: [
					"1.0.0",
					"1.0.1",
					"1.4.0",
					"1.5.0-2016-02-25-182",
					"1.5.0-2016-02-26-202",
				],
				packageLatestVersion: "1.4.0",
				cliVersion: "1.6.0-2016-03-01-182",
				expectedResult: "1.4.0",
			},

			"when CLI's version is beta (has dash) latest matching official version is returned when beta versions do not match (when the prerelease of CLI is higher than prerelease version of runtime)": {
				versions: [
					"1.0.0",
					"1.0.1",
					"1.4.0",
					"1.6.0-2016-02-25-182",
					"1.6.0-2016-02-26-202",
				],
				packageLatestVersion: "1.4.0",
				cliVersion: "1.6.0-2016-10-01-182",
				expectedResult: "1.4.0",
			},
			"When CLI Version has patch version larger than an existing package, should return max compliant package from the same major.minor version": {
				versions: [
					"1.0.0",
					"1.0.1",
					"1.4.0",
					"2.5.0",
					"2.5.1",
					"2.5.2",
					"3.0.0",
				],
				packageLatestVersion: "3.0.0",
				cliVersion: "2.5.4",
				expectedResult: "2.5.2",
			},
			"When reference version is specified as argument": {
				versions: ["122.0.4", "123.0.0", "123.0.1", "123.1.0", "124.0.0"],
				packageLatestVersion: "124.0.0",
				cliVersion: "0.0.0", // should not matter
				expectedResult: "123.0.1",
				referenceVersion: "123.0.5",
			},
		};

		_.each(testData, (currentTestData: ITestData, testName: string) => {
			it(`returns correct latest compatible version, ${testName}`, async () => {
				const testInjector = createTestInjector();

				mockNpm(
					testInjector,
					currentTestData.versions,
					currentTestData.packageLatestVersion
				);

				// Mock staticConfig.version
				const staticConfig = testInjector.resolve("staticConfig");
				staticConfig.version = currentTestData.cliVersion;

				// Mock packageInstallationManager.getLatestVersion
				const packageInstallationManager = testInjector.resolve(
					"packageInstallationManager"
				);
				packageInstallationManager.getLatestVersion = (packageName: string) =>
					Promise.resolve(currentTestData.packageLatestVersion);

				const actualLatestCompatibleVersion = await packageInstallationManager.getLatestCompatibleVersion(
					"",
					currentTestData.referenceVersion
				);
				assert.equal(
					actualLatestCompatibleVersion,
					currentTestData.expectedResult
				);
			});
		});
	});
});