001/*
002 * Copyright (c) 2012, 2013, Werner Keil, Credit Suisse (Anatole Tresch). Licensed under the Apache
003 * License, Version 2.0 (the "License"); you may not use this file except in compliance with the
004 * License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
005 * Unless required by applicable law or agreed to in writing, software distributed under the License
006 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
007 * or implied. See the License for the specific language governing permissions and limitations under
008 * the License. Contributors: Anatole Tresch - initial version.
009 */
010package org.javamoney.tck.tests.internal;
011
012import javax.money.*;
013import java.io.Serializable;
014import java.math.BigDecimal;
015import java.util.Objects;
016
017/**
018 * Created by Anatole on 19.04.2014.
019 */
020public final class TestAmount implements MonetaryAmount, Serializable {
021
022    private BigDecimal value;
023    private CurrencyUnit currencyUnit;
024    public static final MonetaryContext MONETARY_CONTEXT =
025            MonetaryContextBuilder.of().setAmountType(TestAmount.class).setMaxScale(-1).setPrecision(0).build();
026
027    public TestAmount(Number number, CurrencyUnit currency) {
028        this.currencyUnit = currency;
029        this.value = new BigDecimal(String.valueOf(number));
030    }
031
032    @Override
033    public MonetaryAmount with(MonetaryOperator operator) {
034        try {
035            return operator.apply(this);
036        } catch (MonetaryException e) {
037            throw e;
038        } catch (Exception e) {
039            throw new MonetaryException("Exception during operator execution.", e);
040        }
041    }
042
043    @Override
044    public MonetaryAmountFactory<? extends MonetaryAmount> getFactory() {
045
046
047        return new MonetaryAmountFactory<TestAmount>() {
048
049            private CurrencyUnit currency = TestAmount.this.currencyUnit;
050            private BigDecimal number = TestAmount.this.value;
051
052            @Override
053            public Class<? extends MonetaryAmount> getAmountType() {
054                return TestAmount.class;
055            }
056
057            @Override
058            public MonetaryAmountFactory setCurrency(String currencyCode) {
059                this.currency = MonetaryCurrencies.getCurrency(currencyCode);
060                return this;
061            }
062
063            @Override
064            public MonetaryAmountFactory setCurrency(CurrencyUnit currency) {
065                Objects.requireNonNull(currency);
066                this.currency = currency;
067                return this;
068            }
069
070            @Override
071            public MonetaryAmountFactory setNumber(double number) {
072                Objects.requireNonNull(number);
073                this.number = new BigDecimal(String.valueOf(number));
074                return this;
075            }
076
077            @Override
078            public MonetaryAmountFactory setNumber(long number) {
079                Objects.requireNonNull(number);
080                this.number = new BigDecimal(String.valueOf(number));
081                return this;
082            }
083
084            @Override
085            public MonetaryAmountFactory setNumber(Number number) {
086                Objects.requireNonNull(number);
087                this.number = new BigDecimal(String.valueOf(number));
088                return this;
089            }
090
091            @Override
092            public NumberValue getMaxNumber() {
093                return null;
094            }
095
096            @Override
097            public NumberValue getMinNumber() {
098                return null;
099            }
100
101            @Override
102            public MonetaryAmountFactory setContext(MonetaryContext monetaryContext) {
103                return this;
104            }
105
106            @Override
107            public MonetaryAmountFactory setAmount(MonetaryAmount amount) {
108                this.currency = amount.getCurrency();
109                this.number = amount.getNumber().numberValue(BigDecimal.class);
110                return this;
111            }
112
113            @Override
114            public TestAmount create() {
115                return new TestAmount(number, currency);
116            }
117
118            @Override
119            public MonetaryContext getDefaultMonetaryContext() {
120                return MONETARY_CONTEXT;
121            }
122
123            @Override
124            public MonetaryContext getMaximalMonetaryContext() {
125                return MONETARY_CONTEXT;
126            }
127        };
128    }
129
130    @Override
131    public MonetaryAmount subtract(MonetaryAmount amount) {
132        return this;
133    }
134
135    @Override
136    public MonetaryAmount stripTrailingZeros() {
137        value = value.stripTrailingZeros();
138        return this;
139    }
140
141    @Override
142    public int signum() {
143        return value.signum();
144    }
145
146    @Override
147    public MonetaryAmount add(MonetaryAmount amount) {
148        return null;
149    }
150
151    @Override
152    public MonetaryAmount scaleByPowerOfTen(int power) {
153        return this;
154    }
155
156    @Override
157    public MonetaryAmount abs() {
158        return null;
159    }
160
161    @Override
162    public MonetaryAmount remainder(Number divisor) {
163        return this;
164    }
165
166    @Override
167    public MonetaryAmount[] divideAndRemainder(long divisor) {
168        return new MonetaryAmount[0];
169    }
170
171    @Override
172    public MonetaryAmount[] divideAndRemainder(double divisor) {
173        return new MonetaryAmount[0];
174    }
175
176    @Override
177    public MonetaryAmount[] divideAndRemainder(Number divisor) {
178        return new MonetaryAmount[0];
179    }
180
181    @Override
182    public MonetaryAmount divideToIntegralValue(long divisor) {
183        return null;
184    }
185
186    @Override
187    public MonetaryAmount divideToIntegralValue(double divisor) {
188        return null;
189    }
190
191    @Override
192    public MonetaryAmount divideToIntegralValue(Number divisor) {
193        return null;
194    }
195
196    @Override
197    public MonetaryAmount remainder(double divisor) {
198        return this;
199    }
200
201    @Override
202    public MonetaryAmount remainder(long divisor) {
203        return this;
204    }
205
206    @Override
207    public <R> R query(MonetaryQuery<R> query) {
208        return query.queryFrom(this);
209    }
210
211    @Override
212    public MonetaryAmount plus() {
213        return this;
214    }
215
216    @Override
217    public MonetaryAmount negate() {
218        return this;
219    }
220
221    @Override
222    public MonetaryAmount multiply(Number multiplicand) {
223        return new TestAmount(this.value.multiply(new BigDecimal(String.valueOf(multiplicand))), getCurrency());
224    }
225
226    @Override
227    public MonetaryAmount divide(long divisor) {
228        return null;
229    }
230
231    @Override
232    public MonetaryAmount divide(double divisor) {
233        return null;
234    }
235
236    @Override
237    public MonetaryAmount divide(Number divisor) {
238        return null;
239    }
240
241    @Override
242    public MonetaryAmount multiply(double multiplicand) {
243        return this;
244    }
245
246    @Override
247    public MonetaryAmount multiply(long multiplicand) {
248        return this;
249    }
250
251    @Override
252    public boolean isZero() {
253        return false;
254    }
255
256    @Override
257    public boolean isPositiveOrZero() {
258        return true;
259    }
260
261    @Override
262    public boolean isPositive() {
263        return true;
264    }
265
266    @Override
267    public boolean isNegativeOrZero() {
268        return false;
269    }
270
271    @Override
272    public boolean isNegative() {
273        return false;
274    }
275
276    @Override
277    public boolean isLessThanOrEqualTo(MonetaryAmount amount) {
278        return this.value.stripTrailingZeros()
279                .compareTo(amount.getNumber().numberValue(BigDecimal.class).stripTrailingZeros()) == 0;
280    }
281
282    @Override
283    public boolean isLessThan(MonetaryAmount amount) {
284        return this.value.stripTrailingZeros()
285                .compareTo(amount.getNumber().numberValue(BigDecimal.class).stripTrailingZeros()) < 0;
286    }
287
288    @Override
289    public boolean isGreaterThanOrEqualTo(MonetaryAmount amount) {
290        return this.value.stripTrailingZeros()
291                .compareTo(amount.getNumber().numberValue(BigDecimal.class).stripTrailingZeros()) >= 0;
292    }
293
294    @Override
295    public boolean isGreaterThan(MonetaryAmount amount) {
296        return this.value.stripTrailingZeros()
297                .compareTo(amount.getNumber().numberValue(BigDecimal.class).stripTrailingZeros()) > 0;
298    }
299
300    @Override
301    public boolean isEqualTo(MonetaryAmount amount) {
302        return this.value.stripTrailingZeros()
303                .compareTo(amount.getNumber().numberValue(BigDecimal.class).stripTrailingZeros()) == 0;
304    }
305
306    @Override
307    public CurrencyUnit getCurrency() {
308        return currencyUnit;
309    }
310
311    @Override
312    public MonetaryContext getContext() {
313        return MONETARY_CONTEXT;
314    }
315
316    @Override
317    public int compareTo(MonetaryAmount o) {
318        return 0;
319    }
320
321    @Override
322    public String toString() {
323        return currencyUnit.getCurrencyCode() + ' ' + String.valueOf(value);
324    }
325
326    @Override
327    public NumberValue getNumber() {
328        return new TestNumberValue(this.value);
329    }
330
331}