Coverage Report

Coverage Report - org.apache.maven.shared.utils.Os

Classes in this File

Line Coverage

Branch Coverage

Complexity

87%

76/87

61%

59/96

4.417

 package org.apache.maven.shared.utils;
 
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you 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.
  */
 
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Locale;
 import java.util.Set;
 
 /**
  * <p>Condition that tests the OS type.</p>
  * <p/>
  * <p>This class got copied over from Apache ANT.
  * Even the version from plexus-utils was
  * only an ANT fork!<br/>
  * The last time it got copied was on 2011-08-12</p>
  * <p/>
  * <p>When merging changes please take care of the special
  * OS_FAMILY handling in this version of Os.java!</p>
  *
  * @author Stefan Bodewig
  * @author Magesh Umasankar
  * @author Brian Fox
  * @author Mark Struberg
  * @version $Revision: 1401850 $
  * 
  */
 public class Os
 {
     public static final String OS_NAME = System.getProperty( "os.name" ).toLowerCase( Locale.ENGLISH );
 
     public static final String OS_ARCH = System.getProperty( "os.arch" ).toLowerCase( Locale.ENGLISH );
 
     public static final String OS_VERSION = System.getProperty( "os.version" ).toLowerCase( Locale.ENGLISH );
 
     public static final String PATH_SEP = System.getProperty( "path.separator" );
 
     /**
      * system line separator , e.g. &quot;\n&quot; on unixoid systems and &quot;\r\n&quot; on Windows
      */
     public static final String LINE_SEP = System.getProperty( "line.separator" );
 
     public static final String OS_FAMILY = getOsFamily();
 
     // store the valid families
     private static final Set<String> VALID_FAMILIES = getValidFamilies();
 
 
     /**
      * OS family to look for
      */
     private String family;
 
     /**
      * OS family that can be tested for. {@value}
      */
     public static final String FAMILY_WINDOWS = "windows";
 
     /**
      * OS family that can be tested for. {@value}
      */
     public static final String FAMILY_WIN9X = "win9x";
 
     /**
      * OS family that can be tested for. {@value}
      */
     public static final String FAMILY_NT = "winnt";
 
     /**
      * OS family that can be tested for. {@value}
      */
     public static final String FAMILY_OS2 = "os/2";
 
     /**
      * OS family that can be tested for. {@value}
      */
     public static final String FAMILY_NETWARE = "netware";
 
     /**
      * OS family that can be tested for. {@value}
      */
     public static final String FAMILY_DOS = "dos";
 
     /**
      * OS family that can be tested for. {@value}
      */
     public static final String FAMILY_MAC = "mac";
 
     /**
      * OS family that can be tested for. {@value}
      */
     public static final String FAMILY_TANDEM = "tandem";
 
     /**
      * OS family that can be tested for. {@value}
      */
     public static final String FAMILY_UNIX = "unix";
 
     /**
      * OS family that can be tested for. {@value}
      */
     public static final String FAMILY_OPENVMS = "openvms";
 
     /**
      * OS family that can be tested for. {@value}
      */
     public static final String FAMILY_ZOS = "z/os";
 
     /**
      * OS family that can be tested for. {@value}
      */
     public static final String FAMILY_OS400 = "os/400";
 
     /**
      * OpenJDK is reported to call MacOS X "Darwin"
      *
      * @see <a href="https://issues.apache.org/bugzilla/show_bug.cgi?id=44889">bugzilla issue</a>
      * @see <a href="https://issues.apache.org/jira/browse/HADOOP-3318">HADOOP-3318</a>
      */
     private static final String DARWIN = "darwin";
 
 
     /**
      * The set of valid families. This methods initializes the set until
      * VALID_FAMILIES constant is set.
      */
     public static Set<String> getValidFamilies()
     {
         if ( VALID_FAMILIES != null )
         {
             return VALID_FAMILIES;
         }
 
         Set<String> valid = new HashSet<String>();
         valid.add( FAMILY_DOS );
         valid.add( FAMILY_MAC );
         valid.add( FAMILY_NETWARE );
         valid.add( FAMILY_NT );
         valid.add( FAMILY_OPENVMS );
         valid.add( FAMILY_OS2 );
         valid.add( FAMILY_OS400 );
         valid.add( FAMILY_TANDEM );
         valid.add( FAMILY_UNIX );
         valid.add( FAMILY_WIN9X );
         valid.add( FAMILY_WINDOWS );
         valid.add( FAMILY_ZOS );
 
         return Collections.unmodifiableSet( valid );
     }
 
     /**
      * Default constructor
      */
     public Os()
     {
         //default
     }
 
     /**
      * Constructor that sets the family attribute
      *
      * @param family a String value
      */
     public Os( String family )
     {
         setFamily( family );
     }
 
     /**
      * Sets the desired OS family type
      *
      * @param f The OS family type desired<br />
      *          Possible values:<br />
      *          <ul>
      *          <li>dos</li>
      *          <li>mac</li>
      *          <li>netware</li>
      *          <li>os/2</li>
      *          <li>tandem</li>
      *          <li>unix</li>
      *          <li>windows</li>
      *          <li>win9x</li>
      *          <li>z/os</li>
      *          <li>os/400</li>
      *          </ul>
      */
     private void setFamily( String f )
     {
         family = f.toLowerCase( Locale.ENGLISH );
     }
 
     /**
      * Determines if the OS on which Ant is executing matches the type of
      * that set in setFamily.
      *
      * @return true if the os matches.
      * @see Os#setFamily(String)
      */
     boolean eval()
     {
         return isOs( family, null, null, null );
     }
 
     /**
      * Determines if the OS on which Ant is executing matches the
      * given OS family.
      *
      * @param family the family to check for
      * @return true if the OS matches
      * 
      */
     public static boolean isFamily( String family )
     {
         return isOs( family, null, null, null );
     }
 
     /**
      * Determines if the OS on which Ant is executing matches the
      * given OS name.
      *
      * @param name the OS name to check for
      * @return true if the OS matches
      * 
      */
     public static boolean isName( String name )
     {
         return isOs( null, name, null, null );
     }
 
     /**
      * Determines if the OS on which Ant is executing matches the
      * given OS architecture.
      *
      * @param arch the OS architecture to check for
      * @return true if the OS matches
      * 
      */
     public static boolean isArch( String arch )
     {
         return isOs( null, null, arch, null );
     }
 
     /**
      * Determines if the OS on which Ant is executing matches the
      * given OS version.
      *
      * @param version the OS version to check for
      * @return true if the OS matches
      * 
      */
     public static boolean isVersion( String version )
     {
         return isOs( null, null, null, version );
     }
 
     /**
      * Determines if the OS on which Ant is executing matches the
      * given OS family, name, architecture and version
      *
      * @param family  The OS family
      * @param name    The OS name
      * @param arch    The OS architecture
      * @param version The OS version
      * @return true if the OS matches
      * 
      */
     private static boolean isOs( String family, String name, String arch, String version )
     {
         boolean retValue = false;
 
         if ( family != null || name != null || arch != null || version != null )
         {
 
             boolean isFamily = true;
             boolean isName = true;
             boolean isArch = true;
             boolean isVersion = true;
 
             if ( family != null )
             {
 
                 //windows probing logic relies on the word 'windows' in
                 //the OS
                 boolean isWindows = OS_NAME.contains( FAMILY_WINDOWS );
                 boolean is9x = false;
                 boolean isNT = false;
                 if ( isWindows )
                 {
                     //there are only four 9x platforms that we look for
                     is9x =
                         ( OS_NAME.contains( "95" ) || OS_NAME.contains( "98" ) || OS_NAME.contains( "me" )
                             //wince isn't really 9x, but crippled enough to
                             //be a muchness. Ant doesnt run on CE, anyway.
                             || OS_NAME.contains( "ce" ) );
                     isNT = !is9x;
                 }
                 if ( family.equals( FAMILY_WINDOWS ) )
                 {
                     isFamily = isWindows;
                 }
                 else if ( family.equals( FAMILY_WIN9X ) )
                 {
                     isFamily = isWindows && is9x;
                 }
                 else if ( family.equals( FAMILY_NT ) )
                 {
                     isFamily = isWindows && isNT;
                 }
                 else if ( family.equals( FAMILY_OS2 ) )
                 {
                     isFamily = OS_NAME.contains( FAMILY_OS2 );
                 }
                 else if ( family.equals( FAMILY_NETWARE ) )
                 {
                     isFamily = OS_NAME.contains( FAMILY_NETWARE );
                 }
                 else if ( family.equals( FAMILY_DOS ) )
                 {
                     isFamily = PATH_SEP.equals( ";" ) && !isFamily( FAMILY_NETWARE );
                 }
                 else if ( family.equals( FAMILY_MAC ) )
                 {
                     isFamily = OS_NAME.contains( FAMILY_MAC ) || OS_NAME.contains( DARWIN );
                 }
                 else if ( family.equals( FAMILY_TANDEM ) )
                 {
                     isFamily = OS_NAME.contains( "nonstop_kernel" );
                 }
                 else if ( family.equals( FAMILY_UNIX ) )
                 {
                     isFamily = PATH_SEP.equals( ":" ) && !isFamily( FAMILY_OPENVMS ) && ( !isFamily( FAMILY_MAC )
                         || OS_NAME.endsWith( "x" ) || OS_NAME.contains( DARWIN ) );
                 }
                 else if ( family.equals( FAMILY_ZOS ) )
                 {
                     isFamily = OS_NAME.contains( FAMILY_ZOS ) || OS_NAME.contains( "os/390" );
                 }
                 else if ( family.equals( FAMILY_OS400 ) )
                 {
                     isFamily = OS_NAME.contains( FAMILY_OS400 );
                 }
                 else if ( family.equals( FAMILY_OPENVMS ) )
                 {
                     isFamily = OS_NAME.contains( FAMILY_OPENVMS );
                 }
                 else
                 {
                     isFamily = OS_NAME.contains( family.toLowerCase( Locale.US ) );
                 }
             }
             if ( name != null )
             {
                 isName = name.equals( OS_NAME );
             }
             if ( arch != null )
             {
                 isArch = arch.equals( OS_ARCH );
             }
             if ( version != null )
             {
                 isVersion = version.equals( OS_VERSION );
             }
             retValue = isFamily && isName && isArch && isVersion;
         }
         return retValue;
     }
 
     /**
      * Helper method to determine the current OS family.
      *
      * @return name of current OS family.
      */
     private static String getOsFamily()
     {
         Set<String> families = getValidFamilies();
 
         for ( String fam : families )
         {
             if ( Os.isFamily( fam ) )
             {
                 return fam;
             }
         }
         return null;
     }
 
     /**
      * Test if the given family String represents a valid Family
      *
      * @param family the os family
      * @return <code>true</code> if 'family' represents a valid OS-Family, <code>false</code> otherwise.
      */
     public static boolean isValidFamily( String family )
     {
         return VALID_FAMILIES.contains( family );
     }
 
 }

1		package org.apache.maven.shared.utils;
2
3		/*
4		* Licensed to the Apache Software Foundation (ASF) under one
5		* or more contributor license agreements. See the NOTICE file
6		* distributed with this work for additional information
7		* regarding copyright ownership. The ASF licenses this file
8		* to you under the Apache License, Version 2.0 (the
9		* "License"); you may not use this file except in compliance
10		* with the License. You may obtain a copy of the License at
11		*
12		* http://www.apache.org/licenses/LICENSE-2.0
13		*
14		* Unless required by applicable law or agreed to in writing,
15		* software distributed under the License is distributed on an
16		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17		* KIND, either express or implied. See the License for the
18		* specific language governing permissions and limitations
19		* under the License.
20		*/
21
22		import java.util.Collections;
23		import java.util.HashSet;
24		import java.util.Locale;
25		import java.util.Set;
26
27		/**
28		* <p>Condition that tests the OS type.</p>
29		* <p/>
30		* <p>This class got copied over from Apache ANT.
31		* Even the version from plexus-utils was
32		* only an ANT fork!<br/>
33		* The last time it got copied was on 2011-08-12</p>
34		* <p/>
35		* <p>When merging changes please take care of the special
36		* OS_FAMILY handling in this version of Os.java!</p>
37		*
38		* @author Stefan Bodewig
39		* @author Magesh Umasankar
40		* @author Brian Fox
41		* @author Mark Struberg
42		* @version $Revision: 1401850 $
43		*
44		*/
45		public class Os
46		{
47	1	public static final String OS_NAME = System.getProperty( "os.name" ).toLowerCase( Locale.ENGLISH );
48
49	1	public static final String OS_ARCH = System.getProperty( "os.arch" ).toLowerCase( Locale.ENGLISH );
50
51	1	public static final String OS_VERSION = System.getProperty( "os.version" ).toLowerCase( Locale.ENGLISH );
52
53	1	public static final String PATH_SEP = System.getProperty( "path.separator" );
54
55		/**
56		* system line separator , e.g. "\n" on unixoid systems and "\r\n" on Windows
57		*/
58	1	public static final String LINE_SEP = System.getProperty( "line.separator" );
59
60	1	public static final String OS_FAMILY = getOsFamily();
61
62		// store the valid families
63	1	private static final Set<String> VALID_FAMILIES = getValidFamilies();
64
65
66		/**
67		* OS family to look for
68		*/
69		private String family;
70
71		/**
72		* OS family that can be tested for. {@value}
73		*/
74		public static final String FAMILY_WINDOWS = "windows";
75
76		/**
77		* OS family that can be tested for. {@value}
78		*/
79		public static final String FAMILY_WIN9X = "win9x";
80
81		/**
82		* OS family that can be tested for. {@value}
83		*/
84		public static final String FAMILY_NT = "winnt";
85
86		/**
87		* OS family that can be tested for. {@value}
88		*/
89		public static final String FAMILY_OS2 = "os/2";
90
91		/**
92		* OS family that can be tested for. {@value}
93		*/
94		public static final String FAMILY_NETWARE = "netware";
95
96		/**
97		* OS family that can be tested for. {@value}
98		*/
99		public static final String FAMILY_DOS = "dos";
100
101		/**
102		* OS family that can be tested for. {@value}
103		*/
104		public static final String FAMILY_MAC = "mac";
105
106		/**
107		* OS family that can be tested for. {@value}
108		*/
109		public static final String FAMILY_TANDEM = "tandem";
110
111		/**
112		* OS family that can be tested for. {@value}
113		*/
114		public static final String FAMILY_UNIX = "unix";
115
116		/**
117		* OS family that can be tested for. {@value}
118		*/
119		public static final String FAMILY_OPENVMS = "openvms";
120
121		/**
122		* OS family that can be tested for. {@value}
123		*/
124		public static final String FAMILY_ZOS = "z/os";
125
126		/**
127		* OS family that can be tested for. {@value}
128		*/
129		public static final String FAMILY_OS400 = "os/400";
130
131		/**
132		* OpenJDK is reported to call MacOS X "Darwin"
133		*
134		* @see <a href="https://issues.apache.org/bugzilla/show_bug.cgi?id=44889">bugzilla issue</a>
135		* @see <a href="https://issues.apache.org/jira/browse/HADOOP-3318">HADOOP-3318</a>
136		*/
137		private static final String DARWIN = "darwin";
138
139
140		/**
141		* The set of valid families. This methods initializes the set until
142		* VALID_FAMILIES constant is set.
143		*/
144		public static Set<String> getValidFamilies()
145		{
146	3	if ( VALID_FAMILIES != null )
147		{
148	1	return VALID_FAMILIES;
149		}
150
151	2	Set<String> valid = new HashSet<String>();
152	2	valid.add( FAMILY_DOS );
153	2	valid.add( FAMILY_MAC );
154	2	valid.add( FAMILY_NETWARE );
155	2	valid.add( FAMILY_NT );
156	2	valid.add( FAMILY_OPENVMS );
157	2	valid.add( FAMILY_OS2 );
158	2	valid.add( FAMILY_OS400 );
159	2	valid.add( FAMILY_TANDEM );
160	2	valid.add( FAMILY_UNIX );
161	2	valid.add( FAMILY_WIN9X );
162	2	valid.add( FAMILY_WINDOWS );
163	2	valid.add( FAMILY_ZOS );
164
165	2	return Collections.unmodifiableSet( valid );
166		}
167
168		/**
169		* Default constructor
170		*/
171		public Os()
172	1	{
173		//default
174	1	}
175
176		/**
177		* Constructor that sets the family attribute
178		*
179		* @param family a String value
180		*/
181		public Os( String family )
182	0	{
183	0	setFamily( family );
184	0	}
185
186		/**
187		* Sets the desired OS family type
188		*
189		* @param f The OS family type desired<br />
190		* Possible values:<br />
191		* <ul>
192		* <li>dos</li>
193		* <li>mac</li>
194		* <li>netware</li>
195		* <li>os/2</li>
196		* <li>tandem</li>
197		* <li>unix</li>
198		* <li>windows</li>
199		* <li>win9x</li>
200		* <li>z/os</li>
201		* <li>os/400</li>
202		* </ul>
203		*/
204		private void setFamily( String f )
205		{
206	0	family = f.toLowerCase( Locale.ENGLISH );
207	0	}
208
209		/**
210		* Determines if the OS on which Ant is executing matches the type of
211		* that set in setFamily.
212		*
213		* @return true if the os matches.
214		* @see Os#setFamily(String)
215		*/
216		boolean eval()
217		{
218	1	return isOs( family, null, null, null );
219		}
220
221		/**
222		* Determines if the OS on which Ant is executing matches the
223		* given OS family.
224		*
225		* @param family the family to check for
226		* @return true if the OS matches
227		*
228		*/
229		public static boolean isFamily( String family )
230		{
231	33	return isOs( family, null, null, null );
232		}
233
234		/**
235		* Determines if the OS on which Ant is executing matches the
236		* given OS name.
237		*
238		* @param name the OS name to check for
239		* @return true if the OS matches
240		*
241		*/
242		public static boolean isName( String name )
243		{
244	13	return isOs( null, name, null, null );
245		}
246
247		/**
248		* Determines if the OS on which Ant is executing matches the
249		* given OS architecture.
250		*
251		* @param arch the OS architecture to check for
252		* @return true if the OS matches
253		*
254		*/
255		public static boolean isArch( String arch )
256		{
257	2	return isOs( null, null, arch, null );
258		}
259
260		/**
261		* Determines if the OS on which Ant is executing matches the
262		* given OS version.
263		*
264		* @param version the OS version to check for
265		* @return true if the OS matches
266		*
267		*/
268		public static boolean isVersion( String version )
269		{
270	3	return isOs( null, null, null, version );
271		}
272
273		/**
274		* Determines if the OS on which Ant is executing matches the
275		* given OS family, name, architecture and version
276		*
277		* @param family The OS family
278		* @param name The OS name
279		* @param arch The OS architecture
280		* @param version The OS version
281		* @return true if the OS matches
282		*
283		*/
284		private static boolean isOs( String family, String name, String arch, String version )
285		{
286	52	boolean retValue = false;
287
288	52	if ( family != null \|\| name != null \|\| arch != null \|\| version != null )
289		{
290
291	51	boolean isFamily = true;
292	51	boolean isName = true;
293	51	boolean isArch = true;
294	51	boolean isVersion = true;
295
296	51	if ( family != null )
297		{
298
299		//windows probing logic relies on the word 'windows' in
300		//the OS
301	33	boolean isWindows = OS_NAME.contains( FAMILY_WINDOWS );
302	33	boolean is9x = false;
303	33	boolean isNT = false;
304	33	if ( isWindows )
305		{
306		//there are only four 9x platforms that we look for
307	0	is9x =
308		( OS_NAME.contains( "95" ) \|\| OS_NAME.contains( "98" ) \|\| OS_NAME.contains( "me" )
309		//wince isn't really 9x, but crippled enough to
310		//be a muchness. Ant doesnt run on CE, anyway.
311		\|\| OS_NAME.contains( "ce" ) );
312	0	isNT = !is9x;
313		}
314	33	if ( family.equals( FAMILY_WINDOWS ) )
315		{
316	23	isFamily = isWindows;
317		}
318	10	else if ( family.equals( FAMILY_WIN9X ) )
319		{
320	1	isFamily = isWindows && is9x;
321		}
322	9	else if ( family.equals( FAMILY_NT ) )
323		{
324	0	isFamily = isWindows && isNT;
325		}
326	9	else if ( family.equals( FAMILY_OS2 ) )
327		{
328	1	isFamily = OS_NAME.contains( FAMILY_OS2 );
329		}
330	8	else if ( family.equals( FAMILY_NETWARE ) )
331		{
332	1	isFamily = OS_NAME.contains( FAMILY_NETWARE );
333		}
334	7	else if ( family.equals( FAMILY_DOS ) )
335		{
336	0	isFamily = PATH_SEP.equals( ";" ) && !isFamily( FAMILY_NETWARE );
337		}
338	7	else if ( family.equals( FAMILY_MAC ) )
339		{
340	2	isFamily = OS_NAME.contains( FAMILY_MAC ) \|\| OS_NAME.contains( DARWIN );
341		}
342	5	else if ( family.equals( FAMILY_TANDEM ) )
343		{
344	1	isFamily = OS_NAME.contains( "nonstop_kernel" );
345		}
346	4	else if ( family.equals( FAMILY_UNIX ) )
347		{
348	1	isFamily = PATH_SEP.equals( ":" ) && !isFamily( FAMILY_OPENVMS ) && ( !isFamily( FAMILY_MAC )
349		\|\| OS_NAME.endsWith( "x" ) \|\| OS_NAME.contains( DARWIN ) );
350		}
351	3	else if ( family.equals( FAMILY_ZOS ) )
352		{
353	1	isFamily = OS_NAME.contains( FAMILY_ZOS ) \|\| OS_NAME.contains( "os/390" );
354		}
355	2	else if ( family.equals( FAMILY_OS400 ) )
356		{
357	1	isFamily = OS_NAME.contains( FAMILY_OS400 );
358		}
359	1	else if ( family.equals( FAMILY_OPENVMS ) )
360		{
361	1	isFamily = OS_NAME.contains( FAMILY_OPENVMS );
362		}
363		else
364		{
365	0	isFamily = OS_NAME.contains( family.toLowerCase( Locale.US ) );
366		}
367		}
368	51	if ( name != null )
369		{
370	13	isName = name.equals( OS_NAME );
371		}
372	51	if ( arch != null )
373		{
374	2	isArch = arch.equals( OS_ARCH );
375		}
376	51	if ( version != null )
377		{
378	3	isVersion = version.equals( OS_VERSION );
379		}
380	51	retValue = isFamily && isName && isArch && isVersion;
381		}
382	52	return retValue;
383		}
384
385		/**
386		* Helper method to determine the current OS family.
387		*
388		* @return name of current OS family.
389		*/
390		private static String getOsFamily()
391		{
392	1	Set<String> families = getValidFamilies();
393
394	1	for ( String fam : families )
395		{
396	7	if ( Os.isFamily( fam ) )
397		{
398	1	return fam;
399		}
400		}
401	0	return null;
402		}
403
404		/**
405		* Test if the given family String represents a valid Family
406		*
407		* @param family the os family
408		* @return <code>true</code> if 'family' represents a valid OS-Family, <code>false</code> otherwise.
409		*/
410		public static boolean isValidFamily( String family )
411		{
412	2	return VALID_FAMILIES.contains( family );
413		}
414
415		}