src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
DateUtils { public static int getDayDiff(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new InvalidParameterException( "date1 and date2 cannot be null!"); } Date startDate = org.apache.commons.lang3.time.DateUtils.truncate( date1, Calendar.DATE); Date endDate = org.apache.commons.lang3.time.DateUtils.truncate(date2, Calendar.DATE); if (startDate.after(endDate)) { throw new InvalidParameterException("date1 cannot be after date2!"); } long millSecondsInOneDay = HOURS_IN_A_DAY * MINUTES_IN_AN_HOUR * SECONDS_IN_A_MINUTE * MILLIS_IN_A_SECOND; return (int) ((endDate.getTime() - startDate.getTime()) / millSecondsInOneDay); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void getDayDiff() { assertEquals(31, DateUtils.getDayDiff(DateUtils.parseDate("2009-1-1"), DateUtils.parseDate("2009-2-1"))); assertEquals(2, DateUtils.getDayDiff(DateUtils.parseDate("2009-1-31"), DateUtils.parseDate("2009-2-2"))); } |
DateUtils { public static int getMinuteDiffByTime(Date time1, Date time2) { long startMil = 0; long endMil = 0; Calendar calendar = Calendar.getInstance(); calendar.setTime(time1); calendar.set(1900, 1, 1); startMil = calendar.getTimeInMillis(); calendar.setTime(time2); calendar.set(1900, 1, 1); endMil = calendar.getTimeInMillis(); return (int) ((endMil - startMil) / MILLIS_IN_A_SECOND / SECONDS_IN_A_MINUTE); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void getMinuteDiffByTime() { Date time1 = getTime("12:15"); Date time2 = getTime("14:14"); Date time3 = getTime("14:15"); Date time4 = getTime("14:16"); assertEquals(1, DateUtils.getMinuteDiffByTime(time1, time2)); assertEquals(2, DateUtils.getMinuteDiffByTime(time1, time3)); assertEquals(2, DateUtils.getMinuteDiffByTime(time1, time4)); } |
DateUtils { public static boolean isDateAfter(Date date1, Date date2) { Date theDate1 = org.apache.commons.lang3.time.DateUtils.truncate(date1, Calendar.DATE); Date theDate2 = org.apache.commons.lang3.time.DateUtils.truncate(date2, Calendar.DATE); return theDate1.after(theDate2); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void testIsDateAfter() { Date date1 = parseDateTime("2007-1-2 08:12:02"); Date date2 = parseDateTime("2007-1-1 18:12:02"); assertTrue(DateUtils.isDateAfter(date1, date2)); date1 = parseDateTime("2007-1-1 09:12:02"); date2 = parseDateTime("2007-1-1 08:12:02"); assertFalse(DateUtils.isDateAfter(date1, date2)); } |
DateUtils { public static boolean isDateBefore(Date date1, Date date2) { return isDateAfter(date2, date1); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void testIsDateBefore() { Date date1 = parseDateTime("2007-1-2 08:12:02"); Date date2 = parseDateTime("2007-1-1 18:12:02"); assertTrue(DateUtils.isDateBefore(date2, date1)); date1 = parseDateTime("2007-1-1 09:12:02"); date2 = parseDateTime("2007-1-1 08:12:02"); assertFalse(DateUtils.isDateBefore(date2, date1)); } |
DateUtils { public static boolean isTimeAfter(Date time1, Date time2) { Calendar calendar1 = Calendar.getInstance(); calendar1.setTime(time1); calendar1.set(1900, 1, 1); Calendar calendar2 = Calendar.getInstance(); calendar2.setTime(time2); calendar2.set(1900, 1, 1); return calendar1.after(calendar2); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void testIsTimeAfter() { Date date1 = parseDateTime("2007-1-1 18:12:02"); Date date2 = parseDateTime("2007-1-2 08:12:02"); assertTrue(DateUtils.isTimeAfter(date1, date2)); date1 = parseDateTime("2007-1-2 08:12:02"); date2 = parseDateTime("2007-1-1 08:12:02"); assertFalse(DateUtils.isTimeAfter(date1, date2)); } |
DateUtils { public static boolean isTimeBefore(Date time1, Date time2) { return isTimeAfter(time2, time1); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void testIsTimeBefore() { Date date1 = parseDateTime("2007-1-1 18:12:02"); Date date2 = parseDateTime("2007-1-2 08:12:02"); assertTrue(DateUtils.isTimeBefore(date2, date1)); date1 = parseDateTime("2007-1-2 08:12:02"); date2 = parseDateTime("2007-1-1 08:12:02"); assertFalse(DateUtils.isTimeBefore(date2, date1)); } |
DateUtils { public static int getWeekDaysBetween(Date fromDate, Date toDate, int dayOfWeek) { int result = 0; Date firstDate = getFirstWeekdayBetween(fromDate, toDate, dayOfWeek); if (firstDate == null) { return 0; } Calendar aDay = Calendar.getInstance(); aDay.setTime(firstDate); while (aDay.getTime().before(toDate)) { result++; aDay.add(Calendar.DATE, DAYS_IN_A_WEEK); } return result; } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void getWeekDaysBetween() { Date fromDate = DateUtils.parseDate("2009-1-1"); Date toDate = DateUtils.parseDate("2009-2-1"); assertEquals(4, DateUtils.getWeekDaysBetween(fromDate, toDate, Calendar.SUNDAY)); assertEquals(4, DateUtils.getWeekDaysBetween(fromDate, toDate, Calendar.MONDAY)); assertEquals(4, DateUtils.getWeekDaysBetween(fromDate, toDate, Calendar.TUESDAY)); assertEquals(4, DateUtils.getWeekDaysBetween(fromDate, toDate, Calendar.WEDNESDAY)); assertEquals(5, DateUtils.getWeekDaysBetween(fromDate, toDate, Calendar.THURSDAY)); assertEquals(5, DateUtils.getWeekDaysBetween(fromDate, toDate, Calendar.FRIDAY)); assertEquals(5, DateUtils.getWeekDaysBetween(fromDate, toDate, Calendar.SATURDAY)); } |
DateUtils { public static Date getFirstWeekdayBetween(Date fromDate, Date toDate, int dayOfWeek) { Calendar aDay = Calendar.getInstance(); aDay.setTime(fromDate); while (aDay.getTime().before(toDate)) { if (aDay.get(Calendar.DAY_OF_WEEK) == dayOfWeek) { return aDay.getTime(); } aDay.add(Calendar.DATE, 1); } return null; } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void getFirstWeekdayBetween() { Date fromDate = DateUtils.parseDate("2009-1-1"); Date toDate = DateUtils.parseDate("2009-2-1"); assertEquals(DateUtils.parseDate("2009-1-4"), DateUtils.getFirstWeekdayBetween(fromDate, toDate, Calendar.SUNDAY)); assertEquals(DateUtils.parseDate("2009-1-5"), DateUtils.getFirstWeekdayBetween(fromDate, toDate, Calendar.MONDAY)); assertEquals(DateUtils.parseDate("2009-1-6"), DateUtils.getFirstWeekdayBetween(fromDate, toDate, Calendar.TUESDAY)); assertEquals(DateUtils.parseDate("2009-1-7"), DateUtils.getFirstWeekdayBetween(fromDate, toDate, Calendar.WEDNESDAY)); assertEquals(DateUtils.parseDate("2009-1-1"), DateUtils.getFirstWeekdayBetween(fromDate, toDate, Calendar.THURSDAY)); assertEquals(DateUtils.parseDate("2009-1-2"), DateUtils.getFirstWeekdayBetween(fromDate, toDate, Calendar.FRIDAY)); assertEquals(DateUtils.parseDate("2009-1-3"), DateUtils.getFirstWeekdayBetween(fromDate, toDate, Calendar.SATURDAY)); } |
DateUtils { public static int getDaysInYear(int year) { Calendar aDay = Calendar.getInstance(); aDay.set(year, 1, 1); Date from = aDay.getTime(); aDay.set(year + 1, 1, 1); Date to = aDay.getTime(); return getDayDiff(from, to); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void getDaysInYear() { assertEquals(366, DateUtils.getDaysInYear(2000)); assertEquals(365, DateUtils.getDaysInYear(2009)); } |
DateUtils { public static int getDaysInMonth(int year, int month) { Calendar aDay = Calendar.getInstance(); aDay.set(year, month, 1); Date from = aDay.getTime(); if (month == Calendar.DECEMBER) { aDay.set(year + 1, Calendar.JANUARY, 1); } else { aDay.set(year, month + 1, 1); } Date to = aDay.getTime(); return getDayDiff(from, to); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void getDaysInMonth() { assertEquals(29, DateUtils.getDaysInMonth(2000, Calendar.FEBRUARY)); assertEquals(28, DateUtils.getDaysInMonth(2009, Calendar.FEBRUARY)); assertEquals(31, DateUtils.getDaysInMonth(2009, Calendar.DECEMBER)); } |
SessionProvider { public Session getSession() { Session result = sessionHolder.get(); if (result != null && result.isOpen()) { return result; } result = getSessionFromIoC(); sessionHolder.set(result); return result; } SessionProvider(); SessionProvider(Session session); SessionProvider(SessionFactory sessionFactory); Session getSession(); } | @Test public void testDefaultConstructor() { InstanceFactory.bind(SessionFactory.class, sessionFactory); SessionProvider instance = new SessionProvider(); Session session2 = instance.getSession(); assertSame(session2, session); Session session3 = instance.getSession(); assertSame(session3, session); }
@Test public void testConstructorSessionFactory() { SessionProvider instance = new SessionProvider(sessionFactory); Session session2 = instance.getSession(); assertSame(session2, session); Session session3 = instance.getSession(); assertSame(session3, session); } |
DateUtils { public static Date parseDate(String dateString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( dateString, new String[]{"yyyy-MM-dd", "yyyy-M-d", "yyyy-MM-d", "yyyy-M-dd"}); } catch (ParseException e) { return null; } } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void testParseDate() { Calendar calendar = Calendar.getInstance(); calendar.setTime(DateUtils.parseDate("1968-4-16")); assertEquals(1968, calendar.get(Calendar.YEAR)); assertEquals(3, calendar.get(Calendar.MONTH)); assertEquals(16, calendar.get(Calendar.DATE)); calendar.setTime(DateUtils.parseDate("1968-04-16")); assertEquals(1968, calendar.get(Calendar.YEAR)); assertEquals(3, calendar.get(Calendar.MONTH)); assertEquals(16, calendar.get(Calendar.DATE)); } |
DateUtils { public static Date parseTime(String timeString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( timeString, new String[]{"hh:mm:ss", "h:m:s", "hh:mm", "h:m"}); } catch (ParseException e) { return null; } } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void testParseTime() { Calendar calendar = Calendar.getInstance(); calendar.setTime(DateUtils.parseTime("02:04:06")); assertEquals(2, calendar.get(Calendar.HOUR)); assertEquals(4, calendar.get(Calendar.MINUTE)); assertEquals(6, calendar.get(Calendar.SECOND)); calendar.setTime(DateUtils.parseTime("2:4:6")); assertEquals(2, calendar.get(Calendar.HOUR)); assertEquals(4, calendar.get(Calendar.MINUTE)); assertEquals(6, calendar.get(Calendar.SECOND)); } |
DateUtils { public static Date parseDateTime(String timeString) { try { return org.apache.commons.lang3.time.DateUtils.parseDate( timeString, new String[]{"yyyy-MM-dd HH:mm:ss", "yyyy-M-d H:m:s", "yyyy-MM-dd H:m:s", "yyyy-M-d HH:mm:ss"}); } catch (ParseException e) { return null; } } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void testParseDateTime() { Calendar calendar = Calendar.getInstance(); calendar.setTime(DateUtils.parseDateTime("1968-04-16 02:04:06")); assertEquals(1968, calendar.get(Calendar.YEAR)); assertEquals(3, calendar.get(Calendar.MONTH)); assertEquals(16, calendar.get(Calendar.DATE)); assertEquals(2, calendar.get(Calendar.HOUR)); assertEquals(4, calendar.get(Calendar.MINUTE)); assertEquals(6, calendar.get(Calendar.SECOND)); calendar.setTime(DateUtils.parseDateTime("1968-4-16 2:4:6")); assertEquals(1968, calendar.get(Calendar.YEAR)); assertEquals(3, calendar.get(Calendar.MONTH)); assertEquals(16, calendar.get(Calendar.DATE)); assertEquals(2, calendar.get(Calendar.HOUR)); assertEquals(4, calendar.get(Calendar.MINUTE)); assertEquals(6, calendar.get(Calendar.SECOND)); calendar.setTime(DateUtils.parseDateTime("1968-04-16 2:4:6")); assertEquals(1968, calendar.get(Calendar.YEAR)); assertEquals(3, calendar.get(Calendar.MONTH)); assertEquals(16, calendar.get(Calendar.DATE)); assertEquals(2, calendar.get(Calendar.HOUR)); assertEquals(4, calendar.get(Calendar.MINUTE)); assertEquals(6, calendar.get(Calendar.SECOND)); calendar.setTime(DateUtils.parseDateTime("1968-04-16 2:4:6")); assertEquals(1968, calendar.get(Calendar.YEAR)); assertEquals(3, calendar.get(Calendar.MONTH)); assertEquals(16, calendar.get(Calendar.DATE)); assertEquals(2, calendar.get(Calendar.HOUR)); assertEquals(4, calendar.get(Calendar.MINUTE)); assertEquals(6, calendar.get(Calendar.SECOND)); } |
DateUtils { public static final Date dateAfter(Date origDate, int amount, int timeUnit) { Calendar calendar = Calendar.getInstance(); calendar.setTime(origDate); calendar.add(timeUnit, amount); return calendar.getTime(); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void dateAfter() { Date origDate = DateUtils.parseDate("2000-01-02"); assertEquals(DateUtils.parseDate("2000-01-05"), DateUtils.dateAfter(origDate, 3, Calendar.DATE)); assertEquals(DateUtils.parseDate("2003-01-02"), DateUtils.dateAfter(origDate, 3, Calendar.YEAR)); } |
DateUtils { public static final Date dateBefore(Date origDate, int amount, int timeUnit) { Calendar calendar = Calendar.getInstance(); calendar.setTime(origDate); calendar.add(timeUnit, -amount); return calendar.getTime(); } private DateUtils(); static Date date(int year, int month, int day); static Date date(int year, int month, int day,
int hour, int minute, int second); static int getYearDiff(Date date1, Date date2); static int getMonthDiff(Date date1, Date date2); static int getDayDiff(Date date1, Date date2); static int getMinuteDiffByTime(Date time1, Date time2); static Date getPrevDay(Date date); static Date getNextDay(Date date); static boolean isDateAfter(Date date1, Date date2); static boolean isDateBefore(Date date1, Date date2); static boolean isTimeAfter(Date time1, Date time2); static boolean isTimeBefore(Date time1, Date time2); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar date1, Calendar date2); static Date parseDate(String dateString); static Date parseTime(String timeString); static Date parseDateTime(String timeString); static int getWeekDaysBetween(Date fromDate, Date toDate,
int dayOfWeek); static Date getFirstWeekdayBetween(Date fromDate, Date toDate,
int dayOfWeek); static int getDaysInYear(int year); static int getDaysInMonth(int year, int month); static int getYear(Date date); static int getMonth(Date date); static int getDayOfYear(Date date); static int getDayOfMonth(Date date); static int getDayOfWeek(Date date); static final Date dateAfter(Date origDate, int amount, int timeUnit); static final Date dateBefore(Date origDate, int amount, int timeUnit); static final Date MIN_DATE; static final Date MAX_DATE; } | @Test public void dateBefore() { Date origDate = DateUtils.parseDate("2000-01-05"); assertEquals(DateUtils.parseDate("2000-01-02"), DateUtils.dateBefore(origDate, 3, Calendar.DATE)); assertEquals(DateUtils.parseDate("1997-01-05"), DateUtils.dateBefore(origDate, 3, Calendar.YEAR)); } |
BeanClassUtils { public Map<String, Class<?>> getPropTypes() { Map<String, Class<?>> results = new HashMap<String, Class<?>>(); for (Map.Entry<String, PropertyDescriptor> each : getPropertyDescriptors().entrySet()) { results.put(each.getKey(), each.getValue().getPropertyType()); } return results; } BeanClassUtils(final Class<?> clazz); Map<String, Class<?>> getPropTypes(); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Set<String> getReadablePropNamesExclude(String... excludePropNames); Set<String> getReadablePropNamesExclude(Class<? extends Annotation>... excludeAnnotations); } | @Test public void testGetPropTypes() { Map<String, Class<?>> types = instance.getPropTypes(); assertEquals(int.class, types.get("id")); assertEquals(String.class, types.get("name")); assertEquals(boolean.class, types.get("disabled")); assertEquals(double.class, types.get("price")); } |
BeanClassUtils { public Set<String> getPropNames() { return getPropertyDescriptors().keySet(); } BeanClassUtils(final Class<?> clazz); Map<String, Class<?>> getPropTypes(); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Set<String> getReadablePropNamesExclude(String... excludePropNames); Set<String> getReadablePropNamesExclude(Class<? extends Annotation>... excludeAnnotations); } | @Test public void testGetPropNames() { assertTrue(instance.getPropNames().containsAll( Arrays.asList("id", "price", "name", "disabled"))); } |
BeanClassUtils { public Set<String> getReadablePropNames() { Set<String> results = new HashSet<String>(); for (Map.Entry<String, PropertyDescriptor> each : getPropertyDescriptors().entrySet()) { if (each.getValue().getReadMethod() == null) { continue; } results.add(each.getKey()); } return results; } BeanClassUtils(final Class<?> clazz); Map<String, Class<?>> getPropTypes(); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Set<String> getReadablePropNamesExclude(String... excludePropNames); Set<String> getReadablePropNamesExclude(Class<? extends Annotation>... excludeAnnotations); } | @Test public void testGetReadablePropNames() { Set<String> results = instance.getReadablePropNames(); assertTrue(results.containsAll( Arrays.asList("id", "price", "name"))); assertFalse(results.contains("disabled")); } |
BeanClassUtils { public Set<String> getReadablePropNamesExclude(String... excludePropNames) { List<String> propNamesExclude = Arrays.asList(excludePropNames); Set<String> results = new HashSet<String>(); for (String propName : getReadablePropNames()) { if (propNamesExclude.contains(propName)) { continue; } results.add(propName); } return results; } BeanClassUtils(final Class<?> clazz); Map<String, Class<?>> getPropTypes(); Set<String> getPropNames(); Set<String> getReadablePropNames(); Set<String> getWritablePropNames(); Set<String> getReadablePropNamesExclude(String... excludePropNames); Set<String> getReadablePropNamesExclude(Class<? extends Annotation>... excludeAnnotations); } | @Test public void testGetReadablePropNamesexcludeName() { Set<String> results = instance.getReadablePropNamesExclude("id", "price"); assertTrue(results.containsAll( Arrays.asList("name"))); assertFalse(results.contains("id")); assertFalse(results.contains("price")); assertFalse(results.contains("disabled")); }
@Test public void testGetReadablePropNamesexcludeAnnotation() { Set<String> results = instance.getReadablePropNamesExclude(Deprecated.class); assertTrue(results.containsAll( Arrays.asList("name", "id"))); assertFalse(results.contains("price")); assertFalse(results.contains("disabled")); } |
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> T get(final Class<T> clazz, final Serializable id) { return getEntityManager().find(clazz, id); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testGet() { assertEquals(male, repository.get(Dictionary.class, male.getId())); } |
CollectionUtils { public static Collection<?> substract(Collection<?> items, String property) { if (items == null) { return null; } if (StringUtils.isEmpty(property)) { throw new IllegalArgumentException("property name must not empty!"); } Collection<Object> results = new ArrayList<Object>(); for (Object item : items) { Map<String, Object> propValues = new BeanUtils(item).getPropValues(); if (!propValues.containsKey(property)) { throw new IllegalArgumentException("Property " + property + " not exists!"); } results.add(propValues.get(property)); } return results; } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); } | @Test public void testSubstract() { Collection<Item> items = new ArrayList<Item>(); items.add(new Item(1, "A")); items.add(new Item(2, "B")); items.add(new Item(1, "C")); assertEquals(Arrays.asList(1, 2, 1), CollectionUtils.substract(items, "id")); assertEquals(Arrays.asList("A", "B", "C"), CollectionUtils.substract(items, "name")); }
@Test public void testSubstractNull() { assertNull(CollectionUtils.substract(null, "name")); }
@Test public void testSubstractEmpty() { assertTrue(CollectionUtils.substract(Collections.EMPTY_LIST, "name").isEmpty()); }
@Test public void testSubstractSingleElement() { Collection<?> expected = Collections.singletonList(2); Collection<?> actual = CollectionUtils.substract(Collections.singletonList(new Item(2, "B")), "id"); assertEquals(expected, actual); } |
CollectionUtils { public static String join(Collection<?> items, String property, String separator) { if (items == null) { return ""; } return StringUtils.join(substract(items, property), separator); } private CollectionUtils(); static Collection<?> substract(Collection<?> items, String property); static String join(Collection<?> items, String property, String separator); } | @Test public void testJoin() { Collection<Item> items = new ArrayList<Item>(); items.add(new Item(1, "A")); items.add(new Item(2, "B")); items.add(new Item(1, "C")); String separator = ", "; String result = CollectionUtils.join(items, "id", separator); assertEquals("1, 2, 1", result); }
@Test public void testJoinNull() { String separator = ", "; List<Item> items = null; String result = CollectionUtils.join(items, "id", separator); assertTrue(result.isEmpty()); }
@Test public void testJoinEmpty() { String separator = ", "; String result = CollectionUtils.join(new ArrayList<Object>(), "id", separator); assertTrue(result.isEmpty()); }
@Test public void testJoinSingleElement() { Collection<Item> items = new ArrayList<Item>(); items.add(new Item(1, "A")); String separator = ", "; String result = CollectionUtils.join(items, "name", separator); assertEquals("A", result); } |
Slf4JLogger implements org.dayatang.utils.Logger { public void debug(String msg, Object... args) { if (logger.isDebugEnabled()) { logger.debug(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); } | @Test public void testDebugEnable() { when(logger.isDebugEnabled()).thenReturn(true); instance.debug(msg, "A", "B", "C"); verify(logger).debug(msg, args); }
@Test public void testDebugDisable() { when(logger.isDebugEnabled()).thenReturn(false); instance.debug(msg, "A", "B", "C"); verify(logger, never()).debug(msg, args); }
@Test public void testDebugEnabledException() { when(logger.isDebugEnabled()).thenReturn(true); instance.debug(errorMsg, t); verify(logger).debug(errorMsg, t); }
@Test public void testDebugDisabledException() { when(logger.isDebugEnabled()).thenReturn(false); instance.debug(errorMsg, t); verify(logger, never()).debug(errorMsg, t); } |
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> boolean exists(final Class<T> clazz, final Serializable id) { return get(clazz, id) != null; } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testExists() { assertTrue(repository.exists(Dictionary.class, male.getId())); assertFalse(repository.exists(Dictionary.class, 1000L)); } |
Slf4JLogger implements org.dayatang.utils.Logger { public void info(String msg, Object... args) { if (logger.isInfoEnabled()) { logger.info(msg, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); } | @Test public void testInfoEnable() { when(logger.isInfoEnabled()).thenReturn(true); instance.info(msg, "A", "B", "C"); verify(logger).info(msg, args); }
@Test public void testInfoDisable() { when(logger.isInfoEnabled()).thenReturn(false); instance.info(msg, "A", "B", "C"); verify(logger, never()).info(msg, args); }
@Test public void testInfoEnabledException() { when(logger.isInfoEnabled()).thenReturn(true); instance.info(errorMsg, t); verify(logger).info(errorMsg, t); }
@Test public void testInfoDisabledException() { when(logger.isInfoEnabled()).thenReturn(false); instance.info(errorMsg, t); verify(logger, never()).info(errorMsg, t); } |
Slf4JLogger implements org.dayatang.utils.Logger { public void trace(String format, Object... args) { if (logger.isTraceEnabled()) { logger.trace(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); } | @Test public void testTraceEnable() { when(logger.isTraceEnabled()).thenReturn(true); instance.trace(msg, "A", "B", "C"); verify(logger).trace(msg, args); }
@Test public void testTraceDisable() { when(logger.isTraceEnabled()).thenReturn(false); instance.trace(msg, "A", "B", "C"); verify(logger, never()).trace(msg, args); }
@Test public void testTraceEnabledException() { when(logger.isTraceEnabled()).thenReturn(true); instance.trace(errorMsg, t); verify(logger).trace(errorMsg, t); }
@Test public void testTraceDisabledException() { when(logger.isTraceEnabled()).thenReturn(false); instance.trace(errorMsg, t); verify(logger, never()).trace(errorMsg, t); } |
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> T get(final Class<T> clazz, final Serializable id) { return (T) getSession().get(clazz, id); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testGet() { assertEquals(male, repository.get(Dictionary.class, male.getId())); } |
Slf4JLogger implements org.dayatang.utils.Logger { public void warn(String format, Object... args) { if (logger.isWarnEnabled()) { logger.warn(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); } | @Test public void testWarnEnable() { when(logger.isWarnEnabled()).thenReturn(true); instance.warn(msg, "A", "B", "C"); verify(logger).warn(msg, args); }
@Test public void testWarnDisable() { when(logger.isWarnEnabled()).thenReturn(false); instance.warn(msg, "A", "B", "C"); verify(logger, never()).warn(msg, args); }
@Test public void testWarnEnabledException() { when(logger.isWarnEnabled()).thenReturn(true); instance.warn(errorMsg, t); verify(logger).warn(errorMsg, t); }
@Test public void testWarnDisabledException() { when(logger.isWarnEnabled()).thenReturn(false); instance.warn(errorMsg, t); verify(logger, never()).warn(errorMsg, t); } |
Slf4JLogger implements org.dayatang.utils.Logger { public void error(String format, Object... args) { if (logger.isErrorEnabled()) { logger.error(format, args); } } Slf4JLogger(Logger logger); static Slf4JLogger getLogger(Class<?> clazz); static Slf4JLogger getLogger(String name); void debug(String msg, Object... args); void debug(String msg, Throwable t); void info(String msg, Object... args); void info(String msg, Throwable t); void trace(String format, Object... args); void trace(String msg, Throwable t); void warn(String format, Object... args); void warn(String msg, Throwable t); void error(String format, Object... args); void error(String msg, Throwable t); } | @Test public void testErrorEnable() { when(logger.isErrorEnabled()).thenReturn(true); instance.error(msg, "A", "B", "C"); verify(logger).error(msg, args); }
@Test public void testErrorDisable() { when(logger.isErrorEnabled()).thenReturn(false); instance.error(msg, "A", "B", "C"); verify(logger, never()).error(msg, args); }
@Test public void testErrorEnabledException() { when(logger.isErrorEnabled()).thenReturn(true); instance.error(errorMsg, t); verify(logger).error(errorMsg, t); }
@Test public void testErrorDisabledException() { when(logger.isErrorEnabled()).thenReturn(false); instance.error(errorMsg, t); verify(logger, never()).error(errorMsg, t); } |
ExcelUtils { public static int convertColumnNameToIndex(String columnName) { Assert.notBlank(columnName); String theColumn = columnName.toUpperCase(); int length = theColumn.length(); int result = letterToInt(theColumn.charAt(length - 1)); if (length == 1) { return result; } for (int i = 1; i < length; i++) { int letter = theColumn.charAt(length - i - 1); result = (letterToInt(letter) + 1) * ((int) Math.pow(26, i)) + result; } return result; } private ExcelUtils(); static int convertColumnNameToIndex(String columnName); static Double getDouble(Object data); static Integer getInt(Object data); static Long getLong(Object data); static Boolean getBoolean(Object data); static String getString(Object data); static Date getDate(Object data, Version version, boolean isDate1904); } | @Test public void testConvertColumnNameToIndex() { assertEquals(0, ExcelUtils.convertColumnNameToIndex("A")); assertEquals(25, ExcelUtils.convertColumnNameToIndex("Z")); assertEquals(26, ExcelUtils.convertColumnNameToIndex("AA")); assertEquals(52, ExcelUtils.convertColumnNameToIndex("BA")); assertEquals(26 * 26 + 2 * 26 + 1, ExcelUtils.convertColumnNameToIndex("ABB")); } |
ExcelUtils { public static Double getDouble(Object data) { if (data == null) { return null; } if (! (data instanceof Double)) { throw new IllegalStateException("数据类型错误：单元格中的数据不是数值类型"); } return (Double) data; } private ExcelUtils(); static int convertColumnNameToIndex(String columnName); static Double getDouble(Object data); static Integer getInt(Object data); static Long getLong(Object data); static Boolean getBoolean(Object data); static String getString(Object data); static Date getDate(Object data, Version version, boolean isDate1904); } | @Test public void testGetDouble() { assertNull(ExcelUtils.getDouble(null)); assertEquals(10.5, ExcelUtils.getDouble(10.5), 0.001); } |
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> T load(final Class<T> clazz, final Serializable id) { return (T) getSession().load(clazz, id); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testLoad() { assertEquals(male.getId(), repository.load(Dictionary.class, male.getId()).getId()); } |
ExcelUtils { public static Integer getInt(Object data) { Double value = getDouble(data); return value == null ? null : value.intValue(); } private ExcelUtils(); static int convertColumnNameToIndex(String columnName); static Double getDouble(Object data); static Integer getInt(Object data); static Long getLong(Object data); static Boolean getBoolean(Object data); static String getString(Object data); static Date getDate(Object data, Version version, boolean isDate1904); } | @Test public void testGetInt() { assertNull(ExcelUtils.getInt(null)); assertEquals(10, ExcelUtils.getInt(10.0).intValue()); } |
ExcelUtils { public static Long getLong(Object data) { Double value = getDouble(data); return value == null ? null : value.longValue(); } private ExcelUtils(); static int convertColumnNameToIndex(String columnName); static Double getDouble(Object data); static Integer getInt(Object data); static Long getLong(Object data); static Boolean getBoolean(Object data); static String getString(Object data); static Date getDate(Object data, Version version, boolean isDate1904); } | @Test public void testGetLong() { assertNull(ExcelUtils.getLong(null)); assertEquals(10L, ExcelUtils.getLong(10.0).longValue()); } |
ExcelUtils { public static Boolean getBoolean(Object data) { if (data == null) { return null; } if (! (data instanceof Boolean)) { throw new IllegalStateException("数据类型错误：单元格中的数据不是布尔类型"); } return (Boolean) data; } private ExcelUtils(); static int convertColumnNameToIndex(String columnName); static Double getDouble(Object data); static Integer getInt(Object data); static Long getLong(Object data); static Boolean getBoolean(Object data); static String getString(Object data); static Date getDate(Object data, Version version, boolean isDate1904); } | @Test public void testGetBoolean() { assertNull(ExcelUtils.getBoolean(null)); assertTrue(ExcelUtils.getBoolean(true).booleanValue()); } |
ExcelUtils { public static String getString(Object data) { if (data == null) { return null; } if (StringUtils.isBlank(data.toString())) { return null; } return data.toString(); } private ExcelUtils(); static int convertColumnNameToIndex(String columnName); static Double getDouble(Object data); static Integer getInt(Object data); static Long getLong(Object data); static Boolean getBoolean(Object data); static String getString(Object data); static Date getDate(Object data, Version version, boolean isDate1904); } | @Test public void testGetString() { assertNull(ExcelUtils.getString(null)); assertNull(ExcelUtils.getString(" ")); assertEquals("abc", ExcelUtils.getString("abc")); } |
ExcelUtils { public static Date getDate(Object data, Version version, boolean isDate1904) { Double value = getDouble(data); return version.getDate(value, isDate1904); } private ExcelUtils(); static int convertColumnNameToIndex(String columnName); static Double getDouble(Object data); static Integer getInt(Object data); static Long getLong(Object data); static Boolean getBoolean(Object data); static String getString(Object data); static Date getDate(Object data, Version version, boolean isDate1904); } | @Test public void testGetDate() { assertNull(ExcelUtils.getDate(null, Version.XLS, true)); } |
OracleDBManager extends AbstractDBManager { @Override public void cleanDatabase() { ResultSet rs = null; try { dropConstraint(); List<DataObject> allTableNames = DBManagerUtils .getAllTableNames(jConn); DBManagerUtils.dropTables(jConn, allTableNames); logger.info("清理数据库，已删除所有表和视图 !"); } catch (Exception e) { logger.error("cleanDatabase() ", e); } finally { DBManagerUtils.colseRs(rs); } } OracleDBManager(); @Override void cleanDatabase(); @Override void executeSQL(String sqlFile); @Override void exportAll(String filePath); @Override void exportExcludes(String filePath,
List<String> excludedTablePrefixs); @Override void exportIncludes(String filePath,
List<String> includedTablePrefixs); } | @Test public void testCleanDatabase() { dbManager.cleanDatabase(); } |
OracleDBManager extends AbstractDBManager { @Override public void executeSQL(String sqlFile) { StringBuffer command = new StringBuffer(); command.append("cmd /c sqlplus "); command.append(username + "/" + password); command.append("@" + databaseName); command.append(" @" + sqlFile); try { logger.info("执行SQL文件：" + sqlFile); Process process = Runtime.getRuntime().exec(command.toString()); process.waitFor(); } catch (IOException e) { logger.error("执行SQL文件出错：" + sqlFile, e); } catch (InterruptedException e) { logger.error("执行SQL文件出错：" + sqlFile, e); } } OracleDBManager(); @Override void cleanDatabase(); @Override void executeSQL(String sqlFile); @Override void exportAll(String filePath); @Override void exportExcludes(String filePath,
List<String> excludedTablePrefixs); @Override void exportIncludes(String filePath,
List<String> includedTablePrefixs); } | @Test public void testExecuteSQL() { String sqlFile = "src/test/resources/scripts/oracle.sql"; dbManager.executeSQL(sqlFile); } |
OracleDBManager extends AbstractDBManager { @Override public void exportAll(String filePath) { String file = exportFileName(filePath); StringBuffer command = getBaseOracleExpSQL(); command.append(" file=" + file); command.append(" owner=" + username); try { logger.info("执行命令：" + command.toString()); Runtime.getRuntime().exec(command.toString()); logger.info("已导出数据库中所有表(包括视图)到：" + file); } catch (IOException e) { logger.error("", e); } } OracleDBManager(); @Override void cleanDatabase(); @Override void executeSQL(String sqlFile); @Override void exportAll(String filePath); @Override void exportExcludes(String filePath,
List<String> excludedTablePrefixs); @Override void exportIncludes(String filePath,
List<String> includedTablePrefixs); } | @Test public void testExportAll() { dbManager.exportAll(filePath); } |
OracleDBManager extends AbstractDBManager { @Override public void exportExcludes(String filePath, List<String> excludedTablePrefixs) { try { List<String> excludeds = DBManagerUtils.loadIncludedTableName( jConn, excludedTablePrefixs); String tables = DBManagerUtils.getString(excludeds); if (StringUtils.isBlank(tables)) { logger.info("没有任何表或者视图需要导出."); return; } String file = exportFileName(filePath); StringBuffer command = getBaseOracleExpSQL(); command.append(" tables=(" + tables + ")"); command.append(" file=" + file); logger.info("执行命令:" + command.toString()); Runtime.getRuntime().exec(command.toString()); logger.info("已导出数据库中不是以[ " + DBManagerUtils.getString(excludedTablePrefixs) + " ]前缀开头的表(包括视图)到：" + file); } catch (IOException e) { logger.error("", e); } catch (Exception e1) { logger.error("", e1); } } OracleDBManager(); @Override void cleanDatabase(); @Override void executeSQL(String sqlFile); @Override void exportAll(String filePath); @Override void exportExcludes(String filePath,
List<String> excludedTablePrefixs); @Override void exportIncludes(String filePath,
List<String> includedTablePrefixs); } | @Test public void testExportExcludes() { List<String> excludes = new ArrayList<String>(); excludes.add("test_"); dbManager.exportExcludes(filePath,excludes); } |
OracleDBManager extends AbstractDBManager { @Override public void exportIncludes(String filePath, List<String> includedTablePrefixs) { try { List<String> excludeds = DBManagerUtils.loadExcludedTableName( jConn, includedTablePrefixs); String tables = DBManagerUtils.getString(excludeds); if (StringUtils.isBlank(tables)) { logger.info("没有任何表或者视图需要导出."); return; } String file = exportFileName(filePath); StringBuffer command = getBaseOracleExpSQL(); command.append(" tables=(" + tables + ")"); command.append(" file=" + file); logger.info("执行命令:" + command.toString()); Runtime.getRuntime().exec(command.toString()); logger.info("已导出数据库中以[ " + DBManagerUtils.getString(includedTablePrefixs) + " ]前缀开头的表(包括视图)到：" + file); } catch (IOException e) { logger.error("", e); } catch (Exception e1) { logger.error("", e1); } } OracleDBManager(); @Override void cleanDatabase(); @Override void executeSQL(String sqlFile); @Override void exportAll(String filePath); @Override void exportExcludes(String filePath,
List<String> excludedTablePrefixs); @Override void exportIncludes(String filePath,
List<String> includedTablePrefixs); } | @Test public void testExportIncludes() { List<String> includes = new ArrayList<String>(); includes.add("test_"); dbManager.exportIncludes(filePath, includes); } |
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> T getUnmodified(Class<T> clazz, T entity) { getSession().evict(entity); return get(clazz, entity.getId()); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testGetUnmodified() { male.setText("xyz"); Dictionary unmodified = repository.getUnmodified(Dictionary.class, male); assertEquals("男", unmodified.getText()); assertEquals("xyz", male.getText()); } |
MySQLDBManager extends AbstractDBManager { @Override public void cleanDatabase() { ResultSet rs = null; try { dropConstraint(); List<DataObject> allTableNames = DBManagerUtils.getAllTableNames(jConn); DBManagerUtils.dropTables(jConn, allTableNames); info("清理数据库，已删除所有表和视图 !"); } catch (Exception e) { error("cleanDatabase()", e); } finally { DBManagerUtils.colseRs(rs); } } MySQLDBManager(); @Override void cleanDatabase(); @Override void executeSQL(String sqlFile); @Override void exportAll(String filePath); @Override void exportExcludes(String filePath, List<String> excludedTablePrefixs); @Override void exportIncludes(String filePath, List<String> includedTablePrefixs); } | @Test public void testCleanDatabase() { dbManager.cleanDatabase(); } |
MySQLDBManager extends AbstractDBManager { @Override public void executeSQL(String sqlFile) { StringBuffer sb = new StringBuffer(); sb.append("cmd /c mysql"); sb.append(" -h " + hostName); sb.append(" -u" + username); sb.append(" -p" + password); sb.append(" " + databaseName + " < "); sb.append(sqlFile); try { Process process = Runtime.getRuntime().exec(sb.toString()); process.waitFor(); info("已执行完SQL脚本：" + sqlFile); } catch (IOException e) { error("executeSQL() ", e); } catch (InterruptedException e) { error("executeSQL() ", e); } } MySQLDBManager(); @Override void cleanDatabase(); @Override void executeSQL(String sqlFile); @Override void exportAll(String filePath); @Override void exportExcludes(String filePath, List<String> excludedTablePrefixs); @Override void exportIncludes(String filePath, List<String> includedTablePrefixs); } | @Test public void testExecuteSQL() { String sqlFile = "src/test/resources/scripts/mysql.sql"; dbManager.executeSQL(sqlFile); } |
MySQLDBManager extends AbstractDBManager { @Override public void exportAll(String filePath) { StringBuffer commond = getBaseMySQLDumpCommond(); String file = exportFileName(filePath); commond.append(" > " + file); try { Runtime.getRuntime().exec(commond.toString()); info("已导出数据库中所有表(包括视图)到：" + file); } catch (IOException e) { error("exportAll() ", e); } } MySQLDBManager(); @Override void cleanDatabase(); @Override void executeSQL(String sqlFile); @Override void exportAll(String filePath); @Override void exportExcludes(String filePath, List<String> excludedTablePrefixs); @Override void exportIncludes(String filePath, List<String> includedTablePrefixs); } | @Test public void testExportAll() { dbManager.exportAll(filePath); } |
MySQLDBManager extends AbstractDBManager { @Override public void exportExcludes(String filePath, List<String> excludedTablePrefixs) { try { List<String> loadExcludedTableName = DBManagerUtils.loadExcludedTableName(jConn, excludedTablePrefixs); if (loadExcludedTableName == null || loadExcludedTableName.size() <= 0) { info("没有任何表需要导出."); return; } StringBuffer commond = getBaseMySQLDumpCommond(); commond.append(" --tables "); for (String name : loadExcludedTableName) { commond.append(name + " "); } String file = exportFileName(filePath); commond.append(" > " + file); Runtime.getRuntime().exec(commond.toString()); info("已导出数据库中不是以[ " + DBManagerUtils.getString(excludedTablePrefixs) + " ]前缀开头的表(包括视图)到：" + file); } catch (IOException e) { error("exportIncludes() ", e); } catch (Exception e1) { error(e1.getMessage()); } } MySQLDBManager(); @Override void cleanDatabase(); @Override void executeSQL(String sqlFile); @Override void exportAll(String filePath); @Override void exportExcludes(String filePath, List<String> excludedTablePrefixs); @Override void exportIncludes(String filePath, List<String> includedTablePrefixs); } | @Test public void testExportExcludes() { List<String> excludes = new ArrayList<String>(); excludes.add("test_"); dbManager.exportExcludes(filePath,excludes); } |
MySQLDBManager extends AbstractDBManager { @Override public void exportIncludes(String filePath, List<String> includedTablePrefixs) { try { List<String> includedTableName = DBManagerUtils.loadIncludedTableName(jConn, includedTablePrefixs); if (includedTableName == null || includedTableName.size() <= 0) { info("没有任何表需要导出."); return; } StringBuffer commond = getBaseMySQLDumpCommond(); commond.append(" --tables "); for (String name : includedTableName) { commond.append(name + " "); } String file = exportFileName(filePath); commond.append(" > " + file); Runtime.getRuntime().exec(commond.toString()); info("已导出数据库中以[ " + DBManagerUtils.getString(includedTablePrefixs) + " ]前缀开头的表(包括视图)到：" + file); } catch (IOException e) { error("exportIncludes() ", e); } catch (Exception e1) { error("exportIncludes() ", e1); } } MySQLDBManager(); @Override void cleanDatabase(); @Override void executeSQL(String sqlFile); @Override void exportAll(String filePath); @Override void exportExcludes(String filePath, List<String> excludedTablePrefixs); @Override void exportIncludes(String filePath, List<String> includedTablePrefixs); } | @Test public void testExportIncludes() { List<String> includes = new ArrayList<String>(); includes.add("test_"); dbManager.exportIncludes(filePath, includes); } |
Person extends AbstractEntity { public Map<ImType, String> getIms() { return Collections.unmodifiableMap(ims); } Person(PersonName name); Person(String firstName, String lastName); PersonName getName(); void setName(PersonName name); String getIdNumber(); void setIdNumber(String idNumber); Set<Email> getEmails(); void setEmails(Set<Email> emails); void addEmail(Email email); void removeEmail(Email email); Map<ImType, String> getIms(); void setIms(Map<ImType, String> ims); void setIm(ImType imType, String imAddress); void removeIm(ImType imType); Address getHomeAddress(); void setHomeAddress(Address homeAddress); Address getMailAddress(); void setMailAddress(Address mailAddress); @Override String[] businessKeys(); @Override String toString(); } | @Test public void testGetIms() { String jpql = "select o from Person o join o.ims i where KEY(i) = :imType and i = :im"; EntityRepository repository = InstanceFactory.getInstance(EntityRepository.class); List<Person> persons = repository.createJpqlQuery(jpql) .addParameter("imType", ImType.QQ).addParameter("im", "666666").list(); assertFalse(persons.contains(person1)); assertTrue(persons.contains(person2)); } |
Employment extends Accountability<Company, Employee> { public static Company getEmployer(Employee employee, Date date) { return getRepository().createNamedQuery("Employment.getEmployer") .addParameter("employee", employee).addParameter("date", date).singleResult(); } protected Employment(); Employment(Company company, Employee employee, Date date); static Company getEmployer(Employee employee, Date date); static List<Employee> getEmployees(Company employer, Date date); @Override String toString(); } | @Test public final void testGetEmployer() { OrganisationUtils organisationUtils = new OrganisationUtils(); Date date = DateUtils.date(2012, 1, 3); Company company = organisationUtils.createCompany("总公司", date); Person zhang = organisationUtils.createPerson("三", "张"); Employee zhangsan = organisationUtils.createEmployee(zhang, date); Person li = organisationUtils.createPerson("四", "李"); Employee lisi = organisationUtils.createEmployee(li, date); new Employment(company, zhangsan, date).save(); assertThat("张三的雇主应该是company", Employment.getEmployer(zhangsan, DateUtils.date(2012, 1, 3)), is(company)); assertThat("李四的雇主不是company", Employment.getEmployer(lisi, DateUtils.date(2012, 1, 3)), not(is(company))); } |
Accountability extends AbstractEntity { @SuppressWarnings("rawtypes") public static <T extends Accountability> List<T> findAccountabilities(Class<T> accountabilityClass, Date date) { return getRepository().createCriteriaQuery(accountabilityClass).le("fromDate", date).gt("toDate", date).list(); } protected Accountability(); Accountability(C commissioner, R responsible, Date fromDate); C getCommissioner(); void setCommissioner(C commissioner); R getResponsible(); void setResponsible(R responsible); Date getFromDate(); Date getToDate(); @Override String[] businessKeys(); void terminate(Date date); @SuppressWarnings("rawtypes") static List<T> findAccountabilities(Class<T> accountabilityClass, Date date); static void when(PartyTerminatedEvent event); } | @SuppressWarnings("rawtypes") @Test public final void testFindAccountabilities() { OrganisationUtils organisationUtils = new OrganisationUtils(); Date date = DateUtils.date(2012, 1, 3); Company company = organisationUtils.createCompany("总公司", date); Department financial = organisationUtils.createDepartment("财务部", company, date); Person person = organisationUtils.createPerson("Martin", "Fowler"); Employee employee = organisationUtils.createEmployee(person, date); Employment employment = new Employment(company, employee, date); employment.save(); List<Accountability> results = Accountability.findAccountabilities(Accountability.class, date); OrgLineMgmt lineMgmt = OrgLineMgmt.getByResponsible(financial, date); assertTrue(results.contains(lineMgmt)); assertTrue(results.contains(employment)); } |
ScriptService { public ScriptEngine getEngine() { return getScriptEngineManager().getEngineByName(scriptType); } ScriptService(); ScriptService(String scriptType); ScriptEngine getEngine(); ScriptEngineManager getScriptEngineManager(); ScriptEngineFactory getScriptEngineFactory(); } | @Test public void testConstructorWithoutArgs() { ScriptService service = new ScriptService(); String engineName = service.getEngine().getFactory().getEngineName(); assertEquals("Groovy Scripting Engine", engineName); }
@Test public void testConstructorWithArgs() { ScriptService service = new ScriptService(ScriptType.GROOVY); String engineName = service.getEngine().getFactory().getEngineName(); assertEquals("Groovy Scripting Engine", engineName); service = new ScriptService(ScriptType.JS); engineName = service.getEngine().getFactory().getEngineName(); Set<String> engineNames = new HashSet<String>(); engineNames.add("Mozilla Rhino"); engineNames.add("Oracle Nashorn"); assertThat(engineNames, hasItem(engineName)); }
@Test public void testEvalStringGroovy() throws ScriptException { ScriptEngine engine = new ScriptService().getEngine(); String script = "System.out.println(\"Hello!!!!\");"; engine.eval(script); }
@Test public void testEvalStringJavascript() throws ScriptException { ScriptEngine engine = new ScriptService(ScriptType.JS).getEngine(); String script = "eval(\"3 + 2\");"; System.out.println(engine.eval(script)); }
@Test public void testEvalReader() throws ScriptException, FileNotFoundException, MalformedURLException, URISyntaxException { ScriptEngine engine = new ScriptService().getEngine(); InputStream in = getClass().getResourceAsStream("/test.groovy"); engine.eval(new InputStreamReader(in)); } |
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues) { List<T> results = findByProperties(clazz, keyValues); return results.isEmpty() ? null : results.get(0); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testGetByBusinessKeys() { NamedParameters params = NamedParameters.create() .add("category", education) .add("code", "02"); Dictionary result = repository.getByBusinessKeys(Dictionary.class, params); assertEquals(graduate, result); } |
YmlParser extends AbstractDefinitionParser { @Override public Set<ClassDefinition> parseReader(Reader in) { final JsonNode node; try { node = objectMapper.readTree(yamlFactory.createParser(in)); PackageDefinition packageDefinition = objectMapper.readValue(new TreeTraversingParser(node), PackageDefinition.class); return toClassDefinitions(packageDefinition); } catch (IOException e) { throw new ParsingException("Cannot parse reader!"); } } YmlParser(); YmlParser(YAMLFactory yamlFactory, ObjectMapper objectMapper); @Override Set<ClassDefinition> parseReader(Reader in); @Override Set<ClassDefinition> parseClasspath(String file); @Override Set<ClassDefinition> parseFile(String file); @Override Set<ClassDefinition> parseFile(File file); @Override boolean accept(String ext); } | @Test public void parseReader() throws Exception { } |
YmlParser extends AbstractDefinitionParser { @Override public Set<ClassDefinition> parseClasspath(String file) { return null; } YmlParser(); YmlParser(YAMLFactory yamlFactory, ObjectMapper objectMapper); @Override Set<ClassDefinition> parseReader(Reader in); @Override Set<ClassDefinition> parseClasspath(String file); @Override Set<ClassDefinition> parseFile(String file); @Override Set<ClassDefinition> parseFile(File file); @Override boolean accept(String ext); } | @Test public void parseClasspath() throws Exception { Set<ClassDefinition> classDefinitions = instance.parseClasspath("/products.yml"); } |
YmlParser extends AbstractDefinitionParser { @Override public Set<ClassDefinition> parseFile(String file) { return null; } YmlParser(); YmlParser(YAMLFactory yamlFactory, ObjectMapper objectMapper); @Override Set<ClassDefinition> parseReader(Reader in); @Override Set<ClassDefinition> parseClasspath(String file); @Override Set<ClassDefinition> parseFile(String file); @Override Set<ClassDefinition> parseFile(File file); @Override boolean accept(String ext); } | @Test public void parseFile() throws Exception { } |
YmlParser extends AbstractDefinitionParser { @Override public boolean accept(String ext) { return "yml".equals(ext); } YmlParser(); YmlParser(YAMLFactory yamlFactory, ObjectMapper objectMapper); @Override Set<ClassDefinition> parseReader(Reader in); @Override Set<ClassDefinition> parseClasspath(String file); @Override Set<ClassDefinition> parseFile(String file); @Override Set<ClassDefinition> parseFile(File file); @Override boolean accept(String ext); } | @Test public void accept() throws Exception { assertThat(instance.accept("yml")).isTrue(); assertThat(instance.accept("json")).isFalse(); } |
DomainClassGenerator { public Set<JavaSourceFile> generateFromFile(String file) { String ext = getExtOfFile(file); return generateFrom(parserOf(ext).parseFile(file)); } DomainClassGenerator(Set<DefinitionParser> parsers, ClassGenerator generator); Set<JavaSourceFile> generateFromFile(String file); Set<JavaSourceFile> generateFromFile(File file); Set<JavaSourceFile> generateFromClasspath(String filePath); Set<JavaSourceFile> generateFromReader(Reader in, String type); } | @Test public void generateFromFile() throws Exception { String filename = getClass().getResource("/sales.yml").getFile(); File file = new File(filename); when(parser.parseFile(file)).thenReturn(definitions); when(generator.generate(definition1)).thenReturn(sourceFile1); when(generator.generate(definition2)).thenReturn(sourceFile2); Set<JavaSourceFile> results = instance.generateFromFile(file); assertThat(results).containsExactlyInAnyOrder(sourceFile1, sourceFile2); }
@Test public void generateFromFilename() throws Exception { String filename = getClass().getResource("/sales.yml").getFile(); when(parser.parseFile(filename)).thenReturn(definitions); when(generator.generate(definition1)).thenReturn(sourceFile1); when(generator.generate(definition2)).thenReturn(sourceFile2); Set<JavaSourceFile> results = instance.generateFromFile(filename); assertThat(results).containsExactlyInAnyOrder(sourceFile1, sourceFile2); } |
DomainClassGenerator { public Set<JavaSourceFile> generateFromClasspath(String filePath) { String ext = getExtOfFile(filePath); return generateFrom(parserOf(ext).parseClasspath(filePath)); } DomainClassGenerator(Set<DefinitionParser> parsers, ClassGenerator generator); Set<JavaSourceFile> generateFromFile(String file); Set<JavaSourceFile> generateFromFile(File file); Set<JavaSourceFile> generateFromClasspath(String filePath); Set<JavaSourceFile> generateFromReader(Reader in, String type); } | @Test public void generateFromClasspath() throws Exception { String filename = "/sales.yml"; when(parser.parseClasspath(filename)).thenReturn(definitions); when(generator.generate(definition1)).thenReturn(sourceFile1); when(generator.generate(definition2)).thenReturn(sourceFile2); Set<JavaSourceFile> results = instance.generateFromClasspath(filename); assertThat(results).containsExactlyInAnyOrder(sourceFile1, sourceFile2); } |
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> List<T> findAll(Class<T> clazz) { return getSession().createCriteria(clazz).list(); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testFindAll() { List<Dictionary> results = repository.findAll(Dictionary.class); assertTrue(results.containsAll(Arrays.asList(male, undergraduate, graduate, associate))); } |
DomainClassGenerator { public Set<JavaSourceFile> generateFromReader(Reader in, String type) { return generateFrom(parserOf(type).parseReader(in)); } DomainClassGenerator(Set<DefinitionParser> parsers, ClassGenerator generator); Set<JavaSourceFile> generateFromFile(String file); Set<JavaSourceFile> generateFromFile(File file); Set<JavaSourceFile> generateFromClasspath(String filePath); Set<JavaSourceFile> generateFromReader(Reader in, String type); } | @Test public void generateFromReader() throws Exception { String filename = "/sales.yml"; Reader in = new InputStreamReader(getClass().getResourceAsStream(filename)); when(parser.parseReader(in)).thenReturn(definitions); when(generator.generate(definition1)).thenReturn(sourceFile1); when(generator.generate(definition2)).thenReturn(sourceFile2); Set<JavaSourceFile> results = instance.generateFromReader(in, "yml"); assertThat(results).containsExactlyInAnyOrder(sourceFile1, sourceFile2); } |
ThreadLocalTenantService implements TenantService { @Override public String getTenant() { return ThreadLocalTenantHolder.getTenant(); } @Override String getTenant(); } | @Test public void test() { assertNull(instance.getTenant()); String tenant = "abc"; ThreadLocalTenantHolder.setTenant(tenant); assertEquals(tenant, instance.getTenant()); ThreadLocalTenantHolder.removeTenant(); assertNull(instance.getTenant()); } |
SaasDataSource implements DataSource { @Override public PrintWriter getLogWriter() throws SQLException { return getActualDataSource().getLogWriter(); } SaasDataSource(TenantService tenantService, DataSourceRegistry dataSourceRegistry); @Override PrintWriter getLogWriter(); @Override int getLoginTimeout(); @Override void setLogWriter(PrintWriter out); @Override void setLoginTimeout(int seconds); @Override boolean isWrapperFor(Class<?> iface); @Override T unwrap(Class<T> iface); @Override Connection getConnection(); @Override Connection getConnection(String username, String password); Logger getParentLogger(); } | @Test public void testGetLogWriter() throws SQLException { PrintWriter printWriter = mock(PrintWriter.class); when(actualDataSource.getLogWriter()).thenReturn(printWriter); assertSame(printWriter, instance.getLogWriter()); } |
SaasDataSource implements DataSource { @Override public int getLoginTimeout() throws SQLException { return getActualDataSource().getLoginTimeout(); } SaasDataSource(TenantService tenantService, DataSourceRegistry dataSourceRegistry); @Override PrintWriter getLogWriter(); @Override int getLoginTimeout(); @Override void setLogWriter(PrintWriter out); @Override void setLoginTimeout(int seconds); @Override boolean isWrapperFor(Class<?> iface); @Override T unwrap(Class<T> iface); @Override Connection getConnection(); @Override Connection getConnection(String username, String password); Logger getParentLogger(); } | @Test public void testGetLoginTimeout() throws SQLException { int timeout = 1000; when(actualDataSource.getLoginTimeout()).thenReturn(timeout); assertEquals(timeout, actualDataSource.getLoginTimeout()); } |
SaasDataSource implements DataSource { @Override public void setLogWriter(PrintWriter out) throws SQLException { getActualDataSource().setLogWriter(out); } SaasDataSource(TenantService tenantService, DataSourceRegistry dataSourceRegistry); @Override PrintWriter getLogWriter(); @Override int getLoginTimeout(); @Override void setLogWriter(PrintWriter out); @Override void setLoginTimeout(int seconds); @Override boolean isWrapperFor(Class<?> iface); @Override T unwrap(Class<T> iface); @Override Connection getConnection(); @Override Connection getConnection(String username, String password); Logger getParentLogger(); } | @Test public void testSetLogWriter() throws SQLException { PrintWriter printWriter = mock(PrintWriter.class); instance.setLogWriter(printWriter); verify(actualDataSource).setLogWriter(printWriter); } |
SaasDataSource implements DataSource { @Override public void setLoginTimeout(int seconds) throws SQLException { getActualDataSource().setLoginTimeout(seconds); } SaasDataSource(TenantService tenantService, DataSourceRegistry dataSourceRegistry); @Override PrintWriter getLogWriter(); @Override int getLoginTimeout(); @Override void setLogWriter(PrintWriter out); @Override void setLoginTimeout(int seconds); @Override boolean isWrapperFor(Class<?> iface); @Override T unwrap(Class<T> iface); @Override Connection getConnection(); @Override Connection getConnection(String username, String password); Logger getParentLogger(); } | @Test public void testSetLoginTimeout() throws SQLException { int seconds = 100; instance.setLoginTimeout(seconds); verify(actualDataSource).setLoginTimeout(seconds); } |
SaasDataSource implements DataSource { @Override public boolean isWrapperFor(Class<?> iface) throws SQLException { return getActualDataSource().isWrapperFor(iface); } SaasDataSource(TenantService tenantService, DataSourceRegistry dataSourceRegistry); @Override PrintWriter getLogWriter(); @Override int getLoginTimeout(); @Override void setLogWriter(PrintWriter out); @Override void setLoginTimeout(int seconds); @Override boolean isWrapperFor(Class<?> iface); @Override T unwrap(Class<T> iface); @Override Connection getConnection(); @Override Connection getConnection(String username, String password); Logger getParentLogger(); } | @Test public void testIsWrapperFor() throws SQLException { Class<String> stringClass = String.class; Class<Long> longClass = Long.class; when(actualDataSource.isWrapperFor(stringClass)).thenReturn(true); assertTrue(instance.isWrapperFor(stringClass)); when(actualDataSource.isWrapperFor(longClass)).thenReturn(false); assertFalse(instance.isWrapperFor(longClass)); } |
SaasDataSource implements DataSource { @Override public <T> T unwrap(Class<T> iface) throws SQLException { return getActualDataSource().unwrap(iface); } SaasDataSource(TenantService tenantService, DataSourceRegistry dataSourceRegistry); @Override PrintWriter getLogWriter(); @Override int getLoginTimeout(); @Override void setLogWriter(PrintWriter out); @Override void setLoginTimeout(int seconds); @Override boolean isWrapperFor(Class<?> iface); @Override T unwrap(Class<T> iface); @Override Connection getConnection(); @Override Connection getConnection(String username, String password); Logger getParentLogger(); } | @Test public void testUnwrap() throws SQLException { String result = "abcddddd"; when(actualDataSource.unwrap(String.class)).thenReturn(result); assertSame(result, instance.unwrap(String.class)); } |
SaasDataSource implements DataSource { @Override public Connection getConnection() throws SQLException { return getActualDataSource().getConnection(); } SaasDataSource(TenantService tenantService, DataSourceRegistry dataSourceRegistry); @Override PrintWriter getLogWriter(); @Override int getLoginTimeout(); @Override void setLogWriter(PrintWriter out); @Override void setLoginTimeout(int seconds); @Override boolean isWrapperFor(Class<?> iface); @Override T unwrap(Class<T> iface); @Override Connection getConnection(); @Override Connection getConnection(String username, String password); Logger getParentLogger(); } | @Test public void testGetConnection() throws SQLException { Connection result = mock(Connection.class); when(actualDataSource.getConnection()).thenReturn(result); assertSame(result, instance.getConnection()); }
@Test public void testGetConnectionWithUsernameAndPassword() throws SQLException { String username = "zhangsan"; String password = "pwd"; Connection result = mock(Connection.class); when(actualDataSource.getConnection(username, password)).thenReturn(result); assertSame(result, instance.getConnection(username, password)); } |
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> CriteriaQuery createCriteriaQuery(Class<T> entityClass) { return new CriteriaQuery(this, entityClass); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testCreateCriteriaQuery() { CriteriaQuery query = repository.createCriteriaQuery(Dictionary.class); assertEquals(Dictionary.class, query.getEntityClass()); } |
EntityRepositoryHibernate implements EntityRepository { @SuppressWarnings("rawtypes") @Override public <T> List<T> find(CriteriaQuery criteriaQuery) { Query query = getSession().createQuery(criteriaQuery.getQueryString()); processQuery(query, criteriaQuery.getParameters(), criteriaQuery.getFirstResult(), criteriaQuery.getMaxResults()); return query.list(); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testCriteriaQueryFind() { CriteriaQuery query = new CriteriaQuery(repository, Dictionary.class) .eq("category", education); List<Dictionary> results = repository.find(query); assertTrue(results.contains(graduate)); assertTrue(results.contains(undergraduate)); }
@Test public void testFindByCriterion() { QueryCriterion criterion = Criteria.eq("category", education); List<Dictionary> results = repository.find(Dictionary.class, criterion); assertTrue(results.contains(graduate)); assertTrue(results.contains(undergraduate)); }
@Test public void testJpqlQueryFindWithArrayParameters() { String queryString = "select o from Dictionary o where o.category = ?1"; JpqlQuery query = new JpqlQuery(repository, queryString).setParameters(gender); List<Dictionary> results = repository.find(query); assertTrue(results.contains(male)); assertFalse(results.contains(undergraduate)); }
@Test public void testJpqlQueryFindWithMapParameters() { String queryString = "select o from Dictionary o where o.category = :category"; JpqlQuery query = new JpqlQuery(repository, queryString) .addParameter("category", gender); List<Dictionary> results = repository.find(query); assertTrue(results.contains(male)); assertFalse(results.contains(undergraduate)); }
@Test public void testJpqlQueryScalar() { String queryString = "select o.code, o.text from Dictionary o where o.category = :category"; JpqlQuery query = new JpqlQuery(repository, queryString) .addParameter("category", gender); List<Object[]> results = repository.find(query); for (Object[] row : results) { System.out.println(Arrays.toString(row)); } }
@Test public void testNamedQueryFindWithArrayParameters() { NamedQuery query = new NamedQuery(repository, "Dictionay.findByCategoryArrayParams") .setParameters(gender); List<Dictionary> results = repository.find(query); assertTrue(results.contains(male)); assertFalse(results.contains(undergraduate)); }
@Test public void testNamedQueryFindWithMapParameters() { NamedQuery query = new NamedQuery(repository, "Dictionay.findByCategory") .addParameter("category", gender); List<Dictionary> results = repository.find(query); assertTrue(results.contains(male)); assertFalse(results.contains(undergraduate)); }
@Test public void testNamedQueryScalar() { NamedQuery query = new NamedQuery(repository, "Dictionay.findNameAndOrder") .addParameter("category", gender); List<Object[]> results = repository.find(query); for (Object[] row : results) { System.out.println(Arrays.toString(row)); } }
@Test public void testSqlQueryFindWithArrayParameters() { String sql = "select * from dictionaries as o where o.is_disabled = ?1 and o.category_id = ?2 order by o.sort_order"; SqlQuery query = new SqlQuery(repository, sql) .setParameters(false, gender.getId()) .setResultEntityClass(Dictionary.class); List<Dictionary> results = repository.find(query); assertTrue(results.contains(male)); assertFalse(results.contains(undergraduate)); }
@Test public void testSqlQueryFindWithMapParameters() { String sql = "select * from dictionaries as o where o.is_disabled = :disabled " + "and o.category_id = :categoryId order by o.sort_order"; SqlQuery query = new SqlQuery(repository, sql) .addParameter("categoryId", gender.getId()) .addParameter("disabled", false) .setResultEntityClass(Dictionary.class); List<Dictionary> results = repository.find(query); assertTrue(results.contains(male)); assertFalse(results.contains(undergraduate)); }
@Test public void testSqlQueryScalar() { String sql = "select o.code, o.text from dictionaries o where o.category_id = :category"; SqlQuery query = new SqlQuery(repository, sql) .addParameter("category", gender); List<Object[]> results = repository.find(query); for (Object[] row : results) { System.out.println(Arrays.toString(row)); } } |
EntityRepositoryHibernate implements EntityRepository { @Override public <T> T getSingleResult(CriteriaQuery criteriaQuery) { List<T> results = find(criteriaQuery); return results == null || results.isEmpty() ? null : results.get(0); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testCriteriaQueryGetSingleResult() { CriteriaQuery query = new CriteriaQuery(repository, Dictionary.class) .eq("category", gender) .eq("code", "01"); assertEquals(male, repository.getSingleResult(query)); }
@Test public void testGetSingleResultByCriterion() { QueryCriterion criterion = Criteria.eq("category", education).and(Criteria.eq("code", "01")); Dictionary result = repository.getSingleResult(Dictionary.class, criterion); assertEquals(undergraduate, result); }
@Test public void testJpqlQueryGetSingleResult() { String queryString = "select o from Dictionary o where o.category = :category and o.code = :code"; JpqlQuery query = new JpqlQuery(repository, queryString) .addParameter("category", gender) .addParameter("code", "01"); assertEquals(male, repository.getSingleResult(query)); }
@Test public void testJpqlQueryGetSingleResultCount() { String queryString = "select count(o) from Dictionary o where o.category = :category and o.code = :code"; JpqlQuery query = new JpqlQuery(repository, queryString) .addParameter("category", gender) .addParameter("code", "01"); assertEquals(1L, repository.getSingleResult(query)); }
@Test public void testNamedQueryGetSingleResult() { NamedQuery query = new NamedQuery(repository, "Dictionay.findByCategoryAndCode") .setParameters(gender, "01"); assertEquals(male, repository.getSingleResult(query)); }
@Test public void testNamedQueryGetSingleResultCount() { String queryName = "DictionaryCategory.getCount"; NamedQuery query = new NamedQuery(repository, queryName) .addParameter("name", "gender"); assertEquals(1L, repository.getSingleResult(query)); }
@Test public void testSqlQueryGetSingleResult() { String sql = "select * from dictionaries as o where o.is_disabled = ?1 " + "and o.category_id = ?2 and o.code = ?3"; SqlQuery query = new SqlQuery(repository, sql) .setParameters(false, gender.getId(), "01") .setResultEntityClass(Dictionary.class); assertEquals(male, repository.getSingleResult(query)); }
@Test public void testSqlQueryGetSingleResultCount() { String queryString = "select count(*) from categories o where o.name = :name"; SqlQuery query = new SqlQuery(repository, queryString) .addParameter("name", "gender"); assertEquals(1, ((Number)repository.getSingleResult(query)).longValue()); } |
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> T load(final Class<T> clazz, final Serializable id) { return getEntityManager().getReference(clazz, id); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testLoad() { assertEquals(male.getId(), repository.load(Dictionary.class, male.getId()).getId()); } |
EntityRepositoryHibernate implements EntityRepository { @Override public JpqlQuery createJpqlQuery(String jpql) { return new JpqlQuery(this, jpql); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testCreateJpqlQuery() { String jpql = "select o from Dictionary o"; JpqlQuery query = repository.createJpqlQuery(jpql); assertEquals(jpql, query.getJpql()); } |
EntityRepositoryHibernate implements EntityRepository { @Override public NamedQuery createNamedQuery(String queryName) { return new NamedQuery(this, queryName); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testCreateNamedQuery() { String queryName = "Dictionary.findByCategory"; NamedQuery query = repository.createNamedQuery(queryName); assertEquals(queryName, query.getQueryName()); } |
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> T getUnmodified(final Class<T> clazz, final T entity) { getEntityManager().detach(entity); return get(clazz, entity.getId()); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testGetUnmodified() { male.setText("xyz"); Dictionary unmodified = repository.getUnmodified(Dictionary.class, male); assertEquals("男", unmodified.getText()); assertEquals("xyz", male.getText()); } |
EntityRepositoryHibernate implements EntityRepository { @Override public SqlQuery createSqlQuery(String sql) { return new SqlQuery(this, sql); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testCreateSqlQuery() { String sql = "select * from dictionaries"; SqlQuery query = repository.createSqlQuery(sql); assertEquals(sql, query.getSql()); } |
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity, E extends T> List<T> findByExample(final E example, final ExampleSettings<T> settings) { Example theExample = Example.create(example); if (settings.isLikeEnabled()) { theExample.enableLike(MatchMode.ANYWHERE); } if (settings.isIgnoreCaseEnabled()) { theExample.ignoreCase(); } if (settings.isExcludeNone()) { theExample.excludeNone(); } if (settings.isExcludeZeroes()) { theExample.excludeZeroes(); } for (String propName : settings.getExcludedProperties()) { theExample.excludeProperty(propName); } return getSession().createCriteria(settings.getEntityClass()).add(theExample).list(); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testFindByExample() { Dictionary example = new Dictionary(null, "本", null); List<Dictionary> dictionaries = repository.findByExample(example, ExampleSettings.create(Dictionary.class).excludeZeroes()); assertFalse(dictionaries.contains(male)); assertFalse(dictionaries.contains(undergraduate)); dictionaries = repository.findByExample(example, ExampleSettings.create(Dictionary.class).excludeZeroes().enableLike()); assertTrue(dictionaries.contains(undergraduate)); assertFalse(dictionaries.contains(male)); } |
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues) { List<T> results = findByProperties(clazz, keyValues); return results.isEmpty() ? null : results.get(0); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testGetByBusinessKeys() { NamedParameters params = NamedParameters.create() .add("category", education) .add("code", "02"); Dictionary result = repository.getByBusinessKeys(Dictionary.class, params); assertEquals(graduate, result); } |
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue) { return find(new CriteriaQuery(this, clazz).eq(propertyName, propertyValue)); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testFindByProperty() { List<Dictionary> results = repository.findByProperty(Dictionary.class, "category", education); assertTrue(results.contains(undergraduate)); assertTrue(results.contains(graduate)); assertFalse(results.contains(male)); } |
EntityRepositoryHibernate implements EntityRepository { @Override public <T extends Entity> List<T> findByProperties(Class<T> clazz, NamedParameters properties) { CriteriaQuery criteriaQuery = new CriteriaQuery(this, clazz); for (Map.Entry<String, Object> each : properties.getParams().entrySet()) { criteriaQuery = criteriaQuery.eq(each.getKey(), each.getValue()); } return find(criteriaQuery); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testFindByProperties() { NamedParameters params = NamedParameters.create() .add("category", education) .add("code", "02"); List<Dictionary> results = repository.findByProperties(Dictionary.class, params); assertTrue(results.contains(graduate)); assertFalse(results.contains(undergraduate)); assertFalse(results.contains(male)); } |
EntityRepositoryHibernate implements EntityRepository { @Override public String getQueryStringOfNamedQuery(String queryName) { Query query = getSession().getNamedQuery(queryName); return query.getQueryString(); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testGetQueryStringOfNamedQuery() { assertEquals("select o.code, o.text from Dictionary o where o.category = :category", repository.getQueryStringOfNamedQuery("Dictionay.findNameAndOrder")); } |
EntityRepositoryHibernate implements EntityRepository { @Override public void flush() { getSession().flush(); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testFlush() { String description = "Ha Ha Ha!"; male.setDescription(description); repository.flush(); Dictionary male1 = repository.get(Dictionary.class, male.getId()); assertEquals(description, male1.getDescription()); } |
EntityRepositoryHibernate implements EntityRepository { @Override public void refresh(Entity entity) { getSession().refresh(entity); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testRefresh() { String text = "Ha Ha Ha!"; male.setText(text); repository.refresh(male); assertEquals("男", male.getText()); } |
EntityRepositoryHibernate implements EntityRepository { @Override public void clear() { getSession().clear(); } EntityRepositoryHibernate(); EntityRepositoryHibernate(SessionFactory sessionFactory); EntityRepositoryHibernate(Session session); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz, final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(Class<T> clazz, T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @SuppressWarnings("rawtypes") @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @SuppressWarnings("rawtypes") @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testClear() { repository.clear(); } |
TapestryInstanceProvider implements InstanceProvider { @Override public <T> T getInstance(Class<T> beanType) { try { return registry.getService(beanType); } catch (RuntimeException e) { return null; } } TapestryInstanceProvider(Registry registry); TapestryInstanceProvider(Class<?>... modules); @Override T getInstance(Class<T> beanType); @Override T getInstance(Class<T> beanType, String beanName); @Override T getInstance(Class<T> beanType, Class<? extends Annotation> annotationType); @Override Set<T> getInstances(Class<T> beanType); void shutdown(); } | @Test public void testConstructorFromModule() { Service1 service = getProvider().getInstance(Service1.class); assertEquals("MyService1", service.name()); } |
GuiceInstanceProvider implements InstanceProvider { @Override public <T> T getInstance(Class<T> beanType) { try { return injector.getInstance(beanType); } catch (com.google.inject.ConfigurationException e) { return null; } } GuiceInstanceProvider(Module... modules); GuiceInstanceProvider(Injector injector); @Override T getInstance(Class<T> beanType); @Override T getInstance(Class<T> beanType, String beanName); @Override T getInstance(Class<T> beanType, Class<? extends Annotation> annotationType); @Override Set<T> getInstances(Class<T> beanType); } | @Test public void testConstructorFromModule() { assertEquals("I am Service 1", getProvider().getInstance(Service1.class).sayHello()); }
@Test public void testConstructorFromInjector() { InstanceProvider provider = new GuiceInstanceProvider(createInjector()); assertEquals("I am Service 1", provider.getInstance(Service1.class).sayHello()); }
@Override @Test public void testGetInstanceWithAnnotation() { Service3 service = getProvider().getInstance(Service3.class, MyBindingAnnotation.class); assertNotNull(service); } |
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> List<T> findAll(final Class<T> clazz) { String queryString = "select o from " + clazz.getName() + " as o"; return getEntityManager().createQuery(queryString).getResultList(); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testFindAll() { List<Dictionary> results = repository.findAll(Dictionary.class); assertTrue(results.containsAll(Arrays.asList(male, undergraduate, graduate, associate))); } |
GuiceInstanceProvider implements InstanceProvider { @Override public <T> Set<T> getInstances(Class<T> beanType) { Map<Key<?>, Binding<?>> allBindings = injector.getAllBindings(); Set<T> results = new HashSet<T>(); for (Map.Entry<Key<?>, Binding<?>> entry : allBindings.entrySet()) { Key<?> key = entry.getKey(); System.out.println("Key: " + key.getTypeLiteral().getRawType()); if (beanType.isAssignableFrom(key.getTypeLiteral().getRawType())) { System.out.println("True"); results.add((T) entry.getValue().getProvider().get()); } } return results; } GuiceInstanceProvider(Module... modules); GuiceInstanceProvider(Injector injector); @Override T getInstance(Class<T> beanType); @Override T getInstance(Class<T> beanType, String beanName); @Override T getInstance(Class<T> beanType, Class<? extends Annotation> annotationType); @Override Set<T> getInstances(Class<T> beanType); } | @Test public void testGetInstances() { List<Service> expected = Arrays.asList( new MyService1(), new MyService21(), new MyService22(), new MyService31() ); Set<Service> services = getProvider().getInstances(Service.class); assertTrue(services.containsAll(expected)); } |
BaseEntity implements Entity { @Override public boolean existed() { Object id = getId(); if (id == null) { return false; } if (id instanceof Number && ((Number)id).intValue() == 0) { return false; } return getRepository().exists(getClass(), getId()); } @Override boolean existed(); @Override boolean notExisted(); static void setRepository(EntityRepository repository); String[] businessKeys(); @Override int hashCode(); @Override boolean equals(Object other); } | @Test public void testExistedIdIsNull() { guangdong.setId(null); assertFalse(guangdong.existed()); }
@Test public void testExistedIdIsZero() { guangdong.setId(0); assertFalse(guangdong.existed()); }
@Test public void testExistedRepositoryNotFound() { guangdong.setId(3); when(repository.exists(Organization.class, 3)).thenReturn(false); assertFalse(guangdong.existed()); }
@Test public void testExistedRepositoryFound() { guangdong.setId(3); when(repository.exists(Company.class, 3)).thenReturn(true); assertTrue(guangdong.existed()); } |
BaseEntity implements Entity { @Override public boolean notExisted() { return !existed(); } @Override boolean existed(); @Override boolean notExisted(); static void setRepository(EntityRepository repository); String[] businessKeys(); @Override int hashCode(); @Override boolean equals(Object other); } | @Test public void testNotExistedIdIsNull() { guangdong.setId(null); assertTrue(guangdong.notExisted()); }
@Test public void testNotExistedIdIsZero() { guangdong.setId(0); assertTrue(guangdong.notExisted()); }
@Test public void testNotExistedRepositoryNotFound() { guangdong.setId(3); when(repository.exists(Company.class, 3)).thenReturn(false); assertTrue(guangdong.notExisted()); }
@Test public void testNotExistedRepositoryFound() { guangdong.setId(3); when(repository.exists(Company.class, 3)).thenReturn(true); assertFalse(guangdong.notExisted()); }
@Test public void testNotExisted() { guangdong.setId(null); assertTrue(guangdong.notExisted()); guangdong.setId(0); assertTrue(guangdong.notExisted()); guangdong.setId(3); when(repository.exists(Company.class, 3)).thenReturn(false); assertTrue(guangdong.notExisted()); reset(repository); when(repository.exists(Company.class, 3)).thenReturn(true); assertFalse(guangdong.notExisted()); } |
EntityRepositoryJpa implements EntityRepository { @Override public <T extends Entity> CriteriaQuery createCriteriaQuery(Class<T> entityClass) { return new CriteriaQuery(this, entityClass); } EntityRepositoryJpa(); EntityRepositoryJpa(EntityManager entityManager); EntityRepositoryJpa(EntityManagerFactory entityManagerFactory); EntityRepositoryJpa(NamedQueryParser namedQueryParser, EntityManagerFactory entityManagerFactory); final void setNamedQueryParser(NamedQueryParser namedQueryParser); @Override T save(T entity); @Override void remove(Entity entity); @Override boolean exists(final Class<T> clazz,
final Serializable id); @Override T get(final Class<T> clazz, final Serializable id); @Override T load(final Class<T> clazz, final Serializable id); @Override T getUnmodified(final Class<T> clazz,
final T entity); @Override T getByBusinessKeys(Class<T> clazz, NamedParameters keyValues); @Override List<T> findAll(final Class<T> clazz); @Override CriteriaQuery createCriteriaQuery(Class<T> entityClass); @Override List<T> find(CriteriaQuery criteriaQuery); @Override T getSingleResult(CriteriaQuery criteriaQuery); @Override List<T> find(Class<T> entityClass, QueryCriterion criterion); @Override T getSingleResult(Class<T> entityClass, QueryCriterion criterion); @Override JpqlQuery createJpqlQuery(String jpql); @Override List<T> find(JpqlQuery jpqlQuery); @Override T getSingleResult(JpqlQuery jpqlQuery); @Override int executeUpdate(JpqlQuery jpqlQuery); @Override NamedQuery createNamedQuery(String queryName); @Override List<T> find(NamedQuery namedQuery); @Override T getSingleResult(NamedQuery namedQuery); @Override int executeUpdate(NamedQuery namedQuery); @Override SqlQuery createSqlQuery(String sql); @Override List<T> find(SqlQuery sqlQuery); @Override T getSingleResult(SqlQuery sqlQuery); @Override int executeUpdate(SqlQuery sqlQuery); @Override List<T> findByExample(
final E example, final ExampleSettings<T> settings); @Override List<T> findByProperty(Class<T> clazz, String propertyName, Object propertyValue); @Override List<T> findByProperties(Class<T> clazz, NamedParameters properties); @Override String getQueryStringOfNamedQuery(String queryName); @Override void flush(); @Override void refresh(Entity entity); @Override void clear(); } | @Test public void testCreateCriteriaQuery() { CriteriaQuery query = repository.createCriteriaQuery(Dictionary.class); assertEquals(Dictionary.class, query.getEntityClass()); } |
BaseEntity implements Entity { @Override public int hashCode() { HashCodeBuilder builder = new HashCodeBuilder(13, 37); if (businessKeys() == null || businessKeys().length == 0) { return builder.append(getId()).toHashCode(); } BeanUtils thisBeanUtils = new BeanUtils(this); for (String businessKey : businessKeys()) { builder = builder.append(thisBeanUtils.getPropValue(businessKey)); } return builder.toHashCode(); } @Override boolean existed(); @Override boolean notExisted(); static void setRepository(EntityRepository repository); String[] businessKeys(); @Override int hashCode(); @Override boolean equals(Object other); } | @Test public void testHashCode() { assertEquals(guangdong.hashCode(), new Company("Guangdong", 1).hashCode()); } |
BaseEntity implements Entity { @Override public boolean equals(Object other) { return EntityEqualsBuilder.isEquals(this, other); } @Override boolean existed(); @Override boolean notExisted(); static void setRepository(EntityRepository repository); String[] businessKeys(); @Override int hashCode(); @Override boolean equals(Object other); } | @Test public void testEquals() { assertTrue(guangdong.equals(guangdong)); assertFalse(guangdong.equals(guangzhou)); assertFalse(guangdong.equals(financial)); guangdong.disable(); assertTrue(guangdong.equals(new Company("Guangdong", 1))); assertTrue(new Company("Guangdong", 1).equals(guangdong)); } |
AbstractEntity extends BaseEntity { public void save() { getRepository().save(this); } @Override Long getId(); void setId(Long id); int getVersion(); void setVersion(int version); void save(); void remove(); static T get(Class<T> clazz, Serializable id); static T getUnmodified(Class<T> clazz, T entity); static T load(Class<T> clazz, Serializable id); static List<T> findAll(Class<T> clazz); static List<T> findByProperty(Class<T> clazz, String propName, Object value); static List<T> findByProperties(Class<T> clazz, Map<String, Object> propValues); } | @Test public void testSave() { instance.save(); verify(repository.save(instance)); } |
AbstractEntity extends BaseEntity { public void remove() { getRepository().remove(this); } @Override Long getId(); void setId(Long id); int getVersion(); void setVersion(int version); void save(); void remove(); static T get(Class<T> clazz, Serializable id); static T getUnmodified(Class<T> clazz, T entity); static T load(Class<T> clazz, Serializable id); static List<T> findAll(Class<T> clazz); static List<T> findByProperty(Class<T> clazz, String propName, Object value); static List<T> findByProperties(Class<T> clazz, Map<String, Object> propValues); } | @Test public void testRemove() { instance.remove(); verify(repository).remove(instance); } |
AbstractEntity extends BaseEntity { public static <T extends Entity> T get(Class<T> clazz, Serializable id) { return getRepository().get(clazz, id); } @Override Long getId(); void setId(Long id); int getVersion(); void setVersion(int version); void save(); void remove(); static T get(Class<T> clazz, Serializable id); static T getUnmodified(Class<T> clazz, T entity); static T load(Class<T> clazz, Serializable id); static List<T> findAll(Class<T> clazz); static List<T> findByProperty(Class<T> clazz, String propName, Object value); static List<T> findByProperties(Class<T> clazz, Map<String, Object> propValues); } | @Test public void testGet() { when(repository.get(MyEntity.class, 3L)).thenReturn(instance); assertEquals(instance, AbstractEntity.get(MyEntity.class, 3L)); } |
AbstractEntity extends BaseEntity { public static <T extends Entity> T getUnmodified(Class<T> clazz, T entity) { return getRepository().getUnmodified(clazz, entity); } @Override Long getId(); void setId(Long id); int getVersion(); void setVersion(int version); void save(); void remove(); static T get(Class<T> clazz, Serializable id); static T getUnmodified(Class<T> clazz, T entity); static T load(Class<T> clazz, Serializable id); static List<T> findAll(Class<T> clazz); static List<T> findByProperty(Class<T> clazz, String propName, Object value); static List<T> findByProperties(Class<T> clazz, Map<String, Object> propValues); } | @Test public void testGetUnmodified() { MyEntity entity2 = new MyEntity("nnn"); when(repository.getUnmodified(MyEntity.class, instance)).thenReturn(entity2); assertEquals(entity2, AbstractEntity.getUnmodified(MyEntity.class, instance)); } |
AbstractEntity extends BaseEntity { public static <T extends Entity> T load(Class<T> clazz, Serializable id) { return getRepository().load(clazz, id); } @Override Long getId(); void setId(Long id); int getVersion(); void setVersion(int version); void save(); void remove(); static T get(Class<T> clazz, Serializable id); static T getUnmodified(Class<T> clazz, T entity); static T load(Class<T> clazz, Serializable id); static List<T> findAll(Class<T> clazz); static List<T> findByProperty(Class<T> clazz, String propName, Object value); static List<T> findByProperties(Class<T> clazz, Map<String, Object> propValues); } | @Test public void testLoad() { when(repository.load(MyEntity.class, 3L)).thenReturn(instance); assertEquals(instance, AbstractEntity.load(MyEntity.class, 3L)); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.