public void setup() {
Vector employees = getSomeEmployees();
// Bug 223005: Verify that we have at least 1 employee with the required field length otherwise
// an EclipseLinkException will be thrown
Employee emp = getEmployeeWithRequiredNameLength(employees, MIN_FIRSTNAME_LENGTH, getName());
String partialFirstName = "%" + emp.getFirstName().substring(0, 3) + "%";
ReadAllQuery raq = new ReadAllQuery();
raq.setReferenceClass(Employee.class);
Vector parameters = new Vector();
parameters.add(partialFirstName);
ExpressionBuilder eb = new ExpressionBuilder();
Expression whereClause = eb.get("firstName").like(partialFirstName);
raq.setSelectionCriteria(whereClause);
employees = (Vector) getSession().executeQuery(raq);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.firstName LIKE ?1";
setEjbqlString(ejbqlString);
setOriginalOject(employees);
setArguments(parameters);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
setArgumentNames(myArgumentNames);
super.setup();
}
public static SelfEmployee valueOf(Employee employee) {
SelfEmployee selfEmployee = new SelfEmployee();
selfEmployee.setFirstName(employee.getFirstName());
selfEmployee.setLastName(employee.getLastName());
selfEmployee.setPhoneNumber(employee.getPhoneNumber());
return selfEmployee;
}
public void test() {
// test readAll
getSession().readAllObjects(Employee.class);
getSession().getIdentityMapAccessor().initializeIdentityMap(Employee.class);
// test readObject
Employee employee =
(Employee)
getSession().readObject(Employee.class, new ExpressionBuilder().get("id").equal(99));
// test delete with an employee read from the database
employee = (Employee) getSession().readObject(Employee.class);
try {
getAbstractSession().deleteObject(employee);
} catch (DatabaseException exc) {
// if we get an integrity exception here, the query went to the DB and was not redirected
redirectedDeleteObject = false;
}
UnitOfWork uow = getSession().acquireUnitOfWork();
// test update with an employee read from the database
employee = (Employee) uow.readObject(Employee.class);
employee.setFirstName(employee.getFirstName() + "-changed");
// insert an employee to test the insert behavior
employee = new Employee();
employee.setFirstName("Paul");
employee.setLastName("Sheldon");
uow.registerObject(employee);
uow.commit();
}
@OnEvent(NEW_HIRE_CHANNEL)
public void enroll(final Employee employee) {
System.out.printf(
"Employee enrolled into benefits system employee %s %d\n",
employee.getFirstName(), employee.getEmployeeId());
}
@Override
public List<Employee> readEmployees(String infile) {
List<Employee> emps = new ArrayList<>();
Employee emp;
try (InputStream is = new FileInputStream(infile);
JsonReader reader = Json.createReader(is)) {
JsonObject obj = reader.readObject();
JsonArray empArr = obj.getJsonArray("Employees");
for (JsonObject empObj : empArr.getValuesAs(JsonObject.class)) {
emp = new Employee();
emp.setId(empObj.getInt("ID", -1));
emp.setFirstName(empObj.getString("FirstName", null));
emp.setLastName(empObj.getString("LastName", null));
emp.setDepartmentNumber(empObj.getInt("DepartmentNumber", -1));
emp.setLocationId(empObj.getInt("LocationID", -1));
if (emp.getId() > 0 && emp.getFirstName() != null && emp.getLastName() != null)
emps.add(emp);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (JsonParsingException jpe) {
System.err.println("Json file is malformed.");
System.err.println(jpe.getMessage());
System.err.println(jpe.getStackTrace());
}
return emps;
}
public void setup() {
Employee emp = (Employee) getSomeEmployees().firstElement();
String partOne;
String partTwo;
String ejbqlString;
partOne = emp.getFirstName();
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = builder.get("firstName").concat("Smith").like(partOne + "Smith");
ReadAllQuery raq = new ReadAllQuery();
raq.setReferenceClass(Employee.class);
raq.setSelectionCriteria(whereClause);
Vector employees = (Vector) getSession().executeQuery(raq);
ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
ejbqlString = ejbqlString + "CONCAT(emp.firstName,\"Smith\") LIKE ";
ejbqlString = ejbqlString + "\"" + partOne + "Smith\"";
setEjbqlString(ejbqlString);
setOriginalOject(employees);
super.setup();
}
/**
* Return the first employee that has a long enough name for the test. If no match is found throw
* a warning exception. See bug 223005
*
* @param vectorOfEmployees
* @param minFirstNameLength
* @param testName
* @return
*/
public Employee getEmployeeWithRequiredNameLength(
Vector vectorOfEmployees, int minFirstNameLength, String testName) {
Employee empMatch = null;
Vector<Employee> employees = vectorOfEmployees;
String firstName;
StringBuffer partialFirstName;
// Loop through the collection of employees to find one that matches our test requirements
for (int i = 0; i < employees.size(); i++) {
empMatch = employees.get(i);
firstName = empMatch.getFirstName();
// Verify length criteria
if (firstName.length() >= minFirstNameLength) {
// exit the for loop - return the last empMatch
i = employees.size();
}
}
// If we could not find a proper employee for testing - throw a warning
if (null == empMatch) {
throw new RuntimeException(
testName
+ " Setup Failed: unable to find an Employee with firstName size of at least "
+ minFirstNameLength);
} else {
return empMatch;
}
}
@OnEvent(NEW_HIRE_CHANNEL)
public void invite(final Employee employee) {
System.out.printf(
"Employee will be invited to the community outreach program %s %d\n",
employee.getFirstName(), employee.getEmployeeId());
}
public static TestSuite getReadObjectTestSuite() {
TestSuite suite = new TestSuite();
suite.setName("EmployeeReadObjectTestSuite");
suite.setDescription("This suite test the reading of each object in the employee demo.");
Class employeeClass = Employee.class;
PopulationManager manager = PopulationManager.getDefaultManager();
suite.addTest(new ReadObjectTest(manager.getObject(employeeClass, "0001")));
suite.addTest(new ReadObjectTest(manager.getObject(employeeClass, "0002")));
suite.addTest(new ReadObjectTest(manager.getObject(employeeClass, "0003")));
suite.addTest(new ReadObjectTest(manager.getObject(employeeClass, "0004")));
suite.addTest(new ReadObjectTest(manager.getObject(employeeClass, "0005")));
Employee employee = (Employee) manager.getObject(employeeClass, "0001");
suite.addTest(
new ReadObjectCallTest(
employeeClass,
new SQLCall(
"SELECT VERSION, EMP_ID, L_NAME, F_NAME FROM UNIDIR_EMPLOYEE WHERE F_NAME = '"
+ employee.getFirstName()
+ "' AND L_NAME = '"
+ employee.getLastName()
+ "'")));
employee = (Employee) manager.getObject(employeeClass, "0002");
suite.addTest(
new ReadObjectCallTest(
employeeClass,
new SQLCall(
"SELECT VERSION, EMP_ID, L_NAME, F_NAME FROM UNIDIR_EMPLOYEE WHERE F_NAME = '"
+ employee.getFirstName()
+ "' AND L_NAME = '"
+ employee.getLastName()
+ "'")));
employee = (Employee) manager.getObject(employeeClass, "0003");
suite.addTest(
new ReadObjectCallTest(
employeeClass,
new SQLCall(
"SELECT VERSION, EMP_ID, L_NAME, F_NAME FROM UNIDIR_EMPLOYEE WHERE F_NAME = '"
+ employee.getFirstName()
+ "' AND L_NAME = '"
+ employee.getLastName()
+ "'")));
return suite;
}
public static void employeeLogin(Employee employee) {
Entity loginEntity = new Entity("Login", employee.getEmployeeId());
loginEntity.setProperty("EmployeeId", employee.getEmployeeId());
loginEntity.setProperty("UserName", employee.getEmail());
loginEntity.setProperty("Password", employee.getFirstName() + 123);
datastore.put(loginEntity);
}
public void test() {
ReadObjectQuery query = new ReadObjectQuery();
query.setReferenceClass(Employee.class);
query.setExampleObject(employee);
query.setQueryByExamplePolicy(policy);
Employee emp = new Employee();
emp = (Employee) getSession().executeQuery(query);
if (!(emp.getFirstName().charAt(0) == 'J')
&& (emp.getFirstName().charAt(3) == 'l')
&& (emp.getLastName().charAt(0) == 'M')) {
throw (new TestErrorException("Error in using specail operators."));
}
if (!(emp.getSalary() < 60000)) {
throw (new TestErrorException("Error is using spcial operators."));
}
}
@Test
public void allowsPostRequestForAdmin() throws Exception {
HttpHeaders headers = new HttpHeaders();
headers.set(HttpHeaders.ACCEPT, MediaTypes.HAL_JSON_VALUE);
headers.set(
HttpHeaders.AUTHORIZATION,
"Basic " + new String(Base64.encode(("ollie:gierke").getBytes())));
mvc.perform(
get("/employees")
. //
headers(headers))
. //
andExpect(content().contentTypeCompatibleWith(MediaTypes.HAL_JSON))
. //
andExpect(status().isOk())
. //
andDo(print());
headers.set(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
String location =
mvc.perform(
post("/employees")
. //
content(PAYLOAD)
. //
headers(headers))
. //
andExpect(status().isCreated())
. //
andDo(print())
. //
andReturn()
.getResponse()
.getHeader(HttpHeaders.LOCATION);
ObjectMapper mapper = new ObjectMapper();
String content =
mvc.perform(get(location))
. //
andReturn()
.getResponse()
.getContentAsString();
Employee employee = mapper.readValue(content, Employee.class);
assertThat(employee.getFirstName(), is("Saruman"));
assertThat(employee.getLastName(), is("the White"));
assertThat(employee.getTitle(), is("Wizard"));
}
public boolean equals(Object object) {
if (!(object instanceof Employee)) return false;
Employee employeeObject = (Employee) object;
if (this.getProject() == null && employeeObject.getProject() != null) {
return false;
}
if ((this.getFirstName().equals(employeeObject.getFirstName()))
&& ((this.getProject() == null && employeeObject.getProject() == null)
|| (this.getProject().equals(employeeObject.getProject())))) return true;
return false;
}
public void setup() {
if ((getSession().getLogin().getPlatform().isSQLServer())) {
throw new TestWarningException(
"This test is not supported on SQL Server. Because 'LENGTH' is not a recognized function name on SQL Server.");
}
Employee emp = (Employee) getSomeEmployees().firstElement();
String ejbqlString;
ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
ejbqlString = ejbqlString + emp.getFirstName().length();
ejbqlString = ejbqlString + " = LENGTH(emp.firstName)";
setEjbqlString(ejbqlString);
setOriginalOject(emp);
super.setup();
}
public static void main(String[] args) throws Exception {
ArrayList<Employee> emplyoeesList = new ArrayList();
BasePlusCommissionEmployee basePlusCommEmp =
new BasePlusCommissionEmployee("BasePlusCommission", "Employee", "11111", 1000, 0.5, 5000);
basePlusCommEmp.setBirthDate(01, 1, 1991);
// You can check date validation
// basePlusCommEmp.setBirthDate(01, 1, 1991);
emplyoeesList.add(basePlusCommEmp);
CommissionEmployee commEmp =
new BasePlusCommissionEmployee("Excellent", "commEmp", "22222", 2000, 0.7, 7000);
commEmp.setBirthDate(02, 02, 1992);
emplyoeesList.add(commEmp);
HourlyEmployee hourEmp = new HourlyEmployee("Good", "hourEmp", "33333", 25, 160);
emplyoeesList.add(hourEmp);
hourEmp.setBirthDate(03, 03, 1993);
SalariedEmployee salEmp = new SalariedEmployee("best", "salEmp", "44444", 10000);
salEmp.setBirthDate(04, 4, 1994);
emplyoeesList.add(salEmp);
PieceWorker pwEmp = new PieceWorker("nice", "pwEmp", "55555", 1.5, 1000);
pwEmp.setBirthDate(05, 11, 55);
emplyoeesList.add(pwEmp);
for (Employee emp : emplyoeesList) {
if (emp.hasBirthdayThisMonth()) {
System.out.println(
"\nEmployee: "
+ "'"
+ emp.getFirstName()
+ " ,"
+ emp.getLastName()
+ "'"
+ " has birthday this month!\n"
+ emp.getBirthDate()
+ "\nTherefore additional 200$ were added to earnings.\n");
System.out.println(emp + "\n" + "earnings: $" + (emp.earnings() + 200) + "\n");
} else System.out.println(emp + "\n" + "earnings: $" + emp.earnings() + "\n");
}
}
/* Method to READ all the employees */
public void listEmployees() {
Session session = factory.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
List employees = session.createQuery("FROM Employee").list();
for (Iterator iterator = employees.iterator(); iterator.hasNext(); ) {
Employee employee = (Employee) iterator.next();
System.out.print("First Name: " + employee.getFirstName());
System.out.print(" Last Name: " + employee.getLastName());
System.out.println(" Salary: " + employee.getSalary());
}
tx.commit();
} catch (HibernateException e) {
if (tx != null) tx.rollback();
e.printStackTrace();
} finally {
session.close();
}
}
public void test() {
UnitOfWork uow = getSession().acquireUnitOfWork();
employee = (Employee) uow.readObject(Employee.class);
originalReadTime =
((AbstractSession) getSession())
.getIdentityMapAccessorInstance()
.getCacheKeyForObject(employee)
.getReadTime();
employee.setFirstName(employee.getFirstName() + "-mutated");
try {
Thread.sleep(100);
} catch (InterruptedException exc) {
}
uow.commit();
secondReadTime =
getAbstractSession()
.getIdentityMapAccessorInstance()
.getCacheKeyForObject(employee)
.getReadTime();
}
private void createEmployeeAndSearchExpression() {
// Create the example employee
employee =
(org.eclipse.persistence.testing.models.employee.domain.Employee)
new org.eclipse.persistence.testing.models.employee.domain.EmployeePopulator()
.basicEmployeeExample1();
employee.setFirstName("Timugen");
employee.setLastName("Singaera");
employee.addResponsibility("Answer the phones.");
// Create an expression to retreive the employee from the database
ExpressionBuilder expressionBuilder = new ExpressionBuilder();
Expression exp1;
Expression exp2;
Expression expression;
exp1 = expressionBuilder.get("firstName").equal(employee.getFirstName());
exp2 = expressionBuilder.get("lastName").equal(employee.getLastName());
searchExpression = exp1.or(exp2);
}
public void setup() {
Employee emp = (Employee) getSomeEmployees().firstElement();
PhoneNumber phone = (PhoneNumber) emp.getPhoneNumbers().firstElement();
String areaCode = phone.getAreaCode();
String firstName = emp.getFirstName();
setReferenceClass(Employee.class);
ExpressionBuilder employeeBuilder = new ExpressionBuilder();
Expression phones = employeeBuilder.anyOf("phoneNumbers");
Expression whereClause =
phones
.get("owner")
.get("firstName")
.equal(firstName)
.and(phones.get("areaCode").equal(areaCode));
ReportQuery rq = new ReportQuery();
rq.setSelectionCriteria(whereClause);
rq.addAttribute("number", phones.get("number"));
rq.setReferenceClass(Employee.class);
setOriginalOject(getAttributeFromAll("number", (Vector) getSession().executeQuery(rq)));
getSession().getIdentityMapAccessor().initializeAllIdentityMaps();
String ejbqlString;
ejbqlString =
"SELECT phone.number FROM Employee employee, IN(employee.phoneNumbers) phone "
+ "WHERE phone.owner.firstName = \""
+ firstName
+ "\" AND phone.areaCode = \""
+ areaCode
+ "\"";
useReportQuery();
setEjbqlString(ejbqlString);
super.setup();
}
public void setup() {
// Get the baseline employees for the verify
Employee emp = (Employee) getSomeEmployees().firstElement();
String parameterName = "firstName";
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = builder.get("firstName").equal(builder.getParameter(parameterName));
ReadAllQuery raq = new ReadAllQuery();
raq.setReferenceClass(Employee.class);
raq.setSelectionCriteria(whereClause);
raq.addArgument(parameterName);
Vector parameters = new Vector();
parameters.add(emp.getFirstName());
Vector employees = (Vector) getSession().executeQuery(raq, parameters);
emp = (Employee) employees.firstElement();
// Set up the EJBQL using the retrieved employees
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
ejbqlString = ejbqlString + "?1 = emp.firstName ";
setEjbqlString(ejbqlString);
setOriginalOject(employees);
setArguments(parameters);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
setArgumentNames(myArgumentNames);
// Finish the setup
super.setup();
}
public static void main(String[] args) {
String csvFile = "C:/devel/EmployeeList.csv";
List<Employee> jobs = new ArrayList<Employee>();
ReadEmployeeList read = new ReadEmployeeList();
read.readCSV(csvFile, jobs);
try {
for (Employee job : jobs) {
String fullName = job.getFirstName() + " " + job.getLastName();
String payperiod = read.calcPayPeriod(job.getMonth());
int grossIncome = read.calcGrossIncome(job.getAnnualSalary());
int netIncome =
(int)
(read.calcGrossIncome(job.getAnnualSalary())
- read.calcIncomeTax(job.getAnnualSalary()));
int incomeTaxAmount = (int) read.calcIncomeTax(job.getAnnualSalary());
System.out.println("Payslip information for Employee is:");
System.out.println(
fullName
+ ","
+ payperiod
+ ","
+ grossIncome
+ ","
+ incomeTaxAmount
+ ","
+ netIncome
+ ","
+ read.calcSuper(grossIncome, job.getSuperRate()));
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Employee[] empList = new Employee[6]; // 2 salray, 2 hourly, 2 bonus
// populate salary emps
SalariedEmployee s1 = new SalariedEmployee("Helena", "Handbasket", "Theatre Manager");
s1.setEmpType('S');
s1.setPayFrequency('S');
s1.setAnnualSalary(75000.00);
empList[0] = s1;
SalariedEmployee s2 = new SalariedEmployee("Rayne", "Bow", "Lighting Manager");
s2.setEmpType('S');
s2.setPayFrequency('S');
s2.setAnnualSalary(100000.00);
empList[1] = s2;
// populate hourly emps
HourlyEmployee h1 = new HourlyEmployee("Leah", "Tard", "Dancer");
h1.setHourlyRate(20.00);
h1.setHoursWorked(100.0);
empList[2] = h1;
HourlyEmployee h2 = new HourlyEmployee("Cat", "Arwall", "Singer");
h2.setHourlyRate(22.00);
h2.setHoursWorked(80.0);
empList[3] = h2;
// populate salary plus bonus emps
SalaryPlusBonusEmployee b1 = new SalaryPlusBonusEmployee("Bob", "Fosse", "Choreographer");
b1.setEmpType('B');
b1.setPayFrequency('S');
b1.setAnnualSalary(200000.00);
b1.setPayoutBonus(true);
b1.setBonusAmt(3000.00);
empList[4] = b1;
SalaryPlusBonusEmployee b2 = new SalaryPlusBonusEmployee("Ima", "Good", "Artistic Director");
b2.setEmpType('B');
b2.setPayFrequency('M');
b2.setAnnualSalary(150000.00);
b2.setPayoutBonus(false);
empList[5] = b2;
DecimalFormat dollar = new DecimalFormat("#,##0.00");
char freqInd;
String payFreq;
for (Employee emps : empList) {
System.out.println("--------------------------------------");
System.out.println("Name: " + emps.getLastName() + ", " + emps.getFirstName());
System.out.println("Job Title: " + emps.getJobTitle());
freqInd = emps.getPayFrequency();
switch (freqInd) {
case 'S':
payFreq = "SEMI-MONTHLY";
break;
case 'M':
payFreq = "MONTHLY";
break;
case 'B':
default:
payFreq = "BIWEEKLY";
}
System.out.println("Employee is paid " + payFreq);
if (emps instanceof SalaryPlusBonusEmployee) {
System.out.println("Employee is SALARY + BONUS");
SalaryPlusBonusEmployee empBon = (SalaryPlusBonusEmployee) emps;
System.out.println("Annual Salary: $" + dollar.format(empBon.getAnnualSalary()));
System.out.println("Bonus Amount: $" + dollar.format(empBon.getBonusAmt()));
System.out.println("Pay Period Amount: $" + dollar.format(empBon.calcPeriodPay()));
} else if (emps instanceof SalariedEmployee) {
System.out.println("Employee is SALARIED");
SalariedEmployee empSal = (SalariedEmployee) emps;
System.out.println("Annual Salary: $" + dollar.format(empSal.getAnnualSalary()));
System.out.println("Pay Period Amount: $" + dollar.format(empSal.calcPeriodPay()));
} else if (emps instanceof HourlyEmployee) {
System.out.println("Employee is HOURLY");
HourlyEmployee empHour = (HourlyEmployee) emps;
System.out.println("Hourly Rate: " + dollar.format(empHour.getHourlyRate()));
System.out.println("Hours Worked: " + empHour.getHoursWorked());
System.out.println("Pay Period Amount: $" + dollar.format(empHour.calcPeriodPay()));
}
}
}
public void testTwoUnrelatedResultWithOneToOneJoinsWithExtraItem() {
if (getServerSession("fieldaccess").getPlatform().isSymfoware()) {
getServerSession("fieldaccess")
.logMessage(
"Test testTwoUnrelatedResultWithOneToOneJoinsWithExtraItem skipped for this platform, "
+ "Symfoware doesn't support UpdateAll/DeleteAll on multi-table objects (see rfe 298193).");
return;
}
ReadAllQuery raq = new ReadAllQuery(Employee.class);
raq.setSelectionCriteria(
raq.getExpressionBuilder()
.get("lastName")
.equal("Way")
.or(raq.getExpressionBuilder().get("lastName").equal("Jones")));
Employee emp = (Employee) ((Vector) getDbSession().executeQuery(raq)).firstElement();
emp.getAddress();
raq = new ReadAllQuery(Address.class);
raq.setSelectionCriteria(raq.getExpressionBuilder().get("city").like("%ttawa%"));
Address addr = (Address) ((Vector) getDbSession().executeQuery(raq)).firstElement();
addr.getEmployees();
for (Iterator iterator = addr.getEmployees().iterator(); iterator.hasNext(); ) {
((Employee) iterator.next()).getAddress();
}
getDbSession().getIdentityMapAccessor().initializeAllIdentityMaps();
ReportQuery query = new ReportQuery();
query.setShouldReturnWithoutReportQueryResult(true);
query.setReferenceClass(Employee.class);
ExpressionBuilder eb = new ExpressionBuilder(Address.class);
query.setSelectionCriteria(
query
.getExpressionBuilder()
.get("id")
.equal(emp.getId())
.and(eb.get("id").equal(addr.getId())));
List list = new ArrayList();
list.add(query.getExpressionBuilder().get("address"));
query.addItem("employee", query.getExpressionBuilder(), list);
query.addItem("employee_name", query.getExpressionBuilder().get("firstName"));
list = new ArrayList();
list.add(eb.anyOf("employees"));
query.addItem("address", eb, list);
Vector result = (Vector) getDbSession().executeQuery(query);
UpdateAllQuery updall = new UpdateAllQuery(Employee.class);
updall.addUpdate("address", null);
updall.setSelectionCriteria(updall.getExpressionBuilder().get("id").equal(emp.getId()));
UnitOfWork uow = getDbSession().acquireUnitOfWork();
uow.executeQuery(updall);
updall = new UpdateAllQuery(Employee.class);
updall.addUpdate("address", null);
updall.setSelectionCriteria(
updall.getExpressionBuilder().get("address").get("id").equal(addr.getId()));
uow.executeQuery(updall);
uow.commit();
Employee emp2 = (Employee) ((Object[]) result.firstElement())[0];
Address addr2 = (Address) ((Object[]) result.firstElement())[2];
try {
assertTrue(
"Address were not joined correctly, emp.getAddress() = null",
(emp2.getAddress() != null));
assertTrue(
"Employees were not joined correctly, addr.employees.size = "
+ addr.getEmployees().size()
+ "addr2.employees.size = "
+ addr2.getEmployees().size(),
(addr.getEmployees().size() == addr2.getEmployees().size()));
if (!emp2.getFirstName().equals(((Object[]) result.firstElement())[1])) {
fail("Failed to return employee name as an separate item");
}
} finally {
testSetup();
}
}
@Override
public int compare(Employee o1, Employee o2) {
return (o1.getFirstName()).compareTo(o2.getFirstName());
}
@Override
public int compare(Employee e1, Employee e2) {
return ((e1.getFirstName())).compareTo(e2.getFirstName());
}
@Override
public void salaryChanged(Employee employee, int newSalary) {
System.out.printf(
"DIRECT FROM CHANNEL SalaryChangedChannel Employee added to payroll %s %d %d\n",
employee.getFirstName(), employee.getEmployeeId(), newSalary);
}
