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