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

7 files changed, 508 insertions, 302 deletions

diff --git a/amount.cc b/amount.cc
index bcf29d06..f4569571 100644
--- a/amount.cc
+++ b/amount.cc
@@ -505,6 +505,12 @@ void amount_t::_clear()
 
 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)
     return *this;
 
@@ -515,12 +521,6 @@ amount_t& amount_t::operator+=(const amount_t& amt)
 
   _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) {
     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)
 {
+  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)
     return *this;
 
@@ -551,12 +557,6 @@ amount_t& amount_t::operator-=(const amount_t& amt)
 
   _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) {
     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)
     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();
 
   mpz_mul(MPZ(quantity), MPZ(quantity), MPZ(amt.quantity));
   quantity->prec += amt.quantity->prec;
 
-  if (has_commodity()) {
+  if (has_commodity() && ! (quantity->flags & BIGINT_KEEP_PREC)) {
     unsigned int comm_prec = commodity().precision();
     if (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)
     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();
 
   // 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));
   quantity->prec += quantity->prec + 6U;
 
-  if (has_commodity()) {
+  if (has_commodity() && ! (quantity->flags & BIGINT_KEEP_PREC)) {
     unsigned int comm_prec = commodity().precision();
     if (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
 {
-  if (! quantity) {
-    _out << "0";
-    return;
-  }
-
   amount_t base(*this);
   if (! amount_t::keep_base && commodity().larger()) {
     amount_t last(*this);
     while (last.commodity().larger()) {
-      last /= *last.commodity().larger();
+      last /= last.commodity().larger()->number();
       last.commodity_ = last.commodity().larger()->commodity_;
       if (::abs(last) < 1)
 	break;
@@ -910,49 +919,46 @@ void amount_t::print(std::ostream& _out, bool omit_commodity) const
   // outputting it.  NOTE: `rquotient' is used here as a temp variable!
 
   commodity_t&	comm(base.commodity());
-  unsigned char precision;
-
-  if (! comm || base.quantity->flags & BIGINT_KEEP_PREC) {
-    mpz_ui_pow_ui(divisor, 10, base.quantity->prec);
-    mpz_tdiv_qr(quotient, remainder, MPZ(base.quantity), divisor);
-    precision = base.quantity->prec;
-  }
-  else if (comm.precision() < base.quantity->prec) {
-    mpz_round(rquotient, MPZ(base.quantity), base.quantity->prec,
-	      comm.precision());
-    mpz_ui_pow_ui(divisor, 10, comm.precision());
-    mpz_tdiv_qr(quotient, remainder, rquotient, divisor);
-    precision = comm.precision();
-  }
-  else if (comm.precision() > base.quantity->prec) {
-    mpz_ui_pow_ui(divisor, 10, comm.precision() - base.quantity->prec);
-    mpz_mul(rquotient, MPZ(base.quantity), divisor);
-    mpz_ui_pow_ui(divisor, 10, comm.precision());
-    mpz_tdiv_qr(quotient, remainder, rquotient, divisor);
-    precision = comm.precision();
-  }
-  else if (base.quantity->prec) {
-    mpz_ui_pow_ui(divisor, 10, base.quantity->prec);
-    mpz_tdiv_qr(quotient, remainder, MPZ(base.quantity), divisor);
-    precision = base.quantity->prec;
-  }
-  else {
-    mpz_set(quotient, MPZ(base.quantity));
-    mpz_set_ui(remainder, 0);
-    precision = 0;
-  }
+  unsigned char precision = 0;
 
-  if (mpz_sgn(quotient) < 0 || mpz_sgn(remainder) < 0) {
-    negative = true;
+  if (quantity) {
+    if (! comm || base.quantity->flags & BIGINT_KEEP_PREC) {
+      mpz_ui_pow_ui(divisor, 10, base.quantity->prec);
+      mpz_tdiv_qr(quotient, remainder, MPZ(base.quantity), divisor);
+      precision = base.quantity->prec;
+    }
+    else if (comm.precision() < base.quantity->prec) {
+      mpz_round(rquotient, MPZ(base.quantity), base.quantity->prec,
+		comm.precision());
+      mpz_ui_pow_ui(divisor, 10, comm.precision());
+      mpz_tdiv_qr(quotient, remainder, rquotient, divisor);
+      precision = comm.precision();
+    }
+    else if (comm.precision() > base.quantity->prec) {
+      mpz_ui_pow_ui(divisor, 10, comm.precision() - base.quantity->prec);
+      mpz_mul(rquotient, MPZ(base.quantity), divisor);
+      mpz_ui_pow_ui(divisor, 10, comm.precision());
+      mpz_tdiv_qr(quotient, remainder, rquotient, divisor);
+      precision = comm.precision();
+    }
+    else if (base.quantity->prec) {
+      mpz_ui_pow_ui(divisor, 10, base.quantity->prec);
+      mpz_tdiv_qr(quotient, remainder, MPZ(base.quantity), divisor);
+      precision = base.quantity->prec;
+    }
+    else {
+      mpz_set(quotient, MPZ(base.quantity));
+      mpz_set_ui(remainder, 0);
+      precision = 0;
+    }
 
-    mpz_abs(quotient, quotient);
-    mpz_abs(remainder, remainder);
-  }
-  mpz_set(rquotient, remainder);
+    if (mpz_sgn(quotient) < 0 || mpz_sgn(remainder) < 0) {
+      negative = true;
 
-  if (mpz_sgn(quotient) == 0 && mpz_sgn(rquotient) == 0) {
-    _out << "0";
-    return;
+      mpz_abs(quotient, quotient);
+      mpz_abs(remainder, remainder);
+    }
+    mpz_set(rquotient, remainder);
   }
 
   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()
 {
   while (commodity_ && commodity().smaller()) {
-    *this *= *commodity().smaller();
+    *this *= commodity().smaller()->number();
     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);
   smaller.parse(smaller_str.c_str(), AMOUNT_PARSE_NO_REDUCE);
 
-  larger *= smaller;
+  larger *= smaller.number();
 
   if (larger.commodity()) {
     larger.commodity().set_smaller(smaller);
@@ -1614,7 +1620,7 @@ amount_t amount_t::price() const
 {
   if (commodity_ && commodity_->annotated) {
     amount_t t(((annotated_commodity_t *)commodity_)->price);
-    t *= *this;
+    t *= number();
     DEBUG_PRINT("amounts.commodities",
 		"Returning price of " << *this << " = " << t);
     return t;
diff --git a/amount.h b/amount.h
index 680bd57f..9f16f305 100644
--- a/amount.h
+++ b/amount.h
@@ -107,6 +107,12 @@ class amount_t
       _release();
   }
 
+  amount_t number() const {
+    amount_t temp(*this);
+    temp.clear_commodity();
+    return temp;
+  }
+
   bool has_commodity() const;
   commodity_t& commodity() const;
   void set_commodity(commodity_t& comm) {
diff --git a/tests/UnitTests.h b/tests/UnitTests.h
index 13c95a73..49da8f2a 100644
--- a/tests/UnitTests.h
+++ b/tests/UnitTests.h
@@ -7,6 +7,10 @@
 
 #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 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 assertMessage(x,y)	    CPPUNIT_ASSERT_MESSAGE(x,y)
 #define assertThrow(x,y)	    CPPUNIT_ASSERT_THROW(x,y)
diff --git a/tests/corelib/numerics/CommodityAmount.cc b/tests/corelib/numerics/CommodityAmount.cc
index 1862b280..111eb339 100644
--- a/tests/corelib/numerics/CommodityAmount.cc
+++ b/tests/corelib/numerics/CommodityAmount.cc
@@ -11,7 +11,13 @@ inline amount_t internalAmount(const std::string& value) {
   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::testConstructors()
@@ -49,16 +55,16 @@ void CommodityAmountTestCase::testConstructors()
   assertEqual(std::string("123.45€"), x9.to_string());
   assertEqual(std::string("-123.45€"), x10.to_string());
 
-  CPPUNIT_ASSERT(x1.valid());
-  CPPUNIT_ASSERT(x2.valid());
-  CPPUNIT_ASSERT(x3.valid());
-  CPPUNIT_ASSERT(x4.valid());
-  CPPUNIT_ASSERT(x5.valid());
-  CPPUNIT_ASSERT(x6.valid());
-  CPPUNIT_ASSERT(x7.valid());
-  CPPUNIT_ASSERT(x8.valid());
-  CPPUNIT_ASSERT(x9.valid());
-  CPPUNIT_ASSERT(x10.valid());
+  assertValid(x1);
+  assertValid(x2);
+  assertValid(x3);
+  assertValid(x4);
+  assertValid(x5);
+  assertValid(x6);
+  assertValid(x7);
+  assertValid(x8);
+  assertValid(x9);
+  assertValid(x10);
 }
 
 void CommodityAmountTestCase::testNegation()
@@ -96,16 +102,16 @@ void CommodityAmountTestCase::testNegation()
   assertEqual(std::string("-123.45€"), (- x9).to_string());
   assertEqual(std::string("123.45€"), (- x10).to_string());
 
-  CPPUNIT_ASSERT(x1.valid());
-  CPPUNIT_ASSERT(x2.valid());
-  CPPUNIT_ASSERT(x3.valid());
-  CPPUNIT_ASSERT(x4.valid());
-  CPPUNIT_ASSERT(x5.valid());
-  CPPUNIT_ASSERT(x6.valid());
-  CPPUNIT_ASSERT(x7.valid());
-  CPPUNIT_ASSERT(x8.valid());
-  CPPUNIT_ASSERT(x9.valid());
-  CPPUNIT_ASSERT(x10.valid());
+  assertValid(x1);
+  assertValid(x2);
+  assertValid(x3);
+  assertValid(x4);
+  assertValid(x5);
+  assertValid(x6);
+  assertValid(x7);
+  assertValid(x8);
+  assertValid(x9);
+  assertValid(x10);
 }
 
 void CommodityAmountTestCase::testAssignment()
@@ -143,16 +149,16 @@ void CommodityAmountTestCase::testAssignment()
   assertEqual(std::string("123.45€"), x9.to_string());
   assertEqual(std::string("-123.45€"), x10.to_string());
 
-  CPPUNIT_ASSERT(x1.valid());
-  CPPUNIT_ASSERT(x2.valid());
-  CPPUNIT_ASSERT(x3.valid());
-  CPPUNIT_ASSERT(x4.valid());
-  CPPUNIT_ASSERT(x5.valid());
-  CPPUNIT_ASSERT(x6.valid());
-  CPPUNIT_ASSERT(x7.valid());
-  CPPUNIT_ASSERT(x8.valid());
-  CPPUNIT_ASSERT(x9.valid());
-  CPPUNIT_ASSERT(x10.valid());
+  assertValid(x1);
+  assertValid(x2);
+  assertValid(x3);
+  assertValid(x4);
+  assertValid(x5);
+  assertValid(x6);
+  assertValid(x7);
+  assertValid(x8);
+  assertValid(x9);
+  assertValid(x10);
 }
 
 void CommodityAmountTestCase::testEquality()
@@ -168,80 +174,159 @@ void CommodityAmountTestCase::testEquality()
   amount_t x9  = "123.45€";
   amount_t x10 = "-123.45€";
 
-  CPPUNIT_ASSERT(x1 != x2);
-  CPPUNIT_ASSERT(x1 != x4);
-  CPPUNIT_ASSERT(x1 != x7);
-  CPPUNIT_ASSERT(x1 != x9);
-  CPPUNIT_ASSERT(x2 == x3);
-  CPPUNIT_ASSERT(x4 != x5);
-  CPPUNIT_ASSERT(x5 == x6);
-  CPPUNIT_ASSERT(x7 == - x8);
-  CPPUNIT_ASSERT(x9 == - x10);
-
-  CPPUNIT_ASSERT(x1.valid());
-  CPPUNIT_ASSERT(x2.valid());
-  CPPUNIT_ASSERT(x3.valid());
-  CPPUNIT_ASSERT(x4.valid());
-  CPPUNIT_ASSERT(x5.valid());
-  CPPUNIT_ASSERT(x6.valid());
-  CPPUNIT_ASSERT(x7.valid());
-  CPPUNIT_ASSERT(x8.valid());
-  CPPUNIT_ASSERT(x9.valid());
-  CPPUNIT_ASSERT(x10.valid());
+  assertTrue(x1 != x2);
+  assertTrue(x1 != x4);
+  assertTrue(x1 != x7);
+  assertTrue(x1 != x9);
+  assertTrue(x2 == x3);
+  assertTrue(x4 != x5);
+  assertTrue(x5 == x6);
+  assertTrue(x7 == - x8);
+  assertTrue(x9 == - x10);
+
+  assertValid(x1);
+  assertValid(x2);
+  assertValid(x3);
+  assertValid(x4);
+  assertValid(x5);
+  assertValid(x6);
+  assertValid(x7);
+  assertValid(x8);
+  assertValid(x9);
+  assertValid(x10);
 }
 
 void CommodityAmountTestCase::testAddition()
 {
-  // jww (2007-04-16): tbd
-  amount_t x1(123.123);
-  amount_t y1(456.456);
-
-  assertEqual(amount_t(579.579), x1 + y1);
-  assertEqual(amount_t(579.579), x1 + 456.456);
-  assertEqual(amount_t(579.579), 456.456 + x1);
-
-  x1 += amount_t(456.456);
-  assertEqual(amount_t(579.579), x1);
-  x1 += 456.456;
-  assertEqual(amount_t(1036.035), x1);
-  x1 += 456L;
-  assertEqual(amount_t(1492.035), x1);
-
-  amount_t x2("123456789123456789.123456789123456789");
-
-  assertEqual(amount_t("246913578246913578.246913578246913578"), x2 + x2);
+  amount_t x0;
+  amount_t x1("$123.45");
+  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");
 
-  CPPUNIT_ASSERT(x1.valid());
-  CPPUNIT_ASSERT(y1.valid());
-  CPPUNIT_ASSERT(x2.valid());
+  assertEqual(amount_t("$246.90"), x1 + x1);
+  assertNotEqual(amount_t("$246.91"), x1 + x2);
+  assertEqual(internalAmount("$246.906789"), x1 + x2);
+
+  // Converting to string drops internal precision
+  assertEqual(std::string("$246.90"), (x1 + x1).to_string());
+  assertEqual(std::string("$246.91"), (x1 + x2).to_string());
+
+  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("DM 246.90"), x3 + x3);
+  assertEqual(amount_t("246.90 euro"), x4 + x4);
+  assertEqual(amount_t("246.90€"), x5 + x5);
+
+  assertEqual(std::string("DM 246.90"), (x3 + x3).to_string());
+  assertEqual(std::string("246.90 euro"), (x4 + x4).to_string());
+  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()
 {
-  // jww (2007-04-16): tbd
-  amount_t x1(123.123);
-  amount_t y1(456.456);
-
-  assertEqual(amount_t(-333.333), x1 - y1);
-  assertEqual(amount_t(333.333), y1 - x1);
-
-  x1 -= amount_t(456.456);
-  assertEqual(amount_t(-333.333), x1);
-  x1 -= 456.456;
-  assertEqual(amount_t(-789.789), x1);
-  x1 -= 456L;
-  assertEqual(amount_t(-1245.789), x1);
-
-  amount_t x2("123456789123456789.123456789123456789");
-  amount_t y2("9872345982459.248974239578");
-
-  assertEqual(amount_t("123446916777474329.874482549545456789"), x2 - y2);
-  assertEqual(amount_t("-123446916777474329.874482549545456789"), y2 - x2);
+  amount_t x0;
+  amount_t x1("$123.45");
+  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");
 
-  CPPUNIT_ASSERT(x1.valid());
-  CPPUNIT_ASSERT(y1.valid());
-  CPPUNIT_ASSERT(x2.valid());
-  CPPUNIT_ASSERT(y2.valid());
+  assertNotEqual(amount_t(), x1 - 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);
+
+  // Converting to string drops internal precision.  If an amount is
+  // zero, it drops the commodity as well.
+  assertEqual(std::string("$0.00"), (x1 - x1).to_string());
+  assertEqual(std::string("$-0.01"), (x1 - x2).to_string());
+
+  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("DM 0.00"), x3 - x3);
+  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);
+
+  assertEqual(std::string("DM 0.00"), (x3 - x3).to_string());
+  assertEqual(std::string("DM 23.45"), (x3 - amount_t("DM 100.00")).to_string());
+  assertEqual(std::string("DM -23.45"), (amount_t("DM 100.00") - x3).to_string());
+  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()
@@ -277,9 +362,9 @@ void CommodityAmountTestCase::testMultiplication()
   assertEqual(amount_t("15241578780673678546105778311537878.046486820281054720515622620750190521"),
 	      x2 * x2);
 
-  CPPUNIT_ASSERT(x1.valid());
-  CPPUNIT_ASSERT(y1.valid());
-  CPPUNIT_ASSERT(x2.valid());
+  assertValid(x1);
+  assertValid(y1);
+  assertValid(x2);
 }
 
 void CommodityAmountTestCase::testDivision()
@@ -317,103 +402,99 @@ void CommodityAmountTestCase::testDivision()
   assertEqual(amount_t("21739560323910.7554497273748437197344556164"),
 	      x4 / y4);
 
-  CPPUNIT_ASSERT(x1.valid());
-  CPPUNIT_ASSERT(y1.valid());
-  CPPUNIT_ASSERT(x4.valid());
-  CPPUNIT_ASSERT(y4.valid());
+  assertValid(x1);
+  assertValid(y1);
+  assertValid(x4);
+  assertValid(y4);
 }
 
 void CommodityAmountTestCase::testConversion()
 {
-  // jww (2007-04-16): tbd
-  amount_t x1(1234.56);
+  amount_t x1("$1234.56");
 
   assertEqual(true, bool(x1));
   assertEqual(1234L, long(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());
 
-  CPPUNIT_ASSERT(x1.valid());
+  assertValid(x1);
 }
 
 void CommodityAmountTestCase::testRound()
 {
-  // jww (2007-04-16): tbd
-  amount_t x1("1234.567890");
-
-  assertEqual(amount_t("1234.56789"), x1.round(6));
-  assertEqual(amount_t("1234.56789"), x1.round(5));
-  assertEqual(amount_t("1234.5679"), x1.round(4));
-  assertEqual(amount_t("1234.568"), x1.round(3));
-  assertEqual(amount_t("1234.57"), x1.round(2));
-  assertEqual(amount_t("1234.6"), x1.round(1));
-  assertEqual(amount_t("1235"), x1.round(0));
-
-  amount_t x2("9876.543210");
-
-  assertEqual(amount_t("9876.543210"), x2.round(6));
-  assertEqual(amount_t("9876.54321"), x2.round(5));
-  assertEqual(amount_t("9876.5432"), x2.round(4));
-  assertEqual(amount_t("9876.543"), x2.round(3));
-  assertEqual(amount_t("9876.54"), x2.round(2));
-  assertEqual(amount_t("9876.5"), x2.round(1));
-  assertEqual(amount_t("9877"), x2.round(0));
-
-  amount_t x3("-1234.567890");
-
-  assertEqual(amount_t("-1234.56789"), x3.round(6));
-  assertEqual(amount_t("-1234.56789"), x3.round(5));
-  assertEqual(amount_t("-1234.5679"), x3.round(4));
-  assertEqual(amount_t("-1234.568"), x3.round(3));
-  assertEqual(amount_t("-1234.57"), x3.round(2));
-  assertEqual(amount_t("-1234.6"), x3.round(1));
-  assertEqual(amount_t("-1235"), x3.round(0));
-
-  amount_t x4("-9876.543210");
-
-  assertEqual(amount_t("-9876.543210"), x4.round(6));
-  assertEqual(amount_t("-9876.54321"), x4.round(5));
-  assertEqual(amount_t("-9876.5432"), x4.round(4));
-  assertEqual(amount_t("-9876.543"), x4.round(3));
-  assertEqual(amount_t("-9876.54"), x4.round(2));
-  assertEqual(amount_t("-9876.5"), x4.round(1));
-  assertEqual(amount_t("-9877"), x4.round(0));
-
-  CPPUNIT_ASSERT(x1.valid());
-  CPPUNIT_ASSERT(x2.valid());
-  CPPUNIT_ASSERT(x3.valid());
-  CPPUNIT_ASSERT(x4.valid());
+  amount_t x1(internalAmount("$1234.567890"));
+
+  assertEqual(internalAmount("$1234.56789"), x1.round(6));
+  assertEqual(internalAmount("$1234.56789"), x1.round(5));
+  assertEqual(internalAmount("$1234.5679"), x1.round(4));
+  assertEqual(internalAmount("$1234.568"), x1.round(3));
+  assertEqual(amount_t("$1234.57"), x1.round(2));
+  assertEqual(amount_t("$1234.6"), x1.round(1));
+  assertEqual(amount_t("$1235"), x1.round(0));
+
+  amount_t x2(internalAmount("$9876.543210"));
+
+  assertEqual(internalAmount("$9876.543210"), x2.round(6));
+  assertEqual(internalAmount("$9876.54321"), x2.round(5));
+  assertEqual(internalAmount("$9876.5432"), x2.round(4));
+  assertEqual(internalAmount("$9876.543"), x2.round(3));
+  assertEqual(amount_t("$9876.54"), x2.round(2));
+  assertEqual(amount_t("$9876.5"), x2.round(1));
+  assertEqual(amount_t("$9877"), x2.round(0));
+
+  amount_t x3(internalAmount("$-1234.567890"));
+
+  assertEqual(internalAmount("$-1234.56789"), x3.round(6));
+  assertEqual(internalAmount("$-1234.56789"), x3.round(5));
+  assertEqual(internalAmount("$-1234.5679"), x3.round(4));
+  assertEqual(internalAmount("$-1234.568"), x3.round(3));
+  assertEqual(amount_t("$-1234.57"), x3.round(2));
+  assertEqual(amount_t("$-1234.6"), x3.round(1));
+  assertEqual(amount_t("$-1235"), x3.round(0));
+
+  amount_t x4(internalAmount("$-9876.543210"));
+
+  assertEqual(internalAmount("$-9876.543210"), x4.round(6));
+  assertEqual(internalAmount("$-9876.54321"), x4.round(5));
+  assertEqual(internalAmount("$-9876.5432"), x4.round(4));
+  assertEqual(internalAmount("$-9876.543"), x4.round(3));
+  assertEqual(amount_t("$-9876.54"), x4.round(2));
+  assertEqual(amount_t("$-9876.5"), x4.round(1));
+  assertEqual(amount_t("$-9877"), x4.round(0));
+
+  assertValid(x1);
+  assertValid(x2);
+  assertValid(x3);
+  assertValid(x4);
 }
 
 void CommodityAmountTestCase::testDisplayRound()
 {
   amount_t x1("$0.85");
+  amount_t x2("$0.1");
 
   x1 *= 0.19;
 
-  CPPUNIT_ASSERT(amount_t("$0.16") != x1);
+  assertNotEqual(amount_t("$0.16"), x1);
   assertEqual(internalAmount("$0.1615"), x1);
   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;
 
-  CPPUNIT_ASSERT(amount_t("$1.13") != x1);
+  assertNotEqual(amount_t("$1.13"), x1);
   assertEqual(internalAmount("$1.1305"), x1);
   assertEqual(std::string("$1.13"), x1.to_string());
 }
 
 void CommodityAmountTestCase::testTruth()
 {
-  // jww (2007-04-16): tbd
-  amount_t x0;
-  amount_t x1("1234");
-  amount_t x2("1234.56");
-
-  if (x0)
-    CPPUNIT_ASSERT(false);
-  else
-    CPPUNIT_ASSERT(true);
+  amount_t x1("$1234");
+  amount_t x2("$1234.56");
 
   if (x1)
     CPPUNIT_ASSERT(true);
@@ -425,112 +506,104 @@ void CommodityAmountTestCase::testTruth()
   else
     CPPUNIT_ASSERT(false);
 
-  CPPUNIT_ASSERT(x0.valid());
-  CPPUNIT_ASSERT(x1.valid());
-  CPPUNIT_ASSERT(x2.valid());
+  assertValid(x1);
+  assertValid(x2);
 }
 
 void CommodityAmountTestCase::testForZero()
 {
-  // jww (2007-04-16): tbd
-  amount_t x0;
-  amount_t x1("0.000000000000000000001");
+  amount_t x1(internalAmount("$0.000000000000000000001"));
 
-  CPPUNIT_ASSERT(! x0);
-  CPPUNIT_ASSERT(x1);
-  CPPUNIT_ASSERT(x0.zero());
-  CPPUNIT_ASSERT(x0.realzero());
-  CPPUNIT_ASSERT(! x1.zero());
-  CPPUNIT_ASSERT(! x1.realzero());
+  assertFalse(x1);
+  assertTrue(x1.zero());
+  assertFalse(x1.realzero());
 
-  CPPUNIT_ASSERT(x0.valid());
-  CPPUNIT_ASSERT(x1.valid());
+  assertValid(x1);
 }
 
 void CommodityAmountTestCase::testComparisons()
 {
-  // jww (2007-04-16): tbd
   amount_t x0;
-  amount_t x1(-123L);
-  amount_t x2(123L);
-  amount_t x3(-123.45);
-  amount_t x4(123.45);
-  amount_t x5("-123.45");
-  amount_t x6("123.45");
-
-  CPPUNIT_ASSERT(x0 > x1);
-  CPPUNIT_ASSERT(x0 < x2);
-  CPPUNIT_ASSERT(x0 > x3);
-  CPPUNIT_ASSERT(x0 < x4);
-  CPPUNIT_ASSERT(x0 > x5);
-  CPPUNIT_ASSERT(x0 < x6);
-
-  CPPUNIT_ASSERT(x1 > x3);
-  CPPUNIT_ASSERT(x3 <= x5);
-  CPPUNIT_ASSERT(x3 >= x5);
-  CPPUNIT_ASSERT(x3 < x1);
-  CPPUNIT_ASSERT(x3 < x4);
-
-  CPPUNIT_ASSERT(x0.valid());
-  CPPUNIT_ASSERT(x1.valid());
-  CPPUNIT_ASSERT(x2.valid());
-  CPPUNIT_ASSERT(x3.valid());
-  CPPUNIT_ASSERT(x4.valid());
-  CPPUNIT_ASSERT(x5.valid());
-  CPPUNIT_ASSERT(x6.valid());
+  amount_t x1("$-123");
+  amount_t x2("$123.00");
+  amount_t x3(internalAmount("$-123.4544"));
+  amount_t x4(internalAmount("$123.4544"));
+  amount_t x5("$-123.45");
+  amount_t x6("$123.45");
+
+  assertTrue(x0 > x1);
+  assertTrue(x0 < x2);
+  assertTrue(x0 > x3);
+  assertTrue(x0 < x4);
+  assertTrue(x0 > x5);
+  assertTrue(x0 < x6);
+
+  assertTrue(x1 > x3);
+  assertTrue(x3 <= x5);
+  assertTrue(x3 < x5);
+  assertTrue(x3 <= x5);
+  assertFalse(x3 == x5);
+  assertTrue(x3 < x1);
+  assertTrue(x3 < x4);
+
+  assertValid(x0);
+  assertValid(x1);
+  assertValid(x2);
+  assertValid(x3);
+  assertValid(x4);
+  assertValid(x5);
+  assertValid(x6);
 }
 
 void CommodityAmountTestCase::testSign()
 {
-  // jww (2007-04-16): tbd
   amount_t x0;
-  amount_t x1("0.0000000000000000000000000000000000001");
-  amount_t x2("-0.0000000000000000000000000000000000001");
-  amount_t x3("1");
-  amount_t x4("-1");
-
-  CPPUNIT_ASSERT(! x0.sign());
-  CPPUNIT_ASSERT(x1.sign() > 0);
-  CPPUNIT_ASSERT(x2.sign() < 0);
-  CPPUNIT_ASSERT(x3.sign() > 0);
-  CPPUNIT_ASSERT(x4.sign() < 0);
-
-  CPPUNIT_ASSERT(x0.valid());
-  CPPUNIT_ASSERT(x1.valid());
-  CPPUNIT_ASSERT(x2.valid());
-  CPPUNIT_ASSERT(x3.valid());
-  CPPUNIT_ASSERT(x4.valid());
+  amount_t x1(internalAmount("$0.0000000000000000000000000000000000001"));
+  amount_t x2(internalAmount("$-0.0000000000000000000000000000000000001"));
+  amount_t x3("$1");
+  amount_t x4("$-1");
+
+  assertFalse(x0.sign());
+  assertTrue(x1.sign() != 0);
+  assertTrue(x2.sign() != 0);
+  assertTrue(x3.sign() > 0);
+  assertTrue(x4.sign() < 0);
+
+  assertValid(x0);
+  assertValid(x1);
+  assertValid(x2);
+  assertValid(x3);
+  assertValid(x4);
 }
 
 void CommodityAmountTestCase::testAbs()
 {
-  // jww (2007-04-16): tbd
   amount_t x0;
-  amount_t x1(-1234L);
-  amount_t x2(1234L);
+  amount_t x1("$-1234.56");
+  amount_t x2("$1234.56");
 
   assertEqual(amount_t(), abs(x0));
-  assertEqual(amount_t(1234L), abs(x1));
-  assertEqual(amount_t(1234L), abs(x2));
+  assertEqual(amount_t("$1234.56"), abs(x1));
+  assertEqual(amount_t("$1234.56"), abs(x2));
 
   x0.abs();
   x1.abs();
   x2.abs();
 
   assertEqual(amount_t(), x0);
-  assertEqual(amount_t(1234L), x1);
-  assertEqual(amount_t(1234L), x2);
+  assertEqual(amount_t("$1234.56"), x1);
+  assertEqual(amount_t("$1234.56"), x2);
 
-  CPPUNIT_ASSERT(x0.valid());
-  CPPUNIT_ASSERT(x1.valid());
-  CPPUNIT_ASSERT(x2.valid());
+  assertValid(x0);
+  assertValid(x1);
+  assertValid(x2);
 }
 
 void CommodityAmountTestCase::testPrinting()
 {
-  // jww (2007-04-16): tbd
   amount_t x0;
-  amount_t x1("982340823.380238098235098235098235098");
+  amount_t x1(internalAmount("$982340823.386238098235098235098235098"));
+  amount_t x2("$982340823.38");
 
   {
     std::ostringstream bufstr;
@@ -543,10 +616,26 @@ void CommodityAmountTestCase::testPrinting()
     std::ostringstream bufstr;
     bufstr << x1;
 
-    assertEqual(std::string("982340823.380238098235098235098235098"),
+    assertEqual(std::string("$982340823.386238098235098235098235098"),
 		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);
 }
diff --git a/tests/python/UnitTests.py b/tests/python/UnitTests.py
index 981d2827..7a10c9e6 100644
--- a/tests/python/UnitTests.py
+++ b/tests/python/UnitTests.py
@@ -1,9 +1,11 @@
 from unittest import TextTestRunner, TestSuite
 
 import tests.python.corelib.numerics.BasicAmount as BasicAmount
+import tests.python.corelib.numerics.CommodityAmount as CommodityAmount
 
 suites = [
     BasicAmount.suite(),
+    CommodityAmount.suite(),
 ]
 
 TextTestRunner().run(TestSuite(suites))
diff --git a/tests/python/corelib/numerics/BasicAmount.py b/tests/python/corelib/numerics/BasicAmount.py
index ce6479a2..38cfacca 100644
--- a/tests/python/corelib/numerics/BasicAmount.py
+++ b/tests/python/corelib/numerics/BasicAmount.py
@@ -3,7 +3,6 @@ import exceptions
 
 from ledger import amount
 
-
 class BasicAmountTestCase(unittest.TestCase):
     def testConstructors(self):
         x0 = amount()
@@ -53,6 +52,14 @@ class BasicAmountTestCase(unittest.TestCase):
 
         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):
         x0 = amount()
         x1  = amount(123456)
@@ -90,6 +97,16 @@ class BasicAmountTestCase(unittest.TestCase):
         self.assertEqual(amount(1), x4)
         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):
         x1 = amount(123456)
         x2 = amount(456789)
@@ -103,6 +120,12 @@ class BasicAmountTestCase(unittest.TestCase):
         self.assertTrue(x1 == x4)
         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):
         x1 = amount(123)
         y1 = amount(456)
@@ -126,6 +149,12 @@ class BasicAmountTestCase(unittest.TestCase):
 
         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):
         x1 = amount(123.123)
         y1 = amount(456.456)
@@ -145,6 +174,10 @@ class BasicAmountTestCase(unittest.TestCase):
 
         self.assertEqual(amount("246913578246913578.246913578246913578"), x2 + x2)
 
+        self.assertTrue(x1.valid())
+        self.assertTrue(y1.valid())
+        self.assertTrue(x2.valid())
+
     def testIntegerSubtraction(self):
         x1 = amount(123)
         y1 = amount(456)
@@ -170,6 +203,13 @@ class BasicAmountTestCase(unittest.TestCase):
         self.assertEqual(amount("123456789115218063137220803"), x4 - y4)
         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):
         x1 = amount(123.123)
         y1 = amount(456.456)
@@ -190,6 +230,11 @@ class BasicAmountTestCase(unittest.TestCase):
         self.assertEqual(amount("123446916777474329.874482549545456789"), x2 - y2)
         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):
         x1 = amount(123)
         y1 = amount(456)
@@ -224,6 +269,12 @@ class BasicAmountTestCase(unittest.TestCase):
         self.assertEqual(amount("15241578780673678546105778281054720515622620750190521"),
                     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):
         x1 = amount(123.123)
         y1 = amount(456.456)
@@ -255,6 +306,10 @@ class BasicAmountTestCase(unittest.TestCase):
         self.assertEqual(amount("15241578780673678546105778311537878.046486820281054720515622620750190521"),
                     x2 * x2)
 
+        self.assertTrue(x1.valid())
+        self.assertTrue(y1.valid())
+        self.assertTrue(x2.valid())
+
     def divideByZero(self, amt):
         return amt / 0
 
@@ -288,6 +343,11 @@ class BasicAmountTestCase(unittest.TestCase):
         self.assertEqual(amount(1), x4 / x4)
         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):
         x1 = amount(123.123)
         y1 = amount(456.456)
@@ -321,6 +381,11 @@ class BasicAmountTestCase(unittest.TestCase):
         self.assertEqual(amount("21739560323910.7554497273748437197344556164"),
                          x4 / y4)
 
+        self.assertTrue(x1.valid())
+        self.assertTrue(y1.valid())
+        self.assertTrue(x4.valid())
+        self.assertTrue(y4.valid())
+
     def testIntegerConversion(self):
         x1 = amount(123456)
 
@@ -330,6 +395,8 @@ class BasicAmountTestCase(unittest.TestCase):
         self.assertEqual("123456", x1.to_string())
         self.assertEqual("123456", x1.quantity_string())
 
+        self.assertTrue(x1.valid())
+
     def testFractionalConversion(self):
         x1 = amount(1234.56)
 
@@ -339,6 +406,8 @@ class BasicAmountTestCase(unittest.TestCase):
         self.assertEqual("1234.56", x1.to_string())
         self.assertEqual("1234.56", x1.quantity_string())
 
+        self.assertTrue(x1.valid())
+
     def testFractionalRound(self):
         x1 = amount("1234.567890")
 
@@ -380,6 +449,11 @@ class BasicAmountTestCase(unittest.TestCase):
         self.assertEqual(amount("-9876.5"), x4.round(1))
         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):
         x0 = amount()
         x1 = amount("1234")
@@ -389,6 +463,10 @@ class BasicAmountTestCase(unittest.TestCase):
         self.assertTrue(x1 )
         self.assertTrue(x2)
 
+        self.assertTrue(x0.valid())
+        self.assertTrue(x1.valid())
+        self.assertTrue(x2.valid())
+
     def testForZero(self):
         x0 = amount()
         x1 = amount("0.000000000000000000001")
@@ -400,6 +478,9 @@ class BasicAmountTestCase(unittest.TestCase):
         self.assertTrue(not x1.zero())
         self.assertTrue(not x1.realzero())
 
+        self.assertTrue(x0.valid())
+        self.assertTrue(x1.valid())
+
     def testComparisons(self):
         x0 = amount()
         x1 = amount(-123)
@@ -422,6 +503,14 @@ class BasicAmountTestCase(unittest.TestCase):
         self.assertTrue(x3 < x1)
         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):
         x0 = amount()
         x1 = amount("0.0000000000000000000000000000000000001")
@@ -435,6 +524,12 @@ class BasicAmountTestCase(unittest.TestCase):
         self.assertTrue(x3.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):
         x0 = amount()
         x1 = amount(-1234)
@@ -452,6 +547,10 @@ class BasicAmountTestCase(unittest.TestCase):
         self.assertEqual(amount(1234), x1)
         self.assertEqual(amount(1234), x2)
 
+        self.assertTrue(x0.valid())
+        self.assertTrue(x1.valid())
+        self.assertTrue(x2.valid())
+
     def testPrinting(self):
         pass
 
diff --git a/tests/python/corelib/numerics/CommodityAmount.py b/tests/python/corelib/numerics/CommodityAmount.py
index ce6479a2..1a32243f 100644
--- a/tests/python/corelib/numerics/CommodityAmount.py
+++ b/tests/python/corelib/numerics/CommodityAmount.py
@@ -4,7 +4,7 @@ import exceptions
 from ledger import amount
 
 
-class BasicAmountTestCase(unittest.TestCase):
+class CommodityAmountTestCase(unittest.TestCase):
     def testConstructors(self):
         x0 = amount()
         x1 = amount(123456)
@@ -457,7 +457,7 @@ class BasicAmountTestCase(unittest.TestCase):
 
 
 def suite():
-    return unittest.TestLoader().loadTestsFromTestCase(BasicAmountTestCase)
+    return unittest.TestLoader().loadTestsFromTestCase(CommodityAmountTestCase)
 
 if __name__ == '__main__':
     unittest.main()