1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! Inspection and manipulation of the process's environment.
13 //! This module contains methods to inspect various aspects such as
14 //! environment variables, process arguments, the current directory, and various
15 //! other important directories.
17 #![stable(feature = "env", since = "1.0.0")]
22 use ffi::{OsStr, OsString};
25 use path::{Path, PathBuf};
26 use sys::os as os_imp;
28 /// Returns the current working directory as a `PathBuf`.
32 /// Returns an `Err` if the current working directory value is invalid.
35 /// * Current directory does not exist.
36 /// * There are insufficient permissions to access the current directory.
43 /// // We assume that we are in a valid directory.
44 /// let p = env::current_dir().unwrap();
45 /// println!("The current directory is {}", p.display());
47 #[stable(feature = "env", since = "1.0.0")]
48 pub fn current_dir() -> io::Result<PathBuf> {
52 /// Changes the current working directory to the specified path, returning
53 /// whether the change was completed successfully or not.
59 /// use std::path::Path;
61 /// let root = Path::new("/");
62 /// assert!(env::set_current_dir(&root).is_ok());
63 /// println!("Successfully changed working directory to {}!", root.display());
65 #[stable(feature = "env", since = "1.0.0")]
66 pub fn set_current_dir<P: AsRef<Path>>(p: P) -> io::Result<()> {
67 os_imp::chdir(p.as_ref())
70 /// An iterator over a snapshot of the environment variables of this process.
72 /// This iterator is created through `std::env::vars()` and yields `(String,
74 #[stable(feature = "env", since = "1.0.0")]
75 pub struct Vars { inner: VarsOs }
77 /// An iterator over a snapshot of the environment variables of this process.
79 /// This iterator is created through `std::env::vars_os()` and yields
80 /// `(OsString, OsString)` pairs.
81 #[stable(feature = "env", since = "1.0.0")]
82 pub struct VarsOs { inner: os_imp::Env }
84 /// Returns an iterator of (variable, value) pairs of strings, for all the
85 /// environment variables of the current process.
87 /// The returned iterator contains a snapshot of the process's environment
88 /// variables at the time of this invocation, modifications to environment
89 /// variables afterwards will not be reflected in the returned iterator.
93 /// While iterating, the returned iterator will panic if any key or value in the
94 /// environment is not valid unicode. If this is not desired, consider using the
95 /// `env::vars_os` function.
102 /// // We will iterate through the references to the element returned by
104 /// for (key, value) in env::vars() {
105 /// println!("{}: {}", key, value);
108 #[stable(feature = "env", since = "1.0.0")]
109 pub fn vars() -> Vars {
110 Vars { inner: vars_os() }
113 /// Returns an iterator of (variable, value) pairs of OS strings, for all the
114 /// environment variables of the current process.
116 /// The returned iterator contains a snapshot of the process's environment
117 /// variables at the time of this invocation, modifications to environment
118 /// variables afterwards will not be reflected in the returned iterator.
125 /// // We will iterate through the references to the element returned by
126 /// // env::vars_os();
127 /// for (key, value) in env::vars_os() {
128 /// println!("{:?}: {:?}", key, value);
131 #[stable(feature = "env", since = "1.0.0")]
132 pub fn vars_os() -> VarsOs {
133 VarsOs { inner: os_imp::env() }
136 #[stable(feature = "env", since = "1.0.0")]
137 impl Iterator for Vars {
138 type Item = (String, String);
139 fn next(&mut self) -> Option<(String, String)> {
140 self.inner.next().map(|(a, b)| {
141 (a.into_string().unwrap(), b.into_string().unwrap())
144 fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
147 #[stable(feature = "env", since = "1.0.0")]
148 impl Iterator for VarsOs {
149 type Item = (OsString, OsString);
150 fn next(&mut self) -> Option<(OsString, OsString)> { self.inner.next() }
151 fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
154 /// Fetches the environment variable `key` from the current process.
156 /// The returned result is `Ok(s)` if the environment variable is present and is
157 /// valid unicode. If the environment variable is not present, or it is not
158 /// valid unicode, then `Err` will be returned.
165 /// let key = "HOME";
166 /// match env::var(key) {
167 /// Ok(val) => println!("{}: {:?}", key, val),
168 /// Err(e) => println!("couldn't interpret {}: {}", key, e),
171 #[stable(feature = "env", since = "1.0.0")]
172 pub fn var<K: AsRef<OsStr>>(key: K) -> Result<String, VarError> {
176 fn _var(key: &OsStr) -> Result<String, VarError> {
178 Some(s) => s.into_string().map_err(VarError::NotUnicode),
179 None => Err(VarError::NotPresent)
183 /// Fetches the environment variable `key` from the current process, returning
184 /// None if the variable isn't set.
191 /// let key = "HOME";
192 /// match env::var_os(key) {
193 /// Some(val) => println!("{}: {:?}", key, val),
194 /// None => println!("{} is not defined in the environment.", key)
197 #[stable(feature = "env", since = "1.0.0")]
198 pub fn var_os<K: AsRef<OsStr>>(key: K) -> Option<OsString> {
199 _var_os(key.as_ref())
202 fn _var_os(key: &OsStr) -> Option<OsString> {
203 os_imp::getenv(key).unwrap_or_else(|e| {
204 panic!("failed to get environment variable `{:?}`: {}", key, e)
208 /// Possible errors from the `env::var` method.
209 #[derive(Debug, PartialEq, Eq, Clone)]
210 #[stable(feature = "env", since = "1.0.0")]
212 /// The specified environment variable was not present in the current
213 /// process's environment.
214 #[stable(feature = "env", since = "1.0.0")]
217 /// The specified environment variable was found, but it did not contain
218 /// valid unicode data. The found data is returned as a payload of this
220 #[stable(feature = "env", since = "1.0.0")]
221 NotUnicode(#[cfg_attr(not(stage0), stable(feature = "env", since = "1.0.0"))] OsString),
224 #[stable(feature = "env", since = "1.0.0")]
225 impl fmt::Display for VarError {
226 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
228 VarError::NotPresent => write!(f, "environment variable not found"),
229 VarError::NotUnicode(ref s) => {
230 write!(f, "environment variable was not valid unicode: {:?}", s)
236 #[stable(feature = "env", since = "1.0.0")]
237 impl Error for VarError {
238 fn description(&self) -> &str {
240 VarError::NotPresent => "environment variable not found",
241 VarError::NotUnicode(..) => "environment variable was not valid unicode",
246 /// Sets the environment variable `k` to the value `v` for the currently running
249 /// Note that while concurrent access to environment variables is safe in Rust,
250 /// some platforms only expose inherently unsafe non-threadsafe APIs for
251 /// inspecting the environment. As a result extra care needs to be taken when
252 /// auditing calls to unsafe external FFI functions to ensure that any external
253 /// environment accesses are properly synchronized with accesses in Rust.
255 /// Discussion of this unsafety on Unix may be found in:
257 /// - [Austin Group Bugzilla](http://austingroupbugs.net/view.php?id=188)
258 /// - [GNU C library Bugzilla](https://sourceware.org/bugzilla/show_bug.cgi?id=15607#c2)
262 /// This function may panic if `key` is empty, contains an ASCII equals sign
263 /// `'='` or the NUL character `'\0'`, or when the value contains the NUL
272 /// env::set_var(key, "VALUE");
273 /// assert_eq!(env::var(key), Ok("VALUE".to_string()));
275 #[stable(feature = "env", since = "1.0.0")]
276 pub fn set_var<K: AsRef<OsStr>, V: AsRef<OsStr>>(k: K, v: V) {
277 _set_var(k.as_ref(), v.as_ref())
280 fn _set_var(k: &OsStr, v: &OsStr) {
281 os_imp::setenv(k, v).unwrap_or_else(|e| {
282 panic!("failed to set environment variable `{:?}` to `{:?}`: {}",
287 /// Removes an environment variable from the environment of the currently running process.
289 /// Note that while concurrent access to environment variables is safe in Rust,
290 /// some platforms only expose inherently unsafe non-threadsafe APIs for
291 /// inspecting the environment. As a result extra care needs to be taken when
292 /// auditing calls to unsafe external FFI functions to ensure that any external
293 /// environment accesses are properly synchronized with accesses in Rust.
295 /// Discussion of this unsafety on Unix may be found in:
297 /// - [Austin Group Bugzilla](http://austingroupbugs.net/view.php?id=188)
298 /// - [GNU C library Bugzilla](https://sourceware.org/bugzilla/show_bug.cgi?id=15607#c2)
302 /// This function may panic if `key` is empty, contains an ASCII equals sign
303 /// `'='` or the NUL character `'\0'`, or when the value contains the NUL
312 /// env::set_var(key, "VALUE");
313 /// assert_eq!(env::var(key), Ok("VALUE".to_string()));
315 /// env::remove_var(key);
316 /// assert!(env::var(key).is_err());
318 #[stable(feature = "env", since = "1.0.0")]
319 pub fn remove_var<K: AsRef<OsStr>>(k: K) {
320 _remove_var(k.as_ref())
323 fn _remove_var(k: &OsStr) {
324 os_imp::unsetenv(k).unwrap_or_else(|e| {
325 panic!("failed to remove environment variable `{:?}`: {}", k, e)
329 /// An iterator over `PathBuf` instances for parsing an environment variable
330 /// according to platform-specific conventions.
332 /// This structure is returned from `std::env::split_paths`.
333 #[stable(feature = "env", since = "1.0.0")]
334 pub struct SplitPaths<'a> { inner: os_imp::SplitPaths<'a> }
336 /// Parses input according to platform conventions for the `PATH`
337 /// environment variable.
339 /// Returns an iterator over the paths contained in `unparsed`.
346 /// let key = "PATH";
347 /// match env::var_os(key) {
349 /// for path in env::split_paths(&paths) {
350 /// println!("'{}'", path.display());
353 /// None => println!("{} is not defined in the environment.", key)
356 #[stable(feature = "env", since = "1.0.0")]
357 pub fn split_paths<T: AsRef<OsStr> + ?Sized>(unparsed: &T) -> SplitPaths {
358 SplitPaths { inner: os_imp::split_paths(unparsed.as_ref()) }
361 #[stable(feature = "env", since = "1.0.0")]
362 impl<'a> Iterator for SplitPaths<'a> {
364 fn next(&mut self) -> Option<PathBuf> { self.inner.next() }
365 fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
368 /// Error type returned from `std::env::join_paths` when paths fail to be
371 #[stable(feature = "env", since = "1.0.0")]
372 pub struct JoinPathsError {
373 inner: os_imp::JoinPathsError
376 /// Joins a collection of `Path`s appropriately for the `PATH`
377 /// environment variable.
379 /// Returns an `OsString` on success.
381 /// Returns an `Err` (containing an error message) if one of the input
382 /// `Path`s contains an invalid character for constructing the `PATH`
383 /// variable (a double quote on Windows or a colon on Unix).
389 /// use std::path::PathBuf;
391 /// if let Some(path) = env::var_os("PATH") {
392 /// let mut paths = env::split_paths(&path).collect::<Vec<_>>();
393 /// paths.push(PathBuf::from("/home/xyz/bin"));
394 /// let new_path = env::join_paths(paths).unwrap();
395 /// env::set_var("PATH", &new_path);
398 #[stable(feature = "env", since = "1.0.0")]
399 pub fn join_paths<I, T>(paths: I) -> Result<OsString, JoinPathsError>
400 where I: IntoIterator<Item=T>, T: AsRef<OsStr>
402 os_imp::join_paths(paths.into_iter()).map_err(|e| {
403 JoinPathsError { inner: e }
407 #[stable(feature = "env", since = "1.0.0")]
408 impl fmt::Display for JoinPathsError {
409 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
414 #[stable(feature = "env", since = "1.0.0")]
415 impl Error for JoinPathsError {
416 fn description(&self) -> &str { self.inner.description() }
419 /// Returns the path to the current user's home directory if known.
423 /// Returns the value of the 'HOME' environment variable if it is set
424 /// and not equal to the empty string. Otherwise, it tries to determine the
425 /// home directory by invoking the `getpwuid_r` function on the UID of the
430 /// Returns the value of the 'HOME' environment variable if it is
431 /// set and not equal to the empty string. Otherwise, returns the value of the
432 /// 'USERPROFILE' environment variable if it is set and not equal to the empty
433 /// string. If both do not exist, [`GetUserProfileDirectory`][msdn] is used to
434 /// return the appropriate path.
436 /// [msdn]: https://msdn.microsoft.com/en-us/library/windows/desktop/bb762280(v=vs.85).aspx
443 /// match env::home_dir() {
444 /// Some(ref p) => println!("{}", p.display()),
445 /// None => println!("Impossible to get your home dir!")
448 #[stable(feature = "env", since = "1.0.0")]
449 pub fn home_dir() -> Option<PathBuf> {
453 /// Returns the path to a temporary directory.
455 /// On Unix, returns the value of the 'TMPDIR' environment variable if it is
456 /// set, otherwise for non-Android it returns '/tmp'. If Android, since there
457 /// is no global temporary folder (it is usually allocated per-app), we return
458 /// '/data/local/tmp'.
460 /// On Windows, returns the value of, in order, the 'TMP', 'TEMP',
461 /// 'USERPROFILE' environment variable if any are set and not the empty
462 /// string. Otherwise, tmpdir returns the path to the Windows directory. This
463 /// behavior is identical to that of [GetTempPath][msdn], which this function
466 /// [msdn]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa364992(v=vs.85).aspx
470 /// use std::fs::File;
472 /// # fn foo() -> std::io::Result<()> {
473 /// let mut dir = env::temp_dir();
474 /// dir.push("foo.txt");
476 /// let f = try!(File::create(dir));
480 #[stable(feature = "env", since = "1.0.0")]
481 pub fn temp_dir() -> PathBuf {
485 /// Returns the filesystem path to the current executable which is running but
486 /// with the executable name.
488 /// The path returned is not necessarily a "real path" to the executable as
489 /// there may be intermediate symlinks.
493 /// Acquiring the path to the current executable is a platform-specific operation
494 /// that can fail for a good number of reasons. Some errors can include, but not
495 /// be limited to filesystem operations failing or general syscall failures.
502 /// match env::current_exe() {
503 /// Ok(exe_path) => println!("Path of this executable is: {}",
504 /// exe_path.display()),
505 /// Err(e) => println!("failed to get current exe path: {}", e),
508 #[stable(feature = "env", since = "1.0.0")]
509 pub fn current_exe() -> io::Result<PathBuf> {
510 os_imp::current_exe()
513 /// An iterator over the arguments of a process, yielding a `String` value
514 /// for each argument.
516 /// This structure is created through the `std::env::args` method.
517 #[stable(feature = "env", since = "1.0.0")]
518 pub struct Args { inner: ArgsOs }
520 /// An iterator over the arguments of a process, yielding an `OsString` value
521 /// for each argument.
523 /// This structure is created through the `std::env::args_os` method.
524 #[stable(feature = "env", since = "1.0.0")]
525 pub struct ArgsOs { inner: os_imp::Args }
527 /// Returns the arguments which this program was started with (normally passed
528 /// via the command line).
530 /// The first element is traditionally the path to the executable, but it can be
531 /// set to arbitrary text, and it may not even exist, so this property should
532 /// not be relied upon for security purposes.
536 /// The returned iterator will panic during iteration if any argument to the
537 /// process is not valid unicode. If this is not desired it is recommended to
538 /// use the `args_os` function instead.
545 /// // Prints each argument on a separate line
546 /// for argument in env::args() {
547 /// println!("{}", argument);
550 #[stable(feature = "env", since = "1.0.0")]
551 pub fn args() -> Args {
552 Args { inner: args_os() }
555 /// Returns the arguments which this program was started with (normally passed
556 /// via the command line).
558 /// The first element is traditionally the path to the executable, but it can be
559 /// set to arbitrary text, and it may not even exist, so this property should
560 /// not be relied upon for security purposes.
567 /// // Prints each argument on a separate line
568 /// for argument in env::args_os() {
569 /// println!("{:?}", argument);
572 #[stable(feature = "env", since = "1.0.0")]
573 pub fn args_os() -> ArgsOs {
574 ArgsOs { inner: os_imp::args() }
577 #[stable(feature = "env", since = "1.0.0")]
578 impl Iterator for Args {
580 fn next(&mut self) -> Option<String> {
581 self.inner.next().map(|s| s.into_string().unwrap())
583 fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
586 #[stable(feature = "env", since = "1.0.0")]
587 impl ExactSizeIterator for Args {
588 fn len(&self) -> usize { self.inner.len() }
591 #[stable(feature = "env", since = "1.0.0")]
592 impl Iterator for ArgsOs {
593 type Item = OsString;
594 fn next(&mut self) -> Option<OsString> { self.inner.next() }
595 fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
598 #[stable(feature = "env", since = "1.0.0")]
599 impl ExactSizeIterator for ArgsOs {
600 fn len(&self) -> usize { self.inner.len() }
603 /// Constants associated with the current target
604 #[stable(feature = "env", since = "1.0.0")]
606 /// A string describing the architecture of the CPU that this is currently
609 /// Some possible values:
620 #[stable(feature = "env", since = "1.0.0")]
621 pub const ARCH: &'static str = super::arch::ARCH;
623 /// The family of the operating system. In this case, `unix`.
625 /// Some possible values:
629 #[stable(feature = "env", since = "1.0.0")]
630 pub const FAMILY: &'static str = super::os::FAMILY;
632 /// A string describing the specific operating system in use: in this
635 /// Some possible values:
647 #[stable(feature = "env", since = "1.0.0")]
648 pub const OS: &'static str = super::os::OS;
650 /// Specifies the filename prefix used for shared libraries on this
651 /// platform: in this case, `lib`.
653 /// Some possible values:
656 /// - `""` (an empty string)
657 #[stable(feature = "env", since = "1.0.0")]
658 pub const DLL_PREFIX: &'static str = super::os::DLL_PREFIX;
660 /// Specifies the filename suffix used for shared libraries on this
661 /// platform: in this case, `.so`.
663 /// Some possible values:
668 #[stable(feature = "env", since = "1.0.0")]
669 pub const DLL_SUFFIX: &'static str = super::os::DLL_SUFFIX;
671 /// Specifies the file extension used for shared libraries on this
672 /// platform that goes after the dot: in this case, `so`.
674 /// Some possible values:
679 #[stable(feature = "env", since = "1.0.0")]
680 pub const DLL_EXTENSION: &'static str = super::os::DLL_EXTENSION;
682 /// Specifies the filename suffix used for executable binaries on this
683 /// platform: in this case, the empty string.
685 /// Some possible values:
690 /// - `""` (an empty string)
691 #[stable(feature = "env", since = "1.0.0")]
692 pub const EXE_SUFFIX: &'static str = super::os::EXE_SUFFIX;
694 /// Specifies the file extension, if any, used for executable binaries
695 /// on this platform: in this case, the empty string.
697 /// Some possible values:
700 /// - `""` (an empty string)
701 #[stable(feature = "env", since = "1.0.0")]
702 pub const EXE_EXTENSION: &'static str = super::os::EXE_EXTENSION;
706 #[cfg(target_os = "linux")]
708 pub const FAMILY: &'static str = "unix";
709 pub const OS: &'static str = "linux";
710 pub const DLL_PREFIX: &'static str = "lib";
711 pub const DLL_SUFFIX: &'static str = ".so";
712 pub const DLL_EXTENSION: &'static str = "so";
713 pub const EXE_SUFFIX: &'static str = "";
714 pub const EXE_EXTENSION: &'static str = "";
717 #[cfg(target_os = "macos")]
719 pub const FAMILY: &'static str = "unix";
720 pub const OS: &'static str = "macos";
721 pub const DLL_PREFIX: &'static str = "lib";
722 pub const DLL_SUFFIX: &'static str = ".dylib";
723 pub const DLL_EXTENSION: &'static str = "dylib";
724 pub const EXE_SUFFIX: &'static str = "";
725 pub const EXE_EXTENSION: &'static str = "";
728 #[cfg(target_os = "ios")]
730 pub const FAMILY: &'static str = "unix";
731 pub const OS: &'static str = "ios";
732 pub const DLL_PREFIX: &'static str = "lib";
733 pub const DLL_SUFFIX: &'static str = ".dylib";
734 pub const DLL_EXTENSION: &'static str = "dylib";
735 pub const EXE_SUFFIX: &'static str = "";
736 pub const EXE_EXTENSION: &'static str = "";
739 #[cfg(target_os = "freebsd")]
741 pub const FAMILY: &'static str = "unix";
742 pub const OS: &'static str = "freebsd";
743 pub const DLL_PREFIX: &'static str = "lib";
744 pub const DLL_SUFFIX: &'static str = ".so";
745 pub const DLL_EXTENSION: &'static str = "so";
746 pub const EXE_SUFFIX: &'static str = "";
747 pub const EXE_EXTENSION: &'static str = "";
750 #[cfg(target_os = "dragonfly")]
752 pub const FAMILY: &'static str = "unix";
753 pub const OS: &'static str = "dragonfly";
754 pub const DLL_PREFIX: &'static str = "lib";
755 pub const DLL_SUFFIX: &'static str = ".so";
756 pub const DLL_EXTENSION: &'static str = "so";
757 pub const EXE_SUFFIX: &'static str = "";
758 pub const EXE_EXTENSION: &'static str = "";
761 #[cfg(target_os = "bitrig")]
763 pub const FAMILY: &'static str = "unix";
764 pub const OS: &'static str = "bitrig";
765 pub const DLL_PREFIX: &'static str = "lib";
766 pub const DLL_SUFFIX: &'static str = ".so";
767 pub const DLL_EXTENSION: &'static str = "so";
768 pub const EXE_SUFFIX: &'static str = "";
769 pub const EXE_EXTENSION: &'static str = "";
772 #[cfg(target_os = "netbsd")]
774 pub const FAMILY: &'static str = "unix";
775 pub const OS: &'static str = "netbsd";
776 pub const DLL_PREFIX: &'static str = "lib";
777 pub const DLL_SUFFIX: &'static str = ".so";
778 pub const DLL_EXTENSION: &'static str = "so";
779 pub const EXE_SUFFIX: &'static str = "";
780 pub const EXE_EXTENSION: &'static str = "";
783 #[cfg(target_os = "openbsd")]
785 pub const FAMILY: &'static str = "unix";
786 pub const OS: &'static str = "openbsd";
787 pub const DLL_PREFIX: &'static str = "lib";
788 pub const DLL_SUFFIX: &'static str = ".so";
789 pub const DLL_EXTENSION: &'static str = "so";
790 pub const EXE_SUFFIX: &'static str = "";
791 pub const EXE_EXTENSION: &'static str = "";
794 #[cfg(target_os = "android")]
796 pub const FAMILY: &'static str = "unix";
797 pub const OS: &'static str = "android";
798 pub const DLL_PREFIX: &'static str = "lib";
799 pub const DLL_SUFFIX: &'static str = ".so";
800 pub const DLL_EXTENSION: &'static str = "so";
801 pub const EXE_SUFFIX: &'static str = "";
802 pub const EXE_EXTENSION: &'static str = "";
805 #[cfg(target_os = "windows")]
807 pub const FAMILY: &'static str = "windows";
808 pub const OS: &'static str = "windows";
809 pub const DLL_PREFIX: &'static str = "";
810 pub const DLL_SUFFIX: &'static str = ".dll";
811 pub const DLL_EXTENSION: &'static str = "dll";
812 pub const EXE_SUFFIX: &'static str = ".exe";
813 pub const EXE_EXTENSION: &'static str = "exe";
816 #[cfg(all(target_os = "nacl", not(target_arch = "le32")))]
818 pub const FAMILY: &'static str = "unix";
819 pub const OS: &'static str = "nacl";
820 pub const DLL_PREFIX: &'static str = "lib";
821 pub const DLL_SUFFIX: &'static str = ".so";
822 pub const DLL_EXTENSION: &'static str = "so";
823 pub const EXE_SUFFIX: &'static str = ".nexe";
824 pub const EXE_EXTENSION: &'static str = "nexe";
826 #[cfg(all(target_os = "nacl", target_arch = "le32"))]
828 pub const FAMILY: &'static str = "unix";
829 pub const OS: &'static str = "pnacl";
830 pub const DLL_PREFIX: &'static str = "lib";
831 pub const DLL_SUFFIX: &'static str = ".pso";
832 pub const DLL_EXTENSION: &'static str = "pso";
833 pub const EXE_SUFFIX: &'static str = ".pexe";
834 pub const EXE_EXTENSION: &'static str = "pexe";
837 #[cfg(target_arch = "x86")]
839 pub const ARCH: &'static str = "x86";
842 #[cfg(target_arch = "x86_64")]
844 pub const ARCH: &'static str = "x86_64";
847 #[cfg(target_arch = "arm")]
849 pub const ARCH: &'static str = "arm";
852 #[cfg(target_arch = "aarch64")]
854 pub const ARCH: &'static str = "aarch64";
857 #[cfg(target_arch = "mips")]
859 pub const ARCH: &'static str = "mips";
862 #[cfg(target_arch = "mipsel")]
864 pub const ARCH: &'static str = "mipsel";
867 #[cfg(target_arch = "powerpc")]
869 pub const ARCH: &'static str = "powerpc";
872 #[cfg(target_arch = "powerpc64")]
874 pub const ARCH: &'static str = "powerpc64";
877 #[cfg(target_arch = "powerpc64le")]
879 pub const ARCH: &'static str = "powerpc64le";
882 #[cfg(target_arch = "le32")]
884 pub const ARCH: &'static str = "le32";
893 use rand::{self, Rng};
894 use ffi::{OsString, OsStr};
895 use path::{Path, PathBuf};
897 fn make_rand_name() -> OsString {
898 let mut rng = rand::thread_rng();
899 let n = format!("TEST{}", rng.gen_ascii_chars().take(10)
900 .collect::<String>());
901 let n = OsString::from(n);
902 assert!(var_os(&n).is_none());
906 fn eq(a: Option<OsString>, b: Option<&str>) {
907 assert_eq!(a.as_ref().map(|s| &**s), b.map(OsStr::new).map(|s| &*s));
912 let n = make_rand_name();
913 set_var(&n, "VALUE");
914 eq(var_os(&n), Some("VALUE"));
918 fn test_remove_var() {
919 let n = make_rand_name();
920 set_var(&n, "VALUE");
922 eq(var_os(&n), None);
926 fn test_set_var_overwrite() {
927 let n = make_rand_name();
930 eq(var_os(&n), Some("2"));
932 eq(var_os(&n), Some(""));
937 let mut s = "".to_string();
940 s.push_str("aaaaaaaaaa");
943 let n = make_rand_name();
945 eq(var_os(&n), Some(&s));
949 fn test_self_exe_path() {
950 let path = current_exe();
951 assert!(path.is_ok());
952 let path = path.unwrap();
954 // Hard to test this function
955 assert!(path.is_absolute());
959 fn test_env_set_get_huge() {
960 let n = make_rand_name();
961 let s = repeat("x").take(10000).collect::<String>();
963 eq(var_os(&n), Some(&s));
965 eq(var_os(&n), None);
969 fn test_env_set_var() {
970 let n = make_rand_name();
972 let mut e = vars_os();
973 set_var(&n, "VALUE");
974 assert!(!e.any(|(k, v)| {
975 &*k == &*n && &*v == "VALUE"
978 assert!(vars_os().any(|(k, v)| {
979 &*k == &*n && &*v == "VALUE"
985 assert!((!Path::new("test-path").is_absolute()));
987 current_dir().unwrap();
992 fn split_paths_windows() {
993 fn check_parse(unparsed: &str, parsed: &[&str]) -> bool {
994 split_paths(unparsed).collect::<Vec<_>>() ==
995 parsed.iter().map(|s| PathBuf::from(*s)).collect::<Vec<_>>()
998 assert!(check_parse("", &mut [""]));
999 assert!(check_parse(r#""""#, &mut [""]));
1000 assert!(check_parse(";;", &mut ["", "", ""]));
1001 assert!(check_parse(r"c:\", &mut [r"c:\"]));
1002 assert!(check_parse(r"c:\;", &mut [r"c:\", ""]));
1003 assert!(check_parse(r"c:\;c:\Program Files\",
1004 &mut [r"c:\", r"c:\Program Files\"]));
1005 assert!(check_parse(r#"c:\;c:\"foo"\"#, &mut [r"c:\", r"c:\foo\"]));
1006 assert!(check_parse(r#"c:\;c:\"foo;bar"\;c:\baz"#,
1007 &mut [r"c:\", r"c:\foo;bar\", r"c:\baz"]));
1012 fn split_paths_unix() {
1013 fn check_parse(unparsed: &str, parsed: &[&str]) -> bool {
1014 split_paths(unparsed).collect::<Vec<_>>() ==
1015 parsed.iter().map(|s| PathBuf::from(*s)).collect::<Vec<_>>()
1018 assert!(check_parse("", &mut [""]));
1019 assert!(check_parse("::", &mut ["", "", ""]));
1020 assert!(check_parse("/", &mut ["/"]));
1021 assert!(check_parse("/:", &mut ["/", ""]));
1022 assert!(check_parse("/:/usr/local", &mut ["/", "/usr/local"]));
1027 fn join_paths_unix() {
1028 fn test_eq(input: &[&str], output: &str) -> bool {
1029 &*join_paths(input.iter().cloned()).unwrap() ==
1033 assert!(test_eq(&[], ""));
1034 assert!(test_eq(&["/bin", "/usr/bin", "/usr/local/bin"],
1035 "/bin:/usr/bin:/usr/local/bin"));
1036 assert!(test_eq(&["", "/bin", "", "", "/usr/bin", ""],
1037 ":/bin:::/usr/bin:"));
1038 assert!(join_paths(["/te:st"].iter().cloned()).is_err());
1043 fn join_paths_windows() {
1044 fn test_eq(input: &[&str], output: &str) -> bool {
1045 &*join_paths(input.iter().cloned()).unwrap() ==
1049 assert!(test_eq(&[], ""));
1050 assert!(test_eq(&[r"c:\windows", r"c:\"],
1051 r"c:\windows;c:\"));
1052 assert!(test_eq(&["", r"c:\windows", "", "", r"c:\", ""],
1053 r";c:\windows;;;c:\;"));
1054 assert!(test_eq(&[r"c:\te;st", r"c:\"],
1055 r#""c:\te;st";c:\"#));
1056 assert!(join_paths([r#"c:\te"st"#].iter().cloned()).is_err());