method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
MidaoUtils { public static void commitAndCloseQuietly(Connection conn) { try { commitAndClose(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); }### Answer:
@Test public void commitAndCloseQuietly() throws Exception { Connection mockConnection = mock(Connection.class); MidaoUtils.commitAndClose(mockConnection); verify(mockConnection).commit(); verify(mockConnection).close(); } |
### Question:
MidaoUtils { public static void rollback(Connection conn) throws SQLException { if (conn != null) { conn.rollback(); } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); }### Answer:
@Test public void rollbackNull() throws Exception { MidaoUtils.rollback(null); }
@Test public void rollback() throws Exception { Connection mockConnection = mock(Connection.class); MidaoUtils.rollback(mockConnection); verify(mockConnection).rollback(); } |
### Question:
MidaoUtils { public static void rollbackAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.rollback(); } finally { conn.close(); } } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); }### Answer:
@Test public void rollbackAndCloseNull() throws Exception { MidaoUtils.rollbackAndClose(null); }
@Test public void rollbackAndClose() throws Exception { Connection mockConnection = mock(Connection.class); MidaoUtils.rollbackAndClose(mockConnection); verify(mockConnection).rollback(); verify(mockConnection).close(); } |
### Question:
MidaoUtils { public static void rollbackAndCloseQuietly(Connection conn) { try { rollbackAndClose(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); }### Answer:
@Test public void rollbackAndCloseQuietlyNull() throws Exception { MidaoUtils.rollbackAndCloseQuietly(null); }
@Test public void rollbackAndCloseQuietly() throws Exception { Connection mockConnection = mock(Connection.class); MidaoUtils.rollbackAndCloseQuietly(mockConnection); verify(mockConnection).rollback(); verify(mockConnection).close(); } |
### Question:
AssertUtils { public static void assertNotNull(Object value) { if (value == null) { throw new IllegalArgumentException(); } } static void assertNotNull(Object value); static void assertNotNull(Object value, String message); static void assertNotNull(Object value, SQLException exception); static void assertNotTrue(boolean value, String message); static void assertNotFalse(boolean value, String message); }### Answer:
@Test(expected = Exception.class) public void testAssertNotNull() { AssertUtils.assertNotNull(null); }
@Test public void testAssertNotNullMessage() { try { AssertUtils.assertNotNull(null, exceptionMessage); } catch (Exception ex) { Assert.assertEquals(exceptionMessage, ex.getMessage()); } }
@Test public void testAssertNotNullException() throws Exception { SQLException exception = new MjdbcSQLException(exceptionMessage); try { AssertUtils.assertNotNull(null, exception); } catch (MjdbcSQLException ex) { Assert.assertEquals(exceptionMessage, ex.getMessage()); } catch (SQLException ex) { fail(); } } |
### Question:
MjdbcUtils { public static void close(Connection conn) throws SQLException { if (conn != null) { conn.close(); } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); }### Answer:
@Test public void closeNullConnection() throws Exception { MjdbcUtils.close((Connection) null); }
@Test public void closeConnection() throws Exception { Connection mockCon = mock(Connection.class); MjdbcUtils.close(mockCon); verify(mockCon).close(); }
@Test public void closeNullResultSet() throws Exception { MjdbcUtils.close((ResultSet) null); }
@Test public void closeResultSet() throws Exception { ResultSet mockResultSet = mock(ResultSet.class); MjdbcUtils.close(mockResultSet); verify(mockResultSet).close(); }
@Test public void closeNullStatement() throws Exception { MjdbcUtils.close((Statement) null); }
@Test public void closeStatement() throws Exception { Statement mockStatement = mock(Statement.class); MjdbcUtils.close(mockStatement); verify(mockStatement).close(); } |
### Question:
CallableStatementHandler extends BaseStatementHandler { @Override public void setStatement(Statement statement, QueryParameters params) throws SQLException { super.setStatement(statement, params); if (statement instanceof CallableStatement) { CallableStatement callStmt = (CallableStatement) statement; String parameterName = null; for (int i = 0; i < params.orderSize(); i++) { parameterName = params.getNameByPosition(i); if (params.isOutParameter(parameterName) == true) { callStmt.registerOutParameter(i + 1, params.getType(parameterName)); } } } } CallableStatementHandler(Overrider overrider); @Override void setStatement(Statement statement, QueryParameters params); @Override Object[] readStatement(Statement statement, QueryParameters params); }### Answer:
@Test public void testSetStatement() throws Exception { invokeQueries(); verify(callableStatement, times(1)).registerOutParameter(3, MjdbcTypes.OTHER); } |
### Question:
MjdbcUtils { public static void closeQuietly(Connection conn) { try { close(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); }### Answer:
@Test public void closeQuietlyNullConnection() throws Exception { MjdbcUtils.closeQuietly((Connection) null); }
@Test public void closeQuietlyNullResultSet() throws Exception { MjdbcUtils.closeQuietly((ResultSet) null); }
@Test public void closeQuietlyNullStatement() throws Exception { MjdbcUtils.closeQuietly((Statement) null); } |
### Question:
MjdbcUtils { public static void commitAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.commit(); } finally { conn.close(); } } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); }### Answer:
@Test public void commitAndClose() throws Exception { Connection mockConnection = mock(Connection.class); MjdbcUtils.commitAndClose(mockConnection); verify(mockConnection).commit(); verify(mockConnection).close(); } |
### Question:
MjdbcUtils { public static void commitAndCloseQuietly(Connection conn) { try { commitAndClose(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); }### Answer:
@Test public void commitAndCloseQuietly() throws Exception { Connection mockConnection = mock(Connection.class); MjdbcUtils.commitAndClose(mockConnection); verify(mockConnection).commit(); verify(mockConnection).close(); } |
### Question:
MjdbcUtils { public static void rollback(Connection conn) throws SQLException { if (conn != null) { conn.rollback(); } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); }### Answer:
@Test public void rollbackNull() throws Exception { MjdbcUtils.rollback(null); }
@Test public void rollback() throws Exception { Connection mockConnection = mock(Connection.class); MjdbcUtils.rollback(mockConnection); verify(mockConnection).rollback(); } |
### Question:
MjdbcUtils { public static void rollbackAndClose(Connection conn) throws SQLException { if (conn != null) { try { conn.rollback(); } finally { conn.close(); } } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); }### Answer:
@Test public void rollbackAndCloseNull() throws Exception { MjdbcUtils.rollbackAndClose(null); }
@Test public void rollbackAndClose() throws Exception { Connection mockConnection = mock(Connection.class); MjdbcUtils.rollbackAndClose(mockConnection); verify(mockConnection).rollback(); verify(mockConnection).close(); } |
### Question:
CallableStatementHandler extends BaseStatementHandler { @Override public Object[] readStatement(Statement statement, QueryParameters params) throws SQLException { Object[] result = new Object[0]; AssertUtils.assertNotNull(params); super.readStatement(statement, params); if (statement instanceof CallableStatement) { CallableStatement callStmt = (CallableStatement) statement; result = new Object[params.orderSize()]; String parameterName = null; for (int i = 0; i < params.orderSize(); i++) { parameterName = params.getNameByPosition(i); if (params.isOutParameter(parameterName) == true) { result[i] = callStmt.getObject(i + 1); } else { result[i] = null; } } } return result; } CallableStatementHandler(Overrider overrider); @Override void setStatement(Statement statement, QueryParameters params); @Override Object[] readStatement(Statement statement, QueryParameters params); }### Answer:
@Test public void testReadStatement() throws Exception { invokeQueries(); verify(callableStatement, times(1)).getObject(3); } |
### Question:
MjdbcUtils { public static void rollbackAndCloseQuietly(Connection conn) { try { rollbackAndClose(conn); } catch (SQLException e) { } } static void close(Connection conn); static void close(ResultSet rs); static void close(Statement stmt); static void closeQuietly(Connection conn); static void closeQuietly(Connection conn, Statement stmt,
ResultSet rs); static void closeQuietly(ResultSet rs); static void closeQuietly(Statement stmt); static void commitAndClose(Connection conn); static void commitAndCloseQuietly(Connection conn); static boolean loadDriver(String driverClassName); static boolean loadDriver(ClassLoader classLoader, String driverClassName); static void printStackTrace(SQLException e); static void printStackTrace(SQLException e, PrintWriter pw); static void printWarnings(Connection conn); static void printWarnings(Connection conn, PrintWriter pw); static void rollback(Connection conn); static void rollbackAndClose(Connection conn); static void rollbackAndCloseQuietly(Connection conn); }### Answer:
@Test public void rollbackAndCloseQuietlyNull() throws Exception { MjdbcUtils.rollbackAndCloseQuietly(null); }
@Test public void rollbackAndCloseQuietly() throws Exception { Connection mockConnection = mock(Connection.class); MjdbcUtils.rollbackAndCloseQuietly(mockConnection); verify(mockConnection).rollback(); verify(mockConnection).close(); } |
### Question:
BaseInvocationHandler implements java.lang.reflect.InvocationHandler { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result; String className = method.getDeclaringClass().getSimpleName(); String methodName = method.getName(); String parameters = Arrays.deepToString(args); long startInvokeTime = System.currentTimeMillis(); double executionTime = 0; try { result = method.invoke(obj, args); } catch (InvocationTargetException e) { throw e.getTargetException(); } catch (Exception e) { throw new RuntimeException("unexpected invocation exception: " + e.getMessage()); } executionTime = (System.currentTimeMillis() - startInvokeTime) * 1.0 / 1000; logger.info(String.format(this.profilerOutputFormat, new Object[]{ className, methodName, parameters, executionTime})); return result; } BaseInvocationHandler(Object obj, String profilerOutputFormat); Object invoke(Object proxy, Method method, Object[] args); }### Answer:
@Test public void testInvoke() throws Exception { } |
### Question:
ProfilerFactory { public static Object newInstance(Object obj) { if (MjdbcLogger.isSLF4jAvailable() == true && MjdbcLogger.isSLF4jImplementationAvailable() == false) { return obj; } else { if (MjdbcConfig.isProfilerEnabled() == true) { return java.lang.reflect.Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), new BaseInvocationHandler(obj, MjdbcConfig.getProfilerOutputFormat())); } else { return obj; } } } static Object newInstance(Object obj); }### Answer:
@Test public void testNewInstance() throws Exception { List list = null; MjdbcConfig.setProfilerEnabled(true); list = (List) ProfilerFactory.newInstance(new ArrayList()); if (MjdbcLogger.isSLF4jAvailable() == true) { if (MjdbcLogger.isSLF4jImplementationAvailable() == true) { Assert.assertEquals(true, Proxy.isProxyClass(list.getClass())); } else { Assert.assertEquals(false, Proxy.isProxyClass(list.getClass())); } } else { Assert.assertEquals(true, Proxy.isProxyClass(list.getClass())); } MjdbcConfig.setProfilerEnabled(false); list = (List) ProfilerFactory.newInstance(new ArrayList()); Assert.assertEquals(false, Proxy.isProxyClass(list.getClass())); } |
### Question:
MjdbcLogger extends Logger { public static MjdbcLogger getLogger(String name) { MjdbcLogger mjdbcLogger = new MjdbcLogger(name, null); if (isSLF4jAvailable() == true) { try { mjdbcLogger = new MjdbcLogger(name, null); mjdbcLogger.setSlfLogger(MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "getLogger", new Class[]{String.class}, new Object[]{name})); } catch (MjdbcException e) { setSLF4jAvailable(false); } catch (ClassNotFoundException e) { setSLF4jAvailable(false); } } return mjdbcLogger; } private MjdbcLogger(String name, String resourceBundleName); static MjdbcLogger getLogger(String name); static MjdbcLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); }### Answer:
@Test public void testGetLoggerString() throws Exception { MjdbcLogger logger = MjdbcLogger.getLogger("log me!"); Assert.assertEquals(true, logger instanceof Logger); Assert.assertEquals("log me!", logger.getName()); }
@Test public void testGetLoggerClass() throws Exception { MjdbcLogger logger = MjdbcLogger.getLogger(String.class); Assert.assertEquals(true, logger instanceof Logger); Assert.assertEquals("java.lang.String", logger.getName()); } |
### Question:
MjdbcLogger extends Logger { @Override public void info(String msg) { if (isSLF4jAvailable() == false) { super.info(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "info", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.info(msg); } } } private MjdbcLogger(String name, String resourceBundleName); static MjdbcLogger getLogger(String name); static MjdbcLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); }### Answer:
@Test public void testInfo() throws Exception { } |
### Question:
MjdbcLogger extends Logger { @Override public void warning(String msg) { if (isSLF4jAvailable() == false) { super.warning(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "warn", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.warning(msg); } } } private MjdbcLogger(String name, String resourceBundleName); static MjdbcLogger getLogger(String name); static MjdbcLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); }### Answer:
@Test public void testWarning() throws Exception { } |
### Question:
MjdbcLogger extends Logger { @Override public void severe(String msg) { if (isSLF4jAvailable() == false) { super.severe(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "error", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.severe(msg); } } } private MjdbcLogger(String name, String resourceBundleName); static MjdbcLogger getLogger(String name); static MjdbcLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); }### Answer:
@Test public void testSevere() throws Exception { } |
### Question:
MjdbcLogger extends Logger { public static boolean isSLF4jAvailable() { if (SLF4jAvailable == null) { try { Class.forName("org.slf4j.Logger"); setSLF4jAvailable(true); } catch (ClassNotFoundException e) { setSLF4jAvailable(false); } } return SLF4jAvailable; } private MjdbcLogger(String name, String resourceBundleName); static MjdbcLogger getLogger(String name); static MjdbcLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); }### Answer:
@Test public void testIsSLF4jAvailable() throws Exception { Assert.assertEquals(false, MjdbcLogger.isSLF4jAvailable()); } |
### Question:
LazyStatementHandler extends CallableStatementHandler { @Override public void setStatement(Statement statement, QueryParameters params) throws SQLException { super.setStatement(statement, params); } LazyStatementHandler(Overrider overrider); @Override void setStatement(Statement statement, QueryParameters params); @Override List<QueryParameters> wrap(Statement stmt); }### Answer:
@Test public void testSetStatement() throws Exception { } |
### Question:
MjdbcLogger extends Logger { public static boolean isSLF4jImplementationAvailable() { if (SLF4jImplementationAvailable == null) { if (isSLF4jAvailable() == true) { try { Object obj = MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "getILoggerFactory", new Class[]{}, new Object[]{}); if (obj.getClass().getSimpleName().equals("NOPLoggerFactory") == true) { SLF4jImplementationAvailable = false; } else { SLF4jImplementationAvailable = true; } } catch (MjdbcException e) { SLF4jImplementationAvailable = false; } catch (ClassNotFoundException e) { SLF4jImplementationAvailable = false; } } else { SLF4jImplementationAvailable = false; } } return SLF4jImplementationAvailable; } private MjdbcLogger(String name, String resourceBundleName); static MjdbcLogger getLogger(String name); static MjdbcLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); }### Answer:
@Test public void testIsSLF4jImplementationAvailable() throws Exception { Assert.assertEquals(false, MjdbcLogger.isSLF4jImplementationAvailable()); } |
### Question:
LazyStatementHandler extends CallableStatementHandler { @Override public List<QueryParameters> wrap(Statement stmt) throws SQLException { QueryParametersLazyList result = null; ResultSet rs = null; boolean readGeneratedKeys = false; if (this.overrider.hasOverride(MjdbcConstants.OVERRIDE_INT_GET_GENERATED_KEYS) == true) { this.overrider.getOverride(MjdbcConstants.OVERRIDE_INT_GET_GENERATED_KEYS); readGeneratedKeys = true; } TypeHandler typeHandler = (TypeHandler) this.overrider.getOverride(MjdbcConstants.OVERRIDE_INT_TYPE_HANDLER); result = new QueryParametersLazyList(stmt, typeHandler, readGeneratedKeys, -1); return result; } LazyStatementHandler(Overrider overrider); @Override void setStatement(Statement statement, QueryParameters params); @Override List<QueryParameters> wrap(Statement stmt); }### Answer:
@Test public void testWrap() throws Exception { when(stmt.getResultSet()).thenReturn(rs); new LazyStatementHandler(new Overrider()).wrap(stmt); verify(stmt, times(1)).getResultSet(); verify(stmt, never()).getMoreResults(); verify(rs, never()).next(); } |
### Question:
BaseStatementHandler implements StatementHandler { public Object[] readStatement(Statement statement, QueryParameters params) throws SQLException { return new Object[params.orderSize()]; } BaseStatementHandler(Overrider overrider); void setStatement(Statement statement, QueryParameters params); List<QueryParameters> wrap(Statement stmt); Object[] readStatement(Statement statement, QueryParameters params); void beforeClose(); void afterClose(); }### Answer:
@Test public void testReadStatement() throws Exception { } |
### Question:
BaseStatementHandler implements StatementHandler { public void beforeClose() { } BaseStatementHandler(Overrider overrider); void setStatement(Statement statement, QueryParameters params); List<QueryParameters> wrap(Statement stmt); Object[] readStatement(Statement statement, QueryParameters params); void beforeClose(); void afterClose(); }### Answer:
@Test public void testBeforeClose() throws Exception { } |
### Question:
BaseStatementHandler implements StatementHandler { public void afterClose() { } BaseStatementHandler(Overrider overrider); void setStatement(Statement statement, QueryParameters params); List<QueryParameters> wrap(Statement stmt); Object[] readStatement(Statement statement, QueryParameters params); void beforeClose(); void afterClose(); }### Answer:
@Test public void testAfterClose() throws Exception { } |
### Question:
BasicQueryOutputProcessor implements QueryOutputProcessor { public Object[] toArray(List<QueryParameters> paramsList) { Object[] result = new Object[0]; QueryParameters singleParam = null; String parameterName = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } if (iterator.hasNext() == true) { singleParam = iterator.next(); result = new Object[singleParam.size()]; for (int i = 0; i < singleParam.size(); i++) { parameterName = singleParam.getNameByPosition(i); result[i] = singleParam.getValue(parameterName); } } return result; } BasicQueryOutputProcessor(); BasicQueryOutputProcessor(Map<String, String> columnToPropertyOverrides); Object[] toArray(List<QueryParameters> paramsList); List<Object[]> toArrayList(List<QueryParameters> paramsList); T toBean(List<QueryParameters> paramsList, Class<T> type); T toBean(QueryParameters params, Class<T> type); List<T> toBeanList(List<QueryParameters> paramsList, Class<T> type); Map<String, Object> toMap(List<QueryParameters> paramsList); Map<String, Object> toMap(QueryParameters params); List<Map<String, Object>> toMapList(List<QueryParameters> paramsList); Object processValue(QueryParameters params, Integer position, PropertyDescriptor prop); }### Answer:
@Test public void testToArray() throws Exception { QueryParameters params = new QueryParameters(); Object[] expected = new Object[]{"8", "7", "4"}; params.set("intelligence", expected[0]); params.set("charisma", expected[1]); params.set("strength", expected[2]); paramsList.add(params); Object[] result = queryOutputProcessor.toArray(paramsList); Assert.assertEquals(3, result.length); org.junit.Assert.assertArrayEquals(expected, result); } |
### Question:
BasicQueryOutputProcessor implements QueryOutputProcessor { public List<Map<String, Object>> toMapList(List<QueryParameters> paramsList) { List<Map<String, Object>> result = new ArrayList<Map<String, Object>>(); Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } while (iterator.hasNext() == true) { result.add(iterator.next().toMap()); } return result; } BasicQueryOutputProcessor(); BasicQueryOutputProcessor(Map<String, String> columnToPropertyOverrides); Object[] toArray(List<QueryParameters> paramsList); List<Object[]> toArrayList(List<QueryParameters> paramsList); T toBean(List<QueryParameters> paramsList, Class<T> type); T toBean(QueryParameters params, Class<T> type); List<T> toBeanList(List<QueryParameters> paramsList, Class<T> type); Map<String, Object> toMap(List<QueryParameters> paramsList); Map<String, Object> toMap(QueryParameters params); List<Map<String, Object>> toMapList(List<QueryParameters> paramsList); Object processValue(QueryParameters params, Integer position, PropertyDescriptor prop); }### Answer:
@Test public void testToMapList() throws Exception { QueryParameters params1 = null; QueryParameters params2 = null; int age1 = 5; String name1 = "whiskers"; int age2 = 10; String name2 = "lucky"; params1 = new QueryParameters(); params1.set("age", age1); params1.set("name", name1); paramsList.add(params1); params2 = new QueryParameters(); params2.set("age", age2); params2.set("name", name2); paramsList.add(params2); List<Map<String, Object>> result = null; result = queryOutputProcessor.toMapList(paramsList); Assert.assertEquals(age1, result.get(0).get("age")); Assert.assertEquals(name1, result.get(0).get("name")); Assert.assertEquals(age2, result.get(1).get("age")); Assert.assertEquals(name2, result.get(1).get("name")); } |
### Question:
BasicQueryOutputProcessor implements QueryOutputProcessor { public Map<String, Object> toMap(List<QueryParameters> paramsList) { Map<String, Object> result = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } if (iterator.hasNext() == true) { result = this.toMap(iterator.next()); } else { result = new HashMap<String, Object>(); } return result; } BasicQueryOutputProcessor(); BasicQueryOutputProcessor(Map<String, String> columnToPropertyOverrides); Object[] toArray(List<QueryParameters> paramsList); List<Object[]> toArrayList(List<QueryParameters> paramsList); T toBean(List<QueryParameters> paramsList, Class<T> type); T toBean(QueryParameters params, Class<T> type); List<T> toBeanList(List<QueryParameters> paramsList, Class<T> type); Map<String, Object> toMap(List<QueryParameters> paramsList); Map<String, Object> toMap(QueryParameters params); List<Map<String, Object>> toMapList(List<QueryParameters> paramsList); Object processValue(QueryParameters params, Integer position, PropertyDescriptor prop); }### Answer:
@Test public void testToMapNull() { Assert.assertEquals(null, queryOutputProcessor.toMap((QueryParameters) null)); } |
### Question:
BasicQueryOutputProcessor implements QueryOutputProcessor { public <T> T toBean(List<QueryParameters> paramsList, Class<T> type) throws MjdbcException { T result = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } if (iterator.hasNext() == true) { result = this.toBean(iterator.next(), type); } return result; } BasicQueryOutputProcessor(); BasicQueryOutputProcessor(Map<String, String> columnToPropertyOverrides); Object[] toArray(List<QueryParameters> paramsList); List<Object[]> toArrayList(List<QueryParameters> paramsList); T toBean(List<QueryParameters> paramsList, Class<T> type); T toBean(QueryParameters params, Class<T> type); List<T> toBeanList(List<QueryParameters> paramsList, Class<T> type); Map<String, Object> toMap(List<QueryParameters> paramsList); Map<String, Object> toMap(QueryParameters params); List<Map<String, Object>> toMapList(List<QueryParameters> paramsList); Object processValue(QueryParameters params, Integer position, PropertyDescriptor prop); }### Answer:
@Test public void testToBeanNull() throws MjdbcException { Assert.assertEquals(null, queryOutputProcessor.toBean((QueryParameters) null, Cat.class)); } |
### Question:
MidaoConfig { public static QueryInputProcessor getDefaultQueryInputProcessor() { return MjdbcConfig.getDefaultQueryInputProcessor(); } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProcessorUseCache(); static void setQueryInputProcessorUseCache(boolean queryInputProcessorUseCache); static QueryOutputProcessor getDefaultQueryOutputProcessor(); static void setDefaultQueryOutputProcessor(QueryOutputProcessor defaultQueryOutputProcessor); static StatementHandler getDefaultStatementHandler(Overrider overrider); static void setDefaultStatementHandler(Class<? extends StatementHandler> defaultStatementHandler); static TypeHandler getDefaultTypeHandler(Overrider overrider); static void setDefaultTypeHandler(Class<? extends TypeHandler> defaultTypeHandler); static TransactionHandler getDefaultTransactionHandler(Connection conn); static TransactionHandler getDefaultTransactionHandler(DataSource ds); static void setDefaultTransactionHandler(Class<? extends TransactionHandler> defaultTransactionHandler); static ExceptionHandler getDefaultExceptionHandler(String dbName); static void setDefaultExceptionHandler(Class<? extends ExceptionHandler> defaultExceptionHandler); static MetadataHandler getDefaultMetadataHandler(Connection conn); static MetadataHandler getDefaultMetadataHandler(DataSource ds); static void setDefaultMetadataHandler(Class<? extends MetadataHandler> defaultMetadataHandler); static Overrider getDefaultOverrider(); static void setDefaultOverrider(Class<Overrider> defaultOverrider); static boolean isProfilerEnabled(); static void setProfilerEnabled(boolean profilerEnabled); static String getProfilerOutputFormat(); static void setProfilerOutputFormat(String profilerOutputFormat); static int getDefaultLazyCacheMaxSize(); static void setDefaultLazyCacheMaxSize(int lazyCacheMaxSize); }### Answer:
@Test public void testGetDefaultQueryInputProcessor() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultQueryInputProcessor() instanceof QueryInputProcessor); } |
### Question:
MidaoConfig { public static boolean isQueryInputProcessorUseCache() { return MjdbcConfig.isQueryInputProcessorUseCache(); } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProcessorUseCache(); static void setQueryInputProcessorUseCache(boolean queryInputProcessorUseCache); static QueryOutputProcessor getDefaultQueryOutputProcessor(); static void setDefaultQueryOutputProcessor(QueryOutputProcessor defaultQueryOutputProcessor); static StatementHandler getDefaultStatementHandler(Overrider overrider); static void setDefaultStatementHandler(Class<? extends StatementHandler> defaultStatementHandler); static TypeHandler getDefaultTypeHandler(Overrider overrider); static void setDefaultTypeHandler(Class<? extends TypeHandler> defaultTypeHandler); static TransactionHandler getDefaultTransactionHandler(Connection conn); static TransactionHandler getDefaultTransactionHandler(DataSource ds); static void setDefaultTransactionHandler(Class<? extends TransactionHandler> defaultTransactionHandler); static ExceptionHandler getDefaultExceptionHandler(String dbName); static void setDefaultExceptionHandler(Class<? extends ExceptionHandler> defaultExceptionHandler); static MetadataHandler getDefaultMetadataHandler(Connection conn); static MetadataHandler getDefaultMetadataHandler(DataSource ds); static void setDefaultMetadataHandler(Class<? extends MetadataHandler> defaultMetadataHandler); static Overrider getDefaultOverrider(); static void setDefaultOverrider(Class<Overrider> defaultOverrider); static boolean isProfilerEnabled(); static void setProfilerEnabled(boolean profilerEnabled); static String getProfilerOutputFormat(); static void setProfilerOutputFormat(String profilerOutputFormat); static int getDefaultLazyCacheMaxSize(); static void setDefaultLazyCacheMaxSize(int lazyCacheMaxSize); }### Answer:
@Test public void testIsQueryInputProcessorUseCache() throws Exception { boolean defaultValue = MidaoConfig.isQueryInputProcessorUseCache(); MidaoConfig.setQueryInputProcessorUseCache(!defaultValue); Assert.assertEquals(!defaultValue, MidaoConfig.isQueryInputProcessorUseCache()); MidaoConfig.setQueryInputProcessorUseCache(defaultValue); } |
### Question:
MidaoConfig { public static QueryOutputProcessor getDefaultQueryOutputProcessor() { return MjdbcConfig.getDefaultQueryOutputProcessor(); } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProcessorUseCache(); static void setQueryInputProcessorUseCache(boolean queryInputProcessorUseCache); static QueryOutputProcessor getDefaultQueryOutputProcessor(); static void setDefaultQueryOutputProcessor(QueryOutputProcessor defaultQueryOutputProcessor); static StatementHandler getDefaultStatementHandler(Overrider overrider); static void setDefaultStatementHandler(Class<? extends StatementHandler> defaultStatementHandler); static TypeHandler getDefaultTypeHandler(Overrider overrider); static void setDefaultTypeHandler(Class<? extends TypeHandler> defaultTypeHandler); static TransactionHandler getDefaultTransactionHandler(Connection conn); static TransactionHandler getDefaultTransactionHandler(DataSource ds); static void setDefaultTransactionHandler(Class<? extends TransactionHandler> defaultTransactionHandler); static ExceptionHandler getDefaultExceptionHandler(String dbName); static void setDefaultExceptionHandler(Class<? extends ExceptionHandler> defaultExceptionHandler); static MetadataHandler getDefaultMetadataHandler(Connection conn); static MetadataHandler getDefaultMetadataHandler(DataSource ds); static void setDefaultMetadataHandler(Class<? extends MetadataHandler> defaultMetadataHandler); static Overrider getDefaultOverrider(); static void setDefaultOverrider(Class<Overrider> defaultOverrider); static boolean isProfilerEnabled(); static void setProfilerEnabled(boolean profilerEnabled); static String getProfilerOutputFormat(); static void setProfilerOutputFormat(String profilerOutputFormat); static int getDefaultLazyCacheMaxSize(); static void setDefaultLazyCacheMaxSize(int lazyCacheMaxSize); }### Answer:
@Test public void testGetDefaultQueryOutputProcessor() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultQueryOutputProcessor() instanceof QueryOutputProcessor); } |
### Question:
MjdbcConfig { public static QueryInputProcessor getDefaultQueryInputProcessor() { return instance().defaultQueryInputProcessor; } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProcessorUseCache(); static void setQueryInputProcessorUseCache(boolean queryInputProcessorUseCache); static QueryOutputProcessor getDefaultQueryOutputProcessor(); static void setDefaultQueryOutputProcessor(QueryOutputProcessor defaultQueryOutputProcessor); static StatementHandler getDefaultStatementHandler(Overrider overrider); static void setDefaultStatementHandler(Class<? extends StatementHandler> defaultStatementHandler); static TypeHandler getDefaultTypeHandler(Overrider overrider); static void setDefaultTypeHandler(Class<? extends TypeHandler> defaultTypeHandler); static TransactionHandler getDefaultTransactionHandler(Connection conn); static TransactionHandler getDefaultTransactionHandler(DataSource ds); static void setDefaultTransactionHandler(Class<? extends TransactionHandler> defaultTransactionHandler); static ExceptionHandler getDefaultExceptionHandler(String dbName); static void setDefaultExceptionHandler(Class<? extends ExceptionHandler> defaultExceptionHandler); static MetadataHandler getDefaultMetadataHandler(Connection conn); static MetadataHandler getDefaultMetadataHandler(DataSource ds); static void setDefaultMetadataHandler(Class<? extends MetadataHandler> defaultMetadataHandler); static Overrider getDefaultOverrider(); static void setDefaultOverrider(Class<Overrider> defaultOverrider); static boolean isProfilerEnabled(); static void setProfilerEnabled(boolean profilerEnabled); static String getProfilerOutputFormat(); static void setProfilerOutputFormat(String profilerOutputFormat); static int getDefaultLazyCacheMaxSize(); static void setDefaultLazyCacheMaxSize(int lazyCacheMaxSize); static String getOutputHandlerPackage(); static Map<String, OutputHandler> getDefaultOutputHandlers(); }### Answer:
@Test public void testGetDefaultQueryInputProcessor() throws Exception { Assert.assertEquals(true, MjdbcConfig.getDefaultQueryInputProcessor() instanceof QueryInputProcessor); } |
### Question:
MidaoConfig { public static StatementHandler getDefaultStatementHandler(Overrider overrider) { return MjdbcConfig.getDefaultStatementHandler(overrider); } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProcessorUseCache(); static void setQueryInputProcessorUseCache(boolean queryInputProcessorUseCache); static QueryOutputProcessor getDefaultQueryOutputProcessor(); static void setDefaultQueryOutputProcessor(QueryOutputProcessor defaultQueryOutputProcessor); static StatementHandler getDefaultStatementHandler(Overrider overrider); static void setDefaultStatementHandler(Class<? extends StatementHandler> defaultStatementHandler); static TypeHandler getDefaultTypeHandler(Overrider overrider); static void setDefaultTypeHandler(Class<? extends TypeHandler> defaultTypeHandler); static TransactionHandler getDefaultTransactionHandler(Connection conn); static TransactionHandler getDefaultTransactionHandler(DataSource ds); static void setDefaultTransactionHandler(Class<? extends TransactionHandler> defaultTransactionHandler); static ExceptionHandler getDefaultExceptionHandler(String dbName); static void setDefaultExceptionHandler(Class<? extends ExceptionHandler> defaultExceptionHandler); static MetadataHandler getDefaultMetadataHandler(Connection conn); static MetadataHandler getDefaultMetadataHandler(DataSource ds); static void setDefaultMetadataHandler(Class<? extends MetadataHandler> defaultMetadataHandler); static Overrider getDefaultOverrider(); static void setDefaultOverrider(Class<Overrider> defaultOverrider); static boolean isProfilerEnabled(); static void setProfilerEnabled(boolean profilerEnabled); static String getProfilerOutputFormat(); static void setProfilerOutputFormat(String profilerOutputFormat); static int getDefaultLazyCacheMaxSize(); static void setDefaultLazyCacheMaxSize(int lazyCacheMaxSize); }### Answer:
@Test public void testGetDefaultStatementHandler() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultStatementHandler(overrider) instanceof StatementHandler); } |
### Question:
MidaoConfig { public static TypeHandler getDefaultTypeHandler(Overrider overrider) { return MjdbcConfig.getDefaultTypeHandler(overrider); } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProcessorUseCache(); static void setQueryInputProcessorUseCache(boolean queryInputProcessorUseCache); static QueryOutputProcessor getDefaultQueryOutputProcessor(); static void setDefaultQueryOutputProcessor(QueryOutputProcessor defaultQueryOutputProcessor); static StatementHandler getDefaultStatementHandler(Overrider overrider); static void setDefaultStatementHandler(Class<? extends StatementHandler> defaultStatementHandler); static TypeHandler getDefaultTypeHandler(Overrider overrider); static void setDefaultTypeHandler(Class<? extends TypeHandler> defaultTypeHandler); static TransactionHandler getDefaultTransactionHandler(Connection conn); static TransactionHandler getDefaultTransactionHandler(DataSource ds); static void setDefaultTransactionHandler(Class<? extends TransactionHandler> defaultTransactionHandler); static ExceptionHandler getDefaultExceptionHandler(String dbName); static void setDefaultExceptionHandler(Class<? extends ExceptionHandler> defaultExceptionHandler); static MetadataHandler getDefaultMetadataHandler(Connection conn); static MetadataHandler getDefaultMetadataHandler(DataSource ds); static void setDefaultMetadataHandler(Class<? extends MetadataHandler> defaultMetadataHandler); static Overrider getDefaultOverrider(); static void setDefaultOverrider(Class<Overrider> defaultOverrider); static boolean isProfilerEnabled(); static void setProfilerEnabled(boolean profilerEnabled); static String getProfilerOutputFormat(); static void setProfilerOutputFormat(String profilerOutputFormat); static int getDefaultLazyCacheMaxSize(); static void setDefaultLazyCacheMaxSize(int lazyCacheMaxSize); }### Answer:
@Test public void testGetDefaultTypeHandler() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultTypeHandler(overrider) instanceof TypeHandler); } |
### Question:
MidaoConfig { public static TransactionHandler getDefaultTransactionHandler(Connection conn) { return MjdbcConfig.getDefaultTransactionHandler(conn); } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProcessorUseCache(); static void setQueryInputProcessorUseCache(boolean queryInputProcessorUseCache); static QueryOutputProcessor getDefaultQueryOutputProcessor(); static void setDefaultQueryOutputProcessor(QueryOutputProcessor defaultQueryOutputProcessor); static StatementHandler getDefaultStatementHandler(Overrider overrider); static void setDefaultStatementHandler(Class<? extends StatementHandler> defaultStatementHandler); static TypeHandler getDefaultTypeHandler(Overrider overrider); static void setDefaultTypeHandler(Class<? extends TypeHandler> defaultTypeHandler); static TransactionHandler getDefaultTransactionHandler(Connection conn); static TransactionHandler getDefaultTransactionHandler(DataSource ds); static void setDefaultTransactionHandler(Class<? extends TransactionHandler> defaultTransactionHandler); static ExceptionHandler getDefaultExceptionHandler(String dbName); static void setDefaultExceptionHandler(Class<? extends ExceptionHandler> defaultExceptionHandler); static MetadataHandler getDefaultMetadataHandler(Connection conn); static MetadataHandler getDefaultMetadataHandler(DataSource ds); static void setDefaultMetadataHandler(Class<? extends MetadataHandler> defaultMetadataHandler); static Overrider getDefaultOverrider(); static void setDefaultOverrider(Class<Overrider> defaultOverrider); static boolean isProfilerEnabled(); static void setProfilerEnabled(boolean profilerEnabled); static String getProfilerOutputFormat(); static void setProfilerOutputFormat(String profilerOutputFormat); static int getDefaultLazyCacheMaxSize(); static void setDefaultLazyCacheMaxSize(int lazyCacheMaxSize); }### Answer:
@Test public void testGetDefaultTransactionHandlerConn() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultTransactionHandler(conn) instanceof TransactionHandler); }
@Test public void testGetDefaultTransactionHandlerDataSource() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultTransactionHandler(ds) instanceof TransactionHandler); } |
### Question:
MidaoConfig { public static ExceptionHandler getDefaultExceptionHandler(String dbName) { return MjdbcConfig.getDefaultExceptionHandler(dbName); } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProcessorUseCache(); static void setQueryInputProcessorUseCache(boolean queryInputProcessorUseCache); static QueryOutputProcessor getDefaultQueryOutputProcessor(); static void setDefaultQueryOutputProcessor(QueryOutputProcessor defaultQueryOutputProcessor); static StatementHandler getDefaultStatementHandler(Overrider overrider); static void setDefaultStatementHandler(Class<? extends StatementHandler> defaultStatementHandler); static TypeHandler getDefaultTypeHandler(Overrider overrider); static void setDefaultTypeHandler(Class<? extends TypeHandler> defaultTypeHandler); static TransactionHandler getDefaultTransactionHandler(Connection conn); static TransactionHandler getDefaultTransactionHandler(DataSource ds); static void setDefaultTransactionHandler(Class<? extends TransactionHandler> defaultTransactionHandler); static ExceptionHandler getDefaultExceptionHandler(String dbName); static void setDefaultExceptionHandler(Class<? extends ExceptionHandler> defaultExceptionHandler); static MetadataHandler getDefaultMetadataHandler(Connection conn); static MetadataHandler getDefaultMetadataHandler(DataSource ds); static void setDefaultMetadataHandler(Class<? extends MetadataHandler> defaultMetadataHandler); static Overrider getDefaultOverrider(); static void setDefaultOverrider(Class<Overrider> defaultOverrider); static boolean isProfilerEnabled(); static void setProfilerEnabled(boolean profilerEnabled); static String getProfilerOutputFormat(); static void setProfilerOutputFormat(String profilerOutputFormat); static int getDefaultLazyCacheMaxSize(); static void setDefaultLazyCacheMaxSize(int lazyCacheMaxSize); }### Answer:
@Test public void testGetDefaultExceptionHandler() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultExceptionHandler("") instanceof ExceptionHandler); } |
### Question:
MidaoConfig { public static MetadataHandler getDefaultMetadataHandler(Connection conn) { return MjdbcConfig.getDefaultMetadataHandler(conn); } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProcessorUseCache(); static void setQueryInputProcessorUseCache(boolean queryInputProcessorUseCache); static QueryOutputProcessor getDefaultQueryOutputProcessor(); static void setDefaultQueryOutputProcessor(QueryOutputProcessor defaultQueryOutputProcessor); static StatementHandler getDefaultStatementHandler(Overrider overrider); static void setDefaultStatementHandler(Class<? extends StatementHandler> defaultStatementHandler); static TypeHandler getDefaultTypeHandler(Overrider overrider); static void setDefaultTypeHandler(Class<? extends TypeHandler> defaultTypeHandler); static TransactionHandler getDefaultTransactionHandler(Connection conn); static TransactionHandler getDefaultTransactionHandler(DataSource ds); static void setDefaultTransactionHandler(Class<? extends TransactionHandler> defaultTransactionHandler); static ExceptionHandler getDefaultExceptionHandler(String dbName); static void setDefaultExceptionHandler(Class<? extends ExceptionHandler> defaultExceptionHandler); static MetadataHandler getDefaultMetadataHandler(Connection conn); static MetadataHandler getDefaultMetadataHandler(DataSource ds); static void setDefaultMetadataHandler(Class<? extends MetadataHandler> defaultMetadataHandler); static Overrider getDefaultOverrider(); static void setDefaultOverrider(Class<Overrider> defaultOverrider); static boolean isProfilerEnabled(); static void setProfilerEnabled(boolean profilerEnabled); static String getProfilerOutputFormat(); static void setProfilerOutputFormat(String profilerOutputFormat); static int getDefaultLazyCacheMaxSize(); static void setDefaultLazyCacheMaxSize(int lazyCacheMaxSize); }### Answer:
@Test public void testGetDefaultMetadataHandlerConn() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultMetadataHandler(conn) instanceof MetadataHandler); }
@Test public void testGetDefaultMetadataHandlerDataSource() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultMetadataHandler(ds) instanceof MetadataHandler); } |
### Question:
MidaoConfig { public static Overrider getDefaultOverrider() { return MjdbcConfig.getDefaultOverrider(); } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProcessorUseCache(); static void setQueryInputProcessorUseCache(boolean queryInputProcessorUseCache); static QueryOutputProcessor getDefaultQueryOutputProcessor(); static void setDefaultQueryOutputProcessor(QueryOutputProcessor defaultQueryOutputProcessor); static StatementHandler getDefaultStatementHandler(Overrider overrider); static void setDefaultStatementHandler(Class<? extends StatementHandler> defaultStatementHandler); static TypeHandler getDefaultTypeHandler(Overrider overrider); static void setDefaultTypeHandler(Class<? extends TypeHandler> defaultTypeHandler); static TransactionHandler getDefaultTransactionHandler(Connection conn); static TransactionHandler getDefaultTransactionHandler(DataSource ds); static void setDefaultTransactionHandler(Class<? extends TransactionHandler> defaultTransactionHandler); static ExceptionHandler getDefaultExceptionHandler(String dbName); static void setDefaultExceptionHandler(Class<? extends ExceptionHandler> defaultExceptionHandler); static MetadataHandler getDefaultMetadataHandler(Connection conn); static MetadataHandler getDefaultMetadataHandler(DataSource ds); static void setDefaultMetadataHandler(Class<? extends MetadataHandler> defaultMetadataHandler); static Overrider getDefaultOverrider(); static void setDefaultOverrider(Class<Overrider> defaultOverrider); static boolean isProfilerEnabled(); static void setProfilerEnabled(boolean profilerEnabled); static String getProfilerOutputFormat(); static void setProfilerOutputFormat(String profilerOutputFormat); static int getDefaultLazyCacheMaxSize(); static void setDefaultLazyCacheMaxSize(int lazyCacheMaxSize); }### Answer:
@Test public void testGetDefaultOverrider() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultOverrider() instanceof Overrider); } |
### Question:
MidaoConfig { public static boolean isProfilerEnabled() { return MjdbcConfig.isProfilerEnabled(); } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProcessorUseCache(); static void setQueryInputProcessorUseCache(boolean queryInputProcessorUseCache); static QueryOutputProcessor getDefaultQueryOutputProcessor(); static void setDefaultQueryOutputProcessor(QueryOutputProcessor defaultQueryOutputProcessor); static StatementHandler getDefaultStatementHandler(Overrider overrider); static void setDefaultStatementHandler(Class<? extends StatementHandler> defaultStatementHandler); static TypeHandler getDefaultTypeHandler(Overrider overrider); static void setDefaultTypeHandler(Class<? extends TypeHandler> defaultTypeHandler); static TransactionHandler getDefaultTransactionHandler(Connection conn); static TransactionHandler getDefaultTransactionHandler(DataSource ds); static void setDefaultTransactionHandler(Class<? extends TransactionHandler> defaultTransactionHandler); static ExceptionHandler getDefaultExceptionHandler(String dbName); static void setDefaultExceptionHandler(Class<? extends ExceptionHandler> defaultExceptionHandler); static MetadataHandler getDefaultMetadataHandler(Connection conn); static MetadataHandler getDefaultMetadataHandler(DataSource ds); static void setDefaultMetadataHandler(Class<? extends MetadataHandler> defaultMetadataHandler); static Overrider getDefaultOverrider(); static void setDefaultOverrider(Class<Overrider> defaultOverrider); static boolean isProfilerEnabled(); static void setProfilerEnabled(boolean profilerEnabled); static String getProfilerOutputFormat(); static void setProfilerOutputFormat(String profilerOutputFormat); static int getDefaultLazyCacheMaxSize(); static void setDefaultLazyCacheMaxSize(int lazyCacheMaxSize); }### Answer:
@Test public void testIsProfilerEnabled() throws Exception { boolean defaultValue = MidaoConfig.isProfilerEnabled(); MidaoConfig.setProfilerEnabled(!defaultValue); Assert.assertEquals(!defaultValue, MidaoConfig.isProfilerEnabled()); MidaoConfig.setProfilerEnabled(defaultValue); } |
### Question:
MidaoConfig { public static String getProfilerOutputFormat() { return MjdbcConfig.getProfilerOutputFormat(); } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProcessorUseCache(); static void setQueryInputProcessorUseCache(boolean queryInputProcessorUseCache); static QueryOutputProcessor getDefaultQueryOutputProcessor(); static void setDefaultQueryOutputProcessor(QueryOutputProcessor defaultQueryOutputProcessor); static StatementHandler getDefaultStatementHandler(Overrider overrider); static void setDefaultStatementHandler(Class<? extends StatementHandler> defaultStatementHandler); static TypeHandler getDefaultTypeHandler(Overrider overrider); static void setDefaultTypeHandler(Class<? extends TypeHandler> defaultTypeHandler); static TransactionHandler getDefaultTransactionHandler(Connection conn); static TransactionHandler getDefaultTransactionHandler(DataSource ds); static void setDefaultTransactionHandler(Class<? extends TransactionHandler> defaultTransactionHandler); static ExceptionHandler getDefaultExceptionHandler(String dbName); static void setDefaultExceptionHandler(Class<? extends ExceptionHandler> defaultExceptionHandler); static MetadataHandler getDefaultMetadataHandler(Connection conn); static MetadataHandler getDefaultMetadataHandler(DataSource ds); static void setDefaultMetadataHandler(Class<? extends MetadataHandler> defaultMetadataHandler); static Overrider getDefaultOverrider(); static void setDefaultOverrider(Class<Overrider> defaultOverrider); static boolean isProfilerEnabled(); static void setProfilerEnabled(boolean profilerEnabled); static String getProfilerOutputFormat(); static void setProfilerOutputFormat(String profilerOutputFormat); static int getDefaultLazyCacheMaxSize(); static void setDefaultLazyCacheMaxSize(int lazyCacheMaxSize); }### Answer:
@Test public void testGetProfilerOutputFormat() throws Exception { Assert.assertEquals(true, MidaoConfig.getProfilerOutputFormat() != null && MidaoConfig.getProfilerOutputFormat().length() > 0); } |
### Question:
MjdbcConfig { public static boolean isQueryInputProcessorUseCache() { return instance().queryInputProcessorUseCache; } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProcessorUseCache(); static void setQueryInputProcessorUseCache(boolean queryInputProcessorUseCache); static QueryOutputProcessor getDefaultQueryOutputProcessor(); static void setDefaultQueryOutputProcessor(QueryOutputProcessor defaultQueryOutputProcessor); static StatementHandler getDefaultStatementHandler(Overrider overrider); static void setDefaultStatementHandler(Class<? extends StatementHandler> defaultStatementHandler); static TypeHandler getDefaultTypeHandler(Overrider overrider); static void setDefaultTypeHandler(Class<? extends TypeHandler> defaultTypeHandler); static TransactionHandler getDefaultTransactionHandler(Connection conn); static TransactionHandler getDefaultTransactionHandler(DataSource ds); static void setDefaultTransactionHandler(Class<? extends TransactionHandler> defaultTransactionHandler); static ExceptionHandler getDefaultExceptionHandler(String dbName); static void setDefaultExceptionHandler(Class<? extends ExceptionHandler> defaultExceptionHandler); static MetadataHandler getDefaultMetadataHandler(Connection conn); static MetadataHandler getDefaultMetadataHandler(DataSource ds); static void setDefaultMetadataHandler(Class<? extends MetadataHandler> defaultMetadataHandler); static Overrider getDefaultOverrider(); static void setDefaultOverrider(Class<Overrider> defaultOverrider); static boolean isProfilerEnabled(); static void setProfilerEnabled(boolean profilerEnabled); static String getProfilerOutputFormat(); static void setProfilerOutputFormat(String profilerOutputFormat); static int getDefaultLazyCacheMaxSize(); static void setDefaultLazyCacheMaxSize(int lazyCacheMaxSize); static String getOutputHandlerPackage(); static Map<String, OutputHandler> getDefaultOutputHandlers(); }### Answer:
@Test public void testIsQueryInputProcessorUseCache() throws Exception { boolean defaultValue = MjdbcConfig.isQueryInputProcessorUseCache(); MjdbcConfig.setQueryInputProcessorUseCache(!defaultValue); Assert.assertEquals(!defaultValue, MjdbcConfig.isQueryInputProcessorUseCache()); MjdbcConfig.setQueryInputProcessorUseCache(defaultValue); } |
### Question:
MjdbcConfig { public static QueryOutputProcessor getDefaultQueryOutputProcessor() { return instance().defaultQueryOutputProcessor; } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProcessorUseCache(); static void setQueryInputProcessorUseCache(boolean queryInputProcessorUseCache); static QueryOutputProcessor getDefaultQueryOutputProcessor(); static void setDefaultQueryOutputProcessor(QueryOutputProcessor defaultQueryOutputProcessor); static StatementHandler getDefaultStatementHandler(Overrider overrider); static void setDefaultStatementHandler(Class<? extends StatementHandler> defaultStatementHandler); static TypeHandler getDefaultTypeHandler(Overrider overrider); static void setDefaultTypeHandler(Class<? extends TypeHandler> defaultTypeHandler); static TransactionHandler getDefaultTransactionHandler(Connection conn); static TransactionHandler getDefaultTransactionHandler(DataSource ds); static void setDefaultTransactionHandler(Class<? extends TransactionHandler> defaultTransactionHandler); static ExceptionHandler getDefaultExceptionHandler(String dbName); static void setDefaultExceptionHandler(Class<? extends ExceptionHandler> defaultExceptionHandler); static MetadataHandler getDefaultMetadataHandler(Connection conn); static MetadataHandler getDefaultMetadataHandler(DataSource ds); static void setDefaultMetadataHandler(Class<? extends MetadataHandler> defaultMetadataHandler); static Overrider getDefaultOverrider(); static void setDefaultOverrider(Class<Overrider> defaultOverrider); static boolean isProfilerEnabled(); static void setProfilerEnabled(boolean profilerEnabled); static String getProfilerOutputFormat(); static void setProfilerOutputFormat(String profilerOutputFormat); static int getDefaultLazyCacheMaxSize(); static void setDefaultLazyCacheMaxSize(int lazyCacheMaxSize); static String getOutputHandlerPackage(); static Map<String, OutputHandler> getDefaultOutputHandlers(); }### Answer:
@Test public void testGetDefaultQueryOutputProcessor() throws Exception { Assert.assertEquals(true, MjdbcConfig.getDefaultQueryOutputProcessor() instanceof QueryOutputProcessor); } |
### Question:
MjdbcConfig { public static boolean isProfilerEnabled() { return instance().profilerEnabled; } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProcessorUseCache(); static void setQueryInputProcessorUseCache(boolean queryInputProcessorUseCache); static QueryOutputProcessor getDefaultQueryOutputProcessor(); static void setDefaultQueryOutputProcessor(QueryOutputProcessor defaultQueryOutputProcessor); static StatementHandler getDefaultStatementHandler(Overrider overrider); static void setDefaultStatementHandler(Class<? extends StatementHandler> defaultStatementHandler); static TypeHandler getDefaultTypeHandler(Overrider overrider); static void setDefaultTypeHandler(Class<? extends TypeHandler> defaultTypeHandler); static TransactionHandler getDefaultTransactionHandler(Connection conn); static TransactionHandler getDefaultTransactionHandler(DataSource ds); static void setDefaultTransactionHandler(Class<? extends TransactionHandler> defaultTransactionHandler); static ExceptionHandler getDefaultExceptionHandler(String dbName); static void setDefaultExceptionHandler(Class<? extends ExceptionHandler> defaultExceptionHandler); static MetadataHandler getDefaultMetadataHandler(Connection conn); static MetadataHandler getDefaultMetadataHandler(DataSource ds); static void setDefaultMetadataHandler(Class<? extends MetadataHandler> defaultMetadataHandler); static Overrider getDefaultOverrider(); static void setDefaultOverrider(Class<Overrider> defaultOverrider); static boolean isProfilerEnabled(); static void setProfilerEnabled(boolean profilerEnabled); static String getProfilerOutputFormat(); static void setProfilerOutputFormat(String profilerOutputFormat); static int getDefaultLazyCacheMaxSize(); static void setDefaultLazyCacheMaxSize(int lazyCacheMaxSize); static String getOutputHandlerPackage(); static Map<String, OutputHandler> getDefaultOutputHandlers(); }### Answer:
@Test public void testIsProfilerEnabled() throws Exception { boolean defaultValue = MjdbcConfig.isProfilerEnabled(); MjdbcConfig.setProfilerEnabled(!defaultValue); Assert.assertEquals(!defaultValue, MjdbcConfig.isProfilerEnabled()); MjdbcConfig.setProfilerEnabled(defaultValue); } |
### Question:
MjdbcConfig { public static String getProfilerOutputFormat() { return instance().profilerOutputFormat; } static QueryInputProcessor getDefaultQueryInputProcessor(); static void setDefaultQueryInputProcessor(QueryInputProcessor defaultQueryInputProcessor); static boolean isQueryInputProcessorUseCache(); static void setQueryInputProcessorUseCache(boolean queryInputProcessorUseCache); static QueryOutputProcessor getDefaultQueryOutputProcessor(); static void setDefaultQueryOutputProcessor(QueryOutputProcessor defaultQueryOutputProcessor); static StatementHandler getDefaultStatementHandler(Overrider overrider); static void setDefaultStatementHandler(Class<? extends StatementHandler> defaultStatementHandler); static TypeHandler getDefaultTypeHandler(Overrider overrider); static void setDefaultTypeHandler(Class<? extends TypeHandler> defaultTypeHandler); static TransactionHandler getDefaultTransactionHandler(Connection conn); static TransactionHandler getDefaultTransactionHandler(DataSource ds); static void setDefaultTransactionHandler(Class<? extends TransactionHandler> defaultTransactionHandler); static ExceptionHandler getDefaultExceptionHandler(String dbName); static void setDefaultExceptionHandler(Class<? extends ExceptionHandler> defaultExceptionHandler); static MetadataHandler getDefaultMetadataHandler(Connection conn); static MetadataHandler getDefaultMetadataHandler(DataSource ds); static void setDefaultMetadataHandler(Class<? extends MetadataHandler> defaultMetadataHandler); static Overrider getDefaultOverrider(); static void setDefaultOverrider(Class<Overrider> defaultOverrider); static boolean isProfilerEnabled(); static void setProfilerEnabled(boolean profilerEnabled); static String getProfilerOutputFormat(); static void setProfilerOutputFormat(String profilerOutputFormat); static int getDefaultLazyCacheMaxSize(); static void setDefaultLazyCacheMaxSize(int lazyCacheMaxSize); static String getOutputHandlerPackage(); static Map<String, OutputHandler> getDefaultOutputHandlers(); }### Answer:
@Test public void testGetProfilerOutputFormat() throws Exception { Assert.assertEquals(true, MjdbcConfig.getProfilerOutputFormat() != null && MjdbcConfig.getProfilerOutputFormat().length() > 0); } |
### Question:
XmlRepositoryFactory { public static Document getDocument(File file) { InputStream inputStream = null; try { inputStream = new FileInputStream(file); } catch (FileNotFoundException ex) { throw new MjdbcRuntimeException(ex); } return XmlRepositoryFactory.getDocument(inputStream); } static Document getDocument(File file); static Document getDocument(InputStream inputStream); static void add(Document document, String name); static void add(Element element); static void addAll(Document document); static void addAll(List<Element> elementList); static void remove(String name); static void removeAll(Document document); static void removeAll(List<String> elementsId); static void refresh(Document document); static void refresh(Document cachedDocument, Document updatedDocument); static boolean isAutoRefresh(); static void setAutoRefresh(boolean autoRefresh); }### Answer:
@Test public void testGetDocumentStream() throws Exception { Document document = XmlRepositoryFactory.getDocument(new ByteArrayInputStream(xmlQuery.getBytes())); Assert.assertNotNull(document); }
@Test public void testGetDocumentStreamMultiThreadedUsage() throws Exception { final Runnable runnable = new Runnable() { @Override public void run() { XmlRepositoryFactory.getDocument(new ByteArrayInputStream(xmlQuery.getBytes())); } }; for (long i = 0; i < 10; i++) { (new Thread(new Runnable() { @Override public void run() { for (long j = 0; j < 100; j++) { (new Thread(runnable)).start(); } } })).start(); } Thread.sleep(500); } |
### Question:
XmlRepositoryFactory { public static void remove(String name) { xmlQueryString.remove(name); xmlOverrideMap.remove(name); } static Document getDocument(File file); static Document getDocument(InputStream inputStream); static void add(Document document, String name); static void add(Element element); static void addAll(Document document); static void addAll(List<Element> elementList); static void remove(String name); static void removeAll(Document document); static void removeAll(List<String> elementsId); static void refresh(Document document); static void refresh(Document cachedDocument, Document updatedDocument); static boolean isAutoRefresh(); static void setAutoRefresh(boolean autoRefresh); }### Answer:
@Test public void testRemove() throws Exception { XmlRepositoryFactory.addAll(XmlRepositoryFactory.getDocument(new ByteArrayInputStream( xmlQuery.getBytes() ))); Assert.assertNotNull(XmlRepositoryFactory.getQueryString("findOne")); XmlRepositoryFactory.remove("findOne"); try { XmlRepositoryFactory.getQueryString("findOne"); fail(); } catch (MjdbcRuntimeException ex) { } } |
### Question:
XmlRepositoryFactory { public static void refresh(Document document) { refresh(document, document); } static Document getDocument(File file); static Document getDocument(InputStream inputStream); static void add(Document document, String name); static void add(Element element); static void addAll(Document document); static void addAll(List<Element> elementList); static void remove(String name); static void removeAll(Document document); static void removeAll(List<String> elementsId); static void refresh(Document document); static void refresh(Document cachedDocument, Document updatedDocument); static boolean isAutoRefresh(); static void setAutoRefresh(boolean autoRefresh); }### Answer:
@Test public void testRefresh() throws Exception { XmlRepositoryFactory.addAll(XmlRepositoryFactory.getDocument(new ByteArrayInputStream( xmlQuery.getBytes() ))); Assert.assertEquals("SELECT ID FROM CATS WHERE AGE=#{age} AND NAME = #{name}", XmlRepositoryFactory.getQueryString("findOne")); Document document = XmlRepositoryFactory.getDocument(new ByteArrayInputStream( ("<?xml version=\"1.0\"?><root><query id='findOne' outputHandler='MapOutputHandler'>" + "SELECTED ID FROM CATS WHERE AGE=#{age} AND NAME = #{name}" + "</query></root>").getBytes() )); XmlRepositoryFactory.refresh(document); Assert.assertEquals("SELECTED ID FROM CATS WHERE AGE=#{age} AND NAME = #{name}", XmlRepositoryFactory.getQueryString("findOne")); } |
### Question:
XmlRepositoryFactory { public static boolean isAutoRefresh() { return autoRefresh; } static Document getDocument(File file); static Document getDocument(InputStream inputStream); static void add(Document document, String name); static void add(Element element); static void addAll(Document document); static void addAll(List<Element> elementList); static void remove(String name); static void removeAll(Document document); static void removeAll(List<String> elementsId); static void refresh(Document document); static void refresh(Document cachedDocument, Document updatedDocument); static boolean isAutoRefresh(); static void setAutoRefresh(boolean autoRefresh); }### Answer:
@Test public void testIsAutoRefresh() throws Exception { } |
### Question:
XmlRepositoryFactory { public static void setAutoRefresh(boolean autoRefresh) { XmlRepositoryFactory.autoRefresh = autoRefresh; } static Document getDocument(File file); static Document getDocument(InputStream inputStream); static void add(Document document, String name); static void add(Element element); static void addAll(Document document); static void addAll(List<Element> elementList); static void remove(String name); static void removeAll(Document document); static void removeAll(List<String> elementsId); static void refresh(Document document); static void refresh(Document cachedDocument, Document updatedDocument); static boolean isAutoRefresh(); static void setAutoRefresh(boolean autoRefresh); }### Answer:
@Test public void testSetAutoRefresh() throws Exception { } |
### Question:
XmlRepositoryFactory { static String getQueryString(String name) { String result = null; if (xmlQueryString.containsKey(name) == false) { throw new MjdbcRuntimeException("Failed to find query by name: " + name + ". Please ensure that relevant file was loaded into repository"); } result = xmlQueryString.get(name); return result; } static Document getDocument(File file); static Document getDocument(InputStream inputStream); static void add(Document document, String name); static void add(Element element); static void addAll(Document document); static void addAll(List<Element> elementList); static void remove(String name); static void removeAll(Document document); static void removeAll(List<String> elementsId); static void refresh(Document document); static void refresh(Document cachedDocument, Document updatedDocument); static boolean isAutoRefresh(); static void setAutoRefresh(boolean autoRefresh); }### Answer:
@Test public void testGetQueryString() throws Exception { XmlRepositoryFactory.addAll(XmlRepositoryFactory.getDocument(new ByteArrayInputStream( xmlQuery.getBytes() ))); Assert.assertNotNull(XmlRepositoryFactory.getQueryString("findOne")); } |
### Question:
XmlRepositoryFactory { static Overrider getOverride(AbstractXmlInputOutputHandler inputHandler) { AssertUtils.assertNotNull(inputHandler); Overrider result = null; if (xmlOverrideMap.containsKey(inputHandler.getName()) == false) { throw new MjdbcRuntimeException("Failed to find query by name: " + inputHandler.getName() + ". Please ensure that relevant file was loaded into repository"); } result = xmlOverrideMap.get(inputHandler.getName()); return result; } static Document getDocument(File file); static Document getDocument(InputStream inputStream); static void add(Document document, String name); static void add(Element element); static void addAll(Document document); static void addAll(List<Element> elementList); static void remove(String name); static void removeAll(Document document); static void removeAll(List<String> elementsId); static void refresh(Document document); static void refresh(Document cachedDocument, Document updatedDocument); static boolean isAutoRefresh(); static void setAutoRefresh(boolean autoRefresh); }### Answer:
@Test public void testGetOverride() throws Exception { XmlRepositoryFactory.addAll(XmlRepositoryFactory.getDocument(new ByteArrayInputStream( xmlQuery.getBytes() ))); XmlInputOutputHandler handler = new XmlInputOutputHandler("findOne", catMap); Assert.assertNotNull(XmlRepositoryFactory.getOverride(handler)); } |
### Question:
XmlRepositoryFactory { static OutputHandler getOutputHandler(AbstractXmlInputOutputHandler inputHandler) { AssertUtils.assertNotNull(inputHandler); OutputHandler outputHandler = null; String outputHandlerClassName = (String) getOverride(inputHandler).getOverride(XmlParameters.outputHandler); if (outputHandlerClassName.contains(".") == false) { outputHandlerClassName = MjdbcConfig.getOutputHandlerPackage() + outputHandlerClassName; } if (MjdbcConfig.getDefaultOutputHandlers().containsKey(outputHandlerClassName) == true) { outputHandler = MjdbcConfig.getDefaultOutputHandlers().get(outputHandlerClassName); } else { outputHandler = createBeanOutputHandler(inputHandler, outputHandlerClassName); } return outputHandler; } static Document getDocument(File file); static Document getDocument(InputStream inputStream); static void add(Document document, String name); static void add(Element element); static void addAll(Document document); static void addAll(List<Element> elementList); static void remove(String name); static void removeAll(Document document); static void removeAll(List<String> elementsId); static void refresh(Document document); static void refresh(Document cachedDocument, Document updatedDocument); static boolean isAutoRefresh(); static void setAutoRefresh(boolean autoRefresh); }### Answer:
@Test public void testGetOutputHandler() throws Exception { XmlRepositoryFactory.addAll(XmlRepositoryFactory.getDocument(new ByteArrayInputStream( xmlQuery.getBytes() ))); XmlInputOutputHandler handler = new XmlInputOutputHandler("findOne", catMap); Assert.assertNotNull(XmlRepositoryFactory.getOutputHandler(handler)); } |
### Question:
MidaoFactory { public static AsyncQueryRunnerService getAsyncQueryRunner(QueryRunner runner, ExecutorService executorService) { return new AsyncQueryRunner(runner, executorService); } static QueryRunnerService getQueryRunner(DataSource ds); static QueryRunnerService getQueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); static QueryRunnerService getQueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); static QueryRunnerService getQueryRunner(Connection conn); static QueryRunnerService getQueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz); static QueryRunnerService getQueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); static AsyncQueryRunnerService getAsyncQueryRunner(QueryRunner runner, ExecutorService executorService); static DataSource createDataSource(Properties poolProperties); static DataSource createDataSource(String url); static DataSource createDataSource(String url, String userName, String password); static DataSource createDataSource(String driverClassName, String url, String userName, String password); static DataSource createDataSource(String driverClassName, String url, String userName, String password, int initialSize, int maxActive); }### Answer:
@Test public void testGetAsyncQueryRunner() throws Exception { Assert.assertEquals(true, MidaoFactory.getAsyncQueryRunner(null, null) instanceof AsyncQueryRunner); } |
### Question:
QueryParametersLazyList implements List<QueryParameters> { public boolean isEmpty() { boolean result = generatedCacheMap.isEmpty(); return result; } QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, Type type, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys); void setMaxCacheSize(int maxCacheSize); int getMaxCacheSize(); void setType(Type type); boolean isEmpty(); int size(); int sizeCached(); Object[] toArray(); Object[] toArrayCached(); T[] toArray(T[] a); T[] toArrayCached(T[] a); List<QueryParameters> subList(int fromIndex, int toIndex); List<QueryParameters> subListCached(int fromIndex, int toIndex); QueryParameters get(int index); void close(); Iterator<QueryParameters> iterator(); QueryParameters set(int index, QueryParameters element); QueryParameters update(int index, QueryParameters params); void insert(QueryParameters params); ListIterator<QueryParameters> listIterator(); ListIterator<QueryParameters> listIterator(int index); boolean add(QueryParameters queryParameters); boolean addAll(Collection<? extends QueryParameters> c); boolean addAll(int index, Collection<? extends QueryParameters> c); void add(int index, QueryParameters element); boolean remove(Object o); QueryParameters remove(int index); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); int indexOf(Object o); int lastIndexOf(Object o); LazyCacheIterator<QueryParameters> getLazyCacheIterator(); void setCurrentResultSet(ResultSet currentResultSet); }### Answer:
@Test public void testIsEmpty() throws Exception { Assert.assertEquals(false, queryParametersLazyList.isEmpty()); } |
### Question:
QueryParametersLazyList implements List<QueryParameters> { public int size() { throw new MjdbcRuntimeException("Size is unknown in lazy cache implementation. Please use sizeCached()"); } QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, Type type, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys); void setMaxCacheSize(int maxCacheSize); int getMaxCacheSize(); void setType(Type type); boolean isEmpty(); int size(); int sizeCached(); Object[] toArray(); Object[] toArrayCached(); T[] toArray(T[] a); T[] toArrayCached(T[] a); List<QueryParameters> subList(int fromIndex, int toIndex); List<QueryParameters> subListCached(int fromIndex, int toIndex); QueryParameters get(int index); void close(); Iterator<QueryParameters> iterator(); QueryParameters set(int index, QueryParameters element); QueryParameters update(int index, QueryParameters params); void insert(QueryParameters params); ListIterator<QueryParameters> listIterator(); ListIterator<QueryParameters> listIterator(int index); boolean add(QueryParameters queryParameters); boolean addAll(Collection<? extends QueryParameters> c); boolean addAll(int index, Collection<? extends QueryParameters> c); void add(int index, QueryParameters element); boolean remove(Object o); QueryParameters remove(int index); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); int indexOf(Object o); int lastIndexOf(Object o); LazyCacheIterator<QueryParameters> getLazyCacheIterator(); void setCurrentResultSet(ResultSet currentResultSet); }### Answer:
@Test(expected = MjdbcRuntimeException.class) public void testSize() throws Exception { queryParametersLazyList.size(); } |
### Question:
QueryParametersLazyList implements List<QueryParameters> { public int sizeCached() { return generatedCacheMap.size() + resultSetCacheMap.size(); } QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, Type type, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys); void setMaxCacheSize(int maxCacheSize); int getMaxCacheSize(); void setType(Type type); boolean isEmpty(); int size(); int sizeCached(); Object[] toArray(); Object[] toArrayCached(); T[] toArray(T[] a); T[] toArrayCached(T[] a); List<QueryParameters> subList(int fromIndex, int toIndex); List<QueryParameters> subListCached(int fromIndex, int toIndex); QueryParameters get(int index); void close(); Iterator<QueryParameters> iterator(); QueryParameters set(int index, QueryParameters element); QueryParameters update(int index, QueryParameters params); void insert(QueryParameters params); ListIterator<QueryParameters> listIterator(); ListIterator<QueryParameters> listIterator(int index); boolean add(QueryParameters queryParameters); boolean addAll(Collection<? extends QueryParameters> c); boolean addAll(int index, Collection<? extends QueryParameters> c); void add(int index, QueryParameters element); boolean remove(Object o); QueryParameters remove(int index); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); int indexOf(Object o); int lastIndexOf(Object o); LazyCacheIterator<QueryParameters> getLazyCacheIterator(); void setCurrentResultSet(ResultSet currentResultSet); }### Answer:
@Test public void testSizeCached() throws Exception { Assert.assertEquals(1, queryParametersLazyList.sizeCached()); queryParametersLazyList.get(1); queryParametersLazyList.get(2); Assert.assertEquals(3, queryParametersLazyList.sizeCached()); } |
### Question:
QueryParametersLazyList implements List<QueryParameters> { public Object[] toArray() { throw new MjdbcRuntimeException(ERROR_NOT_ALLOWED + " Please use toArrayCached instead."); } QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, Type type, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys); void setMaxCacheSize(int maxCacheSize); int getMaxCacheSize(); void setType(Type type); boolean isEmpty(); int size(); int sizeCached(); Object[] toArray(); Object[] toArrayCached(); T[] toArray(T[] a); T[] toArrayCached(T[] a); List<QueryParameters> subList(int fromIndex, int toIndex); List<QueryParameters> subListCached(int fromIndex, int toIndex); QueryParameters get(int index); void close(); Iterator<QueryParameters> iterator(); QueryParameters set(int index, QueryParameters element); QueryParameters update(int index, QueryParameters params); void insert(QueryParameters params); ListIterator<QueryParameters> listIterator(); ListIterator<QueryParameters> listIterator(int index); boolean add(QueryParameters queryParameters); boolean addAll(Collection<? extends QueryParameters> c); boolean addAll(int index, Collection<? extends QueryParameters> c); void add(int index, QueryParameters element); boolean remove(Object o); QueryParameters remove(int index); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); int indexOf(Object o); int lastIndexOf(Object o); LazyCacheIterator<QueryParameters> getLazyCacheIterator(); void setCurrentResultSet(ResultSet currentResultSet); }### Answer:
@Test(expected = MjdbcRuntimeException.class) public void testToArray() throws Exception { queryParametersLazyList.toArray(); }
@Test(expected = MjdbcRuntimeException.class) public void testToArrayType() throws Exception { queryParametersLazyList.toArray(new String[0]); } |
### Question:
QueryParametersLazyList implements List<QueryParameters> { public List<QueryParameters> subList(int fromIndex, int toIndex) { throw new MjdbcRuntimeException(ERROR_NOT_ALLOWED + " Please use subListCached instead."); } QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, Type type, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys); void setMaxCacheSize(int maxCacheSize); int getMaxCacheSize(); void setType(Type type); boolean isEmpty(); int size(); int sizeCached(); Object[] toArray(); Object[] toArrayCached(); T[] toArray(T[] a); T[] toArrayCached(T[] a); List<QueryParameters> subList(int fromIndex, int toIndex); List<QueryParameters> subListCached(int fromIndex, int toIndex); QueryParameters get(int index); void close(); Iterator<QueryParameters> iterator(); QueryParameters set(int index, QueryParameters element); QueryParameters update(int index, QueryParameters params); void insert(QueryParameters params); ListIterator<QueryParameters> listIterator(); ListIterator<QueryParameters> listIterator(int index); boolean add(QueryParameters queryParameters); boolean addAll(Collection<? extends QueryParameters> c); boolean addAll(int index, Collection<? extends QueryParameters> c); void add(int index, QueryParameters element); boolean remove(Object o); QueryParameters remove(int index); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); int indexOf(Object o); int lastIndexOf(Object o); LazyCacheIterator<QueryParameters> getLazyCacheIterator(); void setCurrentResultSet(ResultSet currentResultSet); }### Answer:
@Test(expected = MjdbcRuntimeException.class) public void testSubList() throws Exception { queryParametersLazyList.subList(0, 2); } |
### Question:
QueryParametersLazyList implements List<QueryParameters> { public void close() { while (getCurrentResultSet() != null) { try { closeResultSet(getCurrentResultSet()); setCurrentResultSet(getNextResultSet()); } catch (SQLException ex) { setCurrentResultSet(null); } } MjdbcUtils.closeQuietly(stmt); } QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, Type type, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys); void setMaxCacheSize(int maxCacheSize); int getMaxCacheSize(); void setType(Type type); boolean isEmpty(); int size(); int sizeCached(); Object[] toArray(); Object[] toArrayCached(); T[] toArray(T[] a); T[] toArrayCached(T[] a); List<QueryParameters> subList(int fromIndex, int toIndex); List<QueryParameters> subListCached(int fromIndex, int toIndex); QueryParameters get(int index); void close(); Iterator<QueryParameters> iterator(); QueryParameters set(int index, QueryParameters element); QueryParameters update(int index, QueryParameters params); void insert(QueryParameters params); ListIterator<QueryParameters> listIterator(); ListIterator<QueryParameters> listIterator(int index); boolean add(QueryParameters queryParameters); boolean addAll(Collection<? extends QueryParameters> c); boolean addAll(int index, Collection<? extends QueryParameters> c); void add(int index, QueryParameters element); boolean remove(Object o); QueryParameters remove(int index); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); int indexOf(Object o); int lastIndexOf(Object o); LazyCacheIterator<QueryParameters> getLazyCacheIterator(); void setCurrentResultSet(ResultSet currentResultSet); }### Answer:
@Test public void testClose() throws Exception { queryParametersLazyList.close(); verify(rs, times(1)).close(); verify(stmt, times(1)).close(); } |
### Question:
QueryParametersLazyList implements List<QueryParameters> { public ListIterator<QueryParameters> listIterator() { throw new MjdbcRuntimeException(ERROR_NOT_ALLOWED + " Please use iterator() instead."); } QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, Type type, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys); void setMaxCacheSize(int maxCacheSize); int getMaxCacheSize(); void setType(Type type); boolean isEmpty(); int size(); int sizeCached(); Object[] toArray(); Object[] toArrayCached(); T[] toArray(T[] a); T[] toArrayCached(T[] a); List<QueryParameters> subList(int fromIndex, int toIndex); List<QueryParameters> subListCached(int fromIndex, int toIndex); QueryParameters get(int index); void close(); Iterator<QueryParameters> iterator(); QueryParameters set(int index, QueryParameters element); QueryParameters update(int index, QueryParameters params); void insert(QueryParameters params); ListIterator<QueryParameters> listIterator(); ListIterator<QueryParameters> listIterator(int index); boolean add(QueryParameters queryParameters); boolean addAll(Collection<? extends QueryParameters> c); boolean addAll(int index, Collection<? extends QueryParameters> c); void add(int index, QueryParameters element); boolean remove(Object o); QueryParameters remove(int index); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); int indexOf(Object o); int lastIndexOf(Object o); LazyCacheIterator<QueryParameters> getLazyCacheIterator(); void setCurrentResultSet(ResultSet currentResultSet); }### Answer:
@Test(expected = MjdbcRuntimeException.class) public void testListIterator() throws Exception { queryParametersLazyList.listIterator(); }
@Test(expected = MjdbcRuntimeException.class) public void testListIteratorIndex() throws Exception { queryParametersLazyList.listIterator(1); } |
### Question:
QueryParametersLazyList implements List<QueryParameters> { public boolean add(QueryParameters queryParameters) { throw new MjdbcRuntimeException(ERROR_NOT_ALLOWED); } QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, Type type, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys); void setMaxCacheSize(int maxCacheSize); int getMaxCacheSize(); void setType(Type type); boolean isEmpty(); int size(); int sizeCached(); Object[] toArray(); Object[] toArrayCached(); T[] toArray(T[] a); T[] toArrayCached(T[] a); List<QueryParameters> subList(int fromIndex, int toIndex); List<QueryParameters> subListCached(int fromIndex, int toIndex); QueryParameters get(int index); void close(); Iterator<QueryParameters> iterator(); QueryParameters set(int index, QueryParameters element); QueryParameters update(int index, QueryParameters params); void insert(QueryParameters params); ListIterator<QueryParameters> listIterator(); ListIterator<QueryParameters> listIterator(int index); boolean add(QueryParameters queryParameters); boolean addAll(Collection<? extends QueryParameters> c); boolean addAll(int index, Collection<? extends QueryParameters> c); void add(int index, QueryParameters element); boolean remove(Object o); QueryParameters remove(int index); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); int indexOf(Object o); int lastIndexOf(Object o); LazyCacheIterator<QueryParameters> getLazyCacheIterator(); void setCurrentResultSet(ResultSet currentResultSet); }### Answer:
@Test(expected = MjdbcRuntimeException.class) public void testAdd() throws Exception { queryParametersLazyList.add(null); }
@Test(expected = MjdbcRuntimeException.class) public void testAddIndex() throws Exception { queryParametersLazyList.add(1, null); } |
### Question:
QueryParametersLazyList implements List<QueryParameters> { public boolean remove(Object o) { throw new MjdbcRuntimeException(ERROR_NOT_ALLOWED); } QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, Type type, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys); void setMaxCacheSize(int maxCacheSize); int getMaxCacheSize(); void setType(Type type); boolean isEmpty(); int size(); int sizeCached(); Object[] toArray(); Object[] toArrayCached(); T[] toArray(T[] a); T[] toArrayCached(T[] a); List<QueryParameters> subList(int fromIndex, int toIndex); List<QueryParameters> subListCached(int fromIndex, int toIndex); QueryParameters get(int index); void close(); Iterator<QueryParameters> iterator(); QueryParameters set(int index, QueryParameters element); QueryParameters update(int index, QueryParameters params); void insert(QueryParameters params); ListIterator<QueryParameters> listIterator(); ListIterator<QueryParameters> listIterator(int index); boolean add(QueryParameters queryParameters); boolean addAll(Collection<? extends QueryParameters> c); boolean addAll(int index, Collection<? extends QueryParameters> c); void add(int index, QueryParameters element); boolean remove(Object o); QueryParameters remove(int index); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); int indexOf(Object o); int lastIndexOf(Object o); LazyCacheIterator<QueryParameters> getLazyCacheIterator(); void setCurrentResultSet(ResultSet currentResultSet); }### Answer:
@Test(expected = MjdbcRuntimeException.class) public void testRemove() throws Exception { queryParametersLazyList.remove(null); }
@Test(expected = MjdbcRuntimeException.class) public void testRemoveIndex() throws Exception { queryParametersLazyList.remove(1); } |
### Question:
QueryParametersLazyList implements List<QueryParameters> { public boolean removeAll(Collection<?> c) { throw new MjdbcRuntimeException(ERROR_NOT_ALLOWED); } QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, Type type, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys); void setMaxCacheSize(int maxCacheSize); int getMaxCacheSize(); void setType(Type type); boolean isEmpty(); int size(); int sizeCached(); Object[] toArray(); Object[] toArrayCached(); T[] toArray(T[] a); T[] toArrayCached(T[] a); List<QueryParameters> subList(int fromIndex, int toIndex); List<QueryParameters> subListCached(int fromIndex, int toIndex); QueryParameters get(int index); void close(); Iterator<QueryParameters> iterator(); QueryParameters set(int index, QueryParameters element); QueryParameters update(int index, QueryParameters params); void insert(QueryParameters params); ListIterator<QueryParameters> listIterator(); ListIterator<QueryParameters> listIterator(int index); boolean add(QueryParameters queryParameters); boolean addAll(Collection<? extends QueryParameters> c); boolean addAll(int index, Collection<? extends QueryParameters> c); void add(int index, QueryParameters element); boolean remove(Object o); QueryParameters remove(int index); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); int indexOf(Object o); int lastIndexOf(Object o); LazyCacheIterator<QueryParameters> getLazyCacheIterator(); void setCurrentResultSet(ResultSet currentResultSet); }### Answer:
@Test(expected = MjdbcRuntimeException.class) public void testRemoveAll() throws Exception { queryParametersLazyList.removeAll(Arrays.<QueryParameters>asList(new QueryParameters[0])); } |
### Question:
QueryParametersLazyList implements List<QueryParameters> { public boolean retainAll(Collection<?> c) { throw new MjdbcRuntimeException(ERROR_NOT_ALLOWED); } QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, Type type, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys); void setMaxCacheSize(int maxCacheSize); int getMaxCacheSize(); void setType(Type type); boolean isEmpty(); int size(); int sizeCached(); Object[] toArray(); Object[] toArrayCached(); T[] toArray(T[] a); T[] toArrayCached(T[] a); List<QueryParameters> subList(int fromIndex, int toIndex); List<QueryParameters> subListCached(int fromIndex, int toIndex); QueryParameters get(int index); void close(); Iterator<QueryParameters> iterator(); QueryParameters set(int index, QueryParameters element); QueryParameters update(int index, QueryParameters params); void insert(QueryParameters params); ListIterator<QueryParameters> listIterator(); ListIterator<QueryParameters> listIterator(int index); boolean add(QueryParameters queryParameters); boolean addAll(Collection<? extends QueryParameters> c); boolean addAll(int index, Collection<? extends QueryParameters> c); void add(int index, QueryParameters element); boolean remove(Object o); QueryParameters remove(int index); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); int indexOf(Object o); int lastIndexOf(Object o); LazyCacheIterator<QueryParameters> getLazyCacheIterator(); void setCurrentResultSet(ResultSet currentResultSet); }### Answer:
@Test(expected = MjdbcRuntimeException.class) public void testRetainAll() throws Exception { queryParametersLazyList.retainAll(Arrays.<QueryParameters>asList(new QueryParameters[0])); } |
### Question:
QueryParametersLazyList implements List<QueryParameters> { public void clear() { throw new MjdbcRuntimeException(ERROR_NOT_ALLOWED); } QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, Type type, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys); void setMaxCacheSize(int maxCacheSize); int getMaxCacheSize(); void setType(Type type); boolean isEmpty(); int size(); int sizeCached(); Object[] toArray(); Object[] toArrayCached(); T[] toArray(T[] a); T[] toArrayCached(T[] a); List<QueryParameters> subList(int fromIndex, int toIndex); List<QueryParameters> subListCached(int fromIndex, int toIndex); QueryParameters get(int index); void close(); Iterator<QueryParameters> iterator(); QueryParameters set(int index, QueryParameters element); QueryParameters update(int index, QueryParameters params); void insert(QueryParameters params); ListIterator<QueryParameters> listIterator(); ListIterator<QueryParameters> listIterator(int index); boolean add(QueryParameters queryParameters); boolean addAll(Collection<? extends QueryParameters> c); boolean addAll(int index, Collection<? extends QueryParameters> c); void add(int index, QueryParameters element); boolean remove(Object o); QueryParameters remove(int index); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); int indexOf(Object o); int lastIndexOf(Object o); LazyCacheIterator<QueryParameters> getLazyCacheIterator(); void setCurrentResultSet(ResultSet currentResultSet); }### Answer:
@Test(expected = MjdbcRuntimeException.class) public void testClear() throws Exception { queryParametersLazyList.clear(); } |
### Question:
QueryParametersLazyList implements List<QueryParameters> { public boolean contains(Object o) { throw new MjdbcRuntimeException(ERROR_NOT_ALLOWED); } QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, Type type, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys); void setMaxCacheSize(int maxCacheSize); int getMaxCacheSize(); void setType(Type type); boolean isEmpty(); int size(); int sizeCached(); Object[] toArray(); Object[] toArrayCached(); T[] toArray(T[] a); T[] toArrayCached(T[] a); List<QueryParameters> subList(int fromIndex, int toIndex); List<QueryParameters> subListCached(int fromIndex, int toIndex); QueryParameters get(int index); void close(); Iterator<QueryParameters> iterator(); QueryParameters set(int index, QueryParameters element); QueryParameters update(int index, QueryParameters params); void insert(QueryParameters params); ListIterator<QueryParameters> listIterator(); ListIterator<QueryParameters> listIterator(int index); boolean add(QueryParameters queryParameters); boolean addAll(Collection<? extends QueryParameters> c); boolean addAll(int index, Collection<? extends QueryParameters> c); void add(int index, QueryParameters element); boolean remove(Object o); QueryParameters remove(int index); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); int indexOf(Object o); int lastIndexOf(Object o); LazyCacheIterator<QueryParameters> getLazyCacheIterator(); void setCurrentResultSet(ResultSet currentResultSet); }### Answer:
@Test(expected = MjdbcRuntimeException.class) public void testContains() throws Exception { queryParametersLazyList.contains(null); } |
### Question:
QueryParametersLazyList implements List<QueryParameters> { public boolean containsAll(Collection<?> c) { throw new MjdbcRuntimeException(ERROR_NOT_ALLOWED); } QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, Type type, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys); void setMaxCacheSize(int maxCacheSize); int getMaxCacheSize(); void setType(Type type); boolean isEmpty(); int size(); int sizeCached(); Object[] toArray(); Object[] toArrayCached(); T[] toArray(T[] a); T[] toArrayCached(T[] a); List<QueryParameters> subList(int fromIndex, int toIndex); List<QueryParameters> subListCached(int fromIndex, int toIndex); QueryParameters get(int index); void close(); Iterator<QueryParameters> iterator(); QueryParameters set(int index, QueryParameters element); QueryParameters update(int index, QueryParameters params); void insert(QueryParameters params); ListIterator<QueryParameters> listIterator(); ListIterator<QueryParameters> listIterator(int index); boolean add(QueryParameters queryParameters); boolean addAll(Collection<? extends QueryParameters> c); boolean addAll(int index, Collection<? extends QueryParameters> c); void add(int index, QueryParameters element); boolean remove(Object o); QueryParameters remove(int index); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); int indexOf(Object o); int lastIndexOf(Object o); LazyCacheIterator<QueryParameters> getLazyCacheIterator(); void setCurrentResultSet(ResultSet currentResultSet); }### Answer:
@Test(expected = MjdbcRuntimeException.class) public void testContainsAll() throws Exception { queryParametersLazyList.containsAll(Arrays.<QueryParameters>asList(new QueryParameters[0])); } |
### Question:
QueryParametersLazyList implements List<QueryParameters> { public int indexOf(Object o) { throw new MjdbcRuntimeException(ERROR_NOT_ALLOWED); } QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, Type type, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys); void setMaxCacheSize(int maxCacheSize); int getMaxCacheSize(); void setType(Type type); boolean isEmpty(); int size(); int sizeCached(); Object[] toArray(); Object[] toArrayCached(); T[] toArray(T[] a); T[] toArrayCached(T[] a); List<QueryParameters> subList(int fromIndex, int toIndex); List<QueryParameters> subListCached(int fromIndex, int toIndex); QueryParameters get(int index); void close(); Iterator<QueryParameters> iterator(); QueryParameters set(int index, QueryParameters element); QueryParameters update(int index, QueryParameters params); void insert(QueryParameters params); ListIterator<QueryParameters> listIterator(); ListIterator<QueryParameters> listIterator(int index); boolean add(QueryParameters queryParameters); boolean addAll(Collection<? extends QueryParameters> c); boolean addAll(int index, Collection<? extends QueryParameters> c); void add(int index, QueryParameters element); boolean remove(Object o); QueryParameters remove(int index); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); int indexOf(Object o); int lastIndexOf(Object o); LazyCacheIterator<QueryParameters> getLazyCacheIterator(); void setCurrentResultSet(ResultSet currentResultSet); }### Answer:
@Test(expected = MjdbcRuntimeException.class) public void testIndexOf() throws Exception { queryParametersLazyList.indexOf(null); } |
### Question:
QueryParametersLazyList implements List<QueryParameters> { public int lastIndexOf(Object o) { throw new MjdbcRuntimeException(ERROR_NOT_ALLOWED); } QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, Type type, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys, int maxCacheSize); QueryParametersLazyList(Statement stmt, TypeHandler typeHandler, boolean readGeneratedKeys); void setMaxCacheSize(int maxCacheSize); int getMaxCacheSize(); void setType(Type type); boolean isEmpty(); int size(); int sizeCached(); Object[] toArray(); Object[] toArrayCached(); T[] toArray(T[] a); T[] toArrayCached(T[] a); List<QueryParameters> subList(int fromIndex, int toIndex); List<QueryParameters> subListCached(int fromIndex, int toIndex); QueryParameters get(int index); void close(); Iterator<QueryParameters> iterator(); QueryParameters set(int index, QueryParameters element); QueryParameters update(int index, QueryParameters params); void insert(QueryParameters params); ListIterator<QueryParameters> listIterator(); ListIterator<QueryParameters> listIterator(int index); boolean add(QueryParameters queryParameters); boolean addAll(Collection<? extends QueryParameters> c); boolean addAll(int index, Collection<? extends QueryParameters> c); void add(int index, QueryParameters element); boolean remove(Object o); QueryParameters remove(int index); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); boolean contains(Object o); boolean containsAll(Collection<?> c); int indexOf(Object o); int lastIndexOf(Object o); LazyCacheIterator<QueryParameters> getLazyCacheIterator(); void setCurrentResultSet(ResultSet currentResultSet); }### Answer:
@Test(expected = MjdbcRuntimeException.class) public void testLastIndexOf() throws Exception { queryParametersLazyList.lastIndexOf(null); } |
### Question:
NoOpBotUpdateProcessor implements BotUpdateProcessor { @Override public boolean handleUpdate(@Nonnull final Update update) { return true; } static NoOpBotUpdateProcessor getDefault(); @Override boolean handleUpdate(@Nonnull final Update update); }### Answer:
@Test public void testMockUpdate() { final BotUpdateProcessor processor = new NoOpBotUpdateProcessor(); final boolean handled = processor.handleUpdate(Mockito.mock(Update.class)); assertTrue(handled); }
@Test public void testHandleNullUpdate() { final BotUpdateProcessor processor = new NoOpBotUpdateProcessor(); final boolean handled = processor.handleUpdate(null); assertTrue(handled); } |
### Question:
SteadyBackOff implements BackOff { public final long getInterval() { return interval; } SteadyBackOff(final long interval); static SteadyBackOff newInstance(); @Override long getNextBackOffInMilli(); @Override void reset(); final long getInterval(); static final long DEFAULT_INTERVAL_IN_MILLI; }### Answer:
@Test public void testGetInterval() { final long interval = new Random().nextInt(1000) + 1; SteadyBackOff backOff = new SteadyBackOff(interval); assertEquals(interval, backOff.getInterval()); int round = new Random().nextInt(100) + 1; while (round > 0) { assertEquals(interval, backOff.getNextBackOffInMilli()); round--; } } |
### Question:
CompletableFutureBasedCallAdapter implements CallAdapter<ApiResponse<T>, CompletableFuture<T>> { @Nonnull @Override public CompletableFuture<T> adapt(@Nonnull final Call<ApiResponse<T>> call) { final CompletableFuture<T> fut = new CompletableFuture<T>() { @Override public boolean cancel(final boolean mayInterruptIfRunning) { if (mayInterruptIfRunning) { call.cancel(); } return super.cancel(mayInterruptIfRunning); } }; call.enqueue(new CompletableFutureBasedCallback<>(fut, retry, logger)); return fut; } CompletableFutureBasedCallAdapter(@Nonnull final Type responseType, final boolean retry, @Nonnull final Logger logger); @Nonnull @Override Type responseType(); @Nonnull @Override CompletableFuture<T> adapt(@Nonnull final Call<ApiResponse<T>> call); }### Answer:
@Test public void testAdapt() { Type returnType = new ParameterizedType() { @Override public Type[] getActualTypeArguments() { return new Type[]{String.class}; } @Override public Type getRawType() { return CompletableFuture.class; } @Override public Type getOwnerType() { return Object.class; } }; CompletableFutureBasedCallAdapter<T> adapter = new CompletableFutureBasedCallAdapter<>(returnType, false, LOGGER); assertEquals(returnType, adapter.responseType()); CompletableFuture<T> future = adapter.adapt(mockCall); verify(mockCall, times(1)).enqueue(any()); future.cancel(true); verify(mockCall, times(1)).cancel(); future.cancel(false); verify(mockCall, times(1)).cancel(); } |
### Question:
FixedBackOff implements BackOff { @Override public BackOffHandler start() { return new FixedBackOffHandler(); } private FixedBackOff(); FixedBackOff(@Nullable final Long internal, @Nullable final Long maxElapsedTime); static FixedBackOff getDefault(); @Override BackOffHandler start(); long getInterval(); @Override long getMaxElapsedTime(); static final long DEFAULT_INTERVAL; static final long DEFAULT_MAX_ELAPSED_TIME; }### Answer:
@Test public void testCustomization() { final long interval = 10; BackOffHandler handler = new FixedBackOff(interval, 100L).start(); for (int i = 1; i <= 11; i++) { if (i <= 10) { assertEquals(interval, handler.nextBackOff()); } else { assertEquals(STOP, handler.nextBackOff()); } } } |
### Question:
ExponentialBackOff implements BackOff { @Override public BackOffHandler start() { return new ExponentialBackOffHandler(); } private ExponentialBackOff(); ExponentialBackOff(
@Nullable final Long initialInterval,
@Nullable final Double multiplier,
@Nullable final Long maxInterval,
@Nullable final Long maxElapsedTime); static ExponentialBackOff getDefault(); @Override BackOffHandler start(); long getInitialInterval(); double getMultiplier(); long getMaxInterval(); @Override long getMaxElapsedTime(); static final long DEFAULT_INITIAL_INTERVAL; static final double DEFAULT_MULTIPLIER; static final long DEFAULT_MAX_INTERVAL; static final long DEFAULT_MAX_ELAPSED_TIME; }### Answer:
@Test public void testCustomization() { long interval = 1; final double multiplier = 2.0; final long maxInterval = 32; BackOffHandler handler = new ExponentialBackOff(1L, multiplier, maxInterval, 128L).start(); for (int i = 1; i <= 12; i++) { if (i <= 6) { assertEquals(interval, handler.nextBackOff()); interval *= multiplier; } else if (i <= 9) { assertEquals(maxInterval, handler.nextBackOff()); } else { assertEquals(STOP, handler.nextBackOff()); } } } |
### Question:
TelegramUtils { public static void verifyToken(final String token) { checkArgument(!isNullOrEmpty(token), "Token can not be null or empty string!"); if (!TOKEN_PATTERN.matcher(token).matches()) { throw new IllegalArgumentException("Invalid token: " + token); } } static void verifyToken(final String token); static String parseBotIdFromToken(final String token); }### Answer:
@Test public void testVerifyToken() { try { verifyToken(null); fail(); } catch (IllegalArgumentException e) { } try { verifyToken("\n"); fail(); } catch (IllegalArgumentException e) { } try { verifyToken(":"); fail(); } catch (IllegalArgumentException e) { } try { verifyToken(":aa"); fail(); } catch (IllegalArgumentException e) { } try { verifyToken("aa:"); fail(); } catch (IllegalArgumentException e) { } try { verifyToken("aa:bb"); fail(); } catch (IllegalArgumentException e) { } try { verifyToken("aa: bb"); fail(); } catch (IllegalArgumentException e) { } try { verifyToken("aa :bb"); fail(); } catch (IllegalArgumentException e) { } try { verifyToken("aa::bb"); fail(); } catch (IllegalArgumentException e) { } try { verifyToken("00:bb\n"); fail(); } catch (IllegalArgumentException e) { } } |
### Question:
TelegramUtils { public static String parseBotIdFromToken(final String token) { verifyToken(token); return token.split(":", 2)[0]; } static void verifyToken(final String token); static String parseBotIdFromToken(final String token); }### Answer:
@Test public void testParseBotIdFromToken() { assertEquals("000", parseBotIdFromToken("000:bb")); } |
### Question:
LogOnlyBotUpdateProcessor implements BotUpdateProcessor { @Override public boolean handleUpdate(@Nonnull final Update update) { logger.info(JsonUtil.toJson(update)); return true; } LogOnlyBotUpdateProcessor(@Nonnull final Logger logger); @Override boolean handleUpdate(@Nonnull final Update update); }### Answer:
@Test public void testMockUpdate() { final BotUpdateProcessor processor = new LogOnlyBotUpdateProcessor(mockLogger); final boolean handled = processor.handleUpdate(Mockito.mock(Update.class)); assertTrue(handled); verify(mockLogger, times(1)).info(anyString()); } |
### Question:
Colors { public static void setTheme(@NonNull PrimaryColor primaryColor, @NonNull AccentColor accentColor) { setTheme(new ColorTheme(primaryColor, accentColor)); } private Colors(); static void theme(Activity activity); static void theme(Activity activity, @Nullable String taskName,
@Nullable Bitmap taskIcon); static void setTheme(@NonNull PrimaryColor primaryColor,
@NonNull AccentColor accentColor); static void setTheme(@NonNull PrimaryColor primaryColor,
@NonNull AccentColor accentColor,
@NonNull NightMode nightMode); static void setTheme(@NonNull ColorTheme theme); @NonNull static ColorTheme getTheme(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testSetThemeThrowsForNullPrimaryColor() { Colors.setTheme(null, AccentColor.AMBER_A200); }
@Test(expected = IllegalArgumentException.class) public void testSetThemeThrowsForNullAccentColor() { Colors.setTheme(PrimaryColor.RED_500, null); }
@Test(expected = IllegalArgumentException.class) public void testSetThemeThrowsForNullNightMode() { Colors.setTheme(PrimaryColor.RED_500, AccentColor.AMBER_A100, null); }
@Test(expected = IllegalArgumentException.class) public void testSetThemeThrowsForNullTheme() { Colors.setTheme(null); } |
### Question:
DigitalOcean { public static void onLoggedIn(String token) { DigitalOcean.authToken = token; if (okHttpClient == null) { OkHttpClient.Builder clientBuilder = new OkHttpClient.Builder() .addInterceptor(new Interceptor() { @Override public Response intercept(Chain chain) throws IOException { Request request = chain.request().newBuilder() .addHeader("Content-Type", "application/json") .addHeader("Authorization", "Bearer " + authToken) .build(); return chain.proceed(request); } }); if (USE_MOCK_API) { clientBuilder.addInterceptor(new MockUtils.MockGetInterceptor() .addPathResponse(MockResponses.api) ); } okHttpClient = clientBuilder.build(); } r = new Retrofit.Builder() .baseUrl(BASE_URL) .addConverterFactory(GsonConverterFactory.create()) .client(okHttpClient) .build(); r2 = new Retrofit.Builder() .baseUrl(BASE_URL_V1) .addConverterFactory(GsonConverterFactory.create()) .client(okHttpClient) .build(); } static String getClientId(); static String getCallbackUrl(); static void init(String clientId, String callbackUrl); static void init(String clientId, String callbackUrl, boolean useMockApi); static void doLogin(Activity act); static void setHttpClient(OkHttpClient customClient); static void onLoggedIn(String token); static DigitalOceanClient getDOClient(@NonNull String authToken); static DigitalOceanStatisticsClient getDOStatsClient(@NonNull String authToken); static final String TAG; static final int LOGIN_ACT_INTENT_CODE; static final String EXTRA_AUTH_TOKEN; static final int LOGIN_SUCCESS; static final int LOGIN_FAIL; static final String BASE_URL; static final String BASE_URL_V1; }### Answer:
@Test public void onLoggedIn() { DigitalOcean.onLoggedIn("m31b5m13b1b23febm1513bj15hb"); } |
### Question:
FragmentFileSet { public void run() throws IOException { FlatPackageWriterImpl flatPackageWriter = new FlatPackageWriterImpl(0); flatPackageWriter.setDebugOutput(debug); flatPackageWriter.setOutputDirectory(outputDir); Movie movie = new Movie(); for (File input : inputFiles) { System.err.println(input.getAbsolutePath()); Movie m = MovieCreator.build(new FileInputStream(input).getChannel()); for (Track track : m.getTracks()) { movie.addTrack(track); } } flatPackageWriter.write(movie); } static void main(String[] args); void run(); }### Answer:
@Test public void testCommandLine() throws IOException { File tmpDir = createTmpDir(); File outputDir = createTmpDir(); copyResource("/smoothstreaming/audio-96000.mp4", tmpDir); copyResource("/smoothstreaming/video-128h-75kbps.mp4", tmpDir); copyResource("/smoothstreaming/video-192h-155kbps.mp4", tmpDir); copyResource("/smoothstreaming/video-240h-231kbps.mp4", tmpDir); copyResource("/smoothstreaming/video-320h-388kbps.mp4", tmpDir); FragmentFileSet fragmentFileSet = new FragmentFileSet(); File inputs[] = tmpDir.listFiles(); Assert.assertNotNull(inputs); fragmentFileSet.inputFiles = Arrays.asList(inputs); fragmentFileSet.outputDir = outputDir; fragmentFileSet.run(); System.err.println(outputDir); Assert.assertTrue(new File(outputDir, "Manifest").exists()); Assert.assertTrue(new File(outputDir, "video").exists()); Assert.assertTrue(new File(outputDir, "audio").exists()); } |
### Question:
BitReaderBuffer { public int remainingBits() { return buffer.limit() * 8 - position; } BitReaderBuffer(ByteBuffer buffer); int readBits(int i); int getPosition(); int byteSync(); int remainingBits(); }### Answer:
@Test public void testRemainingBits() { BitReaderBuffer bitReaderBuffer = new BitReaderBuffer(testSequence); Assert.assertEquals(32, bitReaderBuffer.remainingBits()); int six = 6; bitReaderBuffer.readBits(six); Assert.assertEquals(32 - six, bitReaderBuffer.remainingBits()); } |
### Question:
TwoSecondIntersectionFinder implements FragmentIntersectionFinder { public long[] sampleNumbers(Track track, Movie movie) { List<TimeToSampleBox.Entry> entries = track.getDecodingTimeEntries(); double trackLength = 0; for (Track thisTrack : movie.getTracks()) { double thisTracksLength = getDuration(thisTrack) / thisTrack.getTrackMetaData().getTimescale(); if (trackLength < thisTracksLength) { trackLength = thisTracksLength; } } int fragmentCount = (int) Math.ceil(trackLength / fragmentLength) - 1; if (fragmentCount < 1) { fragmentCount = 1; } long fragments[] = new long[fragmentCount]; Arrays.fill(fragments, -1); fragments[0] = 1; long time = 0; int samples = 0; for (TimeToSampleBox.Entry entry : entries) { for (int i = 0; i < entry.getCount(); i++) { int currentFragment = (int) (time / track.getTrackMetaData().getTimescale() / fragmentLength) + 1; if (currentFragment >= fragments.length) { break; } fragments[currentFragment] = samples++ + 1; time += entry.getDelta(); } } long last = samples + 1; for (int i = fragments.length - 1; i >= 0; i--) { if (fragments[i] == -1) { fragments[i] = last; } last = fragments[i]; } return fragments; } TwoSecondIntersectionFinder(); TwoSecondIntersectionFinder(int fragmentLength); long[] sampleNumbers(Track track, Movie movie); }### Answer:
@Test public void testSampleNumbers() throws Exception { Movie m = MovieCreator.build(Channels.newChannel(TwoSecondIntersectionFinderTest.class.getResourceAsStream("/Beethoven - Bagatelle op.119 no.11 i.m4a"))); TwoSecondIntersectionFinder intersectionFinder = new TwoSecondIntersectionFinder(); long[] s = intersectionFinder.sampleNumbers(m.getTracks().get(0), m); Assert.assertArrayEquals(samples, s); } |
### Question:
Path { public static Box getPath(Box box, String path) { List<? extends Box> all = getPaths(box, path, true); return all.isEmpty() ? null : all.get(0); } private Path(); static String createPath(Box box); static Box getPath(Box box, String path); static List<Box> getPaths(Box box, String path); static List<Box> getPaths(Box box, String path, boolean singleResult); static boolean isContained(Box box, String path); }### Answer:
@Test public void testGetParent() throws Exception { Box b1 = isoFile.getMovieBox().getBoxes(TrackBox.class).get(1).getSampleTableBox().getTimeToSampleBox(); Assert.assertEquals(isoFile.getMovieBox().getBoxes(TrackBox.class).get(1).getSampleTableBox(), Path.getPath(b1, "..")); } |
### Question:
SampleFlags { public void getContent(ByteBuffer os) { BitWriterBuffer bitWriterBuffer = new BitWriterBuffer(os); bitWriterBuffer.writeBits(reserved, 6); bitWriterBuffer.writeBits(sampleDependsOn, 2); bitWriterBuffer.writeBits(sampleIsDependedOn, 2); bitWriterBuffer.writeBits(sampleHasRedundancy, 2); bitWriterBuffer.writeBits(samplePaddingValue, 3); bitWriterBuffer.writeBits(this.sampleIsDifferenceSample ? 1 : 0, 1); bitWriterBuffer.writeBits(sampleDegradationPriority, 16); } SampleFlags(); SampleFlags(ByteBuffer bb); void getContent(ByteBuffer os); int getReserved(); void setReserved(int reserved); int getSampleDependsOn(); void setSampleDependsOn(int sampleDependsOn); int getSampleIsDependedOn(); void setSampleIsDependedOn(int sampleIsDependedOn); int getSampleHasRedundancy(); void setSampleHasRedundancy(int sampleHasRedundancy); int getSamplePaddingValue(); void setSamplePaddingValue(int samplePaddingValue); boolean isSampleIsDifferenceSample(); void setSampleIsDifferenceSample(boolean sampleIsDifferenceSample); int getSampleDegradationPriority(); void setSampleDegradationPriority(int sampleDegradationPriority); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void testSimple() throws IOException { long l = 0x11223344; SampleFlags sf = new SampleFlags(ByteBuffer.wrap(new byte[]{0x11, 0x22, 0x33, 0x44})); ByteBuffer b = ByteBuffer.allocate(4); sf.getContent(b); b.rewind(); Assert.assertEquals(l, IsoTypeReader.readUInt32(b)); } |
### Question:
SampleDependencyTypeBox extends AbstractFullBox { public void setEntries(List<Entry> entries) { this.entries = entries; } SampleDependencyTypeBox(); @Override void _parseDetails(ByteBuffer content); List<Entry> getEntries(); void setEntries(List<Entry> entries); @Override String toString(); static final String TYPE; }### Answer:
@Test public void testParse() throws Exception { SampleDependencyTypeBox stsc = new SampleDependencyTypeBox(); List<SampleDependencyTypeBox.Entry> l = new LinkedList<SampleDependencyTypeBox.Entry>(); for (int i = 0; i < 0xcf; i++) { SampleDependencyTypeBox.Entry e = new SampleDependencyTypeBox.Entry(i); l.add(e); } stsc.setEntries(l); ByteArrayOutputStream baos = new ByteArrayOutputStream(); stsc.getBox(Channels.newChannel(baos)); byte[] content = baos.toByteArray(); SampleDependencyTypeBox stsc2 = new SampleDependencyTypeBox(); stsc2.parse(new ByteBufferByteChannel(ByteBuffer.wrap(content, 8, content.length - 8)), null, content.length - 8, null); Assert.assertEquals(content.length, stsc2.getSize()); } |
### Question:
SampleList extends AbstractList<ByteBuffer> { @Override public ByteBuffer get(int index) { long offset = offsets[index]; int sampleSize = l2i(sizes[index]); for (MediaDataBox mediaDataBox : mdats) { if ((mediaDataBox.getDataStartPosition() <= offset) && (offset + sampleSize <= mediaDataBox.getDataEndPosition())) { return mediaDataBox.getContent(offset - mediaDataBox.getDataStartPosition(), sampleSize); } } throw new RuntimeException("The sample with offset " + offset + " and size " + l2i(sizes[index]) + " is NOT located within an mdat"); } SampleList(TrackBox trackBox); SampleList(TrackFragmentBox traf); long[] getOffsetKeys(); @Override int size(); @Override ByteBuffer get(int index); }### Answer:
@Test public void testGotAll() throws IOException { String input = SampleListTest.class.getProtectionDomain().getCodeSource().getLocation().getFile() + "/Beethoven - Bagatelle op.119 no.11 i.m4a"; IsoFile isoFile = new IsoFile(input); TrackBox tb = isoFile.getBoxes(MovieBox.class).get(0).getBoxes(TrackBox.class).get(0); SampleList sl = new SampleList(tb); FileChannel fc = new RandomAccessFile(input, "r").getChannel(); ByteBuffer mdatContent = getMdatContent(fc); fc.close(); for (ByteBuffer sample : sl) { while (sample.remaining() > 0) { byte ist = sample.get(); byte soll = mdatContent.get(); Assert.assertEquals("Offset " + mdatContent.position() + " soll: " + soll + " ist: " + ist, soll, ist); } } isoFile.close(); } |
### Question:
IsoTypeReader { public static double readFixedPoint1616(ByteBuffer bb) { byte[] bytes = new byte[4]; bb.get(bytes); int result = 0; result |= ((bytes[0] << 24) & 0xFF000000); result |= ((bytes[1] << 16) & 0xFF0000); result |= ((bytes[2] << 8) & 0xFF00); result |= ((bytes[3]) & 0xFF); return ((double) result) / 65536; } static long readUInt32BE(ByteBuffer bb); static long readUInt32(ByteBuffer bb); static int readUInt24(ByteBuffer bb); static int readUInt16(ByteBuffer bb); static int readUInt16BE(ByteBuffer bb); static int readUInt8(ByteBuffer bb); static int byte2int(byte b); static String readString(ByteBuffer byteBuffer); static String readString(ByteBuffer byteBuffer, int length); static long readUInt64(ByteBuffer byteBuffer); static double readFixedPoint1616(ByteBuffer bb); static double readFixedPoint0230(ByteBuffer bb); static float readFixedPoint88(ByteBuffer bb); static String readIso639(ByteBuffer bb); static String read4cc(ByteBuffer bb); }### Answer:
@Test public void testFixedPoint1616() throws IOException { final double fixedPointTest1 = 10.13; final double fixedPointTest2 = -10.13; ByteBuffer bb = ByteBuffer.allocate(8); IsoTypeWriter.writeFixedPoint1616(bb, fixedPointTest1); IsoTypeWriter.writeFixedPoint1616(bb, fixedPointTest2); bb.rewind(); Assert.assertEquals("fixedPointTest1", fixedPointTest1, IsoTypeReader.readFixedPoint1616(bb), 1d / 65536); Assert.assertEquals("fixedPointTest2", fixedPointTest2, IsoTypeReader.readFixedPoint1616(bb), 1d / 65536); } |
### Question:
IsoTypeReader { public static double readFixedPoint0230(ByteBuffer bb) { byte[] bytes = new byte[4]; bb.get(bytes); int result = 0; result |= ((bytes[0] << 24) & 0xFF000000); result |= ((bytes[1] << 16) & 0xFF0000); result |= ((bytes[2] << 8) & 0xFF00); result |= ((bytes[3]) & 0xFF); return ((double) result) / (1 << 30); } static long readUInt32BE(ByteBuffer bb); static long readUInt32(ByteBuffer bb); static int readUInt24(ByteBuffer bb); static int readUInt16(ByteBuffer bb); static int readUInt16BE(ByteBuffer bb); static int readUInt8(ByteBuffer bb); static int byte2int(byte b); static String readString(ByteBuffer byteBuffer); static String readString(ByteBuffer byteBuffer, int length); static long readUInt64(ByteBuffer byteBuffer); static double readFixedPoint1616(ByteBuffer bb); static double readFixedPoint0230(ByteBuffer bb); static float readFixedPoint88(ByteBuffer bb); static String readIso639(ByteBuffer bb); static String read4cc(ByteBuffer bb); }### Answer:
@Test public void testFixedPoint0230() throws IOException { final double fixedPointTest1 = 1.13; final double fixedPointTest2 = -1.13; ByteBuffer bb = ByteBuffer.allocate(8); IsoTypeWriter.writeFixedPoint0230(bb, fixedPointTest1); IsoTypeWriter.writeFixedPoint0230(bb, fixedPointTest2); bb.rewind(); Assert.assertEquals("fixedPointTest1", fixedPointTest1, IsoTypeReader.readFixedPoint0230(bb), 1d / 65536); Assert.assertEquals("fixedPointTest2", fixedPointTest2, IsoTypeReader.readFixedPoint0230(bb), 1d / 65536); } |
### Question:
IsoTypeReader { public static float readFixedPoint88(ByteBuffer bb) { byte[] bytes = new byte[2]; bb.get(bytes); short result = 0; result |= ((bytes[0] << 8) & 0xFF00); result |= ((bytes[1]) & 0xFF); return ((float) result) / 256; } static long readUInt32BE(ByteBuffer bb); static long readUInt32(ByteBuffer bb); static int readUInt24(ByteBuffer bb); static int readUInt16(ByteBuffer bb); static int readUInt16BE(ByteBuffer bb); static int readUInt8(ByteBuffer bb); static int byte2int(byte b); static String readString(ByteBuffer byteBuffer); static String readString(ByteBuffer byteBuffer, int length); static long readUInt64(ByteBuffer byteBuffer); static double readFixedPoint1616(ByteBuffer bb); static double readFixedPoint0230(ByteBuffer bb); static float readFixedPoint88(ByteBuffer bb); static String readIso639(ByteBuffer bb); static String read4cc(ByteBuffer bb); }### Answer:
@Test public void testFixedPoint88() throws IOException { final double fixedPointTest1 = 10.13; final double fixedPointTest2 = -10.13; ByteBuffer bb = ByteBuffer.allocate(4); IsoTypeWriter.writeFixedPoint88(bb, fixedPointTest1); IsoTypeWriter.writeFixedPoint88(bb, fixedPointTest2); bb.rewind(); Assert.assertEquals("fixedPointTest1", fixedPointTest1, IsoTypeReader.readFixedPoint88(bb), 1d / 256); Assert.assertEquals("fixedPointTest2", fixedPointTest2, IsoTypeReader.readFixedPoint88(bb), 1d / 256); } |
### Question:
IsoTypeReader { public static String read4cc(ByteBuffer bb) { bb.get(codeBytes); int result = ((codeBytes[0] << 24) & 0xFF000000); result |= ((codeBytes[1] << 16) & 0xFF0000); result |= ((codeBytes[2] << 8) & 0xFF00); result |= ((codeBytes[3]) & 0xFF); String code; if ((code = (String) codeCache.get(result)) != null) { return code; } else { try { code = new String(codeBytes, "ISO-8859-1"); codeCache.put(result, code); return code; } catch (UnsupportedEncodingException e) { throw new RuntimeException(e); } } } static long readUInt32BE(ByteBuffer bb); static long readUInt32(ByteBuffer bb); static int readUInt24(ByteBuffer bb); static int readUInt16(ByteBuffer bb); static int readUInt16BE(ByteBuffer bb); static int readUInt8(ByteBuffer bb); static int byte2int(byte b); static String readString(ByteBuffer byteBuffer); static String readString(ByteBuffer byteBuffer, int length); static long readUInt64(ByteBuffer byteBuffer); static double readFixedPoint1616(ByteBuffer bb); static double readFixedPoint0230(ByteBuffer bb); static float readFixedPoint88(ByteBuffer bb); static String readIso639(ByteBuffer bb); static String read4cc(ByteBuffer bb); }### Answer:
@Test public void testRead4cc() throws IOException { ByteBuffer bb = ByteBuffer.wrap("abcd".getBytes()); String code = IsoTypeReader.read4cc(bb); Assert.assertEquals(4, bb.position()); Assert.assertEquals("abcd", code); } |
### Question:
EmployeeService { @Transactional(rollbackFor = Exception.class) public void updateAgeById(Integer id, Integer age) { this.employeeRepository.updateAgeById(id, age); } @Transactional(rollbackFor = Exception.class) void updateAgeById(Integer id, Integer age); @Transactional(rollbackFor = Exception.class) void save(List<Employee> employees); }### Answer:
@Test public void updateAgeByIdTest() { EmployeeService employeeService = ctx.getBean(EmployeeService.class); employeeService.updateAgeById(1, 55); } |
### Question:
HelloController { @RequestMapping(value = "say", method = RequestMethod.GET) @ResponseBody public String say() { return girlProperties.getCupSize(); } @RequestMapping(method = RequestMethod.GET) String index(); @RequestMapping(value = "say", method = RequestMethod.GET) @ResponseBody String say(); @GetMapping(value = "/say/one") @ResponseBody String sayOne(@RequestParam(value = "id", required = false, defaultValue = "0") Integer myId); }### Answer:
@Test public void say() throws Exception { String response = mockMvc.perform(get("/hello/say") .contentType(APPLICATION_JSON_UTF8)) .andExpect(status().isOk()) .andReturn() .getResponse() .getContentAsString(); System.out.println(response); } |
### Question:
HelloController { @GetMapping(value = "/say/one") @ResponseBody public String sayOne(@RequestParam(value = "id", required = false, defaultValue = "0") Integer myId) { return "id:" + myId; } @RequestMapping(method = RequestMethod.GET) String index(); @RequestMapping(value = "say", method = RequestMethod.GET) @ResponseBody String say(); @GetMapping(value = "/say/one") @ResponseBody String sayOne(@RequestParam(value = "id", required = false, defaultValue = "0") Integer myId); }### Answer:
@Test public void sayOne() throws Exception { MultiValueMap<String, String> params = new LinkedMultiValueMap<>(16); params.add("id", "5"); String response = mockMvc.perform(get("/hello/say/one") .contentType(APPLICATION_JSON_UTF8) .params(params)) .andExpect(status().isOk()) .andReturn() .getResponse() .getContentAsString(); System.out.println(response); } |
### Question:
GirlController { @GetMapping public List<Girl> listGirl() { return girlRepository.findAll(); } @GetMapping List<Girl> listGirl(); @PostMapping Result<Girl> girlAdd(@Valid Girl girl, BindingResult bindingResult); @GetMapping("/{id}") Girl getGirlById(@PathVariable("id") Integer id); @PutMapping("/{id}") Girl updateGirlById(@PathVariable("id") Integer id,
@RequestParam("cupSize") String cupSize,
@RequestParam("age") Integer age); @DeleteMapping("/{id}") void removeGirl(@PathVariable("id") Integer id); @GetMapping("/age/{age}") List<Girl> listGirlByAge(@PathVariable("age") Integer age); @PostMapping("/two") void saveGirlTwo(); @GetMapping(value = "/getAge/{id}") void getAge(@PathVariable("id") Integer id); }### Answer:
@Test public void listGirl() throws Exception { String response = mockMvc.perform(get("/girls") .contentType(APPLICATION_JSON_UTF8)) .andExpect(status().isOk()) .andReturn() .getResponse() .getContentAsString(); System.out.println(response); } |
### Question:
GirlController { @PostMapping public Result<Girl> girlAdd(@Valid Girl girl, BindingResult bindingResult) { if (bindingResult.hasErrors()) { FieldError fieldError = bindingResult.getFieldError(); if (Objects.nonNull(fieldError)) { return ResultUtil.error(ResultUtil.RESPONSE_CODE_ERROR_PARAM, fieldError.getDefaultMessage()); } return ResultUtil.error(ResultUtil.RESPONSE_CODE_ERROR_PARAM, "未知参数错误"); } girl.setCupSize(girl.getCupSize()); girl.setAge(girl.getAge()); return ResultUtil.success(girlRepository.save(girl)); } @GetMapping List<Girl> listGirl(); @PostMapping Result<Girl> girlAdd(@Valid Girl girl, BindingResult bindingResult); @GetMapping("/{id}") Girl getGirlById(@PathVariable("id") Integer id); @PutMapping("/{id}") Girl updateGirlById(@PathVariable("id") Integer id,
@RequestParam("cupSize") String cupSize,
@RequestParam("age") Integer age); @DeleteMapping("/{id}") void removeGirl(@PathVariable("id") Integer id); @GetMapping("/age/{age}") List<Girl> listGirlByAge(@PathVariable("age") Integer age); @PostMapping("/two") void saveGirlTwo(); @GetMapping(value = "/getAge/{id}") void getAge(@PathVariable("id") Integer id); }### Answer:
@Test public void girlAdd() throws Exception { MultiValueMap<String, String> params = new LinkedMultiValueMap<>(16); params.add("cupSize", "B"); params.add("age", "20"); String response = mockMvc.perform(post("/girls") .contentType(APPLICATION_JSON_UTF8) .params(params)) .andExpect(status().isOk()) .andReturn() .getResponse() .getContentAsString(); System.out.println(response); } |
### Question:
GirlController { @GetMapping("/{id}") public Girl getGirlById(@PathVariable("id") Integer id) { return girlRepository.findById(id).orElse(null); } @GetMapping List<Girl> listGirl(); @PostMapping Result<Girl> girlAdd(@Valid Girl girl, BindingResult bindingResult); @GetMapping("/{id}") Girl getGirlById(@PathVariable("id") Integer id); @PutMapping("/{id}") Girl updateGirlById(@PathVariable("id") Integer id,
@RequestParam("cupSize") String cupSize,
@RequestParam("age") Integer age); @DeleteMapping("/{id}") void removeGirl(@PathVariable("id") Integer id); @GetMapping("/age/{age}") List<Girl> listGirlByAge(@PathVariable("age") Integer age); @PostMapping("/two") void saveGirlTwo(); @GetMapping(value = "/getAge/{id}") void getAge(@PathVariable("id") Integer id); }### Answer:
@Test public void getGirlById() throws Exception { int id = 3; String response = mockMvc.perform(get("/girls/" + id) .contentType(APPLICATION_JSON_UTF8)) .andExpect(status().isOk()) .andReturn() .getResponse() .getContentAsString(); TypeReference<Girl> typeReference = new TypeReference<Girl>() { }; Girl girl = objectMapper.readValue(response, typeReference); System.out.println(girl); } |
### Question:
GirlController { @PutMapping("/{id}") public Girl updateGirlById(@PathVariable("id") Integer id, @RequestParam("cupSize") String cupSize, @RequestParam("age") Integer age) { Girl girl = new Girl(); girl.setId(id); girl.setCupSize(cupSize); girl.setAge(age); return girlRepository.save(girl); } @GetMapping List<Girl> listGirl(); @PostMapping Result<Girl> girlAdd(@Valid Girl girl, BindingResult bindingResult); @GetMapping("/{id}") Girl getGirlById(@PathVariable("id") Integer id); @PutMapping("/{id}") Girl updateGirlById(@PathVariable("id") Integer id,
@RequestParam("cupSize") String cupSize,
@RequestParam("age") Integer age); @DeleteMapping("/{id}") void removeGirl(@PathVariable("id") Integer id); @GetMapping("/age/{age}") List<Girl> listGirlByAge(@PathVariable("age") Integer age); @PostMapping("/two") void saveGirlTwo(); @GetMapping(value = "/getAge/{id}") void getAge(@PathVariable("id") Integer id); }### Answer:
@Test public void updateGirlById() throws Exception { int id = 3; MultiValueMap<String, String> params = new LinkedMultiValueMap<>(16); params.add("cupSize", "C"); params.add("age", "22"); String response = mockMvc.perform(put("/girls/" + id) .contentType(APPLICATION_JSON_UTF8) .params(params)) .andExpect(status().isOk()) .andReturn() .getResponse() .getContentAsString(); TypeReference<Girl> typeReference = new TypeReference<Girl>() { }; Girl girl = objectMapper.readValue(response, typeReference); System.out.println(girl); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.