sfos/ledger
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Got most of the commodity tests working, save multiplication and division.

Browse source
This commit is contained in:
John Wiegley 2007-04-17 07:33:36 +00:00
parent 2e3082e734
commit 0f2cad4cab
7 changed files with 486 additions and 280 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

62
amount.cc
View file

@ -505,6 +505,12 @@ void amount_t::_clear()
amount_t& amount_t::operator+=(const amount_t& amt) amount_t& amount_t::operator+=(const amount_t& amt)
{ {
if (commodity() != amt.commodity())
throw new amount_error
(std::string("Adding amounts with different commodities: ") +
(has_commodity() ? commodity_->qualified_symbol : "NONE") + " != " +
(amt.has_commodity() ? amt.commodity_->qualified_symbol : "NONE"));
if (! amt.quantity) if (! amt.quantity)
return *this; return *this;
@ -515,12 +521,6 @@ amount_t& amount_t::operator+=(const amount_t& amt)
_dup(); _dup();
if (commodity() != amt.commodity())
throw new amount_error
(std::string("Adding amounts with different commodities: ") +
commodity_->qualified_symbol + " != " +
amt.commodity_->qualified_symbol);
if (quantity->prec == amt.quantity->prec) { if (quantity->prec == amt.quantity->prec) {
mpz_add(MPZ(quantity), MPZ(quantity), MPZ(amt.quantity)); mpz_add(MPZ(quantity), MPZ(quantity), MPZ(amt.quantity));
} }
@ -539,6 +539,12 @@ amount_t& amount_t::operator+=(const amount_t& amt)
amount_t& amount_t::operator-=(const amount_t& amt) amount_t& amount_t::operator-=(const amount_t& amt)
{ {
if (commodity() != amt.commodity())
throw new amount_error
(std::string("Subtracting amounts with different commodities: ") +
(has_commodity() ? commodity_->qualified_symbol : "NONE") + " != " +
(amt.has_commodity() ? amt.commodity_->qualified_symbol : "NONE"));
if (! amt.quantity) if (! amt.quantity)
return *this; return *this;
@ -551,12 +557,6 @@ amount_t& amount_t::operator-=(const amount_t& amt)
_dup(); _dup();
if (commodity() != amt.commodity())
throw new amount_error
(std::string("Subtracting amounts with different commodities: ") +
commodity_->qualified_symbol + " != " +
amt.commodity_->qualified_symbol);
if (quantity->prec == amt.quantity->prec) { if (quantity->prec == amt.quantity->prec) {
mpz_sub(MPZ(quantity), MPZ(quantity), MPZ(amt.quantity)); mpz_sub(MPZ(quantity), MPZ(quantity), MPZ(amt.quantity));
} }
@ -580,12 +580,19 @@ amount_t& amount_t::operator*=(const amount_t& amt)
else if (! quantity) else if (! quantity)
return *this; return *this;
if (has_commodity() && amt.has_commodity() &&
commodity() != amt.commodity())
throw new amount_error
(std::string("Multiplying amounts with different commodities: ") +
(has_commodity() ? commodity_->qualified_symbol : "NONE") + " != " +
(amt.has_commodity() ? amt.commodity_->qualified_symbol : "NONE"));
_dup(); _dup();
mpz_mul(MPZ(quantity), MPZ(quantity), MPZ(amt.quantity)); mpz_mul(MPZ(quantity), MPZ(quantity), MPZ(amt.quantity));
quantity->prec += amt.quantity->prec; quantity->prec += amt.quantity->prec;
if (has_commodity()) { if (has_commodity() && ! (quantity->flags & BIGINT_KEEP_PREC)) {
unsigned int comm_prec = commodity().precision(); unsigned int comm_prec = commodity().precision();
if (quantity->prec > comm_prec + 6U) { if (quantity->prec > comm_prec + 6U) {
mpz_round(MPZ(quantity), MPZ(quantity), quantity->prec, comm_prec + 6U); mpz_round(MPZ(quantity), MPZ(quantity), quantity->prec, comm_prec + 6U);
@ -603,6 +610,13 @@ amount_t& amount_t::operator/=(const amount_t& amt)
else if (! quantity) else if (! quantity)
return *this; return *this;
if (has_commodity() && amt.has_commodity() &&
commodity() != amt.commodity())
throw new amount_error
(std::string("Dividing amounts with different commodities: ") +
(has_commodity() ? commodity_->qualified_symbol : "NONE") + " != " +
(amt.has_commodity() ? amt.commodity_->qualified_symbol : "NONE"));
_dup(); _dup();
// Increase the value's precision, to capture fractional parts after // Increase the value's precision, to capture fractional parts after
@ -612,7 +626,7 @@ amount_t& amount_t::operator/=(const amount_t& amt)
mpz_tdiv_q(MPZ(quantity), MPZ(quantity), MPZ(amt.quantity)); mpz_tdiv_q(MPZ(quantity), MPZ(quantity), MPZ(amt.quantity));
quantity->prec += quantity->prec + 6U; quantity->prec += quantity->prec + 6U;
if (has_commodity()) { if (has_commodity() && ! (quantity->flags & BIGINT_KEEP_PREC)) {
unsigned int comm_prec = commodity().precision(); unsigned int comm_prec = commodity().precision();
if (quantity->prec > comm_prec + 6U) { if (quantity->prec > comm_prec + 6U) {
mpz_round(MPZ(quantity), MPZ(quantity), quantity->prec, comm_prec + 6U); mpz_round(MPZ(quantity), MPZ(quantity), quantity->prec, comm_prec + 6U);
@ -877,16 +891,11 @@ void amount_t::print_quantity(std::ostream& out) const
void amount_t::print(std::ostream& _out, bool omit_commodity) const void amount_t::print(std::ostream& _out, bool omit_commodity) const
{ {
if (! quantity) {
_out << "0";
return;
}
amount_t base(*this); amount_t base(*this);
if (! amount_t::keep_base && commodity().larger()) { if (! amount_t::keep_base && commodity().larger()) {
amount_t last(*this); amount_t last(*this);
while (last.commodity().larger()) { while (last.commodity().larger()) {
last /= *last.commodity().larger(); last /= last.commodity().larger()->number();
last.commodity_ = last.commodity().larger()->commodity_; last.commodity_ = last.commodity().larger()->commodity_;
if (::abs(last) < 1) if (::abs(last) < 1)
break; break;
@ -910,8 +919,9 @@ void amount_t::print(std::ostream& _out, bool omit_commodity) const
// outputting it. NOTE: `rquotient' is used here as a temp variable! // outputting it. NOTE: `rquotient' is used here as a temp variable!
commodity_t& comm(base.commodity()); commodity_t& comm(base.commodity());
unsigned char precision; unsigned char precision = 0;
if (quantity) {
if (! comm || base.quantity->flags & BIGINT_KEEP_PREC) { if (! comm || base.quantity->flags & BIGINT_KEEP_PREC) {
mpz_ui_pow_ui(divisor, 10, base.quantity->prec); mpz_ui_pow_ui(divisor, 10, base.quantity->prec);
mpz_tdiv_qr(quotient, remainder, MPZ(base.quantity), divisor); mpz_tdiv_qr(quotient, remainder, MPZ(base.quantity), divisor);
@ -949,10 +959,6 @@ void amount_t::print(std::ostream& _out, bool omit_commodity) const
mpz_abs(remainder, remainder); mpz_abs(remainder, remainder);
} }
mpz_set(rquotient, remainder); mpz_set(rquotient, remainder);
if (mpz_sgn(quotient) == 0 && mpz_sgn(rquotient) == 0) {
_out << "0";
return;
} }
if (! omit_commodity && ! (comm.flags() & COMMODITY_STYLE_SUFFIXED)) { if (! omit_commodity && ! (comm.flags() & COMMODITY_STYLE_SUFFIXED)) {
@ -1337,7 +1343,7 @@ void amount_t::parse(std::istream& in, unsigned char flags)
void amount_t::reduce() void amount_t::reduce()
{ {
while (commodity_ && commodity().smaller()) { while (commodity_ && commodity().smaller()) {
*this *= *commodity().smaller(); *this *= commodity().smaller()->number();
commodity_ = commodity().smaller()->commodity_; commodity_ = commodity().smaller()->commodity_;
} }
} }
@ -1350,7 +1356,7 @@ void parse_conversion(const std::string& larger_str,
larger.parse(larger_str.c_str(), AMOUNT_PARSE_NO_REDUCE); larger.parse(larger_str.c_str(), AMOUNT_PARSE_NO_REDUCE);
smaller.parse(smaller_str.c_str(), AMOUNT_PARSE_NO_REDUCE); smaller.parse(smaller_str.c_str(), AMOUNT_PARSE_NO_REDUCE);
larger *= smaller; larger *= smaller.number();
if (larger.commodity()) { if (larger.commodity()) {
larger.commodity().set_smaller(smaller); larger.commodity().set_smaller(smaller);
@ -1614,7 +1620,7 @@ amount_t amount_t::price() const
{ {
if (commodity_ && commodity_->annotated) { if (commodity_ && commodity_->annotated) {
amount_t t(((annotated_commodity_t *)commodity_)->price); amount_t t(((annotated_commodity_t *)commodity_)->price);
t *= *this; t *= number();
DEBUG_PRINT("amounts.commodities", DEBUG_PRINT("amounts.commodities",
"Returning price of " << *this << " = " << t); "Returning price of " << *this << " = " << t);
return t; return t;

6
amount.h
View file

@ -107,6 +107,12 @@ class amount_t
_release(); _release();
} }
amount_t number() const {
amount_t temp(*this);
temp.clear_commodity();
return temp;
}
bool has_commodity() const; bool has_commodity() const;
commodity_t& commodity() const; commodity_t& commodity() const;
void set_commodity(commodity_t& comm) { void set_commodity(commodity_t& comm) {

4
tests/UnitTests.h
View file

@ -7,6 +7,10 @@
#define assertDoublesEqual(x,y,z,w) CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE(x,y,z,w) #define assertDoublesEqual(x,y,z,w) CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE(x,y,z,w)
#define assertEqual(x,y) CPPUNIT_ASSERT_EQUAL(x,y) #define assertEqual(x,y) CPPUNIT_ASSERT_EQUAL(x,y)
#define assertNotEqual(x,y) CPPUNIT_ASSERT((x) != (y))
#define assertTrue(x) CPPUNIT_ASSERT(x)
#define assertFalse(x) CPPUNIT_ASSERT(! (x))
#define assertValid(x) CPPUNIT_ASSERT((x).valid())
#define assertEqualMessage(x,y,z) CPPUNIT_ASSERT_EQUAL_MESSAGE(x,y,z) #define assertEqualMessage(x,y,z) CPPUNIT_ASSERT_EQUAL_MESSAGE(x,y,z)
#define assertMessage(x,y) CPPUNIT_ASSERT_MESSAGE(x,y) #define assertMessage(x,y) CPPUNIT_ASSERT_MESSAGE(x,y)
#define assertThrow(x,y) CPPUNIT_ASSERT_THROW(x,y) #define assertThrow(x,y) CPPUNIT_ASSERT_THROW(x,y)

517
tests/corelib/numerics/CommodityAmount.cc
View file

@ -11,7 +11,13 @@ inline amount_t internalAmount(const std::string& value) {
return temp; return temp;
} }
void CommodityAmountTestCase::setUp() {} void CommodityAmountTestCase::setUp()
{
// Cause the display precision for dollars to be initialized to 2.
amount_t x1("$1.00");
assertTrue(x1);
}
void CommodityAmountTestCase::tearDown() {} void CommodityAmountTestCase::tearDown() {}
void CommodityAmountTestCase::testConstructors() void CommodityAmountTestCase::testConstructors()
@ -49,16 +55,16 @@ void CommodityAmountTestCase::testConstructors()
assertEqual(std::string("123.45€"), x9.to_string()); assertEqual(std::string("123.45€"), x9.to_string());
assertEqual(std::string("-123.45€"), x10.to_string()); assertEqual(std::string("-123.45€"), x10.to_string());
CPPUNIT_ASSERT(x1.valid()); assertValid(x1);
CPPUNIT_ASSERT(x2.valid()); assertValid(x2);
CPPUNIT_ASSERT(x3.valid()); assertValid(x3);
CPPUNIT_ASSERT(x4.valid()); assertValid(x4);
CPPUNIT_ASSERT(x5.valid()); assertValid(x5);
CPPUNIT_ASSERT(x6.valid()); assertValid(x6);
CPPUNIT_ASSERT(x7.valid()); assertValid(x7);
CPPUNIT_ASSERT(x8.valid()); assertValid(x8);
CPPUNIT_ASSERT(x9.valid()); assertValid(x9);
CPPUNIT_ASSERT(x10.valid()); assertValid(x10);
} }
void CommodityAmountTestCase::testNegation() void CommodityAmountTestCase::testNegation()
@ -96,16 +102,16 @@ void CommodityAmountTestCase::testNegation()
assertEqual(std::string("-123.45€"), (- x9).to_string()); assertEqual(std::string("-123.45€"), (- x9).to_string());
assertEqual(std::string("123.45€"), (- x10).to_string()); assertEqual(std::string("123.45€"), (- x10).to_string());
CPPUNIT_ASSERT(x1.valid()); assertValid(x1);
CPPUNIT_ASSERT(x2.valid()); assertValid(x2);
CPPUNIT_ASSERT(x3.valid()); assertValid(x3);
CPPUNIT_ASSERT(x4.valid()); assertValid(x4);
CPPUNIT_ASSERT(x5.valid()); assertValid(x5);
CPPUNIT_ASSERT(x6.valid()); assertValid(x6);
CPPUNIT_ASSERT(x7.valid()); assertValid(x7);
CPPUNIT_ASSERT(x8.valid()); assertValid(x8);
CPPUNIT_ASSERT(x9.valid()); assertValid(x9);
CPPUNIT_ASSERT(x10.valid()); assertValid(x10);
} }
void CommodityAmountTestCase::testAssignment() void CommodityAmountTestCase::testAssignment()
@ -143,16 +149,16 @@ void CommodityAmountTestCase::testAssignment()
assertEqual(std::string("123.45€"), x9.to_string()); assertEqual(std::string("123.45€"), x9.to_string());
assertEqual(std::string("-123.45€"), x10.to_string()); assertEqual(std::string("-123.45€"), x10.to_string());
CPPUNIT_ASSERT(x1.valid()); assertValid(x1);
CPPUNIT_ASSERT(x2.valid()); assertValid(x2);
CPPUNIT_ASSERT(x3.valid()); assertValid(x3);
CPPUNIT_ASSERT(x4.valid()); assertValid(x4);
CPPUNIT_ASSERT(x5.valid()); assertValid(x5);
CPPUNIT_ASSERT(x6.valid()); assertValid(x6);
CPPUNIT_ASSERT(x7.valid()); assertValid(x7);
CPPUNIT_ASSERT(x8.valid()); assertValid(x8);
CPPUNIT_ASSERT(x9.valid()); assertValid(x9);
CPPUNIT_ASSERT(x10.valid()); assertValid(x10);
} }
void CommodityAmountTestCase::testEquality() void CommodityAmountTestCase::testEquality()
@ -168,80 +174,159 @@ void CommodityAmountTestCase::testEquality()
amount_t x9 = "123.45€"; amount_t x9 = "123.45€";
amount_t x10 = "-123.45€"; amount_t x10 = "-123.45€";
CPPUNIT_ASSERT(x1 != x2); assertTrue(x1 != x2);
CPPUNIT_ASSERT(x1 != x4); assertTrue(x1 != x4);
CPPUNIT_ASSERT(x1 != x7); assertTrue(x1 != x7);
CPPUNIT_ASSERT(x1 != x9); assertTrue(x1 != x9);
CPPUNIT_ASSERT(x2 == x3); assertTrue(x2 == x3);
CPPUNIT_ASSERT(x4 != x5); assertTrue(x4 != x5);
CPPUNIT_ASSERT(x5 == x6); assertTrue(x5 == x6);
CPPUNIT_ASSERT(x7 == - x8); assertTrue(x7 == - x8);
CPPUNIT_ASSERT(x9 == - x10); assertTrue(x9 == - x10);
CPPUNIT_ASSERT(x1.valid()); assertValid(x1);
CPPUNIT_ASSERT(x2.valid()); assertValid(x2);
CPPUNIT_ASSERT(x3.valid()); assertValid(x3);
CPPUNIT_ASSERT(x4.valid()); assertValid(x4);
CPPUNIT_ASSERT(x5.valid()); assertValid(x5);
CPPUNIT_ASSERT(x6.valid()); assertValid(x6);
CPPUNIT_ASSERT(x7.valid()); assertValid(x7);
CPPUNIT_ASSERT(x8.valid()); assertValid(x8);
CPPUNIT_ASSERT(x9.valid()); assertValid(x9);
CPPUNIT_ASSERT(x10.valid()); assertValid(x10);
} }
void CommodityAmountTestCase::testAddition() void CommodityAmountTestCase::testAddition()
{ {
// jww (2007-04-16): tbd amount_t x0;
amount_t x1(123.123); amount_t x1("$123.45");
amount_t y1(456.456); amount_t x2(internalAmount("$123.456789"));
amount_t x3("DM 123.45");
amount_t x4("123.45 euro");
amount_t x5("123.45€");
amount_t x6("123.45");
assertEqual(amount_t(579.579), x1 + y1); assertEqual(amount_t("$246.90"), x1 + x1);
assertEqual(amount_t(579.579), x1 + 456.456); assertNotEqual(amount_t("$246.91"), x1 + x2);
assertEqual(amount_t(579.579), 456.456 + x1); assertEqual(internalAmount("$246.906789"), x1 + x2);
x1 += amount_t(456.456); // Converting to string drops internal precision
assertEqual(amount_t(579.579), x1); assertEqual(std::string("$246.90"), (x1 + x1).to_string());
x1 += 456.456; assertEqual(std::string("$246.91"), (x1 + x2).to_string());
assertEqual(amount_t(1036.035), x1);
x1 += 456L;
assertEqual(amount_t(1492.035), x1);
amount_t x2("123456789123456789.123456789123456789"); assertThrow(x1 + x0, amount_error *);
assertThrow(x1 + x3, amount_error *);
assertThrow(x1 + x4, amount_error *);
assertThrow(x1 + x5, amount_error *);
assertThrow(x1 + x6, amount_error *);
assertThrow(x1 + 123.45, amount_error *);
assertThrow(x1 + 123L, amount_error *);
assertEqual(amount_t("246913578246913578.246913578246913578"), x2 + x2); assertEqual(amount_t("DM 246.90"), x3 + x3);
assertEqual(amount_t("246.90 euro"), x4 + x4);
assertEqual(amount_t("246.90€"), x5 + x5);
CPPUNIT_ASSERT(x1.valid()); assertEqual(std::string("DM 246.90"), (x3 + x3).to_string());
CPPUNIT_ASSERT(y1.valid()); assertEqual(std::string("246.90 euro"), (x4 + x4).to_string());
CPPUNIT_ASSERT(x2.valid()); assertEqual(std::string("246.90€"), (x5 + x5).to_string());
x1 += amount_t("$456.45");
assertEqual(amount_t("$579.90"), x1);
x1 += amount_t("$456.45");
assertEqual(amount_t("$1036.35"), x1);
x1 += amount_t("$456");
assertEqual(amount_t("$1492.35"), x1);
amount_t x7(internalAmount("$123456789123456789.123456789123456789"));
assertEqual(internalAmount("$246913578246913578.246913578246913578"), x7 + x7);
assertValid(x1);
assertValid(x2);
assertValid(x3);
assertValid(x4);
assertValid(x5);
assertValid(x6);
assertValid(x7);
} }
void CommodityAmountTestCase::testSubtraction() void CommodityAmountTestCase::testSubtraction()
{ {
// jww (2007-04-16): tbd amount_t x0;
amount_t x1(123.123); amount_t x1("$123.45");
amount_t y1(456.456); amount_t x2(internalAmount("$123.456789"));
amount_t x3("DM 123.45");
amount_t x4("123.45 euro");
amount_t x5("123.45€");
amount_t x6("123.45");
assertEqual(amount_t(-333.333), x1 - y1); assertNotEqual(amount_t(), x1 - x1);
assertEqual(amount_t(333.333), y1 - x1); assertEqual(amount_t("$0"), x1 - x1);
assertEqual(amount_t("$23.45"), x1 - amount_t("$100.00"));
assertEqual(amount_t("$-23.45"), amount_t("$100.00") - x1);
assertNotEqual(amount_t("$-0.01"), x1 - x2);
assertEqual(internalAmount("$-0.006789"), x1 - x2);
x1 -= amount_t(456.456); // Converting to string drops internal precision. If an amount is
assertEqual(amount_t(-333.333), x1); // zero, it drops the commodity as well.
x1 -= 456.456; assertEqual(std::string("$0.00"), (x1 - x1).to_string());
assertEqual(amount_t(-789.789), x1); assertEqual(std::string("$-0.01"), (x1 - x2).to_string());
x1 -= 456L;
assertEqual(amount_t(-1245.789), x1);
amount_t x2("123456789123456789.123456789123456789"); assertThrow(x1 - x0, amount_error *);
amount_t y2("9872345982459.248974239578"); assertThrow(x1 - x3, amount_error *);
assertThrow(x1 - x4, amount_error *);
assertThrow(x1 - x5, amount_error *);
assertThrow(x1 - x6, amount_error *);
assertThrow(x1 - 123.45, amount_error *);
assertThrow(x1 - 123L, amount_error *);
assertEqual(amount_t("123446916777474329.874482549545456789"), x2 - y2); assertEqual(amount_t("DM 0.00"), x3 - x3);
assertEqual(amount_t("-123446916777474329.874482549545456789"), y2 - x2); assertEqual(amount_t("DM 23.45"), x3 - amount_t("DM 100.00"));
assertEqual(amount_t("DM -23.45"), amount_t("DM 100.00") - x3);
assertEqual(amount_t("0.00 euro"), x4 - x4);
assertEqual(amount_t("23.45 euro"), x4 - amount_t("100.00 euro"));
assertEqual(amount_t("-23.45 euro"), amount_t("100.00 euro") - x4);
assertEqual(amount_t("0.00€"), x5 - x5);
assertEqual(amount_t("23.45€"), x5 - amount_t("100.00€"));
assertEqual(amount_t("-23.45€"), amount_t("100.00€") - x5);
CPPUNIT_ASSERT(x1.valid()); assertEqual(std::string("DM 0.00"), (x3 - x3).to_string());
CPPUNIT_ASSERT(y1.valid()); assertEqual(std::string("DM 23.45"), (x3 - amount_t("DM 100.00")).to_string());
CPPUNIT_ASSERT(x2.valid()); assertEqual(std::string("DM -23.45"), (amount_t("DM 100.00") - x3).to_string());
CPPUNIT_ASSERT(y2.valid()); assertEqual(std::string("0.00 euro"), (x4 - x4).to_string());
assertEqual(std::string("23.45 euro"), (x4 - amount_t("100.00 euro")).to_string());
assertEqual(std::string("-23.45 euro"), (amount_t("100.00 euro") - x4).to_string());
assertEqual(std::string("0.00€"), (x5 - x5).to_string());
assertEqual(std::string("23.45€"), (x5 - amount_t("100.00€")).to_string());
assertEqual(std::string("-23.45€"), (amount_t("100.00€") - x5).to_string());
x1 -= amount_t("$456.45");
assertEqual(amount_t("$-333.00"), x1);
x1 -= amount_t("$456.45");
assertEqual(amount_t("$-789.45"), x1);
x1 -= amount_t("$456");
assertEqual(amount_t("$-1245.45"), x1);
amount_t x7(internalAmount("$123456789123456789.123456789123456789"));
amount_t x8(internalAmount("$2354974984698.98459845984598"));
assertEqual(internalAmount("$123454434148472090.138858329277476789"), x7 - x8);
assertEqual(std::string("$123454434148472090.138858329277476789"), (x7 - x8).to_string());
assertEqual(std::string("$123454434148472090.14"),
(amount_t("$1.00") * (x7 - x8)).to_string());
assertEqual(internalAmount("$-123454434148472090.138858329277476789"), x8 - x7);
assertEqual(std::string("$-123454434148472090.138858329277476789"), (x8 - x7).to_string());
assertEqual(std::string("$-123454434148472090.14"),
(amount_t("$1.00") * (x8 - x7)).to_string());
assertValid(x1);
assertValid(x2);
assertValid(x3);
assertValid(x4);
assertValid(x5);
assertValid(x6);
assertValid(x7);
assertValid(x8);
} }
void CommodityAmountTestCase::testMultiplication() void CommodityAmountTestCase::testMultiplication()
@ -277,9 +362,9 @@ void CommodityAmountTestCase::testMultiplication()
assertEqual(amount_t("15241578780673678546105778311537878.046486820281054720515622620750190521"), assertEqual(amount_t("15241578780673678546105778311537878.046486820281054720515622620750190521"),
x2 * x2); x2 * x2);
CPPUNIT_ASSERT(x1.valid()); assertValid(x1);
CPPUNIT_ASSERT(y1.valid()); assertValid(y1);
CPPUNIT_ASSERT(x2.valid()); assertValid(x2);
} }
void CommodityAmountTestCase::testDivision() void CommodityAmountTestCase::testDivision()
@ -317,103 +402,99 @@ void CommodityAmountTestCase::testDivision()
assertEqual(amount_t("21739560323910.7554497273748437197344556164"), assertEqual(amount_t("21739560323910.7554497273748437197344556164"),
x4 / y4); x4 / y4);
CPPUNIT_ASSERT(x1.valid()); assertValid(x1);
CPPUNIT_ASSERT(y1.valid()); assertValid(y1);
CPPUNIT_ASSERT(x4.valid()); assertValid(x4);
CPPUNIT_ASSERT(y4.valid()); assertValid(y4);
} }
void CommodityAmountTestCase::testConversion() void CommodityAmountTestCase::testConversion()
{ {
// jww (2007-04-16): tbd amount_t x1("$1234.56");
amount_t x1(1234.56);
assertEqual(true, bool(x1)); assertEqual(true, bool(x1));
assertEqual(1234L, long(x1)); assertEqual(1234L, long(x1));
assertEqual(1234.56, double(x1)); assertEqual(1234.56, double(x1));
assertEqual(std::string("1234.56"), x1.to_string()); assertEqual(std::string("$1234.56"), x1.to_string());
assertEqual(std::string("1234.56"), x1.quantity_string()); assertEqual(std::string("1234.56"), x1.quantity_string());
CPPUNIT_ASSERT(x1.valid()); assertValid(x1);
} }
void CommodityAmountTestCase::testRound() void CommodityAmountTestCase::testRound()
{ {
// jww (2007-04-16): tbd amount_t x1(internalAmount("$1234.567890"));
amount_t x1("1234.567890");
assertEqual(amount_t("1234.56789"), x1.round(6)); assertEqual(internalAmount("$1234.56789"), x1.round(6));
assertEqual(amount_t("1234.56789"), x1.round(5)); assertEqual(internalAmount("$1234.56789"), x1.round(5));
assertEqual(amount_t("1234.5679"), x1.round(4)); assertEqual(internalAmount("$1234.5679"), x1.round(4));
assertEqual(amount_t("1234.568"), x1.round(3)); assertEqual(internalAmount("$1234.568"), x1.round(3));
assertEqual(amount_t("1234.57"), x1.round(2)); assertEqual(amount_t("$1234.57"), x1.round(2));
assertEqual(amount_t("1234.6"), x1.round(1)); assertEqual(amount_t("$1234.6"), x1.round(1));
assertEqual(amount_t("1235"), x1.round(0)); assertEqual(amount_t("$1235"), x1.round(0));
amount_t x2("9876.543210"); amount_t x2(internalAmount("$9876.543210"));
assertEqual(amount_t("9876.543210"), x2.round(6)); assertEqual(internalAmount("$9876.543210"), x2.round(6));
assertEqual(amount_t("9876.54321"), x2.round(5)); assertEqual(internalAmount("$9876.54321"), x2.round(5));
assertEqual(amount_t("9876.5432"), x2.round(4)); assertEqual(internalAmount("$9876.5432"), x2.round(4));
assertEqual(amount_t("9876.543"), x2.round(3)); assertEqual(internalAmount("$9876.543"), x2.round(3));
assertEqual(amount_t("9876.54"), x2.round(2)); assertEqual(amount_t("$9876.54"), x2.round(2));
assertEqual(amount_t("9876.5"), x2.round(1)); assertEqual(amount_t("$9876.5"), x2.round(1));
assertEqual(amount_t("9877"), x2.round(0)); assertEqual(amount_t("$9877"), x2.round(0));
amount_t x3("-1234.567890"); amount_t x3(internalAmount("$-1234.567890"));
assertEqual(amount_t("-1234.56789"), x3.round(6)); assertEqual(internalAmount("$-1234.56789"), x3.round(6));
assertEqual(amount_t("-1234.56789"), x3.round(5)); assertEqual(internalAmount("$-1234.56789"), x3.round(5));
assertEqual(amount_t("-1234.5679"), x3.round(4)); assertEqual(internalAmount("$-1234.5679"), x3.round(4));
assertEqual(amount_t("-1234.568"), x3.round(3)); assertEqual(internalAmount("$-1234.568"), x3.round(3));
assertEqual(amount_t("-1234.57"), x3.round(2)); assertEqual(amount_t("$-1234.57"), x3.round(2));
assertEqual(amount_t("-1234.6"), x3.round(1)); assertEqual(amount_t("$-1234.6"), x3.round(1));
assertEqual(amount_t("-1235"), x3.round(0)); assertEqual(amount_t("$-1235"), x3.round(0));
amount_t x4("-9876.543210"); amount_t x4(internalAmount("$-9876.543210"));
assertEqual(amount_t("-9876.543210"), x4.round(6)); assertEqual(internalAmount("$-9876.543210"), x4.round(6));
assertEqual(amount_t("-9876.54321"), x4.round(5)); assertEqual(internalAmount("$-9876.54321"), x4.round(5));
assertEqual(amount_t("-9876.5432"), x4.round(4)); assertEqual(internalAmount("$-9876.5432"), x4.round(4));
assertEqual(amount_t("-9876.543"), x4.round(3)); assertEqual(internalAmount("$-9876.543"), x4.round(3));
assertEqual(amount_t("-9876.54"), x4.round(2)); assertEqual(amount_t("$-9876.54"), x4.round(2));
assertEqual(amount_t("-9876.5"), x4.round(1)); assertEqual(amount_t("$-9876.5"), x4.round(1));
assertEqual(amount_t("-9877"), x4.round(0)); assertEqual(amount_t("$-9877"), x4.round(0));
CPPUNIT_ASSERT(x1.valid()); assertValid(x1);
CPPUNIT_ASSERT(x2.valid()); assertValid(x2);
CPPUNIT_ASSERT(x3.valid()); assertValid(x3);
CPPUNIT_ASSERT(x4.valid()); assertValid(x4);
} }
void CommodityAmountTestCase::testDisplayRound() void CommodityAmountTestCase::testDisplayRound()
{ {
amount_t x1("$0.85"); amount_t x1("$0.85");
amount_t x2("$0.1");
x1 *= 0.19; x1 *= 0.19;
CPPUNIT_ASSERT(amount_t("$0.16") != x1); assertNotEqual(amount_t("$0.16"), x1);
assertEqual(internalAmount("$0.1615"), x1); assertEqual(internalAmount("$0.1615"), x1);
assertEqual(std::string("$0.16"), x1.to_string()); assertEqual(std::string("$0.16"), x1.to_string());
assertEqual(amount_t("$0.10"), x2);
assertNotEqual(internalAmount("$0.101"), x2);
assertEqual(std::string("$0.10"), x2.to_string());
x1 *= 7L; x1 *= 7L;
CPPUNIT_ASSERT(amount_t("$1.13") != x1); assertNotEqual(amount_t("$1.13"), x1);
assertEqual(internalAmount("$1.1305"), x1); assertEqual(internalAmount("$1.1305"), x1);
assertEqual(std::string("$1.13"), x1.to_string()); assertEqual(std::string("$1.13"), x1.to_string());
} }
void CommodityAmountTestCase::testTruth() void CommodityAmountTestCase::testTruth()
{ {
// jww (2007-04-16): tbd amount_t x1("$1234");
amount_t x0; amount_t x2("$1234.56");
amount_t x1("1234");
amount_t x2("1234.56");
if (x0)
CPPUNIT_ASSERT(false);
else
CPPUNIT_ASSERT(true);
if (x1) if (x1)
CPPUNIT_ASSERT(true); CPPUNIT_ASSERT(true);
@ -425,112 +506,104 @@ void CommodityAmountTestCase::testTruth()
else else
CPPUNIT_ASSERT(false); CPPUNIT_ASSERT(false);
CPPUNIT_ASSERT(x0.valid()); assertValid(x1);
CPPUNIT_ASSERT(x1.valid()); assertValid(x2);
CPPUNIT_ASSERT(x2.valid());
} }
void CommodityAmountTestCase::testForZero() void CommodityAmountTestCase::testForZero()
{ {
// jww (2007-04-16): tbd amount_t x1(internalAmount("$0.000000000000000000001"));
amount_t x0;
amount_t x1("0.000000000000000000001");
CPPUNIT_ASSERT(! x0); assertFalse(x1);
CPPUNIT_ASSERT(x1); assertTrue(x1.zero());
CPPUNIT_ASSERT(x0.zero()); assertFalse(x1.realzero());
CPPUNIT_ASSERT(x0.realzero());
CPPUNIT_ASSERT(! x1.zero());
CPPUNIT_ASSERT(! x1.realzero());
CPPUNIT_ASSERT(x0.valid()); assertValid(x1);
CPPUNIT_ASSERT(x1.valid());
} }
void CommodityAmountTestCase::testComparisons() void CommodityAmountTestCase::testComparisons()
{ {
// jww (2007-04-16): tbd
amount_t x0; amount_t x0;
amount_t x1(-123L); amount_t x1("$-123");
amount_t x2(123L); amount_t x2("$123.00");
amount_t x3(-123.45); amount_t x3(internalAmount("$-123.4544"));
amount_t x4(123.45); amount_t x4(internalAmount("$123.4544"));
amount_t x5("-123.45"); amount_t x5("$-123.45");
amount_t x6("123.45"); amount_t x6("$123.45");
CPPUNIT_ASSERT(x0 > x1); assertTrue(x0 > x1);
CPPUNIT_ASSERT(x0 < x2); assertTrue(x0 < x2);
CPPUNIT_ASSERT(x0 > x3); assertTrue(x0 > x3);
CPPUNIT_ASSERT(x0 < x4); assertTrue(x0 < x4);
CPPUNIT_ASSERT(x0 > x5); assertTrue(x0 > x5);
CPPUNIT_ASSERT(x0 < x6); assertTrue(x0 < x6);
CPPUNIT_ASSERT(x1 > x3); assertTrue(x1 > x3);
CPPUNIT_ASSERT(x3 <= x5); assertTrue(x3 <= x5);
CPPUNIT_ASSERT(x3 >= x5); assertTrue(x3 < x5);
CPPUNIT_ASSERT(x3 < x1); assertTrue(x3 <= x5);
CPPUNIT_ASSERT(x3 < x4); assertFalse(x3 == x5);
assertTrue(x3 < x1);
assertTrue(x3 < x4);
CPPUNIT_ASSERT(x0.valid()); assertValid(x0);
CPPUNIT_ASSERT(x1.valid()); assertValid(x1);
CPPUNIT_ASSERT(x2.valid()); assertValid(x2);
CPPUNIT_ASSERT(x3.valid()); assertValid(x3);
CPPUNIT_ASSERT(x4.valid()); assertValid(x4);
CPPUNIT_ASSERT(x5.valid()); assertValid(x5);
CPPUNIT_ASSERT(x6.valid()); assertValid(x6);
} }
void CommodityAmountTestCase::testSign() void CommodityAmountTestCase::testSign()
{ {
// jww (2007-04-16): tbd
amount_t x0; amount_t x0;
amount_t x1("0.0000000000000000000000000000000000001"); amount_t x1(internalAmount("$0.0000000000000000000000000000000000001"));
amount_t x2("-0.0000000000000000000000000000000000001"); amount_t x2(internalAmount("$-0.0000000000000000000000000000000000001"));
amount_t x3("1"); amount_t x3("$1");
amount_t x4("-1"); amount_t x4("$-1");
CPPUNIT_ASSERT(! x0.sign()); assertFalse(x0.sign());
CPPUNIT_ASSERT(x1.sign() > 0); assertTrue(x1.sign() != 0);
CPPUNIT_ASSERT(x2.sign() < 0); assertTrue(x2.sign() != 0);
CPPUNIT_ASSERT(x3.sign() > 0); assertTrue(x3.sign() > 0);
CPPUNIT_ASSERT(x4.sign() < 0); assertTrue(x4.sign() < 0);
CPPUNIT_ASSERT(x0.valid()); assertValid(x0);
CPPUNIT_ASSERT(x1.valid()); assertValid(x1);
CPPUNIT_ASSERT(x2.valid()); assertValid(x2);
CPPUNIT_ASSERT(x3.valid()); assertValid(x3);
CPPUNIT_ASSERT(x4.valid()); assertValid(x4);
} }
void CommodityAmountTestCase::testAbs() void CommodityAmountTestCase::testAbs()
{ {
// jww (2007-04-16): tbd
amount_t x0; amount_t x0;
amount_t x1(-1234L); amount_t x1("$-1234.56");
amount_t x2(1234L); amount_t x2("$1234.56");
assertEqual(amount_t(), abs(x0)); assertEqual(amount_t(), abs(x0));
assertEqual(amount_t(1234L), abs(x1)); assertEqual(amount_t("$1234.56"), abs(x1));
assertEqual(amount_t(1234L), abs(x2)); assertEqual(amount_t("$1234.56"), abs(x2));
x0.abs(); x0.abs();
x1.abs(); x1.abs();
x2.abs(); x2.abs();
assertEqual(amount_t(), x0); assertEqual(amount_t(), x0);
assertEqual(amount_t(1234L), x1); assertEqual(amount_t("$1234.56"), x1);
assertEqual(amount_t(1234L), x2); assertEqual(amount_t("$1234.56"), x2);
CPPUNIT_ASSERT(x0.valid()); assertValid(x0);
CPPUNIT_ASSERT(x1.valid()); assertValid(x1);
CPPUNIT_ASSERT(x2.valid()); assertValid(x2);
} }
void CommodityAmountTestCase::testPrinting() void CommodityAmountTestCase::testPrinting()
{ {
// jww (2007-04-16): tbd
amount_t x0; amount_t x0;
amount_t x1("982340823.380238098235098235098235098"); amount_t x1(internalAmount("$982340823.386238098235098235098235098"));
amount_t x2("$982340823.38");
{ {
std::ostringstream bufstr; std::ostringstream bufstr;
@ -543,10 +616,26 @@ void CommodityAmountTestCase::testPrinting()
std::ostringstream bufstr; std::ostringstream bufstr;
bufstr << x1; bufstr << x1;
assertEqual(std::string("982340823.380238098235098235098235098"), assertEqual(std::string("$982340823.386238098235098235098235098"),
bufstr.str()); bufstr.str());
} }
CPPUNIT_ASSERT(x0.valid()); {
CPPUNIT_ASSERT(x1.valid()); std::ostringstream bufstr;
bufstr << (x1 * x2);
assertEqual(std::string("$964993493285024293.18099172508158508135413499124"),
bufstr.str());
}
{
std::ostringstream bufstr;
bufstr << (x2 * x1);
assertEqual(std::string("$964993493285024293.18"), bufstr.str());
}
assertValid(x0);
assertValid(x1);
assertValid(x2);
} }

2
tests/python/UnitTests.py
View file

@ -1,9 +1,11 @@
from unittest import TextTestRunner, TestSuite from unittest import TextTestRunner, TestSuite
import tests.python.corelib.numerics.BasicAmount as BasicAmount import tests.python.corelib.numerics.BasicAmount as BasicAmount
import tests.python.corelib.numerics.CommodityAmount as CommodityAmount
suites = [ suites = [
BasicAmount.suite(), BasicAmount.suite(),
CommodityAmount.suite(),
] ]
TextTestRunner().run(TestSuite(suites)) TextTestRunner().run(TestSuite(suites))

101
tests/python/corelib/numerics/BasicAmount.py
View file

@ -3,7 +3,6 @@ import exceptions
from ledger import amount from ledger import amount
class BasicAmountTestCase(unittest.TestCase): class BasicAmountTestCase(unittest.TestCase):
def testConstructors(self): def testConstructors(self):
x0 = amount() x0 = amount()
@ -53,6 +52,14 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertEqual(x3, x10) self.assertEqual(x3, x10)
self.assertTrue(x0.valid())
self.assertTrue(x1.valid())
self.assertTrue(x3.valid())
self.assertTrue(x5.valid())
self.assertTrue(x6.valid())
self.assertTrue(x9.valid())
self.assertTrue(x10.valid())
def testAssignment(self): def testAssignment(self):
x0 = amount() x0 = amount()
x1 = amount(123456) x1 = amount(123456)
@ -90,6 +97,16 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertEqual(amount(1), x4) self.assertEqual(amount(1), x4)
self.assertEqual(x10, x9) self.assertEqual(x10, x9)
self.assertTrue(x0.valid())
self.assertTrue(x1.valid())
self.assertTrue(x2.valid())
self.assertTrue(x3.valid())
self.assertTrue(x4.valid())
self.assertTrue(x5.valid())
self.assertTrue(x6.valid())
self.assertTrue(x9.valid())
self.assertTrue(x10.valid())
def testEquality(self): def testEquality(self):
x1 = amount(123456) x1 = amount(123456)
x2 = amount(456789) x2 = amount(456789)
@ -103,6 +120,12 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertTrue(x1 == x4) self.assertTrue(x1 == x4)
self.assertTrue(x4 == x5) self.assertTrue(x4 == x5)
self.assertTrue(x1.valid())
self.assertTrue(x2.valid())
self.assertTrue(x3.valid())
self.assertTrue(x4.valid())
self.assertTrue(x5.valid())
def testIntegerAddition(self): def testIntegerAddition(self):
x1 = amount(123) x1 = amount(123)
y1 = amount(456) y1 = amount(456)
@ -126,6 +149,12 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertEqual(amount("246913578246913578246913578"), x4 + x4) self.assertEqual(amount("246913578246913578246913578"), x4 + x4)
self.assertTrue(x1.valid())
self.assertTrue(y1.valid())
self.assertTrue(x3.valid())
self.assertTrue(y3.valid())
self.assertTrue(x4.valid())
def testFractionalAddition(self): def testFractionalAddition(self):
x1 = amount(123.123) x1 = amount(123.123)
y1 = amount(456.456) y1 = amount(456.456)
@ -145,6 +174,10 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertEqual(amount("246913578246913578.246913578246913578"), x2 + x2) self.assertEqual(amount("246913578246913578.246913578246913578"), x2 + x2)
self.assertTrue(x1.valid())
self.assertTrue(y1.valid())
self.assertTrue(x2.valid())
def testIntegerSubtraction(self): def testIntegerSubtraction(self):
x1 = amount(123) x1 = amount(123)
y1 = amount(456) y1 = amount(456)
@ -170,6 +203,13 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertEqual(amount("123456789115218063137220803"), x4 - y4) self.assertEqual(amount("123456789115218063137220803"), x4 - y4)
self.assertEqual(amount("-123456789115218063137220803"), y4 - x4) self.assertEqual(amount("-123456789115218063137220803"), y4 - x4)
self.assertTrue(x1.valid())
self.assertTrue(y1.valid())
self.assertTrue(x3.valid())
self.assertTrue(y3.valid())
self.assertTrue(x4.valid())
self.assertTrue(y4.valid())
def testFractionalSubtraction(self): def testFractionalSubtraction(self):
x1 = amount(123.123) x1 = amount(123.123)
y1 = amount(456.456) y1 = amount(456.456)
@ -190,6 +230,11 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertEqual(amount("123446916777474329.874482549545456789"), x2 - y2) self.assertEqual(amount("123446916777474329.874482549545456789"), x2 - y2)
self.assertEqual(amount("-123446916777474329.874482549545456789"), y2 - x2) self.assertEqual(amount("-123446916777474329.874482549545456789"), y2 - x2)
self.assertTrue(x1.valid())
self.assertTrue(y1.valid())
self.assertTrue(x2.valid())
self.assertTrue(y2.valid())
def testIntegerMultiplication(self): def testIntegerMultiplication(self):
x1 = amount(123) x1 = amount(123)
y1 = amount(456) y1 = amount(456)
@ -224,6 +269,12 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertEqual(amount("15241578780673678546105778281054720515622620750190521"), self.assertEqual(amount("15241578780673678546105778281054720515622620750190521"),
x4 * x4) x4 * x4)
self.assertTrue(x1.valid())
self.assertTrue(y1.valid())
self.assertTrue(x3.valid())
self.assertTrue(y3.valid())
self.assertTrue(x4.valid())
def testFractionalMultiplication(self): def testFractionalMultiplication(self):
x1 = amount(123.123) x1 = amount(123.123)
y1 = amount(456.456) y1 = amount(456.456)
@ -255,6 +306,10 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertEqual(amount("15241578780673678546105778311537878.046486820281054720515622620750190521"), self.assertEqual(amount("15241578780673678546105778311537878.046486820281054720515622620750190521"),
x2 * x2) x2 * x2)
self.assertTrue(x1.valid())
self.assertTrue(y1.valid())
self.assertTrue(x2.valid())
def divideByZero(self, amt): def divideByZero(self, amt):
return amt / 0 return amt / 0
@ -288,6 +343,11 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertEqual(amount(1), x4 / x4) self.assertEqual(amount(1), x4 / x4)
self.assertEqual(amount("2204585520061728377204585.517857"), x4 / y4) self.assertEqual(amount("2204585520061728377204585.517857"), x4 / y4)
self.assertTrue(x1.valid())
self.assertTrue(y1.valid())
self.assertTrue(x4.valid())
self.assertTrue(y4.valid())
def testFractionalDivision(self): def testFractionalDivision(self):
x1 = amount(123.123) x1 = amount(123.123)
y1 = amount(456.456) y1 = amount(456.456)
@ -321,6 +381,11 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertEqual(amount("21739560323910.7554497273748437197344556164"), self.assertEqual(amount("21739560323910.7554497273748437197344556164"),
x4 / y4) x4 / y4)
self.assertTrue(x1.valid())
self.assertTrue(y1.valid())
self.assertTrue(x4.valid())
self.assertTrue(y4.valid())
def testIntegerConversion(self): def testIntegerConversion(self):
x1 = amount(123456) x1 = amount(123456)
@ -330,6 +395,8 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertEqual("123456", x1.to_string()) self.assertEqual("123456", x1.to_string())
self.assertEqual("123456", x1.quantity_string()) self.assertEqual("123456", x1.quantity_string())
self.assertTrue(x1.valid())
def testFractionalConversion(self): def testFractionalConversion(self):
x1 = amount(1234.56) x1 = amount(1234.56)
@ -339,6 +406,8 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertEqual("1234.56", x1.to_string()) self.assertEqual("1234.56", x1.to_string())
self.assertEqual("1234.56", x1.quantity_string()) self.assertEqual("1234.56", x1.quantity_string())
self.assertTrue(x1.valid())
def testFractionalRound(self): def testFractionalRound(self):
x1 = amount("1234.567890") x1 = amount("1234.567890")
@ -380,6 +449,11 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertEqual(amount("-9876.5"), x4.round(1)) self.assertEqual(amount("-9876.5"), x4.round(1))
self.assertEqual(amount("-9877"), x4.round(0)) self.assertEqual(amount("-9877"), x4.round(0))
self.assertTrue(x1.valid())
self.assertTrue(x2.valid())
self.assertTrue(x3.valid())
self.assertTrue(x4.valid())
def testTruth(self): def testTruth(self):
x0 = amount() x0 = amount()
x1 = amount("1234") x1 = amount("1234")
@ -389,6 +463,10 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertTrue(x1 ) self.assertTrue(x1 )
self.assertTrue(x2) self.assertTrue(x2)
self.assertTrue(x0.valid())
self.assertTrue(x1.valid())
self.assertTrue(x2.valid())
def testForZero(self): def testForZero(self):
x0 = amount() x0 = amount()
x1 = amount("0.000000000000000000001") x1 = amount("0.000000000000000000001")
@ -400,6 +478,9 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertTrue(not x1.zero()) self.assertTrue(not x1.zero())
self.assertTrue(not x1.realzero()) self.assertTrue(not x1.realzero())
self.assertTrue(x0.valid())
self.assertTrue(x1.valid())
def testComparisons(self): def testComparisons(self):
x0 = amount() x0 = amount()
x1 = amount(-123) x1 = amount(-123)
@ -422,6 +503,14 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertTrue(x3 < x1) self.assertTrue(x3 < x1)
self.assertTrue(x3 < x4) self.assertTrue(x3 < x4)
self.assertTrue(x0.valid())
self.assertTrue(x1.valid())
self.assertTrue(x2.valid())
self.assertTrue(x3.valid())
self.assertTrue(x4.valid())
self.assertTrue(x5.valid())
self.assertTrue(x6.valid())
def testSign(self): def testSign(self):
x0 = amount() x0 = amount()
x1 = amount("0.0000000000000000000000000000000000001") x1 = amount("0.0000000000000000000000000000000000001")
@ -435,6 +524,12 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertTrue(x3.sign() > 0) self.assertTrue(x3.sign() > 0)
self.assertTrue(x4.sign() < 0) self.assertTrue(x4.sign() < 0)
self.assertTrue(x0.valid())
self.assertTrue(x1.valid())
self.assertTrue(x2.valid())
self.assertTrue(x3.valid())
self.assertTrue(x4.valid())
def testAbs(self): def testAbs(self):
x0 = amount() x0 = amount()
x1 = amount(-1234) x1 = amount(-1234)
@ -452,6 +547,10 @@ class BasicAmountTestCase(unittest.TestCase):
self.assertEqual(amount(1234), x1) self.assertEqual(amount(1234), x1)
self.assertEqual(amount(1234), x2) self.assertEqual(amount(1234), x2)
self.assertTrue(x0.valid())
self.assertTrue(x1.valid())
self.assertTrue(x2.valid())
def testPrinting(self): def testPrinting(self):
pass pass

4
tests/python/corelib/numerics/CommodityAmount.py
View file

@ -4,7 +4,7 @@ import exceptions
from ledger import amount from ledger import amount
class BasicAmountTestCase(unittest.TestCase): class CommodityAmountTestCase(unittest.TestCase):
def testConstructors(self): def testConstructors(self):
x0 = amount() x0 = amount()
x1 = amount(123456) x1 = amount(123456)
@ -457,7 +457,7 @@ class BasicAmountTestCase(unittest.TestCase):
def suite(): def suite():
return unittest.TestLoader().loadTestsFromTestCase(BasicAmountTestCase) return unittest.TestLoader().loadTestsFromTestCase(CommodityAmountTestCase)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()