<p>
The environment variables for the application launch.
</p>

@param environmentVariables
The environment variables for the application launch.
@return Returns a reference to this object so that method calls can be chained together.
975551
public LaunchConfig withEnvironmentVariables(java.util.Map<String, String> environmentVariables) {
        setEnvironmentVariables(environmentVariables);
        return this;
    }
1140229
public EnvVars getCharacteristicEnvVars() {
        EnvVars env = new EnvVars();
        env.put("JENKINS_SERVER_COOKIE",SERVER_COOKIE.get());
        env.put("HUDSON_SERVER_COOKIE",SERVER_COOKIE.get()); // Legacy compatibility
        env.put("JOB_NAME",getFullName());
        env.put("JOB_BASE_NAME", getName());
        return env;
    }
1260695
public java.util.Map<java.lang.String, java.lang.String> getEnvVariablesMap() {
    return internalGetEnvVariables().getMap();
  }
493919
static Path getEnvironemtVariableConfigFilePath() {
        final String value = System.getenv(ENVIRONMENT_CONFIG_VARIABLE_NAME);
        return Paths.get(value);
    }
1039299
public void addEnv(final Environment.Variable env){
        if(null==envVars) {
            envVars = new ArrayList<Environment.Variable>();
        }
        envVars.add(env);
    }
850320
public static String getEnv(String name, String defaultValue) {
        Map<String, String> env = System.getenv();

        // try to get value from environment variables
        if (env.get(name) != null) {
            return env.get(name);
        }

        // fall back to system properties
        return System.getProperty(name, defaultValue);
    }
976686
public ScriptEnvironment getEnvironment(String environmentName) {
      Preconditions.checkArgument(StringUtils.isNotNullOrBlank(environmentName),
                                  "Environment name cannot be null or empty"
                                 );
      ScriptEngine engine = engineManager.getEngineByName(environmentName);
      Preconditions.checkArgument(engine != null, environmentName + " is an unknown.");
      environmentName = engine.getFactory().getEngineName();
      if (!environments.containsKey(environmentName)) {
         environments.put(environmentName, new ScriptEnvironment(engine));
      }
      return environments.get(environmentName);
   }
1327432
public static Protos.Environment.Variable variable(String name, String value) {
		checkNotNull(name);
		return Protos.Environment.Variable.newBuilder()
			.setName(name)
			.setValue(value)
			.build();
	}
717751
public static String readEnvironment(String environmentName, String defaultValue) {
		String property = System.getenv(environmentName);
		if (isNullOrEmpty(property)) {
			return defaultValue;
		}
		return property;
	}
542766
public void addEnv(final Environment.Variable var) {
    if (this.env == null) {
      this.env = new Environment();
      this.newEnvironment = true;
      if (this.processor != null) {
        // Change the environment in the processor
        setProcessor(this.processor);
      }
    }
    this.env.addVariable(var);
  }
682347
public static void logShellEnvironmentVariables() {
		Map<String, String> env = System.getenv();
		Iterator<String> keys = env.keySet().iterator();
		while (keys.hasNext() ) {
			String key = keys.next();
			String value = env.get(key);
			logMessage("Env, "+key+"="+value.trim());
		}
	}
1140619
public java.lang.String getEnvVariablesOrDefault(
      java.lang.String key,
      java.lang.String defaultValue) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    java.util.Map<java.lang.String, java.lang.String> map =
        internalGetEnvVariables().getMap();
    return map.containsKey(key) ? map.get(key) : defaultValue;
  }
542686
public static List<Variable> getRunTimeVariables(
      final Collection<Variable> variables) {
    final List<Variable> runtimeVariables =
        ReportalUtil.getVariablesByRegex(variables,
            Reportal.REPORTAL_CONFIG_PREFIX_NEGATION_REGEX);

    return runtimeVariables;
  }
379425
public void setEnvironmentVariables(Map<String, String> environment) {
    for (Map.Entry<String, String> entry : environment.entrySet()) {
      setEnvironmentVariable(entry.getKey(), entry.getValue());
    }
  }
222740
public static Variable[] getVariables(NameSpace ns, String[] names) {
        if (null == ns || null == names)
            return new Variable[0];
        return Stream.of(names).map(name->getVariable(ns, name))
            .filter(Objects::nonNull).toArray(Variable[]::new);
    }
204277
@Override
    public void makeBuildVariables(@SuppressWarnings("rawtypes") AbstractBuild build, Map<String, String> variables) {
        variables.put("ghprbShowMatrixStatus", Boolean.toString(getShowMatrixStatus()));
        variables.put("ghprbUpstreamStatus", "true");
        variables.put("ghprbCommitStatusContext", getCommitStatusContext());
        variables.put("ghprbTriggeredStatus", getTriggeredStatus());
        variables.put("ghprbStartedStatus", getStartedStatus());
        variables.put("ghprbStatusUrl", getStatusUrl());
        variables.put("ghprbAddTestResults", Boolean.toString(getAddTestResults()));

        Map<GHCommitState, StringBuilder> statusMessages = new HashMap<GHCommitState, StringBuilder>(INITIAL_CAPACITY);

        for (GhprbBuildResultMessage message : getCompletedStatus()) {
            GHCommitState state = message.getResult();
            StringBuilder sb;
            if (!statusMessages.containsKey(state)) {
                sb = new StringBuilder();
                statusMessages.put(state, sb);
            } else {
                sb = statusMessages.get(state);
                sb.append("\n");
            }
            sb.append(message.getMessage());
        }

        for (Entry<GHCommitState, StringBuilder> next : statusMessages.entrySet()) {
            String key = String.format("ghprb%sMessage", next.getKey().name());
            variables.put(key, next.getValue().toString());
        }
    }
779672
public static Environment create(final EnvVars envVars) {
		return new Environment() {
			@Override
			public void buildEnvVars(Map<String, String> env) {
				env.putAll(envVars);
			}
		};
	}