/*
* The Kuali Financial System, a comprehensive financial management system for higher education.
*
* Copyright 2005-2014 The Kuali Foundation
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.kuali.kfs.sys;
import java.text.Collator;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import junit.framework.TestCase;
import org.apache.commons.beanutils.PropertyUtils;
import org.kuali.kfs.coa.businessobject.Account;
import org.kuali.kfs.sys.DynamicCollectionComparator.SortOrder;
import org.kuali.kfs.sys.fixture.AccountFixture;
public class DynamicCollectionComparatorTest extends TestCase {
// the default sort order is ascending
public void testSort_DefaultOrder() throws Exception {
List<Account> accounts = this.getAccounts();
String[] fieldNames = { KFSPropertyConstants.CHART_OF_ACCOUNTS_CODE };
DynamicCollectionComparator.sort(accounts, fieldNames);
assertTrue(this.isSortedByAscendingOrder(accounts, KFSPropertyConstants.CHART_OF_ACCOUNTS_CODE));
}
// test if the given list of objects can be sorted by ascending order
public void testSort_Ascending() throws Exception {
List<Account> accounts = this.getAccounts();
String[] fieldNames = { KFSPropertyConstants.CHART_OF_ACCOUNTS_CODE };
DynamicCollectionComparator.sort(accounts, SortOrder.ASC, fieldNames);
assertTrue(this.isSortedByAscendingOrder(accounts, KFSPropertyConstants.CHART_OF_ACCOUNTS_CODE));
}
// test if the given list of objects can be sorted by descending order
public void testSort_Descending() throws Exception {
List<Account> accounts = this.getAccounts();
String[] fieldNames = { KFSPropertyConstants.CHART_OF_ACCOUNTS_CODE };
DynamicCollectionComparator.sort(accounts, SortOrder.DESC, fieldNames);
assertTrue(this.isSortedByDescendingOrder(accounts, KFSPropertyConstants.CHART_OF_ACCOUNTS_CODE));
}
// test if the given list of objects can be sorted by ascending order
public void testSort_ByMultipleFields_Ascending() throws Exception {
List<Account> accounts = this.getAccounts();
String[] fieldNames = { KFSPropertyConstants.CHART_OF_ACCOUNTS_CODE, KFSPropertyConstants.ACCOUNT_NUMBER };
DynamicCollectionComparator.sort(accounts, SortOrder.ASC, fieldNames);
Map<String, List<Account>> accountMap = this.groupAccounts(accounts);
for (String key : accountMap.keySet()) {
assertTrue(this.isSortedByAscendingOrder(accountMap.get(key), KFSPropertyConstants.ACCOUNT_NUMBER));
}
}
// test if the given list of objects can be sorted by descending order
public void testSort_ByMultipleFields_Descending() throws Exception {
List<Account> accounts = this.getAccounts();
String[] fieldNames = { KFSPropertyConstants.CHART_OF_ACCOUNTS_CODE, KFSPropertyConstants.ACCOUNT_NUMBER };
DynamicCollectionComparator.sort(accounts, SortOrder.DESC, fieldNames);
Map<String, List<Account>> accountMap = this.groupAccounts(accounts);
for (String key : accountMap.keySet()) {
assertTrue(this.isSortedByDescendingOrder(accountMap.get(key), KFSPropertyConstants.ACCOUNT_NUMBER));
}
}
// create a list of accounts that will be posted in report
private List<Account> getAccounts() {
List<Account> accounts = new ArrayList<Account>();
for (AccountFixture account : AccountFixture.values()) {
accounts.add(account.createAccount());
}
return accounts;
}
// group the given accounts with chart accounts code
private Map<String, List<Account>> groupAccounts(List<Account> accounts) {
Map<String, List<Account>> accountMap = new HashMap<String, List<Account>>();
for (Account account : accounts) {
String chartOfAccountsCode = account.getChartOfAccountsCode();
if (accountMap.containsKey(chartOfAccountsCode)) {
List<Account> accountList = accountMap.get(chartOfAccountsCode);
accountList.add(account);
}
else {
List<Account> accountList = new ArrayList<Account>();
accountList.add(account);
accountMap.put(chartOfAccountsCode, accountList);
}
}
return accountMap;
}
// determine whether the given object list has been sorted by the specified field by ascending order
private <T> boolean isSortedByAscendingOrder(List<T> objectList, String fieldName) throws Exception {
Collator collator = Collator.getInstance();
Object tempValue = null;
for (T object : objectList) {
Object fieldValue = PropertyUtils.getProperty(object, fieldName);
if (tempValue == null || collator.compare(tempValue, fieldValue) <= 0) {
tempValue = fieldValue;
}
else {
return false;
}
}
return true;
}
// determine whether the given object list has been sorted by the specified field by ascending order
private <T> boolean isSortedByDescendingOrder(List<T> objectList, String fieldName) throws Exception {
Collator collator = Collator.getInstance();
Object tempValue = null;
int count = 0;
for (T object : objectList) {
Object fieldValue = PropertyUtils.getProperty(object, fieldName);
if (count == 0) {
tempValue = fieldValue;
count++;
}
else if (tempValue == null && fieldValue == null) {
tempValue = fieldValue;
}
else if (tempValue == null) {
return false;
}
else if (fieldValue == null) {
tempValue = fieldValue;
}
else if (collator.compare(tempValue, fieldValue) >= 0) {
tempValue = fieldValue;
}
else {
return false;
}
}
return true;
}
}