payrolltest.cpp

著名的uncle Bob的Agile software development的代码

#include "PayrollTest.h"
#include "PayrollDatabase.h"
#include "AddSalariedEmployee.h"
#include "Employee.h"
#include "SalariedClassification.h"
#include "AddHourlyEmployee.h"
#include "MonthlySchedule.h"
#include "HoldMethod.h"
#include "HourlyClassification.h"
#include "WeeklySchedule.h"
#include "AddCommissionedEmployee.h"
#include "CommissionedClassification.h"
#include "BiweeklySchedule.h"
#include "DeleteEmployeeTransaction.h"
#include "TimeCardTransaction.h"
#include "TimeCard.h"
#include "SalesReceiptTransaction.h"
#include "SalesReceipt.h"
#include "UnionAffiliation.h"
#include "ServiceChargeTransaction.h"
#include "ServiceCharge.h"
#include "ChangeNameTransaction.h"
#include "ChangeAddressTransaction.h"
#include "ChangeHourlyTransaction.h"
#include "ChangeSalariedTransaction.h"
#include "ChangeCommissionedTransaction.h"
#include "ChangeMailTransaction.h"
#include "MailMethod.h"
#include "ChangeDirectTransaction.h"
#include "DirectMethod.h"
#include "ChangeHoldTransaction.h"
#include "ChangeMemberTransaction.h"
#include "ChangeUnaffiliatedTransaction.h"
#include "NoAffiliation.h"
#include "PaydayTransaction.h"
#include "Paycheck.h"

extern PayrollDatabase GpayrollDatabase;

void PayrollTest::setUp ()
{
  GpayrollDatabase.clear();
}

void PayrollTest::TestAddSalariedEmployee()
{
  cerr << "TestAddSalariedEmployee" << endl;
  int empId = 1;
  AddSalariedEmployee t(empId, "Bob", "Home", 1000.00);
  t.Execute();
  Employee* e = GpayrollDatabase.GetEmployee(empId);
  assert(e);
  assert("Bob" == e->GetName());
  PaymentClassification* pc = e->GetClassification();
  SalariedClassification* sc = dynamic_cast<SalariedClassification*>(pc);
  assert(sc);
  assertEquals(1000.00, sc->GetSalary(), .001);
  PaymentSchedule* ps = e->GetSchedule();
  MonthlySchedule* ms = dynamic_cast<MonthlySchedule*>(ps);
  assert(ms);
  PaymentMethod* pm = e->GetMethod();
  HoldMethod* hm = dynamic_cast<HoldMethod*>(pm);
  assert(hm);
}

void PayrollTest::TestAddHourlyEmployee()
{
  cerr << "TestAddHourlyEmployee" << endl;
  int empId = 2;
  AddHourlyEmployee t(empId, "Bill", "Home", 15.25);
  t.Execute();
  Employee* e = GpayrollDatabase.GetEmployee(empId);
  assert(e);
  assert("Bill" == e->GetName());
  PaymentClassification* pc = e->GetClassification();
  HourlyClassification* hc = dynamic_cast<HourlyClassification*>(pc);
  assert(hc);
  assertEquals(15.25, hc->GetRate(), .001);
  PaymentSchedule* ps = e->GetSchedule();
  WeeklySchedule* ws = dynamic_cast<WeeklySchedule*>(ps);
  assert(ws);
  PaymentMethod* pm = e->GetMethod();
  HoldMethod* hm = dynamic_cast<HoldMethod*>(pm);
  assert(hm);
}

void PayrollTest::TestAddCommissionedEmployee()
{
  cerr << "TestAddCommissionedEmployee" << endl;
  int empId = 3;
  AddCommissionedEmployee t(empId, "Lance", "Home", 2500, 3.2);
  t.Execute();
  Employee* e = GpayrollDatabase.GetEmployee(empId);
  assert(e);
  assert("Lance" == e->GetName());
  PaymentClassification* pc = e->GetClassification();
  CommissionedClassification* cc = dynamic_cast<CommissionedClassification*>(pc);
  assert(cc);
  assertEquals(2500, cc->GetSalary(), .001);
  PaymentSchedule* ps = e->GetSchedule();
  BiweeklySchedule* bws = dynamic_cast<BiweeklySchedule*>(ps);
  assert(bws);
  PaymentMethod* pm = e->GetMethod();
  HoldMethod* hm = dynamic_cast<HoldMethod*>(pm);
  assert(hm);
}

void PayrollTest::TestDeleteEmployee()
{
  cerr << "TestDeleteEmployee" << endl;
  int empId = 3;
  AddCommissionedEmployee t(empId, "Lance", "Home", 2500, 3.2);
  t.Execute();
  {
    Employee* e = GpayrollDatabase.GetEmployee(empId);
    assert(e);
  }
  DeleteEmployeeTransaction dt(empId);
  dt.Execute();
  {
    Employee* e = GpayrollDatabase.GetEmployee(empId);
    assert(e == 0);
  }
}

void PayrollTest::TestTimeCardTransaction()
{
  cerr << "TestTimeCardTransaction" << endl;
  int empId = 2;
  AddHourlyEmployee t(empId, "Bill", "Home", 15.25);
  t.Execute();
  TimeCardTransaction tct(Date(10,31,2001), 8.0, empId);
  tct.Execute();
  Employee* e = GpayrollDatabase.GetEmployee(empId);
  assert(e);
  PaymentClassification* pc = e->GetClassification();
  HourlyClassification* hc = dynamic_cast<HourlyClassification*>(pc);
  assert(hc);
  TimeCard* tc = hc->GetTimeCard(Date(10,31,2001));
  assert(tc);
  assertEquals(8.0, tc->GetHours());
}

void PayrollTest::TestBadTimeCardTransaction()
{
  cerr << "TestBadTimeCardTransaction" << endl;
  int empId = 3;
  AddCommissionedEmployee t(empId, "Lance", "Home", 2500, 3.2);
  t.Execute();
  TimeCardTransaction tct(Date(10,31,2001), 8.0, empId);
  try {
    tct.Execute();
    assert(false);
  }
  catch(const char* s) {
    cerr << "Caught: " << s << endl;
  }
}

void PayrollTest::TestSalesReceiptTransaction()
{
  cerr << "TestSalesReceiptTransaction" << endl;
  int empId = 3;
  AddCommissionedEmployee t(empId, "Lance", "Home", 2500, 3.2);
  t.Execute();
  Date saleDate(11, 12, 2001); // Monday
  SalesReceiptTransaction srt(saleDate, 25000, empId);
  srt.Execute();
  Employee* e = GpayrollDatabase.GetEmployee(empId);
  assert(e);
  PaymentClassification* pc = e->GetClassification();
  CommissionedClassification* cc = dynamic_cast<CommissionedClassification*>(pc);
  assert(cc);
  SalesReceipt* receipt = cc->GetReceipt(saleDate);
  assert(receipt);
  assertEquals(25000, receipt->GetAmount(), .001);
}

void PayrollTest::TestBadSalesReceiptTransaction()
{
  cerr << "TestBadSalesReceiptTransaction" << endl;
  int empId = 2;
  AddHourlyEmployee t(empId, "Bill", "Home", 15.25);
  t.Execute();
  Date saleDate(11,12,2001);
  SalesReceiptTransaction tct(saleDate, 25000, empId);
  try {
    tct.Execute();
    assert(false);
  }
  catch(const char* s) {
    cerr << "Caught: " << s << endl;
  }
}

void PayrollTest::TestAddServiceCharge()
{
  cerr << "TestAddServiceCharge" << endl;
  int empId = 2;
  int memberId = 86; // Maxwell Smart
  AddHourlyEmployee t(empId, "Bill", "Home", 15.25);
  t.Execute();
  Employee* e = GpayrollDatabase.GetEmployee(empId);
  assert(e);
  UnionAffiliation* af = new UnionAffiliation(memberId, 12.5);
  e->SetAffiliation(af);
  GpayrollDatabase.AddUnionMember(memberId, e);
  Date serviceChargeDate(11,01,2001);
  ServiceChargeTransaction sct(memberId, serviceChargeDate, 12.95);
  sct.Execute();
  ServiceCharge* sc = af->GetServiceCharge(serviceChargeDate);
  assert(sc);
  assertEquals(12.95, sc->GetAmount(), .001);
}

void PayrollTest::TestChangeNameTransaction()
{
  cerr << "TestChangeNameTransaction" << endl;
  int empId = 2;
  AddHourlyEmployee t(empId, "Bill", "Home", 15.25);
  t.Execute();
  ChangeNameTransaction cnt(empId, "Bob");
  cnt.Execute();
  Employee* e = GpayrollDatabase.GetEmployee(empId);
  assert(e);
  assert("Bob" == e->GetName());
}

void PayrollTest::TestChangeAddressTransaction()
{
  cerr << "TestChangeAddressTransaction" << endl;
  int empId = 2;
  AddHourlyEmployee t(empId, "Bill", "Home", 15.25);
  t.Execute();
  ChangeAddressTransaction cnt(empId, "PO Box 7575");
  cnt.Execute();
  Employee* e = GpayrollDatabase.GetEmployee(empId);
  assert(e);
  assert("PO Box 7575" == e->GetAddress());
}

void PayrollTest::TestChangeHourlyTransaction()
{
  cerr << "TestChangeHourlyTransaction" << endl;
  int empId = 3;
  AddCommissionedEmployee t(empId, "Lance", "Home", 2500, 3.2);
  t.Execute();
  ChangeHourlyTransaction cht(empId, 27.52);
  cht.Execute();
  Employee* e = GpayrollDatabase.GetEmployee(empId);
  assert(e);
  PaymentClassification* pc = e->GetClassification();
  assert(pc);
  HourlyClassification* hc = dynamic_cast<HourlyClassification*>(pc);
  assert(hc);
  assertEquals(27.52, hc->GetRate(), .001);
  PaymentSchedule* ps = e->GetSchedule();
  WeeklySchedule* ws = dynamic_cast<WeeklySchedule*>(ps);
  assert(ws);
}

void PayrollTest::TestChangeSalariedTransaction()
{
  cerr << "TestChangeSalariedTransaction" << endl;
  int empId = 3;
  AddCommissionedEmployee t(empId, "Lance", "Home", 2500, 3.2);
  t.Execute();
  ChangeSalariedTransaction cht(empId, 25000);
  cht.Execute();
  Employee* e = GpayrollDatabase.GetEmployee(empId);
  assert(e);
  PaymentClassification* pc = e->GetClassification();
  assert(pc);
  SalariedClassification* sc = dynamic_cast<SalariedClassification*>(pc);
  assert(sc);
  assertEquals(25000, sc->GetSalary(), .001);
  PaymentSchedule* ps = e->GetSchedule();
  MonthlySchedule* ms = dynamic_cast<MonthlySchedule*>(ps);
  assert(ms);
}

void PayrollTest::TestChangeCommissionedTransaction()
{
  cerr << "TestChangeCommissionedTransaction" << endl;
  int empId = 2;
  AddHourlyEmployee t(empId, "Bill", "Home", 15.25);
  t.Execute();
  ChangeCommissionedTransaction cht(empId, 25000, 4.5);
  cht.Execute();
  Employee* e = GpayrollDatabase.GetEmployee(empId);
  assert(e);
  PaymentClassification* pc = e->GetClassification();
  assert(pc);
  CommissionedClassification* cc = dynamic_cast<CommissionedClassification*>(pc);
  assert(cc);
  assertEquals(25000, cc->GetSalary(), .001);
  assertEquals(4.5, cc->GetRate(), .001);
  PaymentSchedule* ps = e->GetSchedule();
  BiweeklySchedule* bws = dynamic_cast<BiweeklySchedule*>(ps);
  assert(bws);
}

void PayrollTest::TestChangeMailTransaction()
{
  cerr << "TestChangeMailTransaction" << endl;
  int empId = 2;
  AddHourlyEmployee t(empId, "Bill", "Home", 15.25);
  t.Execute();
  ChangeMailTransaction cmt(empId, "4080 El Cerrito Road");
  cmt.Execute();
  Employee* e = GpayrollDatabase.GetEmployee(empId);
  assert(e);
  PaymentMethod* pm = e->GetMethod();
  assert(pm);
  MailMethod* mm = dynamic_cast<MailMethod*>(pm);
  assert(mm);
  assert("4080 El Cerrito Road" == mm->GetAddress());
}

void PayrollTest::TestChangeDirectTransaction()
{
  cerr << "TestChangeDirectTransaction" << endl;
  int empId = 2;
  AddHourlyEmployee t(empId, "Bill", "Home", 15.25);
  t.Execute();
  ChangeDirectTransaction cdt(empId, "FirstNational", "1058209");
  cdt.Execute();
  Employee* e = GpayrollDatabase.GetEmployee(empId);
  assert(e);
  PaymentMethod* pm = e->GetMethod();
  assert(pm);
  DirectMethod* dm = dynamic_cast<DirectMethod*>(pm);
  assert(dm);
  assert("FirstNational" == dm->GetBank());
  assert("1058209" == dm->GetAccount());
}

void PayrollTest::TestChangeHoldTransaction()
{
  cerr << "TestChangeHoldTransaction" << endl;
  int empId = 2;
  AddHourlyEmployee t(empId, "Bill", "Home", 15.25);
  t.Execute();
  ChangeDirectTransaction cdt(empId, "FirstNational", "1058209");
  cdt.Execute();
  ChangeHoldTransaction cht(empId);
  cht.Execute();
  Employee* e = GpayrollDatabase.GetEmployee(empId);
  assert(e);
  PaymentMethod* pm = e->GetMethod();
  assert(pm);
  HoldMethod* hm = dynamic_cast<HoldMethod*>(pm);
  assert(hm);
}

void PayrollTest::TestChangeMemberTransaction()
{
  cerr << "TestChangeMemberTransaction" << endl;
  int empId = 2;
  int memberId = 7734;
  AddHourlyEmployee t(empId, "Bill", "Home", 15.25);
  t.Execute();
  ChangeMemberTransaction cmt(empId, memberId, 99.42);
  cmt.Execute();
  Employee* e = GpayrollDatabase.GetEmployee(empId);
  assert(e);
  Affiliation* af = e->GetAffiliation();
  assert(af);
  UnionAffiliation* uf = dynamic_cast<UnionAffiliation*>(af);
  assert(uf);
  assertEquals(99.42, uf->GetDues(), .001);
  Employee* member = GpayrollDatabase.GetUnionMember(memberId);
  assert(member);
  assert(e == member);
}

void PayrollTest::TestChangeUnaffiliatedTransaction()
{
  cerr << "TestChangeUnaffiliatedTransaction" << endl;
  int empId = 2;
  int memberId = 7734;
  AddHourlyEmployee t(empId, "Bill", "Home", 15.25);
  t.Execute();
  ChangeMemberTransaction cmt(empId, memberId, 99.42);
  cmt.Execute();
  ChangeUnaffiliatedTransaction cut(empId);
  cut.Execute();
  Employee* e = GpayrollDatabase.GetEmployee(empId);
  assert(e);
  Affiliation* af = e->GetAffiliation();
  assert(af);
  NoAffiliation* nf = dynamic_cast<NoAffiliation*>(af);
  assert(nf);
  Employee* member = GpayrollDatabase.GetUnionMember(memberId);
  assert(member == 0);
}

void PayrollTest::TestPaySingleSalariedEmployee()
{
  cerr << "TestPaySingleSalariedEmployee" << endl;
  int empId = 1;
  AddSalariedEmployee t(empId, "Bob", "Home", 1000.00);