/*
* This is a common dao with basic CRUD operations and is not limited to any
* persistent layer implementation
*
* Copyright (C) 2008 Imran M Yousuf (imyousuf@smartitengineering.com)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
* This library 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
* Lesser General Public License for more details.
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
package com.smartitengineering.dao.impl.hibernate;
import com.smartitengineering.dao.common.queryparam.FetchMode;
import com.smartitengineering.dao.common.queryparam.MatchMode;
import com.smartitengineering.dao.common.queryparam.Order;
import com.smartitengineering.dao.common.queryparam.QueryParameter;
import com.smartitengineering.dao.common.queryparam.QueryParameterFactory;
import com.smartitengineering.dao.common.queryparam.QueryParameterWithPropertyName;
import com.smartitengineering.dao.impl.hibernate.domain.Author;
import com.smartitengineering.dao.impl.hibernate.domain.Book;
import com.smartitengineering.dao.impl.hibernate.domain.Publisher;
import com.smartitengineering.domain.PersistentDTO;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
*
* @author imyousuf
*/
public class AbstractDAOTest
extends TestCase {
private static ApplicationContext context;
public AbstractDAOTest(String testName) {
super(testName);
}
@Override
protected void setUp()
throws Exception {
super.setUp();
if (context == null) {
context = new ClassPathXmlApplicationContext("app-context.xml");
}
}
@Override
protected void tearDown()
throws Exception {
super.tearDown();
}
/**
* Test of createEntity method, of class AbstractDAO.
*/
public void testCreateEntity() {
System.out.println("createEntity");
AbstractDAO<Book> bookInstance = getDaoInstance();
AbstractDAO<Author> authorInstance = getDaoInstance();
AbstractDAO<Publisher> publisherInstance = getDaoInstance();
/**
* Test null object creation, should throw IllegalArgumentException
*/
try {
bookInstance.createEntity((Book) null);
fail("Should not proceed with saving NULL entity!");
}
catch (IllegalArgumentException argumentException) {
}
catch (Exception exception) {
fail(exception.getMessage());
}
/**
* Create proper test data.
* This set will contain single of everything - author, publisher, book
*/
Publisher shebaProkashani = getShebaProkashani();
try {
publisherInstance.createEntity(shebaProkashani);
System.out.println(shebaProkashani.getId());
}
catch (Exception ex) {
fail(ex.getMessage());
}
Author kaziAnowarHossain = getKaziAnowarHossain();
try {
authorInstance.createEntity(kaziAnowarHossain);
System.out.println(kaziAnowarHossain.getId());
}
catch (Exception ex) {
fail(ex.getMessage());
}
Book book = getAgniSopoth(kaziAnowarHossain, shebaProkashani);
try {
bookInstance.createEntity(book);
System.out.println(book.getId());
}
catch (Exception ex) {
fail(ex.getMessage());
}
/**
* Create multiple publications at once.
* One of the publications should have more than one book
*/
Publisher oReilly = getOReilly();
Publisher annoProkash = getAnnoProkash();
try {
publisherInstance.createEntity(oReilly, annoProkash);
System.out.println(oReilly.getId() + ", " + annoProkash.getId());
}
catch (Exception ex) {
fail(ex.getMessage());
}
/**
* Create multiple authors at once.
* There should be at least one book with multiple authors.
* A single author (set) should have multiple books.
*/
Author brettMcLaugblin = getBrett();
Author davidLane = getDavidLane();
Author hughWilliams = getHughWilliams();
Author humayunAhmed = getHumayunAhmed();
try {
authorInstance.createEntity(brettMcLaugblin, davidLane, humayunAhmed,
hughWilliams);
System.out.println(brettMcLaugblin.getId() + ", " +
davidLane.getId() + ", " + humayunAhmed.getId() + ", " +
hughWilliams.getId());
}
catch (Exception ex) {
fail(ex.getMessage());
}
Book kothaoKeoNei = getKothaoKeoNei(annoProkash, humayunAhmed);
Book agunerPoroshMoni = getAgunerPoroshMoni(annoProkash, humayunAhmed);
Book webDbApp = getWebDbApp(oReilly, davidLane, hughWilliams);
Book javaAndXml = getJavaAndXml(oReilly, brettMcLaugblin);
try {
bookInstance.createEntity(kothaoKeoNei, agunerPoroshMoni, webDbApp,
javaAndXml);
System.out.println(kothaoKeoNei.getId() + ", " +
agunerPoroshMoni.getId() + ", " + webDbApp.getId() + ", " +
javaAndXml.getId());
}
catch (Exception ex) {
fail(ex.getMessage());
}
}
public void testGetAll() {
System.out.println("getAll");
/**
* Add test for read all
*/
AbstractDAO<Book> bookInstance = getDaoInstance();
Set<Book> allBooks = getAll(bookInstance, Book.class);
assertTrue(5 <= allBooks.size());
AbstractDAO<Author> authorInstance = getDaoInstance();
Set<Author> allAuthors = getAll(authorInstance, Author.class);
assertTrue(5 <= allAuthors.size());
AbstractDAO<Publisher> publisherInstance = getDaoInstance();
Set<Publisher> allPublishers =
getAll(publisherInstance, Publisher.class);
assertTrue(3 <= allPublishers.size());
Map<String, Integer> bookNameToIdMap = new HashMap<String, Integer>();
Map<String, Integer> publisherNameToIdMap =
new HashMap<String, Integer>();
Map<String, Integer> authorNameToIdMap = new HashMap<String, Integer>();
makeNameToIdMap(bookNameToIdMap, bookInstance, authorNameToIdMap,
authorInstance, publisherNameToIdMap, publisherInstance);
/**
* Update one book at a time
*/
{
QueryParameter<Integer> idInParam = getIdInParam(
bookNameToIdMap);
List<Book> books = new ArrayList<Book>(new HashSet<Book>(
bookInstance.readList(Book.class, idInParam)));
List<String> names = new ArrayList<String>(bookNameToIdMap.keySet());
for (Book book : books) {
names.remove(book.getName());
}
assertEmpty(names);
}
/**
* Update all publisher at once
*/
{
QueryParameter<Integer> idInParam = getIdInParam(
publisherNameToIdMap);
List<Publisher> publishers = new ArrayList<Publisher>(
new HashSet<Publisher>(publisherInstance.readList(
Publisher.class, idInParam)));
List<String> names = new ArrayList<String>(publisherNameToIdMap.
keySet());
for (Publisher publisher : publishers) {
names.remove(publisher.getName());
}
assertEmpty(names);
}
/**
* Update all author at once
*/
{
QueryParameter<Integer> idInParam = getIdInParam(
authorNameToIdMap);
List<Author> authors = new ArrayList<Author>(new HashSet<Author>(
authorInstance.readList(Author.class, idInParam)));
List<String> names = new ArrayList<String>(
authorNameToIdMap.keySet());
for (Author author : authors) {
names.remove(author.getName());
}
assertEmpty(names);
}
}
/**
* Test of readSingle method, of class AbstractDAO.
*/
public void testReadSingle_Class_QueryParameterArr() {
System.out.println("readSingleArgs");
performTestReadSingle(MethodInvocationType.VAR_ARGS);
}
/**
* Test of readSingle method, of class AbstractDAO.
*/
public void testReadSingle_Class_Hashtable() {
System.out.println("readSingleHashTable");
performTestReadSingle(MethodInvocationType.HASH_TABLE);
}
/**
* Test of readSingle method, of class AbstractDAO.
*/
public void testReadSingle_Class_List() {
System.out.println("readSingleList");
performTestReadSingle(MethodInvocationType.LIST);
}
/**
* Test of readOther method, of class AbstractDAO.
*/
public void testReadOther_Class_QueryParameterArr() {
System.out.println("readOtherVarArgs");
performTestReadOtherSingle(MethodInvocationType.VAR_ARGS);
}
/**
* Test of readOther method, of class AbstractDAO.
*/
public void testReadOther_Class_Hashtable() {
System.out.println("readOtherHashtable");
performTestReadOtherSingle(MethodInvocationType.HASH_TABLE);
}
/**
* Test of readOther method, of class AbstractDAO.
*/
public void testReadOther_Class_List() {
System.out.println("readOther_List");
performTestReadOtherSingle(MethodInvocationType.LIST);
}
/**
* Test of readOtherList method, of class AbstractDAO.
*/
public void testReadOtherList_Class_QueryParameterArr() {
System.out.println("readOtherListVarArgs");
performTestReadOtherList(MethodInvocationType.VAR_ARGS);
}
/**
* Test of readOtherList method, of class AbstractDAO.
*/
public void testReadOtherList_Class_Hashtable() {
System.out.println("readOtherListHashtable");
performTestReadOtherList(MethodInvocationType.HASH_TABLE);
}
/**
* Test of readOtherList method, of class AbstractDAO.
*/
public void testReadOtherList_Class_List() {
System.out.println("readOtherList_List");
performTestReadOtherList(MethodInvocationType.LIST);
}
/**
* Test of updateEntity method, of class AbstractDAO.
*/
public void testUpdateEntity() {
System.out.println("updateEntity");
AbstractDAO<Book> bookInstance = getDaoInstance();
AbstractDAO<Author> authorInstance = getDaoInstance();
AbstractDAO<Publisher> publisherInstance = getDaoInstance();
Map<String, Integer> bookNameToIdMap = new HashMap<String, Integer>();
Map<String, Integer> publisherNameToIdMap =
new HashMap<String, Integer>();
Map<String, Integer> authorNameToIdMap = new HashMap<String, Integer>();
makeNameToIdMap(bookNameToIdMap, bookInstance, authorNameToIdMap,
authorInstance, publisherNameToIdMap, publisherInstance);
/**
* Update one book at a time
*/
{
QueryParameter<Integer> idInParam = getIdInParam(
bookNameToIdMap);
List<Book> books = new ArrayList<Book>(new HashSet<Book>(
bookInstance.readList(Book.class, idInParam)));
Collections.sort(books);
Calendar calendar = getBookFirstPubCal();
for (Book book : books) {
book.setPublishDate(calendar.getTime());
bookInstance.updateEntity(book);
QueryParameter parameter = getIdQueryParam(book.getId());
Book updatedBook =
bookInstance.readSingle(Book.class, parameter);
assertEquals(book.getPublishDate(), updatedBook.getPublishDate());
calendar.add(Calendar.MONTH, 1);
}
}
/**
* Update all publisher at once
*/
{
QueryParameter<Integer> idInParam = getIdInParam(
publisherNameToIdMap);
List<Publisher> publishers = new ArrayList<Publisher>(
new HashSet<Publisher>(publisherInstance.readList(
Publisher.class, idInParam)));
Collections.sort(publishers);
Calendar calendar = getPubFirstEstCal();
for (Publisher publisher : publishers) {
publisher.setEstablishedDate(calendar.getTime());
calendar.add(Calendar.MONTH, 1);
}
publisherInstance.updateEntity(publishers.toArray(new Publisher[]{}));
for (Publisher publisher : publishers) {
QueryParameter parameter = getIdQueryParam(publisher.getId());
Publisher updatedPublisher = publisherInstance.readSingle(
Publisher.class, parameter);
assertEquals(publisher.getEstablishedDate(), updatedPublisher.
getEstablishedDate());
}
}
/**
* Update all author at once
*/
{
QueryParameter<Integer> idInParam = getIdInParam(
authorNameToIdMap);
List<Author> authors = new ArrayList<Author>(new HashSet<Author>(
authorInstance.readList(Author.class, idInParam)));
Collections.sort(authors);
Calendar calendar = getAuthorFirstBirthCal();
for (Author author : authors) {
author.setBirthDate(calendar.getTime());
calendar.add(Calendar.MONTH, 1);
}
authorInstance.updateEntity(authors.toArray(new Author[]{}));
for (Author author : authors) {
QueryParameter parameter = getIdQueryParam(author.getId());
Author updatedAuthor = authorInstance.readSingle(Author.class,
parameter);
assertEquals(author.getBirthDate(), updatedAuthor.getBirthDate());
}
}
}
/**
* Test of readList method, of class AbstractDAO.
*/
public void testReadList_Class_QueryParameterArr() {
System.out.println("readList");
performTestReadList(MethodInvocationType.VAR_ARGS);
}
/**
* Test of readList method, of class AbstractDAO.
*/
public void testReadList_Class_Hashtable() {
System.out.println("readList");
performTestReadList(MethodInvocationType.HASH_TABLE);
}
/**
* Test of readList method, of class AbstractDAO.
*/
public void testReadList_Class_List() {
System.out.println("readList");
performTestReadList(MethodInvocationType.LIST);
}
/**
* Test of deleteEntity method, of class AbstractDAO.
*/
public void testDeleteEntity() {
System.out.println("deleteEntity");
AbstractDAO<Book> bookInstance = getDaoInstance();
AbstractDAO<Author> authorInstance = getDaoInstance();
AbstractDAO<Publisher> publisherInstance = getDaoInstance();
Map<String, Integer> bookNameToIdMap = new HashMap<String, Integer>();
Map<String, Integer> publisherNameToIdMap =
new HashMap<String, Integer>();
Map<String, Integer> authorNameToIdMap = new HashMap<String, Integer>();
makeNameToIdMap(bookNameToIdMap, bookInstance, authorNameToIdMap,
authorInstance, publisherNameToIdMap, publisherInstance);
/**
* Delete one book at a time
*/
{
QueryParameter<Integer> idInParam = getIdInParam(
bookNameToIdMap);
Set<Book> books = new HashSet<Book>(
bookInstance.readList(Book.class, idInParam));
for (Book book : books) {
bookInstance.deleteEntity(book);
}
assertEmpty(bookInstance.readList(Book.class, idInParam));
}
/**
* Delete all publisher at once
*/
{
QueryParameter<Integer> idInParam = getIdInParam(
publisherNameToIdMap);
Set<Publisher> publishers = new HashSet<Publisher>(
publisherInstance.readList(Publisher.class, idInParam));
publisherInstance.deleteEntity(publishers.toArray(new Publisher[]{}));
assertEmpty(publisherInstance.readList(Publisher.class, idInParam));
}
/**
* Delete all author at once
*/
{
QueryParameter<Integer> idInParam = getIdInParam(
authorNameToIdMap);
Set<Author> authors = new HashSet<Author>(
authorInstance.readList(Author.class, idInParam));
authorInstance.deleteEntity(authors.toArray(new Author[]{}));
assertEmpty(authorInstance.readList(Author.class, idInParam));
}
}
private void assertEmpty(List readList) {
if (readList != null && !readList.isEmpty()) {
throw new AssertionFailedError();
}
}
private Calendar getAuthorFirstBirthCal() {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(0);
calendar.add(Calendar.YEAR, 10);
return calendar;
}
private Calendar getBookFirstPubCal() {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(0);
calendar.add(Calendar.YEAR, 30);
return calendar;
}
private QueryParameter<Date> getDateBetweenParam(final String propName,
final Date startDate,
final Date endDate) {
return QueryParameterFactory.<Date>getBetweenPropertyParam(propName,
startDate, endDate);
}
private QueryParameter<Date> getDateGreaterThanParam(final String propName,
Date startDate) {
return QueryParameterFactory.<Date>getGreaterThanPropertyParam(propName,
startDate);
}
private QueryParameter<Date> getDateLesserThanParam(final String propName,
Date endDate) {
return QueryParameterFactory.<Date>getLesserThanPropertyParam(propName,
endDate);
}
private QueryParameter<Void> getDisjunctionalParam(
QueryParameter... parameters) {
return QueryParameterFactory.getDisjunctionParam(parameters);
}
private QueryParameter<Integer> getFirstResultParam(int startIndex) {
return QueryParameterFactory.getFirstResultParam(startIndex);
}
private QueryParameter<Integer> getGreaterThanEqualIntParam(String idProp,
int authorId) {
return QueryParameterFactory.<Integer>getGreaterThanEqualToPropertyParam(
idProp, authorId);
}
private QueryParameter<Integer> getIdInParam(
Map<String, Integer> bookNameToIdMap) {
return QueryParameterFactory.<Integer>getIsInPropertyParam("id", bookNameToIdMap.values().
toArray(new Integer[0]));
}
private QueryParameter<Integer> getIdNotInParam(
List<Integer> ids) {
return QueryParameterFactory.<Integer>getIsNotInPropertyParam("id", ids.
toArray(new Integer[0]));
}
private QueryParameter<Void> getIsNotNullParam(String propertyName) {
return QueryParameterFactory.getIsNotNullPropertyParam(propertyName);
}
private QueryParameter<Void> getIsNullParam(String propertyName) {
return QueryParameterFactory.getIsNullPropertyParam(propertyName);
}
private QueryParameter<Void> getIsNotEmptyParam(String propertyName) {
return QueryParameterFactory.getIsNotEmptyCollectionPropertyParam(
propertyName);
}
private QueryParameter<Void> getIsEmptyParam(String propertyName) {
return QueryParameterFactory.getIsEmptyCollectionPropertyParam(
propertyName);
}
private QueryParameter<Integer> getLesserThanEqualIntParam(String idProp,
int authorId) {
return QueryParameterFactory.<Integer>getLesserThanEqualToPropertyParam(
idProp, authorId);
}
private QueryParameter<Integer> getMaxResultParam(int max) {
return QueryParameterFactory.getMaxResultsParam(max);
}
private QueryParameter<Integer> getNotEqualIdParam(int id) {
return QueryParameterFactory.<Integer>getNotEqualPropertyParam("id", id);
}
private Calendar getPubFirstEstCal() {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(0);
calendar.add(Calendar.YEAR, 0);
return calendar;
}
private void performTestReadList(MethodInvocationType type) {
AbstractDAO<Book> bookInstance = getDaoInstance();
AbstractDAO<Author> authorInstance = getDaoInstance();
AbstractDAO<Publisher> publisherInstance = getDaoInstance();
Map<String, Integer> bookNameToIdMap = new HashMap<String, Integer>();
Map<String, Integer> publisherNameToIdMap =
new HashMap<String, Integer>();
Map<String, Integer> authorNameToIdMap = new HashMap<String, Integer>();
makeNameToIdMap(bookNameToIdMap, bookInstance, authorNameToIdMap,
authorInstance, publisherNameToIdMap, publisherInstance);
QueryParameter<Integer> idInParam = getIdInParam(
publisherNameToIdMap);
List<Publisher> allPublishers = new ArrayList<Publisher>(
new HashSet<Publisher>(publisherInstance.readList(Publisher.class,
idInParam)));
Collections.sort(allPublishers);
idInParam = getIdInParam(authorNameToIdMap);
List<Author> allAuthors = new ArrayList<Author>(new HashSet<Author>(
authorInstance.readList(Author.class, idInParam)));
Collections.sort(allAuthors);
idInParam = getIdInParam(bookNameToIdMap);
List<Book> allBooks = new ArrayList<Book>(new HashSet<Book>(
bookInstance.readList(Book.class, idInParam)));
Collections.sort(allBooks);
/**
* Test between
*/
{
Calendar calendar = getBookFirstPubCal();
Date startDate = calendar.getTime();
calendar.add(Calendar.MONTH, 2);
Date endDate = calendar.getTime();
final String propName = "publishDate";
QueryParameter<Date> dateBetweenParam =
getDateBetweenParam(propName, startDate, endDate);
QueryParameter<Order> orderParam = getOrderByIdParam(Order.DESC);
List<Book> result;
switch (type) {
case HASH_TABLE: {
result = new ArrayList<Book>(new LinkedHashSet<Book>(
bookInstance.readList(Book.class,
getQueryParamHashtable(dateBetweenParam, orderParam))));
break;
}
case LIST: {
result = new ArrayList<Book>(new LinkedHashSet<Book>(
bookInstance.readList(Book.class, getQueryParamList(
dateBetweenParam, orderParam))));
break;
}
case VAR_ARGS:
default: {
result = new ArrayList<Book>(new LinkedHashSet<Book>(
bookInstance.readList(Book.class, dateBetweenParam,
orderParam)));
break;
}
}
List<Book> expectedResult = new ArrayList<Book>();
for (Book book : allBooks) {
if (book.getPublishDate().compareTo(startDate) > -1 && book.
getPublishDate().compareTo(endDate) < 1) {
expectedResult.add(book);
}
}
System.out.println("EEEEEEEEEEEEEEE : " + expectedResult + " ------ " + result);
assertTrue(Arrays.equals(expectedResult.toArray(), result.toArray()));
}
/**
* Test disjunction
*/
{
Calendar calendar = getAuthorFirstBirthCal();
calendar.add(Calendar.MONTH, 1);
Date endDate = calendar.getTime();
calendar = getAuthorFirstBirthCal();
calendar.add(Calendar.MONTH, allAuthors.size() - 2);
Date startDate = calendar.getTime();
final String propName = "birthDate";
QueryParameter<Date> gtDateParam = getDateGreaterThanParam(propName,
startDate);
QueryParameter<Date> ltDateParam = getDateLesserThanParam(propName,
endDate);
QueryParameter<Void> disjunctionalParam = getDisjunctionalParam(
gtDateParam, ltDateParam);
QueryParameter<Order> orderParam = getOrderByIdParam(Order.DESC);
List<Author> result;
switch (type) {
case HASH_TABLE: {
result = authorInstance.readList(Author.class,
getQueryParamHashtable(disjunctionalParam, orderParam));
break;
}
case LIST: {
result = authorInstance.readList(Author.class,
getQueryParamList(disjunctionalParam, orderParam));
break;
}
case VAR_ARGS:
default: {
result = authorInstance.readList(Author.class,
disjunctionalParam, orderParam);
break;
}
}
result = new ArrayList<Author>(new LinkedHashSet<Author>(result));
List<Author> expectedAuthors = new ArrayList<Author>();
expectedAuthors.add(allAuthors.get(0));
expectedAuthors.add(allAuthors.get(allAuthors.size() - 1));
assertTrue(
Arrays.equals(expectedAuthors.toArray(), result.toArray()));
}
/**
* Test not in
*/
{
List<Integer> ids = Collections.singletonList(allPublishers.get(0).
getId());
QueryParameter<Integer> idNotInParam = getIdNotInParam(
ids);
QueryParameter<Order> orderParam = getOrderByIdParam(Order.DESC);
List<Publisher> result;
switch (type) {
case HASH_TABLE: {
result = publisherInstance.readList(Publisher.class,
getQueryParamHashtable(idNotInParam, orderParam));
break;
}
case LIST: {
result = publisherInstance.readList(Publisher.class,
getQueryParamList(idNotInParam, orderParam));
break;
}
case VAR_ARGS:
default: {
result = publisherInstance.readList(Publisher.class,
idNotInParam, orderParam);
break;
}
}
List<Publisher> expectedResult = allPublishers.subList(1,
allPublishers.size());
assertTrue(Arrays.equals(expectedResult.toArray(), result.toArray()));
}
/**
* Test first result & max result
*/
{
/**
* There is a bug in Derby JDBC Driver or Hibernate Dialect for it,
* as startIndex 1 and 2 returns the same result which is absurd.
*/
int startIndex =
Math.abs(new Random().nextInt()) % (allBooks.size() - 1) + 2;
int max = 1;
QueryParameter<Order> orderParam = getOrderByIdParam(Order.DESC);
QueryParameter<Integer> firstResult =
getFirstResultParam(startIndex);
QueryParameter<Integer> maxResult = getMaxResultParam(max);
List<Book> result;
switch (type) {
case HASH_TABLE: {
result = bookInstance.readList(Book.class,
getQueryParamHashtable(firstResult, maxResult,
orderParam));
break;
}
case LIST: {
result = bookInstance.readList(Book.class,
getQueryParamList(firstResult, maxResult, orderParam));
break;
}
case VAR_ARGS:
default: {
result = bookInstance.readList(Book.class, firstResult,
maxResult, orderParam);
break;
}
}
List<Book> expectedResult = allBooks.subList(startIndex - 1,
startIndex + max - 1);
assertEquals(max, result.size());
assertTrue(Arrays.equals(expectedResult.toArray(), result.toArray()));
}
/**
* Test not equal
*/
{
QueryParameter<Order> orderParam = getOrderByIdParam(Order.DESC);
int id = allAuthors.get(0).getId();
QueryParameter<Integer> notEqualIdParam = getNotEqualIdParam(id);
List<Author> result;
switch (type) {
case HASH_TABLE: {
result = authorInstance.readList(Author.class,
getQueryParamHashtable(notEqualIdParam, orderParam));
break;
}
case LIST: {
result = authorInstance.readList(Author.class,
getQueryParamList(notEqualIdParam, orderParam));
break;
}
case VAR_ARGS:
default: {
result = authorInstance.readList(Author.class,
notEqualIdParam, orderParam);
break;
}
}
List<Author> expectedResult = allAuthors.subList(1,
allAuthors.size());
assertTrue(Arrays.equals(expectedResult.toArray(), result.toArray()));
}
/**
* Test less-than-equal, greater-than-equal
*/
{
int authorIndex = Math.abs(new Random().nextInt()) %
allAuthors.size();
int authorId = allAuthors.get(authorIndex).getId();
String idProp = "id";
QueryParameter<Integer> lteParameter = getLesserThanEqualIntParam(
idProp, authorId);
QueryParameter<Integer> gteParameter = getGreaterThanEqualIntParam(
idProp, authorId);
List<Author> result;
switch (type) {
case HASH_TABLE: {
result = authorInstance.readList(Author.class,
getQueryParamHashtable(lteParameter, gteParameter));
break;
}
case LIST: {
result = authorInstance.readList(Author.class,
getQueryParamList(lteParameter, gteParameter));
break;
}
case VAR_ARGS:
default: {
result = authorInstance.readList(Author.class, lteParameter,
gteParameter);
break;
}
}
List<Author> expectedResult = Collections.singletonList(allAuthors.
get(authorIndex));
assertTrue(Arrays.equals(expectedResult.toArray(), result.toArray()));
}
/**
* Test null
*/
{
String propertyName = "establishedDate";
QueryParameter<Void> nullParam = getIsNullParam(propertyName);
List<Publisher> result;
switch (type) {
case HASH_TABLE: {
result = publisherInstance.readList(Publisher.class,
getQueryParamHashtable(nullParam));
break;
}
case LIST: {
result = publisherInstance.readList(Publisher.class,
getQueryParamList(nullParam));
break;
}
case VAR_ARGS:
default: {
result = publisherInstance.readList(Publisher.class,
nullParam);
break;
}
}
assertEmpty(result);
}
/**
* Test not null
*/
{
String propertyName = "establishedDate";
QueryParameter<Void> notNullParam =
getIsNotNullParam(propertyName);
QueryParameter<Order> orderParam = getOrderByIdParam(Order.DESC);
List<Publisher> result;
switch (type) {
case HASH_TABLE: {
result = publisherInstance.readList(Publisher.class,
getQueryParamHashtable(notNullParam, orderParam));
break;
}
case LIST: {
result = publisherInstance.readList(Publisher.class,
getQueryParamList(notNullParam, orderParam));
break;
}
case VAR_ARGS:
default: {
result = publisherInstance.readList(Publisher.class,
notNullParam, orderParam);
break;
}
}
assertTrue(Arrays.equals(allPublishers.toArray(), result.toArray()));
}
/**
* Test empty
*/
{
String propertyName = "authors";
QueryParameter<Void> emptyParam = getIsEmptyParam(propertyName);
List<Book> result;
switch (type) {
case HASH_TABLE: {
result = bookInstance.readList(Book.class,
getQueryParamHashtable(emptyParam));
break;
}
case LIST: {
result = bookInstance.readList(Book.class,
getQueryParamList(emptyParam));
break;
}
case VAR_ARGS:
default: {
result = bookInstance.readList(Book.class, emptyParam);
break;
}
}
assertEmpty(result);
}
/**
* Test not empty
*/
{
String propertyName = "authors";
QueryParameter<Void> notEmptyParam =
getIsNotEmptyParam(propertyName);
QueryParameter<Order> orderParam = getOrderByIdParam(Order.DESC);
List<Book> result;
switch (type) {
case HASH_TABLE: {
result = bookInstance.readList(Book.class,
getQueryParamHashtable(notEmptyParam, orderParam));
break;
}
case LIST: {
result = bookInstance.readList(Book.class,
getQueryParamList(notEmptyParam, orderParam));
break;
}
case VAR_ARGS:
default: {
result = bookInstance.readList(Book.class,
notEmptyParam, orderParam);
break;
}
}
result = new ArrayList<Book>(new LinkedHashSet<Book>(result));
assertTrue(Arrays.equals(allBooks.toArray(), result.toArray()));
}
}
private void performTestReadOtherSingle(MethodInvocationType type) {
AbstractDAO<Publisher> publisherInstance = getDaoInstance();
QueryParameter<Void> param;
/**
* Test average
*/
{
param = getAvgEmployeesParam();
Double average;
switch (type) {
case HASH_TABLE: {
average = (Double) publisherInstance.readOther(
Publisher.class, getQueryParamHashtable(param));
break;
}
case LIST: {
average = (Double) publisherInstance.readOther(
Publisher.class, getQueryParamList(param));
break;
}
case VAR_ARGS:
default: {
average = (Double) publisherInstance.readOther(
Publisher.class, param);
break;
}
}
int expectedAverage = getTotalNumOfEmployeesFromPubs() /
getAllPublishers().length;
assertEquals(expectedAverage, average.intValue());
}
/**
* Test count
*/
{
param = getCountIdParam();
Integer count;
switch (type) {
case HASH_TABLE: {
count = (Integer) publisherInstance.readOther(
Publisher.class, getQueryParamHashtable(param));
break;
}
case LIST: {
count = (Integer) publisherInstance.readOther(
Publisher.class, getQueryParamList(param));
break;
}
case VAR_ARGS:
default: {
count = (Integer) publisherInstance.readOther(
Publisher.class, param);
break;
}
}
int expectedCount = getAllPublishers().length;
assertEquals(expectedCount, count.intValue());
}
/**
* Test count distinct
*/
{
param = getCountDistinctNumOfEmployeeParam();
Integer distinctCount;
switch (type) {
case HASH_TABLE: {
distinctCount = (Integer) publisherInstance.readOther(
Publisher.class, getQueryParamHashtable(param));
break;
}
case LIST: {
distinctCount = (Integer) publisherInstance.readOther(
Publisher.class, getQueryParamList(param));
break;
}
case VAR_ARGS:
default: {
distinctCount = (Integer) publisherInstance.readOther(
Publisher.class, param);
break;
}
}
int expectedDistinctCount = getDistinctNumOfEmployeeNum();
assertEquals(expectedDistinctCount, distinctCount.intValue());
}
/**
* Test Max
*/
{
param = getMaxNumOfEmployeeParam();
Integer max = (Integer) publisherInstance.readOther(Publisher.class,
param);
switch (type) {
case HASH_TABLE: {
max = (Integer) publisherInstance.readOther(Publisher.class,
getQueryParamHashtable(param));
break;
}
case LIST: {
max = (Integer) publisherInstance.readOther(Publisher.class,
getQueryParamList(param));
break;
}
case VAR_ARGS:
default: {
max = (Integer) publisherInstance.readOther(Publisher.class,
param);
break;
}
}
int expectedMax = getMaxEmployeesFromPubs();
assertEquals(expectedMax, max.intValue());
}
/**
* Test Min
*/
{
param = getMinNumOfEmployeeParam();
Integer min;
switch (type) {
case HASH_TABLE: {
min = (Integer) publisherInstance.readOther(Publisher.class,
getQueryParamHashtable(param));
break;
}
case LIST: {
min = (Integer) publisherInstance.readOther(Publisher.class,
getQueryParamList(param));
break;
}
case VAR_ARGS:
default: {
min = (Integer) publisherInstance.readOther(Publisher.class,
param);
break;
}
}
int expectedMin = getMinEmployeesFromPubs();
assertEquals(expectedMin, min.intValue());
}
/**
* Test Sum
*/
{
param = getTotalNumOfEmployeesParam();
Integer sum;
switch (type) {
case HASH_TABLE: {
sum = (Integer) publisherInstance.readOther(Publisher.class,
getQueryParamHashtable(param));
break;
}
case LIST: {
sum = (Integer) publisherInstance.readOther(Publisher.class,
getQueryParamList(param));
break;
}
case VAR_ARGS:
default: {
sum = (Integer) publisherInstance.readOther(Publisher.class,
param);
break;
}
}
int expectedSum = getTotalNumOfEmployeesFromPubs();
assertEquals(expectedSum, sum.intValue());
}
}
private void performTestReadSingle(MethodInvocationType type) {
AbstractDAO<Book> bookInstance = getDaoInstance();
AbstractDAO<Author> authorInstance = getDaoInstance();
AbstractDAO<Publisher> publisherInstance = getDaoInstance();
Map<String, Integer> bookNameToIdMap = new HashMap<String, Integer>();
Map<String, Integer> publisherNameToIdMap =
new HashMap<String, Integer>();
Map<String, Integer> authorNameToIdMap = new HashMap<String, Integer>();
makeNameToIdMap(bookNameToIdMap, bookInstance, authorNameToIdMap,
authorInstance, publisherNameToIdMap, publisherInstance);
/**
* Test non single request
*/
try {
bookInstance.readSingle(Book.class);
fail("Should not succeed retrieving 1 Book!");
}
catch (IllegalArgumentException argumentException) {
}
catch (Exception exception) {
fail(exception.getMessage());
}
QueryParameter<Integer> param;
/**
* Try to load a book with non-existing id
*/
{
param = getIdQueryParam(-1);
Book nonExistingBook;
switch (type) {
case HASH_TABLE: {
nonExistingBook = bookInstance.readSingle(Book.class,
getQueryParamHashtable(param));
break;
}
case LIST: {
nonExistingBook = bookInstance.readSingle(Book.class,
getQueryParamList(param));
break;
}
case VAR_ARGS:
default: {
nonExistingBook = bookInstance.readSingle(Book.class, param);
break;
}
}
assertNull(nonExistingBook);
}
/**
* Test a random single book with id
*/
{
Book kothaoKeoNei = getKothaoKeoNei(null, null);
int bookId = bookNameToIdMap.get(kothaoKeoNei.getName());
param = getIdQueryParam(bookId);
Book kothaoKeoNeiFromDao;
switch (type) {
case HASH_TABLE: {
kothaoKeoNeiFromDao = bookInstance.readSingle(Book.class,
getQueryParamHashtable(param));
break;
}
case LIST: {
kothaoKeoNeiFromDao = bookInstance.readSingle(Book.class,
getQueryParamList(param));
break;
}
case VAR_ARGS:
default: {
kothaoKeoNeiFromDao = bookInstance.readSingle(Book.class,
param);
break;
}
}
assertBook(kothaoKeoNei, kothaoKeoNeiFromDao, bookNameToIdMap, 1);
}
/**
* Test a random single publisher with id
*/
{
Publisher annoProkash = getAnnoProkash();
int publisherId = publisherNameToIdMap.get(annoProkash.getName());
param = getIdQueryParam(publisherId);
Publisher annoProkashFromDao;
switch (type) {
case HASH_TABLE: {
annoProkashFromDao = publisherInstance.readSingle(
Publisher.class, getQueryParamHashtable(param));
break;
}
case LIST: {
annoProkashFromDao = publisherInstance.readSingle(
Publisher.class, getQueryParamList(param));
break;
}
case VAR_ARGS:
default: {
annoProkashFromDao = publisherInstance.readSingle(
Publisher.class, param);
break;
}
}
assertPublisher(annoProkash, annoProkashFromDao,
publisherNameToIdMap);
}
/**
* Test a random single author with id
*/
{
Author humayunAhmed = getHumayunAhmed();
int authorId = authorNameToIdMap.get(humayunAhmed.getName());
param = getIdQueryParam(authorId);
Author humayunAhmedFromDao = authorInstance.readSingle(Author.class,
param);
switch (type) {
case HASH_TABLE: {
humayunAhmedFromDao =
authorInstance.readSingle(Author.class,
getQueryParamHashtable(param));
break;
}
case LIST: {
humayunAhmedFromDao =
authorInstance.readSingle(Author.class,
getQueryParamList(param));
break;
}
case VAR_ARGS:
default: {
humayunAhmedFromDao =
authorInstance.readSingle(Author.class, param);
break;
}
}
assertAuthor(humayunAhmed, humayunAhmedFromDao, authorNameToIdMap);
}
QueryParameter<String> strParam;
/**
* Test different match modes
*/
/**
* Test a random single book with exact name
*/
{
Book webDbApp = getWebDbApp(null, null, null);
String bookName = webDbApp.getName();
strParam = getNameQueryParam(bookName, MatchMode.EXACT);
Book webDbAppFromDao;
final int numOfAuthors = 2;
switch (type) {
case HASH_TABLE: {
webDbAppFromDao = bookInstance.readSingle(Book.class,
getQueryParamHashtable(strParam));
break;
}
case LIST: {
webDbAppFromDao = bookInstance.readSingle(Book.class,
getQueryParamList(strParam));
break;
}
case VAR_ARGS:
default: {
webDbAppFromDao = bookInstance.readSingle(Book.class,
strParam);
break;
}
}
assertBook(webDbApp, webDbAppFromDao, bookNameToIdMap, numOfAuthors);
}
/**
* Test a random single author with start and end match of name
*/
{
Author brett = getBrett();
strParam = getNameQueryParam(brett.getName().substring(0, 4),
MatchMode.START);
Author brettFromDao;
switch (type) {
case HASH_TABLE: {
brettFromDao = authorInstance.readSingle(Author.class,
getQueryParamHashtable(strParam));
break;
}
case LIST: {
brettFromDao = authorInstance.readSingle(Author.class,
getQueryParamList(strParam));
break;
}
case VAR_ARGS:
default: {
brettFromDao = authorInstance.readSingle(Author.class,
strParam);
break;
}
}
assertAuthor(brett, brettFromDao, authorNameToIdMap);
Author anwar = getKaziAnowarHossain();
strParam = getNameQueryParam(anwar.getName().substring(4),
MatchMode.END);
Author anwarFromDao;
switch (type) {
case HASH_TABLE: {
anwarFromDao = authorInstance.readSingle(Author.class,
getQueryParamHashtable(strParam));
break;
}
case LIST: {
anwarFromDao = authorInstance.readSingle(Author.class,
getQueryParamList(strParam));
break;
}
case VAR_ARGS:
default: {
anwarFromDao = authorInstance.readSingle(Author.class,
strParam);
break;
}
}
assertAuthor(anwar, anwarFromDao, authorNameToIdMap);
}
/**
* Test a random single book with anywhere name
*/
{
Publisher sheba = getAnnoProkash();
strParam = getNameQueryParam(sheba.getName().substring(1, sheba.
getName().
length() - 2), MatchMode.ANYWHERE);
Publisher shebaFromDao;
switch (type) {
case HASH_TABLE: {
shebaFromDao = publisherInstance.readSingle(Publisher.class,
getQueryParamHashtable(strParam));
break;
}
case LIST: {
shebaFromDao = publisherInstance.readSingle(Publisher.class,
getQueryParamList(strParam));
break;
}
case VAR_ARGS:
default: {
shebaFromDao = publisherInstance.readSingle(Publisher.class,
strParam);
break;
}
}
assertPublisher(sheba, shebaFromDao,
publisherNameToIdMap);
}
/**
* Test a random single book with author's name
*/
{
Book webDbApp = getWebDbApp(null, null, null);
Author hughWilliams = getHughWilliams();
strParam =
getNameQueryParam(hughWilliams.getName(), MatchMode.EXACT);
QueryParameter<Void> authorParam = getAuthorNestedParam(strParam);
Book webDbAppFromDao;
switch (type) {
case HASH_TABLE: {
webDbAppFromDao = bookInstance.readSingle(Book.class,
getQueryParamHashtable(authorParam));
break;
}
case LIST: {
webDbAppFromDao = bookInstance.readSingle(Book.class,
getQueryParamList(authorParam));
break;
}
case VAR_ARGS:
default: {
webDbAppFromDao = bookInstance.readSingle(Book.class,
authorParam);
break;
}
}
final int numOfAuthors = 2;
assertBook(webDbApp, webDbAppFromDao, bookNameToIdMap, numOfAuthors);
}
}
private void performTestReadOtherList(MethodInvocationType type) {
AbstractDAO<Book> bookInstance = getDaoInstance();
AbstractDAO<Author> authorInstance = getDaoInstance();
AbstractDAO<Publisher> publisherInstance = getDaoInstance();
Map<String, Integer> bookNameToIdMap = new HashMap<String, Integer>();
Map<String, Integer> publisherNameToIdMap =
new HashMap<String, Integer>();
Map<String, Integer> authorNameToIdMap = new HashMap<String, Integer>();
makeNameToIdMap(bookNameToIdMap, bookInstance, authorNameToIdMap,
authorInstance, publisherNameToIdMap, publisherInstance);
QueryParameter<Void> param;
/**
* Test group by and order by
*/
{
param = getGroupByPubParam();
QueryParameter<Void> countParam = getCountIdParam();
QueryParameter<Order> orderByParam =
getDescOrderByPubParam();
List others;
switch (type) {
case HASH_TABLE: {
others = bookInstance.readOtherList(Book.class,
getQueryParamHashtable(param, countParam, orderByParam));
break;
}
case LIST: {
others = bookInstance.readOtherList(Book.class,
getQueryParamList(param, countParam, orderByParam));
break;
}
case VAR_ARGS:
default: {
others = bookInstance.readOtherList(Book.class, param,
countParam, orderByParam);
break;
}
}
int[] pubId = new int[others.size()];
Map<Integer, Integer> bookCount = new HashMap<Integer, Integer>(
others.size());
int i = 0;
for (Object other : others) {
assertTrue(other instanceof Object[]);
Object[] values = (Object[]) other;
pubId[i] = Integer.parseInt(values[0].toString());
bookCount.put(pubId[i++], Integer.parseInt(values[1].toString()));
}
for (i = 1; i < pubId.length; ++i) {
assertTrue(pubId[i - 1] > pubId[i]);
}
Map<Integer, Integer> expectedBookCount = getExpectedBookCount();
for (Integer publisherId : getExpectedBookCount().keySet()) {
final Integer bookCountForPub = bookCount.get(publisherId);
assertNotNull(bookCountForPub);
assertEquals(bookCountForPub.intValue(), expectedBookCount.get(
publisherId).intValue());
}
}
/**
* Test multiple property projection
*/
{
QueryParameter<Void> idProjectionParam = getIdProjectionParam();
QueryParameter<Void> nameProjectionParam =
getNameProjectionParam();
List others;
switch (type) {
case HASH_TABLE: {
others = authorInstance.readOtherList(Author.class,
getQueryParamHashtable(nameProjectionParam,
idProjectionParam));
break;
}
case LIST: {
others =
authorInstance.readOtherList(Author.class,
getQueryParamList(nameProjectionParam, idProjectionParam));
break;
}
case VAR_ARGS:
default: {
others = authorInstance.readOtherList(Author.class,
nameProjectionParam, idProjectionParam);
break;
}
}
assertNameIdPair(others, authorNameToIdMap);
List<QueryParameter<Void>> propsParam = getNameIdPropsParam();
switch (type) {
case HASH_TABLE: {
others = authorInstance.readOtherList(Author.class,
getQueryParamHashtable(propsParam.toArray(
new QueryParameter[0])));
break;
}
case LIST: {
others = authorInstance.readOtherList(Author.class,
getQueryParamList(propsParam.toArray(
new QueryParameter[0])));
break;
}
case VAR_ARGS:
others = authorInstance.readOtherList(Author.class,
propsParam.toArray(new QueryParameter[0]));
default: {
break;
}
}
assertNameIdPair(others, authorNameToIdMap);
}
/**
* Test distinct property projection
*/
{
QueryParameter<Void> distinctNumOfEmployeeProjectionParam =
getDistinctNumOfEmployeeParam();
List<Integer> nums;
switch (type) {
case HASH_TABLE: {
nums = (List<Integer>) publisherInstance.readOtherList(
Publisher.class, getQueryParamHashtable(
distinctNumOfEmployeeProjectionParam));
break;
}
case LIST: {
nums = publisherInstance.<Integer>readOtherList(
Publisher.class, getQueryParamList(
distinctNumOfEmployeeProjectionParam));
break;
}
case VAR_ARGS:
default: {
nums = publisherInstance.<Integer>readOtherList(
Publisher.class, distinctNumOfEmployeeProjectionParam);
break;
}
}
Set<Integer> expectedNums = new HashSet<Integer>();
Publisher[] publishers = getAllPublishers();
for (Publisher publisher : publishers) {
expectedNums.add(publisher.getNumOfEmployees());
}
assertEquals(expectedNums.size(), nums.size());
for (Integer num : nums) {
assertTrue(expectedNums.contains(num));
}
}
}
private void assertAuthor(final Author author,
final Author authorFromDao,
final Map<String, Integer> authorNameToIdMap) {
assertNotNull(authorFromDao);
assertEquals(authorNameToIdMap.get(author.getName()).intValue(),
authorFromDao.getId().intValue());
assertEquals(author.getName(), authorFromDao.getName());
}
private void assertBook(final Book book,
final Book bookFromDao,
final Map<String, Integer> bookNameToIdMap,
final int numOfAuthors) {
assertNotNull(bookFromDao);
assertEquals(bookNameToIdMap.get(book.getName()).intValue(),
bookFromDao.getId().intValue());
assertEquals(book.getName(), bookFromDao.getName());
assertEquals(book.getIsbn(), bookFromDao.getIsbn());
assertEquals(book.getPrice().doubleValue(), bookFromDao.getPrice().
doubleValue());
assertEquals(book.getQuantityInStock().intValue(), bookFromDao.
getQuantityInStock().intValue());
if (numOfAuthors > -1) {
assertEquals(numOfAuthors, bookFromDao.getAuthors().size());
}
}
private void assertNameIdPair(List others,
Map<String, Integer> authorNameToIdMap)
throws NumberFormatException {
Map<String, Integer> nameIds =
new HashMap<String, Integer>(others.size());
for (Object other : others) {
assertTrue(other instanceof Object[]);
Object[] values = (Object[]) other;
nameIds.put(values[0].toString(),
Integer.parseInt(values[1].toString()));
}
for (String name : authorNameToIdMap.keySet()) {
assertEquals(authorNameToIdMap.get(name).intValue(),
nameIds.get(name).intValue());
}
}
private void assertPublisher(final Publisher publisher,
final Publisher publisherFromDao,
final Map<String, Integer> publisherNameToIdMap) {
assertNotNull(publisherFromDao);
assertEquals(publisherNameToIdMap.get(publisher.getName()).intValue(),
publisherFromDao.getId().intValue());
assertEquals(publisher.getName(), publisherFromDao.getName());
assertEquals(publisher.getNumOfEmployees(),
publisherFromDao.getNumOfEmployees());
}
private void enterBookToIndex(List<Book> bookList,
Book searchedBook,
Map<String, Integer> bookNameToIdMap) {
int index = getBookIndex(bookList, searchedBook);
assertTrue(index > -1);
bookNameToIdMap.put(searchedBook.getName(), bookList.get(index).getId());
bookList.remove(index);
}
private void enterAuthorToIndex(List<Author> authorList,
Author searchedAuthor,
Map<String, Integer> authorNameToIdMap) {
int index = getAuthorIndex(authorList, searchedAuthor);
assertTrue(index > -1);
authorNameToIdMap.put(searchedAuthor.getName(), authorList.get(index).
getId());
authorList.remove(index);
}
private void enterPublisherToIndex(List<Publisher> publisherList,
Publisher searchedPublisher,
Map<String, Integer> publisherNameToIdMap) {
int index = getPublisherIndex(publisherList, searchedPublisher);
assertTrue(index > -1);
publisherNameToIdMap.put(searchedPublisher.getName(), publisherList.get(
index).getId());
publisherList.remove(index);
}
private Book getAgniSopoth(Author author,
Publisher publisher) {
final String bookName = "Agni Sopoth";
final Date publishDate = new Date();
final String isbn = "123ABC";
return getBook(publisher, bookName, publishDate, isbn, 40, 400.0, author);
}
private Book getAgunerPoroshMoni(Publisher annoProkash,
Author humayunAhmed) {
return getBook(annoProkash, "Aguner Poroshmoni", new Date(), "222VFEE3",
10, 100.0, humayunAhmed);
}
private <Template extends PersistentDTO> Set<Template> getAll(
final AbstractDAO<Template> bookInstance,
final Class<Template> templateClass) {
return new LinkedHashSet<Template>(bookInstance.readList(templateClass));
}
private Publisher[] getAllPublishers() {
return new Publisher[]{getAnnoProkash(), getOReilly(),
getShebaProkashani()
};
}
private Publisher getAnnoProkash() {
return getPublisher(new Date(), 50, "Anno Prokash");
}
private QueryParameter<Void> getAuthorNestedParam(
QueryParameter... parameters) {
return QueryParameterFactory.getNestedParametersParam("authors",
FetchMode.DEFAULT, parameters);
}
private QueryParameter<Void> getAvgEmployeesParam() {
return QueryParameterFactory.getElementAvgParam("numOfEmployees");
}
private int getBookIndex(final List<Book> bookList,
final Book searchedBook) {
int index;
for (index = 0; index < bookList.size();
++index) {
Book book = bookList.get(index);
if (searchedBook.getName().equals(book.getName())) {
break;
}
}
return index;
}
private QueryParameter<Void> getCountDistinctNumOfEmployeeParam() {
return QueryParameterFactory.getDistinctElementCountParam(
"numOfEmployees");
}
private QueryParameter<Void> getCountIdParam() {
return QueryParameterFactory.getElementCountParam("id");
}
private int getDistinctNumOfEmployeeNum() {
HashSet<Integer> numbers = new HashSet<Integer>();
for (Publisher publisher : getAllPublishers()) {
numbers.add(publisher.getNumOfEmployees());
}
return numbers.size();
}
private QueryParameter<Void> getDistinctNumOfEmployeeParam() {
return QueryParameterFactory.getDistinctPropProjectionParam(
"numOfEmployees");
}
private HashMap<Integer, Integer> getExpectedBookCount() {
final HashMap<Integer, Integer> result =
new HashMap<Integer, Integer>();
AbstractDAO<Book> bookInstance = getDaoInstance();
AbstractDAO<Author> authorInstance = getDaoInstance();
AbstractDAO<Publisher> publisherInstance = getDaoInstance();
Map<String, Integer> bookNameToIdMap = new HashMap<String, Integer>();
Map<String, Integer> publisherNameToIdMap =
new HashMap<String, Integer>();
Map<String, Integer> authorNameToIdMap = new HashMap<String, Integer>();
makeNameToIdMap(bookNameToIdMap, bookInstance, authorNameToIdMap,
authorInstance, publisherNameToIdMap, publisherInstance);
result.put(publisherNameToIdMap.get(getOReilly().getName()), 2);
result.put(publisherNameToIdMap.get(getAnnoProkash().getName()), 2);
result.put(publisherNameToIdMap.get(getShebaProkashani().getName()), 1);
return result;
}
private QueryParameter<Void> getIdProjectionParam() {
return QueryParameterFactory.getPropProjectionParam("id");
}
private QueryParameter<Void> getMaxNumOfEmployeeParam() {
return QueryParameterFactory.getElementMaxParam("numOfEmployees");
}
private QueryParameter<Void> getMinNumOfEmployeeParam() {
return QueryParameterFactory.getElementMinParam("numOfEmployees");
}
private QueryParameter<Void> getGroupByPubParam() {
return QueryParameterFactory.getGroupByPropParam("publisher.id");
}
private QueryParameter<Order> getDescOrderByPubParam() {
return QueryParameterFactory.getOrderByParam("publisher.id", Order.DESC);
}
private QueryParameter<Order> getOrderByIdParam(final Order order) {
return QueryParameterFactory.getOrderByParam("id", order);
}
private List<QueryParameter<Void>> getNameIdPropsParam() {
return QueryParameterFactory.getMultiPropProjectionParam("name", "id");
}
private QueryParameter<Void> getNameProjectionParam() {
return QueryParameterFactory.getPropProjectionParam("name");
}
private Hashtable<String, QueryParameter> getQueryParamHashtable(
QueryParameter... params) {
Hashtable<String, QueryParameter> table =
new Hashtable<String, QueryParameter>();
for (QueryParameter parameter : params) {
String paramName = getPropertyName(parameter);
if (table.containsKey(paramName)) {
int i = 1;
while (table.containsKey(new StringBuilder(paramName).append(
i).toString())) {
i++;
}
paramName = new StringBuilder(paramName).append(i).toString();
}
table.put(paramName, parameter);
}
return table;
}
private List<QueryParameter> getQueryParamList(QueryParameter... params) {
ArrayList<QueryParameter> result = new ArrayList<QueryParameter>();
Collections.addAll(result, params);
return result;
}
private QueryParameter<Integer> getIdQueryParam(int id) {
return QueryParameterFactory.<Integer>getEqualPropertyParam("id", id);
}
private QueryParameter<String> getNameQueryParam(String name,
MatchMode mode) {
return QueryParameterFactory.<String>getStringLikePropertyParam("name",
name, mode);
}
private int getPublisherIndex(final List<Publisher> publisherList,
final Publisher searchedBook) {
int index;
for (index = 0; index < publisherList.size();
++index) {
Publisher publisher = publisherList.get(index);
if (searchedBook.getName().equals(publisher.getName())) {
break;
}
}
return index;
}
private int getAuthorIndex(final List<Author> authorList,
final Author searchedBook) {
int index;
for (index = 0; index < authorList.size();
++index) {
Author author = authorList.get(index);
if (searchedBook.getName().equals(author.getName())) {
break;
}
}
return index;
}
private Author getBrett() {
return getAuthor("Brett McLaugblin", new Date());
}
private Author getDavidLane() {
return getAuthor("David Lane", new Date());
}
private Author getHughWilliams() {
return getAuthor("Hugh E. Williams", new Date());
}
private Author getHumayunAhmed() {
return getAuthor("Humayun Ahmed", new Date());
}
private Book getJavaAndXml(Publisher oReilly,
Author brettMcLaugblin) {
return getBook(oReilly, "Java & XML", new Date(), "555UIP66", 20, 200.0,
brettMcLaugblin);
}
private Author getKaziAnowarHossain() {
final String name = "Kazi Anowar Hossain";
final Date birthDate = new Date();
return getAuthor(name, birthDate);
}
private Book getKothaoKeoNei(Publisher annoProkash,
Author humayunAhmed) {
return getBook(annoProkash, "Kothao Keo Nei", new Date(), "11134BCE", 30,
300.0, humayunAhmed);
}
private Publisher getOReilly() {
return getPublisher(new Date(), 100, "O\'Reilly");
}
private Publisher getShebaProkashani() {
final String name = "Sheba Prokashoni";
final Date establishDate = new Date();
final int numOfEmployees = 100;
return getPublisher(establishDate, numOfEmployees, name);
}
private Publisher getPublisher(final Date establishDate,
final int numOfEmployees,
final String name) {
Publisher publisher =
new Publisher();
publisher.setEstablishedDate(establishDate);
publisher.setNumOfEmployees(numOfEmployees);
publisher.setName(name);
return publisher;
}
private Author getAuthor(final String name,
final Date birthDate) {
Author author =
new Author();
author.setName(name);
author.setBirthDate(birthDate);
return author;
}
private Book getBook(final Publisher publisher,
final String bookName,
final Date publishDate,
final String isbn,
final Integer quantityInStock,
final Double price,
final Author... authors) {
Book book = new Book();
Set<Author> authorSet =
new HashSet<Author>();
for (Author author : authors) {
authorSet.add(author);
}
book.setAuthors(authorSet);
book.setPublisher(publisher);
book.setName(bookName);
book.setPublishDate(publishDate);
book.setIsbn(isbn);
book.setPrice(price);
book.setQuantityInStock(quantityInStock);
return book;
}
private <T extends PersistentDTO> AbstractDAO<T> getDaoInstance()
throws BeansException {
AbstractDAO<T> instance =
(AbstractDAO<T>) context.getBean("testDao");
assertNotNull(instance);
return instance;
}
private int getTotalNumOfEmployeesFromPubs() {
Publisher[] publishers = getAllPublishers();
int total = 0;
for (Publisher publisher : publishers) {
total += publisher.getNumOfEmployees();
}
return total;
}
private QueryParameter<Void> getTotalNumOfEmployeesParam() {
return QueryParameterFactory.getElementSumParam("numOfEmployees");
}
private Book getWebDbApp(Publisher oReilly,
Author davidLane,
Author hughWilliams) {
return getBook(oReilly, "Web Database Applications", new Date(),
"444ERT6", 50, 500.0, davidLane, hughWilliams);
}
private void makeNameToIdMap(Map<String, Integer> bookNameToIdMap,
AbstractDAO<Book> bookInstance,
Map<String, Integer> authorNameToIdMap,
AbstractDAO<Author> authorInstance,
Map<String, Integer> publisherNameToIdMap,
AbstractDAO<Publisher> publisherInstance) {
/**
* Map Books
*/
Set<Book> books = getAll(bookInstance, Book.class);
List<Book> bookList = new ArrayList<Book>(books);
Book kothaoKeoNei = getKothaoKeoNei(null, null);
enterBookToIndex(bookList, kothaoKeoNei, bookNameToIdMap);
Book agunerPoroshMoni = getAgunerPoroshMoni(null, null);
enterBookToIndex(bookList, agunerPoroshMoni, bookNameToIdMap);
Book webDbApp = getWebDbApp(null, null, null);
enterBookToIndex(bookList, webDbApp, bookNameToIdMap);
Book javaAndXml = getJavaAndXml(null, null);
enterBookToIndex(bookList, javaAndXml, bookNameToIdMap);
Book agniSopoth = getAgniSopoth(null, null);
enterBookToIndex(bookList, agniSopoth, bookNameToIdMap);
/**
* Map Publishers
*/
Set<Publisher> publishers = getAll(publisherInstance, Publisher.class);
List<Publisher> publisherList = new ArrayList<Publisher>(publishers);
Publisher shebaProkashani = getShebaProkashani();
enterPublisherToIndex(publisherList, shebaProkashani,
publisherNameToIdMap);
Publisher oReilly = getOReilly();
enterPublisherToIndex(publisherList, oReilly, publisherNameToIdMap);
Publisher annoProkash = getAnnoProkash();
enterPublisherToIndex(publisherList, annoProkash, publisherNameToIdMap);
/**
* Map Authors
*/
Set<Author> authors = getAll(authorInstance, Author.class);
List<Author> authorList = new ArrayList<Author>(authors);
Author kaziAnowarHossain = getKaziAnowarHossain();
enterAuthorToIndex(authorList, kaziAnowarHossain, authorNameToIdMap);
Author brettMcLaugblin = getBrett();
enterAuthorToIndex(authorList, brettMcLaugblin, authorNameToIdMap);
Author davidLane = getDavidLane();
enterAuthorToIndex(authorList, davidLane, authorNameToIdMap);
Author hughWilliams = getHughWilliams();
enterAuthorToIndex(authorList, hughWilliams, authorNameToIdMap);
Author humayunAhmed = getHumayunAhmed();
enterAuthorToIndex(authorList, humayunAhmed, authorNameToIdMap);
}
private int getMaxEmployeesFromPubs() {
int max = Integer.MIN_VALUE;
Publisher[] publishers = getAllPublishers();
for (Publisher publisher : publishers) {
max = Math.max(max, publisher.getNumOfEmployees());
}
return max;
}
private int getMinEmployeesFromPubs() {
int min = Integer.MAX_VALUE;
Publisher[] publishers = getAllPublishers();
for (Publisher publisher : publishers) {
min = Math.min(min, publisher.getNumOfEmployees());
}
return min;
}
private String getPropertyName(
QueryParameter param) {
String propertyName;
if (param instanceof QueryParameterWithPropertyName) {
propertyName =
((QueryParameterWithPropertyName) param).getPropertyName();
}
else {
propertyName = null;
}
if (propertyName == null) {
propertyName = "";
}
return propertyName;
}
private enum MethodInvocationType {
VAR_ARGS, HASH_TABLE, LIST;
}
}