Coverage Report

Coverage Report - jaggregate.internal.number.OperableShort

Classes in this File

Line Coverage

Branch Coverage

Complexity

OperableShort

100%

22/22

100%

7/7

OperableShort$1

100%

2/2

N/A

 /*
  Copyright 2004-2008 Paul R. Holser, Jr.  All rights reserved.
  Licensed under the Academic Free License version 3.0
  */
 
 package jaggregate.internal.number;
 
 /**
  * Wrapper for a {@code short}.
  *
  * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
  * @version $Id: OperableShort.java,v 1.1 2008/03/26 18:01:25 pholser Exp $
  */
 public class OperableShort extends OperableNumber<Short> {
     private static final long serialVersionUID = -1L;
 
     private static final OperableShort ONE = new OperableShort( (short) 1 ) {
         private static final long serialVersionUID = -1L;
 
         @Override
         public void incrementBy( OperableNumber<Short> increment ) {
             throw new UnsupportedOperationException();
         }
     };
 
     /**
      * Creates a wrapper for the given number.
      *
      * @param wrapped the wrapped number
      */
     public OperableShort( Short wrapped ) {
         super( wrapped );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isZero() {
         return unwrapped() == 0;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableShort plus( Short addend ) {
         return new OperableShort( (short) ( unwrapped() + addend ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableShort plus( int addend ) {
         return new OperableShort( (short) ( unwrapped() + addend ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableShort minus( Short subtrahend ) {
         return new OperableShort( (short) ( unwrapped() - subtrahend ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableShort times( Short multiplier ) {
         return new OperableShort( (short) ( unwrapped() * multiplier ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableShort times( int multiplier ) {
         return new OperableShort( (short) ( unwrapped() * multiplier ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableShort dividedBy( Short divisor ) {
         return new OperableShort( (short) ( unwrapped() / divisor ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableShort modulo( Short divisor ) {
         return new OperableShort( (short) ( unwrapped() % divisor ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isPositive() {
         return unwrapped() > 0;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isNegative() {
         return unwrapped() < 0;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean greaterThan( Short comparand ) {
         return unwrapped() > comparand;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean greaterThanOrEqualTo( Short comparand ) {
         return unwrapped() >= comparand;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean lessThan( Short comparand ) {
         return unwrapped() < comparand;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean lessThanOrEqualTo( Short comparand ) {
         return unwrapped() <= comparand;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableShort negated() {
         return new OperableShort( (short) -unwrapped() );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void incrementBy( OperableNumber<Short> increment ) {
         update( (short) ( unwrapped() + increment.unwrapped() ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableNumber<Short> one() {
         return ONE;
     }
 }

1		/*
2		Copyright 2004-2008 Paul R. Holser, Jr. All rights reserved.
3		Licensed under the Academic Free License version 3.0
4		*/
5
6		package jaggregate.internal.number;
7
8		/**
9		* Wrapper for a {@code short}.
10		*
11		* @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
12		* @version $Id: OperableShort.java,v 1.1 2008/03/26 18:01:25 pholser Exp $
13		*/
14	11041	public class OperableShort extends OperableNumber<Short> {
15		private static final long serialVersionUID = -1L;
16
17	1	private static final OperableShort ONE = new OperableShort( (short) 1 ) {
18		private static final long serialVersionUID = -1L;
19
20		@Override
21	204	public void incrementBy( OperableNumber<Short> increment ) {
22	1	throw new UnsupportedOperationException();
23		}
24		};
25
26		/**
27		* Creates a wrapper for the given number.
28		*
29		* @param wrapped the wrapped number
30		*/
31		public OperableShort( Short wrapped ) {
32	8629	super( wrapped );
33	8629	}
34
35		/**
36		* {@inheritDoc}
37		*/
38		@Override
39		public boolean isZero() {
40	809	return unwrapped() == 0;
41		}
42
43		/**
44		* {@inheritDoc}
45		*/
46		@Override
47		public OperableShort plus( Short addend ) {
48	1595	return new OperableShort( (short) ( unwrapped() + addend ) );
49		}
50
51		/**
52		* {@inheritDoc}
53		*/
54		@Override
55		public OperableShort plus( int addend ) {
56	633	return new OperableShort( (short) ( unwrapped() + addend ) );
57		}
58
59		/**
60		* {@inheritDoc}
61		*/
62		@Override
63		public OperableShort minus( Short subtrahend ) {
64	1266	return new OperableShort( (short) ( unwrapped() - subtrahend ) );
65		}
66
67		/**
68		* {@inheritDoc}
69		*/
70		@Override
71		public OperableShort times( Short multiplier ) {
72	633	return new OperableShort( (short) ( unwrapped() * multiplier ) );
73		}
74
75		/**
76		* {@inheritDoc}
77		*/
78		@Override
79		public OperableShort times( int multiplier ) {
80	847	return new OperableShort( (short) ( unwrapped() * multiplier ) );
81		}
82
83		/**
84		* {@inheritDoc}
85		*/
86		@Override
87		public OperableShort dividedBy( Short divisor ) {
88	1266	return new OperableShort( (short) ( unwrapped() / divisor ) );
89		}
90
91		/**
92		* {@inheritDoc}
93		*/
94		@Override
95		public OperableShort modulo( Short divisor ) {
96	79	return new OperableShort( (short) ( unwrapped() % divisor ) );
97		}
98
99		/**
100		* {@inheritDoc}
101		*/
102		@Override
103		public boolean isPositive() {
104	2239	return unwrapped() > 0;
105		}
106
107		/**
108		* {@inheritDoc}
109		*/
110		@Override
111		public boolean isNegative() {
112	1078	return unwrapped() < 0;
113		}
114
115		/**
116		* {@inheritDoc}
117		*/
118		@Override
119		public boolean greaterThan( Short comparand ) {
120	2094	return unwrapped() > comparand;
121		}
122
123		/**
124		* {@inheritDoc}
125		*/
126		@Override
127		public boolean greaterThanOrEqualTo( Short comparand ) {
128	385	return unwrapped() >= comparand;
129		}
130
131		/**
132		* {@inheritDoc}
133		*/
134		@Override
135		public boolean lessThan( Short comparand ) {
136	1920	return unwrapped() < comparand;
137		}
138
139		/**
140		* {@inheritDoc}
141		*/
142		@Override
143		public boolean lessThanOrEqualTo( Short comparand ) {
144	429	return unwrapped() <= comparand;
145		}
146
147		/**
148		* {@inheritDoc}
149		*/
150		@Override
151		public OperableShort negated() {
152	97	return new OperableShort( (short) -unwrapped() );
153		}
154
155		/**
156		* {@inheritDoc}
157		*/
158		@Override
159		public void incrementBy( OperableNumber<Short> increment ) {
160	596	update( (short) ( unwrapped() + increment.unwrapped() ) );
161	596	}
162
163		/**
164		* {@inheritDoc}
165		*/
166		@Override
167		public OperableNumber<Short> one() {
168	181	return ONE;
169		}
170		}